xref: /openbmc/linux/lib/test_bpf.c (revision 0bbaa02b) 
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 #define FLAG_VERIFIER_ZEXT	BIT(3)
56 
57 enum {
58 	CLASSIC  = BIT(6),	/* Old BPF instructions only. */
59 	INTERNAL = BIT(7),	/* Extended instruction set.  */
60 };
61 
62 #define TEST_TYPE_MASK		(CLASSIC | INTERNAL)
63 
64 struct bpf_test {
65 	const char *descr;
66 	union {
67 		struct sock_filter insns[MAX_INSNS];
68 		struct bpf_insn insns_int[MAX_INSNS];
69 		struct {
70 			void *insns;
71 			unsigned int len;
72 		} ptr;
73 	} u;
74 	__u8 aux;
75 	__u8 data[MAX_DATA];
76 	struct {
77 		int data_size;
78 		__u32 result;
79 	} test[MAX_SUBTESTS];
80 	int (*fill_helper)(struct bpf_test *self);
81 	int expected_errcode; /* used when FLAG_EXPECTED_FAIL is set in the aux */
82 	__u8 frag_data[MAX_DATA];
83 	int stack_depth; /* for eBPF only, since tests don't call verifier */
84 	int nr_testruns; /* Custom run count, defaults to MAX_TESTRUNS if 0 */
85 };
86 
87 /* Large test cases need separate allocation and fill handler. */
88 
89 static int bpf_fill_maxinsns1(struct bpf_test *self)
90 {
91 	unsigned int len = BPF_MAXINSNS;
92 	struct sock_filter *insn;
93 	__u32 k = ~0;
94 	int i;
95 
96 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
97 	if (!insn)
98 		return -ENOMEM;
99 
100 	for (i = 0; i < len; i++, k--)
101 		insn[i] = __BPF_STMT(BPF_RET | BPF_K, k);
102 
103 	self->u.ptr.insns = insn;
104 	self->u.ptr.len = len;
105 
106 	return 0;
107 }
108 
109 static int bpf_fill_maxinsns2(struct bpf_test *self)
110 {
111 	unsigned int len = BPF_MAXINSNS;
112 	struct sock_filter *insn;
113 	int i;
114 
115 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
116 	if (!insn)
117 		return -ENOMEM;
118 
119 	for (i = 0; i < len; i++)
120 		insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
121 
122 	self->u.ptr.insns = insn;
123 	self->u.ptr.len = len;
124 
125 	return 0;
126 }
127 
128 static int bpf_fill_maxinsns3(struct bpf_test *self)
129 {
130 	unsigned int len = BPF_MAXINSNS;
131 	struct sock_filter *insn;
132 	struct rnd_state rnd;
133 	int i;
134 
135 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
136 	if (!insn)
137 		return -ENOMEM;
138 
139 	prandom_seed_state(&rnd, 3141592653589793238ULL);
140 
141 	for (i = 0; i < len - 1; i++) {
142 		__u32 k = prandom_u32_state(&rnd);
143 
144 		insn[i] = __BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, k);
145 	}
146 
147 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
148 
149 	self->u.ptr.insns = insn;
150 	self->u.ptr.len = len;
151 
152 	return 0;
153 }
154 
155 static int bpf_fill_maxinsns4(struct bpf_test *self)
156 {
157 	unsigned int len = BPF_MAXINSNS + 1;
158 	struct sock_filter *insn;
159 	int i;
160 
161 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
162 	if (!insn)
163 		return -ENOMEM;
164 
165 	for (i = 0; i < len; i++)
166 		insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
167 
168 	self->u.ptr.insns = insn;
169 	self->u.ptr.len = len;
170 
171 	return 0;
172 }
173 
174 static int bpf_fill_maxinsns5(struct bpf_test *self)
175 {
176 	unsigned int len = BPF_MAXINSNS;
177 	struct sock_filter *insn;
178 	int i;
179 
180 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
181 	if (!insn)
182 		return -ENOMEM;
183 
184 	insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0);
185 
186 	for (i = 1; i < len - 1; i++)
187 		insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
188 
189 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab);
190 
191 	self->u.ptr.insns = insn;
192 	self->u.ptr.len = len;
193 
194 	return 0;
195 }
196 
197 static int bpf_fill_maxinsns6(struct bpf_test *self)
198 {
199 	unsigned int len = BPF_MAXINSNS;
200 	struct sock_filter *insn;
201 	int i;
202 
203 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
204 	if (!insn)
205 		return -ENOMEM;
206 
207 	for (i = 0; i < len - 1; i++)
208 		insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
209 				     SKF_AD_VLAN_TAG_PRESENT);
210 
211 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
212 
213 	self->u.ptr.insns = insn;
214 	self->u.ptr.len = len;
215 
216 	return 0;
217 }
218 
219 static int bpf_fill_maxinsns7(struct bpf_test *self)
220 {
221 	unsigned int len = BPF_MAXINSNS;
222 	struct sock_filter *insn;
223 	int i;
224 
225 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
226 	if (!insn)
227 		return -ENOMEM;
228 
229 	for (i = 0; i < len - 4; i++)
230 		insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
231 				     SKF_AD_CPU);
232 
233 	insn[len - 4] = __BPF_STMT(BPF_MISC | BPF_TAX, 0);
234 	insn[len - 3] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
235 				   SKF_AD_CPU);
236 	insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0);
237 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
238 
239 	self->u.ptr.insns = insn;
240 	self->u.ptr.len = len;
241 
242 	return 0;
243 }
244 
245 static int bpf_fill_maxinsns8(struct bpf_test *self)
246 {
247 	unsigned int len = BPF_MAXINSNS;
248 	struct sock_filter *insn;
249 	int i, jmp_off = len - 3;
250 
251 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
252 	if (!insn)
253 		return -ENOMEM;
254 
255 	insn[0] = __BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff);
256 
257 	for (i = 1; i < len - 1; i++)
258 		insn[i] = __BPF_JUMP(BPF_JMP | BPF_JGT, 0xffffffff, jmp_off--, 0);
259 
260 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
261 
262 	self->u.ptr.insns = insn;
263 	self->u.ptr.len = len;
264 
265 	return 0;
266 }
267 
268 static int bpf_fill_maxinsns9(struct bpf_test *self)
269 {
270 	unsigned int len = BPF_MAXINSNS;
271 	struct bpf_insn *insn;
272 	int i;
273 
274 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
275 	if (!insn)
276 		return -ENOMEM;
277 
278 	insn[0] = BPF_JMP_IMM(BPF_JA, 0, 0, len - 2);
279 	insn[1] = BPF_ALU32_IMM(BPF_MOV, R0, 0xcbababab);
280 	insn[2] = BPF_EXIT_INSN();
281 
282 	for (i = 3; i < len - 2; i++)
283 		insn[i] = BPF_ALU32_IMM(BPF_MOV, R0, 0xfefefefe);
284 
285 	insn[len - 2] = BPF_EXIT_INSN();
286 	insn[len - 1] = BPF_JMP_IMM(BPF_JA, 0, 0, -(len - 1));
287 
288 	self->u.ptr.insns = insn;
289 	self->u.ptr.len = len;
290 
291 	return 0;
292 }
293 
294 static int bpf_fill_maxinsns10(struct bpf_test *self)
295 {
296 	unsigned int len = BPF_MAXINSNS, hlen = len - 2;
297 	struct bpf_insn *insn;
298 	int i;
299 
300 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
301 	if (!insn)
302 		return -ENOMEM;
303 
304 	for (i = 0; i < hlen / 2; i++)
305 		insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 2 - 2 * i);
306 	for (i = hlen - 1; i > hlen / 2; i--)
307 		insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 1 - 2 * i);
308 
309 	insn[hlen / 2] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen / 2 - 1);
310 	insn[hlen]     = BPF_ALU32_IMM(BPF_MOV, R0, 0xabababac);
311 	insn[hlen + 1] = BPF_EXIT_INSN();
312 
313 	self->u.ptr.insns = insn;
314 	self->u.ptr.len = len;
315 
316 	return 0;
317 }
318 
319 static int __bpf_fill_ja(struct bpf_test *self, unsigned int len,
320 			 unsigned int plen)
321 {
322 	struct sock_filter *insn;
323 	unsigned int rlen;
324 	int i, j;
325 
326 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
327 	if (!insn)
328 		return -ENOMEM;
329 
330 	rlen = (len % plen) - 1;
331 
332 	for (i = 0; i + plen < len; i += plen)
333 		for (j = 0; j < plen; j++)
334 			insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA,
335 						 plen - 1 - j, 0, 0);
336 	for (j = 0; j < rlen; j++)
337 		insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA, rlen - 1 - j,
338 					 0, 0);
339 
340 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xababcbac);
341 
342 	self->u.ptr.insns = insn;
343 	self->u.ptr.len = len;
344 
345 	return 0;
346 }
347 
348 static int bpf_fill_maxinsns11(struct bpf_test *self)
349 {
350 	/* Hits 70 passes on x86_64 and triggers NOPs padding. */
351 	return __bpf_fill_ja(self, BPF_MAXINSNS, 68);
352 }
353 
354 static int bpf_fill_maxinsns12(struct bpf_test *self)
355 {
356 	unsigned int len = BPF_MAXINSNS;
357 	struct sock_filter *insn;
358 	int i = 0;
359 
360 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
361 	if (!insn)
362 		return -ENOMEM;
363 
364 	insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0);
365 
366 	for (i = 1; i < len - 1; i++)
367 		insn[i] = __BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0);
368 
369 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab);
370 
371 	self->u.ptr.insns = insn;
372 	self->u.ptr.len = len;
373 
374 	return 0;
375 }
376 
377 static int bpf_fill_maxinsns13(struct bpf_test *self)
378 {
379 	unsigned int len = BPF_MAXINSNS;
380 	struct sock_filter *insn;
381 	int i = 0;
382 
383 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
384 	if (!insn)
385 		return -ENOMEM;
386 
387 	for (i = 0; i < len - 3; i++)
388 		insn[i] = __BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0);
389 
390 	insn[len - 3] = __BPF_STMT(BPF_LD | BPF_IMM, 0xabababab);
391 	insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0);
392 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
393 
394 	self->u.ptr.insns = insn;
395 	self->u.ptr.len = len;
396 
397 	return 0;
398 }
399 
400 static int bpf_fill_ja(struct bpf_test *self)
401 {
402 	/* Hits exactly 11 passes on x86_64 JIT. */
403 	return __bpf_fill_ja(self, 12, 9);
404 }
405 
406 static int bpf_fill_ld_abs_get_processor_id(struct bpf_test *self)
407 {
408 	unsigned int len = BPF_MAXINSNS;
409 	struct sock_filter *insn;
410 	int i;
411 
412 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
413 	if (!insn)
414 		return -ENOMEM;
415 
416 	for (i = 0; i < len - 1; i += 2) {
417 		insn[i] = __BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 0);
418 		insn[i + 1] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
419 					 SKF_AD_OFF + SKF_AD_CPU);
420 	}
421 
422 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xbee);
423 
424 	self->u.ptr.insns = insn;
425 	self->u.ptr.len = len;
426 
427 	return 0;
428 }
429 
430 static int __bpf_fill_stxdw(struct bpf_test *self, int size)
431 {
432 	unsigned int len = BPF_MAXINSNS;
433 	struct bpf_insn *insn;
434 	int i;
435 
436 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
437 	if (!insn)
438 		return -ENOMEM;
439 
440 	insn[0] = BPF_ALU32_IMM(BPF_MOV, R0, 1);
441 	insn[1] = BPF_ST_MEM(size, R10, -40, 42);
442 
443 	for (i = 2; i < len - 2; i++)
444 		insn[i] = BPF_STX_XADD(size, R10, R0, -40);
445 
446 	insn[len - 2] = BPF_LDX_MEM(size, R0, R10, -40);
447 	insn[len - 1] = BPF_EXIT_INSN();
448 
449 	self->u.ptr.insns = insn;
450 	self->u.ptr.len = len;
451 	self->stack_depth = 40;
452 
453 	return 0;
454 }
455 
456 static int bpf_fill_stxw(struct bpf_test *self)
457 {
458 	return __bpf_fill_stxdw(self, BPF_W);
459 }
460 
461 static int bpf_fill_stxdw(struct bpf_test *self)
462 {
463 	return __bpf_fill_stxdw(self, BPF_DW);
464 }
465 
466 static int __bpf_ld_imm64(struct bpf_insn insns[2], u8 reg, s64 imm64)
467 {
468 	struct bpf_insn tmp[] = {BPF_LD_IMM64(reg, imm64)};
469 
470 	memcpy(insns, tmp, sizeof(tmp));
471 	return 2;
472 }
473 
474 /*
475  * Branch conversion tests. Complex operations can expand to a lot
476  * of instructions when JITed. This in turn may cause jump offsets
477  * to overflow the field size of the native instruction, triggering
478  * a branch conversion mechanism in some JITs.
479  */
480 static int __bpf_fill_max_jmp(struct bpf_test *self, int jmp, int imm)
481 {
482 	struct bpf_insn *insns;
483 	int len = S16_MAX + 5;
484 	int i;
485 
486 	insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL);
487 	if (!insns)
488 		return -ENOMEM;
489 
490 	i = __bpf_ld_imm64(insns, R1, 0x0123456789abcdefULL);
491 	insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
492 	insns[i++] = BPF_JMP_IMM(jmp, R0, imm, S16_MAX);
493 	insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 2);
494 	insns[i++] = BPF_EXIT_INSN();
495 
496 	while (i < len - 1) {
497 		static const int ops[] = {
498 			BPF_LSH, BPF_RSH, BPF_ARSH, BPF_ADD,
499 			BPF_SUB, BPF_MUL, BPF_DIV, BPF_MOD,
500 		};
501 		int op = ops[(i >> 1) % ARRAY_SIZE(ops)];
502 
503 		if (i & 1)
504 			insns[i++] = BPF_ALU32_REG(op, R0, R1);
505 		else
506 			insns[i++] = BPF_ALU64_REG(op, R0, R1);
507 	}
508 
509 	insns[i++] = BPF_EXIT_INSN();
510 	self->u.ptr.insns = insns;
511 	self->u.ptr.len = len;
512 	BUG_ON(i != len);
513 
514 	return 0;
515 }
516 
517 /* Branch taken by runtime decision */
518 static int bpf_fill_max_jmp_taken(struct bpf_test *self)
519 {
520 	return __bpf_fill_max_jmp(self, BPF_JEQ, 1);
521 }
522 
523 /* Branch not taken by runtime decision */
524 static int bpf_fill_max_jmp_not_taken(struct bpf_test *self)
525 {
526 	return __bpf_fill_max_jmp(self, BPF_JEQ, 0);
527 }
528 
529 /* Branch always taken, known at JIT time */
530 static int bpf_fill_max_jmp_always_taken(struct bpf_test *self)
531 {
532 	return __bpf_fill_max_jmp(self, BPF_JGE, 0);
533 }
534 
535 /* Branch never taken, known at JIT time */
536 static int bpf_fill_max_jmp_never_taken(struct bpf_test *self)
537 {
538 	return __bpf_fill_max_jmp(self, BPF_JLT, 0);
539 }
540 
541 /* Test an ALU shift operation for all valid shift values */
542 static int __bpf_fill_alu_shift(struct bpf_test *self, u8 op,
543 				u8 mode, bool alu32)
544 {
545 	static const s64 regs[] = {
546 		0x0123456789abcdefLL, /* dword > 0, word < 0 */
547 		0xfedcba9876543210LL, /* dowrd < 0, word > 0 */
548 		0xfedcba0198765432LL, /* dowrd < 0, word < 0 */
549 		0x0123458967abcdefLL, /* dword > 0, word > 0 */
550 	};
551 	int bits = alu32 ? 32 : 64;
552 	int len = (2 + 7 * bits) * ARRAY_SIZE(regs) + 3;
553 	struct bpf_insn *insn;
554 	int imm, k;
555 	int i = 0;
556 
557 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
558 	if (!insn)
559 		return -ENOMEM;
560 
561 	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
562 
563 	for (k = 0; k < ARRAY_SIZE(regs); k++) {
564 		s64 reg = regs[k];
565 
566 		i += __bpf_ld_imm64(&insn[i], R3, reg);
567 
568 		for (imm = 0; imm < bits; imm++) {
569 			u64 val;
570 
571 			/* Perform operation */
572 			insn[i++] = BPF_ALU64_REG(BPF_MOV, R1, R3);
573 			insn[i++] = BPF_ALU64_IMM(BPF_MOV, R2, imm);
574 			if (alu32) {
575 				if (mode == BPF_K)
576 					insn[i++] = BPF_ALU32_IMM(op, R1, imm);
577 				else
578 					insn[i++] = BPF_ALU32_REG(op, R1, R2);
579 				switch (op) {
580 				case BPF_LSH:
581 					val = (u32)reg << imm;
582 					break;
583 				case BPF_RSH:
584 					val = (u32)reg >> imm;
585 					break;
586 				case BPF_ARSH:
587 					val = (u32)reg >> imm;
588 					if (imm > 0 && (reg & 0x80000000))
589 						val |= ~(u32)0 << (32 - imm);
590 					break;
591 				}
592 			} else {
593 				if (mode == BPF_K)
594 					insn[i++] = BPF_ALU64_IMM(op, R1, imm);
595 				else
596 					insn[i++] = BPF_ALU64_REG(op, R1, R2);
597 				switch (op) {
598 				case BPF_LSH:
599 					val = (u64)reg << imm;
600 					break;
601 				case BPF_RSH:
602 					val = (u64)reg >> imm;
603 					break;
604 				case BPF_ARSH:
605 					val = (u64)reg >> imm;
606 					if (imm > 0 && reg < 0)
607 						val |= ~(u64)0 << (64 - imm);
608 					break;
609 				}
610 			}
611 
612 			/*
613 			 * When debugging a JIT that fails this test, one
614 			 * can write the immediate value to R0 here to find
615 			 * out which operand values that fail.
616 			 */
617 
618 			/* Load reference and check the result */
619 			i += __bpf_ld_imm64(&insn[i], R4, val);
620 			insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R4, 1);
621 			insn[i++] = BPF_EXIT_INSN();
622 		}
623 	}
624 
625 	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
626 	insn[i++] = BPF_EXIT_INSN();
627 
628 	self->u.ptr.insns = insn;
629 	self->u.ptr.len = len;
630 	BUG_ON(i > len);
631 
632 	return 0;
633 }
634 
635 static int bpf_fill_alu_lsh_imm(struct bpf_test *self)
636 {
637 	return __bpf_fill_alu_shift(self, BPF_LSH, BPF_K, false);
638 }
639 
640 static int bpf_fill_alu_rsh_imm(struct bpf_test *self)
641 {
642 	return __bpf_fill_alu_shift(self, BPF_RSH, BPF_K, false);
643 }
644 
645 static int bpf_fill_alu_arsh_imm(struct bpf_test *self)
646 {
647 	return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_K, false);
648 }
649 
650 static int bpf_fill_alu_lsh_reg(struct bpf_test *self)
651 {
652 	return __bpf_fill_alu_shift(self, BPF_LSH, BPF_X, false);
653 }
654 
655 static int bpf_fill_alu_rsh_reg(struct bpf_test *self)
656 {
657 	return __bpf_fill_alu_shift(self, BPF_RSH, BPF_X, false);
658 }
659 
660 static int bpf_fill_alu_arsh_reg(struct bpf_test *self)
661 {
662 	return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_X, false);
663 }
664 
665 static int bpf_fill_alu32_lsh_imm(struct bpf_test *self)
666 {
667 	return __bpf_fill_alu_shift(self, BPF_LSH, BPF_K, true);
668 }
669 
670 static int bpf_fill_alu32_rsh_imm(struct bpf_test *self)
671 {
672 	return __bpf_fill_alu_shift(self, BPF_RSH, BPF_K, true);
673 }
674 
675 static int bpf_fill_alu32_arsh_imm(struct bpf_test *self)
676 {
677 	return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_K, true);
678 }
679 
680 static int bpf_fill_alu32_lsh_reg(struct bpf_test *self)
681 {
682 	return __bpf_fill_alu_shift(self, BPF_LSH, BPF_X, true);
683 }
684 
685 static int bpf_fill_alu32_rsh_reg(struct bpf_test *self)
686 {
687 	return __bpf_fill_alu_shift(self, BPF_RSH, BPF_X, true);
688 }
689 
690 static int bpf_fill_alu32_arsh_reg(struct bpf_test *self)
691 {
692 	return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_X, true);
693 }
694 
695 /*
696  * Common operand pattern generator for exhaustive power-of-two magnitudes
697  * tests. The block size parameters can be adjusted to increase/reduce the
698  * number of combinatons tested and thereby execution speed and memory
699  * footprint.
700  */
701 
702 static inline s64 value(int msb, int delta, int sign)
703 {
704 	return sign * (1LL << msb) + delta;
705 }
706 
707 static int __bpf_fill_pattern(struct bpf_test *self, void *arg,
708 			      int dbits, int sbits, int block1, int block2,
709 			      int (*emit)(struct bpf_test*, void*,
710 					  struct bpf_insn*, s64, s64))
711 {
712 	static const int sgn[][2] = {{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
713 	struct bpf_insn *insns;
714 	int di, si, bt, db, sb;
715 	int count, len, k;
716 	int extra = 1 + 2;
717 	int i = 0;
718 
719 	/* Total number of iterations for the two pattern */
720 	count = (dbits - 1) * (sbits - 1) * block1 * block1 * ARRAY_SIZE(sgn);
721 	count += (max(dbits, sbits) - 1) * block2 * block2 * ARRAY_SIZE(sgn);
722 
723 	/* Compute the maximum number of insns and allocate the buffer */
724 	len = extra + count * (*emit)(self, arg, NULL, 0, 0);
725 	insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL);
726 	if (!insns)
727 		return -ENOMEM;
728 
729 	/* Add head instruction(s) */
730 	insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
731 
732 	/*
733 	 * Pattern 1: all combinations of power-of-two magnitudes and sign,
734 	 * and with a block of contiguous values around each magnitude.
735 	 */
736 	for (di = 0; di < dbits - 1; di++)                 /* Dst magnitudes */
737 		for (si = 0; si < sbits - 1; si++)         /* Src magnitudes */
738 			for (k = 0; k < ARRAY_SIZE(sgn); k++) /* Sign combos */
739 				for (db = -(block1 / 2);
740 				     db < (block1 + 1) / 2; db++)
741 					for (sb = -(block1 / 2);
742 					     sb < (block1 + 1) / 2; sb++) {
743 						s64 dst, src;
744 
745 						dst = value(di, db, sgn[k][0]);
746 						src = value(si, sb, sgn[k][1]);
747 						i += (*emit)(self, arg,
748 							     &insns[i],
749 							     dst, src);
750 					}
751 	/*
752 	 * Pattern 2: all combinations for a larger block of values
753 	 * for each power-of-two magnitude and sign, where the magnitude is
754 	 * the same for both operands.
755 	 */
756 	for (bt = 0; bt < max(dbits, sbits) - 1; bt++)        /* Magnitude   */
757 		for (k = 0; k < ARRAY_SIZE(sgn); k++)         /* Sign combos */
758 			for (db = -(block2 / 2); db < (block2 + 1) / 2; db++)
759 				for (sb = -(block2 / 2);
760 				     sb < (block2 + 1) / 2; sb++) {
761 					s64 dst, src;
762 
763 					dst = value(bt % dbits, db, sgn[k][0]);
764 					src = value(bt % sbits, sb, sgn[k][1]);
765 					i += (*emit)(self, arg, &insns[i],
766 						     dst, src);
767 				}
768 
769 	/* Append tail instructions */
770 	insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
771 	insns[i++] = BPF_EXIT_INSN();
772 	BUG_ON(i > len);
773 
774 	self->u.ptr.insns = insns;
775 	self->u.ptr.len = i;
776 
777 	return 0;
778 }
779 
780 /*
781  * Block size parameters used in pattern tests below. une as needed to
782  * increase/reduce the number combinations tested, see following examples.
783  *        block   values per operand MSB
784  * ----------------------------------------
785  *           0     none
786  *           1     (1 << MSB)
787  *           2     (1 << MSB) + [-1, 0]
788  *           3     (1 << MSB) + [-1, 0, 1]
789  */
790 #define PATTERN_BLOCK1 1
791 #define PATTERN_BLOCK2 5
792 
793 /* Number of test runs for a pattern test */
794 #define NR_PATTERN_RUNS 1
795 
796 /*
797  * Exhaustive tests of ALU operations for all combinations of power-of-two
798  * magnitudes of the operands, both for positive and negative values. The
799  * test is designed to verify e.g. the ALU and ALU64 operations for JITs that
800  * emit different code depending on the magnitude of the immediate value.
801  */
802 
803 static bool __bpf_alu_result(u64 *res, u64 v1, u64 v2, u8 op)
804 {
805 	*res = 0;
806 	switch (op) {
807 	case BPF_MOV:
808 		*res = v2;
809 		break;
810 	case BPF_AND:
811 		*res = v1 & v2;
812 		break;
813 	case BPF_OR:
814 		*res = v1 | v2;
815 		break;
816 	case BPF_XOR:
817 		*res = v1 ^ v2;
818 		break;
819 	case BPF_ADD:
820 		*res = v1 + v2;
821 		break;
822 	case BPF_SUB:
823 		*res = v1 - v2;
824 		break;
825 	case BPF_MUL:
826 		*res = v1 * v2;
827 		break;
828 	case BPF_DIV:
829 		if (v2 == 0)
830 			return false;
831 		*res = div64_u64(v1, v2);
832 		break;
833 	case BPF_MOD:
834 		if (v2 == 0)
835 			return false;
836 		div64_u64_rem(v1, v2, res);
837 		break;
838 	}
839 	return true;
840 }
841 
842 static int __bpf_emit_alu64_imm(struct bpf_test *self, void *arg,
843 				struct bpf_insn *insns, s64 dst, s64 imm)
844 {
845 	int op = *(int *)arg;
846 	int i = 0;
847 	u64 res;
848 
849 	if (!insns)
850 		return 7;
851 
852 	if (__bpf_alu_result(&res, dst, (s32)imm, op)) {
853 		i += __bpf_ld_imm64(&insns[i], R1, dst);
854 		i += __bpf_ld_imm64(&insns[i], R3, res);
855 		insns[i++] = BPF_ALU64_IMM(op, R1, imm);
856 		insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
857 		insns[i++] = BPF_EXIT_INSN();
858 	}
859 
860 	return i;
861 }
862 
863 static int __bpf_emit_alu32_imm(struct bpf_test *self, void *arg,
864 				struct bpf_insn *insns, s64 dst, s64 imm)
865 {
866 	int op = *(int *)arg;
867 	int i = 0;
868 	u64 res;
869 
870 	if (!insns)
871 		return 7;
872 
873 	if (__bpf_alu_result(&res, (u32)dst, (u32)imm, op)) {
874 		i += __bpf_ld_imm64(&insns[i], R1, dst);
875 		i += __bpf_ld_imm64(&insns[i], R3, (u32)res);
876 		insns[i++] = BPF_ALU32_IMM(op, R1, imm);
877 		insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
878 		insns[i++] = BPF_EXIT_INSN();
879 	}
880 
881 	return i;
882 }
883 
884 static int __bpf_emit_alu64_reg(struct bpf_test *self, void *arg,
885 				struct bpf_insn *insns, s64 dst, s64 src)
886 {
887 	int op = *(int *)arg;
888 	int i = 0;
889 	u64 res;
890 
891 	if (!insns)
892 		return 9;
893 
894 	if (__bpf_alu_result(&res, dst, src, op)) {
895 		i += __bpf_ld_imm64(&insns[i], R1, dst);
896 		i += __bpf_ld_imm64(&insns[i], R2, src);
897 		i += __bpf_ld_imm64(&insns[i], R3, res);
898 		insns[i++] = BPF_ALU64_REG(op, R1, R2);
899 		insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
900 		insns[i++] = BPF_EXIT_INSN();
901 	}
902 
903 	return i;
904 }
905 
906 static int __bpf_emit_alu32_reg(struct bpf_test *self, void *arg,
907 				struct bpf_insn *insns, s64 dst, s64 src)
908 {
909 	int op = *(int *)arg;
910 	int i = 0;
911 	u64 res;
912 
913 	if (!insns)
914 		return 9;
915 
916 	if (__bpf_alu_result(&res, (u32)dst, (u32)src, op)) {
917 		i += __bpf_ld_imm64(&insns[i], R1, dst);
918 		i += __bpf_ld_imm64(&insns[i], R2, src);
919 		i += __bpf_ld_imm64(&insns[i], R3, (u32)res);
920 		insns[i++] = BPF_ALU32_REG(op, R1, R2);
921 		insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
922 		insns[i++] = BPF_EXIT_INSN();
923 	}
924 
925 	return i;
926 }
927 
928 static int __bpf_fill_alu64_imm(struct bpf_test *self, int op)
929 {
930 	return __bpf_fill_pattern(self, &op, 64, 32,
931 				  PATTERN_BLOCK1, PATTERN_BLOCK2,
932 				  &__bpf_emit_alu64_imm);
933 }
934 
935 static int __bpf_fill_alu32_imm(struct bpf_test *self, int op)
936 {
937 	return __bpf_fill_pattern(self, &op, 64, 32,
938 				  PATTERN_BLOCK1, PATTERN_BLOCK2,
939 				  &__bpf_emit_alu32_imm);
940 }
941 
942 static int __bpf_fill_alu64_reg(struct bpf_test *self, int op)
943 {
944 	return __bpf_fill_pattern(self, &op, 64, 64,
945 				  PATTERN_BLOCK1, PATTERN_BLOCK2,
946 				  &__bpf_emit_alu64_reg);
947 }
948 
949 static int __bpf_fill_alu32_reg(struct bpf_test *self, int op)
950 {
951 	return __bpf_fill_pattern(self, &op, 64, 64,
952 				  PATTERN_BLOCK1, PATTERN_BLOCK2,
953 				  &__bpf_emit_alu32_reg);
954 }
955 
956 /* ALU64 immediate operations */
957 static int bpf_fill_alu64_mov_imm(struct bpf_test *self)
958 {
959 	return __bpf_fill_alu64_imm(self, BPF_MOV);
960 }
961 
962 static int bpf_fill_alu64_and_imm(struct bpf_test *self)
963 {
964 	return __bpf_fill_alu64_imm(self, BPF_AND);
965 }
966 
967 static int bpf_fill_alu64_or_imm(struct bpf_test *self)
968 {
969 	return __bpf_fill_alu64_imm(self, BPF_OR);
970 }
971 
972 static int bpf_fill_alu64_xor_imm(struct bpf_test *self)
973 {
974 	return __bpf_fill_alu64_imm(self, BPF_XOR);
975 }
976 
977 static int bpf_fill_alu64_add_imm(struct bpf_test *self)
978 {
979 	return __bpf_fill_alu64_imm(self, BPF_ADD);
980 }
981 
982 static int bpf_fill_alu64_sub_imm(struct bpf_test *self)
983 {
984 	return __bpf_fill_alu64_imm(self, BPF_SUB);
985 }
986 
987 static int bpf_fill_alu64_mul_imm(struct bpf_test *self)
988 {
989 	return __bpf_fill_alu64_imm(self, BPF_MUL);
990 }
991 
992 static int bpf_fill_alu64_div_imm(struct bpf_test *self)
993 {
994 	return __bpf_fill_alu64_imm(self, BPF_DIV);
995 }
996 
997 static int bpf_fill_alu64_mod_imm(struct bpf_test *self)
998 {
999 	return __bpf_fill_alu64_imm(self, BPF_MOD);
1000 }
1001 
1002 /* ALU32 immediate operations */
1003 static int bpf_fill_alu32_mov_imm(struct bpf_test *self)
1004 {
1005 	return __bpf_fill_alu32_imm(self, BPF_MOV);
1006 }
1007 
1008 static int bpf_fill_alu32_and_imm(struct bpf_test *self)
1009 {
1010 	return __bpf_fill_alu32_imm(self, BPF_AND);
1011 }
1012 
1013 static int bpf_fill_alu32_or_imm(struct bpf_test *self)
1014 {
1015 	return __bpf_fill_alu32_imm(self, BPF_OR);
1016 }
1017 
1018 static int bpf_fill_alu32_xor_imm(struct bpf_test *self)
1019 {
1020 	return __bpf_fill_alu32_imm(self, BPF_XOR);
1021 }
1022 
1023 static int bpf_fill_alu32_add_imm(struct bpf_test *self)
1024 {
1025 	return __bpf_fill_alu32_imm(self, BPF_ADD);
1026 }
1027 
1028 static int bpf_fill_alu32_sub_imm(struct bpf_test *self)
1029 {
1030 	return __bpf_fill_alu32_imm(self, BPF_SUB);
1031 }
1032 
1033 static int bpf_fill_alu32_mul_imm(struct bpf_test *self)
1034 {
1035 	return __bpf_fill_alu32_imm(self, BPF_MUL);
1036 }
1037 
1038 static int bpf_fill_alu32_div_imm(struct bpf_test *self)
1039 {
1040 	return __bpf_fill_alu32_imm(self, BPF_DIV);
1041 }
1042 
1043 static int bpf_fill_alu32_mod_imm(struct bpf_test *self)
1044 {
1045 	return __bpf_fill_alu32_imm(self, BPF_MOD);
1046 }
1047 
1048 /* ALU64 register operations */
1049 static int bpf_fill_alu64_mov_reg(struct bpf_test *self)
1050 {
1051 	return __bpf_fill_alu64_reg(self, BPF_MOV);
1052 }
1053 
1054 static int bpf_fill_alu64_and_reg(struct bpf_test *self)
1055 {
1056 	return __bpf_fill_alu64_reg(self, BPF_AND);
1057 }
1058 
1059 static int bpf_fill_alu64_or_reg(struct bpf_test *self)
1060 {
1061 	return __bpf_fill_alu64_reg(self, BPF_OR);
1062 }
1063 
1064 static int bpf_fill_alu64_xor_reg(struct bpf_test *self)
1065 {
1066 	return __bpf_fill_alu64_reg(self, BPF_XOR);
1067 }
1068 
1069 static int bpf_fill_alu64_add_reg(struct bpf_test *self)
1070 {
1071 	return __bpf_fill_alu64_reg(self, BPF_ADD);
1072 }
1073 
1074 static int bpf_fill_alu64_sub_reg(struct bpf_test *self)
1075 {
1076 	return __bpf_fill_alu64_reg(self, BPF_SUB);
1077 }
1078 
1079 static int bpf_fill_alu64_mul_reg(struct bpf_test *self)
1080 {
1081 	return __bpf_fill_alu64_reg(self, BPF_MUL);
1082 }
1083 
1084 static int bpf_fill_alu64_div_reg(struct bpf_test *self)
1085 {
1086 	return __bpf_fill_alu64_reg(self, BPF_DIV);
1087 }
1088 
1089 static int bpf_fill_alu64_mod_reg(struct bpf_test *self)
1090 {
1091 	return __bpf_fill_alu64_reg(self, BPF_MOD);
1092 }
1093 
1094 /* ALU32 register operations */
1095 static int bpf_fill_alu32_mov_reg(struct bpf_test *self)
1096 {
1097 	return __bpf_fill_alu32_reg(self, BPF_MOV);
1098 }
1099 
1100 static int bpf_fill_alu32_and_reg(struct bpf_test *self)
1101 {
1102 	return __bpf_fill_alu32_reg(self, BPF_AND);
1103 }
1104 
1105 static int bpf_fill_alu32_or_reg(struct bpf_test *self)
1106 {
1107 	return __bpf_fill_alu32_reg(self, BPF_OR);
1108 }
1109 
1110 static int bpf_fill_alu32_xor_reg(struct bpf_test *self)
1111 {
1112 	return __bpf_fill_alu32_reg(self, BPF_XOR);
1113 }
1114 
1115 static int bpf_fill_alu32_add_reg(struct bpf_test *self)
1116 {
1117 	return __bpf_fill_alu32_reg(self, BPF_ADD);
1118 }
1119 
1120 static int bpf_fill_alu32_sub_reg(struct bpf_test *self)
1121 {
1122 	return __bpf_fill_alu32_reg(self, BPF_SUB);
1123 }
1124 
1125 static int bpf_fill_alu32_mul_reg(struct bpf_test *self)
1126 {
1127 	return __bpf_fill_alu32_reg(self, BPF_MUL);
1128 }
1129 
1130 static int bpf_fill_alu32_div_reg(struct bpf_test *self)
1131 {
1132 	return __bpf_fill_alu32_reg(self, BPF_DIV);
1133 }
1134 
1135 static int bpf_fill_alu32_mod_reg(struct bpf_test *self)
1136 {
1137 	return __bpf_fill_alu32_reg(self, BPF_MOD);
1138 }
1139 
1140 /*
1141  * Exhaustive tests of atomic operations for all power-of-two operand
1142  * magnitudes, both for positive and negative values.
1143  */
1144 
1145 static int __bpf_emit_atomic64(struct bpf_test *self, void *arg,
1146 			       struct bpf_insn *insns, s64 dst, s64 src)
1147 {
1148 	int op = *(int *)arg;
1149 	u64 keep, fetch, res;
1150 	int i = 0;
1151 
1152 	if (!insns)
1153 		return 21;
1154 
1155 	switch (op) {
1156 	case BPF_XCHG:
1157 		res = src;
1158 		break;
1159 	default:
1160 		__bpf_alu_result(&res, dst, src, BPF_OP(op));
1161 	}
1162 
1163 	keep = 0x0123456789abcdefULL;
1164 	if (op & BPF_FETCH)
1165 		fetch = dst;
1166 	else
1167 		fetch = src;
1168 
1169 	i += __bpf_ld_imm64(&insns[i], R0, keep);
1170 	i += __bpf_ld_imm64(&insns[i], R1, dst);
1171 	i += __bpf_ld_imm64(&insns[i], R2, src);
1172 	i += __bpf_ld_imm64(&insns[i], R3, res);
1173 	i += __bpf_ld_imm64(&insns[i], R4, fetch);
1174 	i += __bpf_ld_imm64(&insns[i], R5, keep);
1175 
1176 	insns[i++] = BPF_STX_MEM(BPF_DW, R10, R1, -8);
1177 	insns[i++] = BPF_ATOMIC_OP(BPF_DW, op, R10, R2, -8);
1178 	insns[i++] = BPF_LDX_MEM(BPF_DW, R1, R10, -8);
1179 
1180 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
1181 	insns[i++] = BPF_EXIT_INSN();
1182 
1183 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R2, R4, 1);
1184 	insns[i++] = BPF_EXIT_INSN();
1185 
1186 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R5, 1);
1187 	insns[i++] = BPF_EXIT_INSN();
1188 
1189 	return i;
1190 }
1191 
1192 static int __bpf_emit_atomic32(struct bpf_test *self, void *arg,
1193 			       struct bpf_insn *insns, s64 dst, s64 src)
1194 {
1195 	int op = *(int *)arg;
1196 	u64 keep, fetch, res;
1197 	int i = 0;
1198 
1199 	if (!insns)
1200 		return 21;
1201 
1202 	switch (op) {
1203 	case BPF_XCHG:
1204 		res = src;
1205 		break;
1206 	default:
1207 		__bpf_alu_result(&res, (u32)dst, (u32)src, BPF_OP(op));
1208 	}
1209 
1210 	keep = 0x0123456789abcdefULL;
1211 	if (op & BPF_FETCH)
1212 		fetch = (u32)dst;
1213 	else
1214 		fetch = src;
1215 
1216 	i += __bpf_ld_imm64(&insns[i], R0, keep);
1217 	i += __bpf_ld_imm64(&insns[i], R1, (u32)dst);
1218 	i += __bpf_ld_imm64(&insns[i], R2, src);
1219 	i += __bpf_ld_imm64(&insns[i], R3, (u32)res);
1220 	i += __bpf_ld_imm64(&insns[i], R4, fetch);
1221 	i += __bpf_ld_imm64(&insns[i], R5, keep);
1222 
1223 	insns[i++] = BPF_STX_MEM(BPF_W, R10, R1, -4);
1224 	insns[i++] = BPF_ATOMIC_OP(BPF_W, op, R10, R2, -4);
1225 	insns[i++] = BPF_LDX_MEM(BPF_W, R1, R10, -4);
1226 
1227 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
1228 	insns[i++] = BPF_EXIT_INSN();
1229 
1230 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R2, R4, 1);
1231 	insns[i++] = BPF_EXIT_INSN();
1232 
1233 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R5, 1);
1234 	insns[i++] = BPF_EXIT_INSN();
1235 
1236 	return i;
1237 }
1238 
1239 static int __bpf_emit_cmpxchg64(struct bpf_test *self, void *arg,
1240 				struct bpf_insn *insns, s64 dst, s64 src)
1241 {
1242 	int i = 0;
1243 
1244 	if (!insns)
1245 		return 23;
1246 
1247 	i += __bpf_ld_imm64(&insns[i], R0, ~dst);
1248 	i += __bpf_ld_imm64(&insns[i], R1, dst);
1249 	i += __bpf_ld_imm64(&insns[i], R2, src);
1250 
1251 	/* Result unsuccessful */
1252 	insns[i++] = BPF_STX_MEM(BPF_DW, R10, R1, -8);
1253 	insns[i++] = BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -8);
1254 	insns[i++] = BPF_LDX_MEM(BPF_DW, R3, R10, -8);
1255 
1256 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 2);
1257 	insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1258 	insns[i++] = BPF_EXIT_INSN();
1259 
1260 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R3, 2);
1261 	insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1262 	insns[i++] = BPF_EXIT_INSN();
1263 
1264 	/* Result successful */
1265 	insns[i++] = BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -8);
1266 	insns[i++] = BPF_LDX_MEM(BPF_DW, R3, R10, -8);
1267 
1268 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R2, R3, 2);
1269 	insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1270 	insns[i++] = BPF_EXIT_INSN();
1271 
1272 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R1, 2);
1273 	insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1274 	insns[i++] = BPF_EXIT_INSN();
1275 
1276 	return i;
1277 }
1278 
1279 static int __bpf_emit_cmpxchg32(struct bpf_test *self, void *arg,
1280 				struct bpf_insn *insns, s64 dst, s64 src)
1281 {
1282 	int i = 0;
1283 
1284 	if (!insns)
1285 		return 27;
1286 
1287 	i += __bpf_ld_imm64(&insns[i], R0, ~dst);
1288 	i += __bpf_ld_imm64(&insns[i], R1, (u32)dst);
1289 	i += __bpf_ld_imm64(&insns[i], R2, src);
1290 
1291 	/* Result unsuccessful */
1292 	insns[i++] = BPF_STX_MEM(BPF_W, R10, R1, -4);
1293 	insns[i++] = BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R2, -4);
1294 	insns[i++] = BPF_ZEXT_REG(R0), /* Zext always inserted by verifier */
1295 	insns[i++] = BPF_LDX_MEM(BPF_W, R3, R10, -4);
1296 
1297 	insns[i++] = BPF_JMP32_REG(BPF_JEQ, R1, R3, 2);
1298 	insns[i++] = BPF_MOV32_IMM(R0, __LINE__);
1299 	insns[i++] = BPF_EXIT_INSN();
1300 
1301 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R3, 2);
1302 	insns[i++] = BPF_MOV32_IMM(R0, __LINE__);
1303 	insns[i++] = BPF_EXIT_INSN();
1304 
1305 	/* Result successful */
1306 	i += __bpf_ld_imm64(&insns[i], R0, dst);
1307 	insns[i++] = BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R2, -4);
1308 	insns[i++] = BPF_ZEXT_REG(R0), /* Zext always inserted by verifier */
1309 	insns[i++] = BPF_LDX_MEM(BPF_W, R3, R10, -4);
1310 
1311 	insns[i++] = BPF_JMP32_REG(BPF_JEQ, R2, R3, 2);
1312 	insns[i++] = BPF_MOV32_IMM(R0, __LINE__);
1313 	insns[i++] = BPF_EXIT_INSN();
1314 
1315 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R1, 2);
1316 	insns[i++] = BPF_MOV32_IMM(R0, __LINE__);
1317 	insns[i++] = BPF_EXIT_INSN();
1318 
1319 	return i;
1320 }
1321 
1322 static int __bpf_fill_atomic64(struct bpf_test *self, int op)
1323 {
1324 	return __bpf_fill_pattern(self, &op, 64, 64,
1325 				  0, PATTERN_BLOCK2,
1326 				  &__bpf_emit_atomic64);
1327 }
1328 
1329 static int __bpf_fill_atomic32(struct bpf_test *self, int op)
1330 {
1331 	return __bpf_fill_pattern(self, &op, 64, 64,
1332 				  0, PATTERN_BLOCK2,
1333 				  &__bpf_emit_atomic32);
1334 }
1335 
1336 /* 64-bit atomic operations */
1337 static int bpf_fill_atomic64_add(struct bpf_test *self)
1338 {
1339 	return __bpf_fill_atomic64(self, BPF_ADD);
1340 }
1341 
1342 static int bpf_fill_atomic64_and(struct bpf_test *self)
1343 {
1344 	return __bpf_fill_atomic64(self, BPF_AND);
1345 }
1346 
1347 static int bpf_fill_atomic64_or(struct bpf_test *self)
1348 {
1349 	return __bpf_fill_atomic64(self, BPF_OR);
1350 }
1351 
1352 static int bpf_fill_atomic64_xor(struct bpf_test *self)
1353 {
1354 	return __bpf_fill_atomic64(self, BPF_XOR);
1355 }
1356 
1357 static int bpf_fill_atomic64_add_fetch(struct bpf_test *self)
1358 {
1359 	return __bpf_fill_atomic64(self, BPF_ADD | BPF_FETCH);
1360 }
1361 
1362 static int bpf_fill_atomic64_and_fetch(struct bpf_test *self)
1363 {
1364 	return __bpf_fill_atomic64(self, BPF_AND | BPF_FETCH);
1365 }
1366 
1367 static int bpf_fill_atomic64_or_fetch(struct bpf_test *self)
1368 {
1369 	return __bpf_fill_atomic64(self, BPF_OR | BPF_FETCH);
1370 }
1371 
1372 static int bpf_fill_atomic64_xor_fetch(struct bpf_test *self)
1373 {
1374 	return __bpf_fill_atomic64(self, BPF_XOR | BPF_FETCH);
1375 }
1376 
1377 static int bpf_fill_atomic64_xchg(struct bpf_test *self)
1378 {
1379 	return __bpf_fill_atomic64(self, BPF_XCHG);
1380 }
1381 
1382 static int bpf_fill_cmpxchg64(struct bpf_test *self)
1383 {
1384 	return __bpf_fill_pattern(self, NULL, 64, 64, 0, PATTERN_BLOCK2,
1385 				  &__bpf_emit_cmpxchg64);
1386 }
1387 
1388 /* 32-bit atomic operations */
1389 static int bpf_fill_atomic32_add(struct bpf_test *self)
1390 {
1391 	return __bpf_fill_atomic32(self, BPF_ADD);
1392 }
1393 
1394 static int bpf_fill_atomic32_and(struct bpf_test *self)
1395 {
1396 	return __bpf_fill_atomic32(self, BPF_AND);
1397 }
1398 
1399 static int bpf_fill_atomic32_or(struct bpf_test *self)
1400 {
1401 	return __bpf_fill_atomic32(self, BPF_OR);
1402 }
1403 
1404 static int bpf_fill_atomic32_xor(struct bpf_test *self)
1405 {
1406 	return __bpf_fill_atomic32(self, BPF_XOR);
1407 }
1408 
1409 static int bpf_fill_atomic32_add_fetch(struct bpf_test *self)
1410 {
1411 	return __bpf_fill_atomic32(self, BPF_ADD | BPF_FETCH);
1412 }
1413 
1414 static int bpf_fill_atomic32_and_fetch(struct bpf_test *self)
1415 {
1416 	return __bpf_fill_atomic32(self, BPF_AND | BPF_FETCH);
1417 }
1418 
1419 static int bpf_fill_atomic32_or_fetch(struct bpf_test *self)
1420 {
1421 	return __bpf_fill_atomic32(self, BPF_OR | BPF_FETCH);
1422 }
1423 
1424 static int bpf_fill_atomic32_xor_fetch(struct bpf_test *self)
1425 {
1426 	return __bpf_fill_atomic32(self, BPF_XOR | BPF_FETCH);
1427 }
1428 
1429 static int bpf_fill_atomic32_xchg(struct bpf_test *self)
1430 {
1431 	return __bpf_fill_atomic32(self, BPF_XCHG);
1432 }
1433 
1434 static int bpf_fill_cmpxchg32(struct bpf_test *self)
1435 {
1436 	return __bpf_fill_pattern(self, NULL, 64, 64, 0, PATTERN_BLOCK2,
1437 				  &__bpf_emit_cmpxchg32);
1438 }
1439 
1440 /*
1441  * Test the two-instruction 64-bit immediate load operation for all
1442  * power-of-two magnitudes of the immediate operand. For each MSB, a block
1443  * of immediate values centered around the power-of-two MSB are tested,
1444  * both for positive and negative values. The test is designed to verify
1445  * the operation for JITs that emit different code depending on the magnitude
1446  * of the immediate value. This is often the case if the native instruction
1447  * immediate field width is narrower than 32 bits.
1448  */
1449 static int bpf_fill_ld_imm64(struct bpf_test *self)
1450 {
1451 	int block = 64; /* Increase for more tests per MSB position */
1452 	int len = 3 + 8 * 63 * block * 2;
1453 	struct bpf_insn *insn;
1454 	int bit, adj, sign;
1455 	int i = 0;
1456 
1457 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
1458 	if (!insn)
1459 		return -ENOMEM;
1460 
1461 	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
1462 
1463 	for (bit = 0; bit <= 62; bit++) {
1464 		for (adj = -block / 2; adj < block / 2; adj++) {
1465 			for (sign = -1; sign <= 1; sign += 2) {
1466 				s64 imm = sign * ((1LL << bit) + adj);
1467 
1468 				/* Perform operation */
1469 				i += __bpf_ld_imm64(&insn[i], R1, imm);
1470 
1471 				/* Load reference */
1472 				insn[i++] = BPF_ALU32_IMM(BPF_MOV, R2, imm);
1473 				insn[i++] = BPF_ALU32_IMM(BPF_MOV, R3,
1474 							  (u32)(imm >> 32));
1475 				insn[i++] = BPF_ALU64_IMM(BPF_LSH, R3, 32);
1476 				insn[i++] = BPF_ALU64_REG(BPF_OR, R2, R3);
1477 
1478 				/* Check result */
1479 				insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R2, 1);
1480 				insn[i++] = BPF_EXIT_INSN();
1481 			}
1482 		}
1483 	}
1484 
1485 	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
1486 	insn[i++] = BPF_EXIT_INSN();
1487 
1488 	self->u.ptr.insns = insn;
1489 	self->u.ptr.len = len;
1490 	BUG_ON(i != len);
1491 
1492 	return 0;
1493 }
1494 
1495 /*
1496  * Exhaustive tests of JMP operations for all combinations of power-of-two
1497  * magnitudes of the operands, both for positive and negative values. The
1498  * test is designed to verify e.g. the JMP and JMP32 operations for JITs that
1499  * emit different code depending on the magnitude of the immediate value.
1500  */
1501 
1502 static bool __bpf_match_jmp_cond(s64 v1, s64 v2, u8 op)
1503 {
1504 	switch (op) {
1505 	case BPF_JSET:
1506 		return !!(v1 & v2);
1507 	case BPF_JEQ:
1508 		return v1 == v2;
1509 	case BPF_JNE:
1510 		return v1 != v2;
1511 	case BPF_JGT:
1512 		return (u64)v1 > (u64)v2;
1513 	case BPF_JGE:
1514 		return (u64)v1 >= (u64)v2;
1515 	case BPF_JLT:
1516 		return (u64)v1 < (u64)v2;
1517 	case BPF_JLE:
1518 		return (u64)v1 <= (u64)v2;
1519 	case BPF_JSGT:
1520 		return v1 > v2;
1521 	case BPF_JSGE:
1522 		return v1 >= v2;
1523 	case BPF_JSLT:
1524 		return v1 < v2;
1525 	case BPF_JSLE:
1526 		return v1 <= v2;
1527 	}
1528 	return false;
1529 }
1530 
1531 static int __bpf_emit_jmp_imm(struct bpf_test *self, void *arg,
1532 			      struct bpf_insn *insns, s64 dst, s64 imm)
1533 {
1534 	int op = *(int *)arg;
1535 
1536 	if (insns) {
1537 		bool match = __bpf_match_jmp_cond(dst, (s32)imm, op);
1538 		int i = 0;
1539 
1540 		insns[i++] = BPF_ALU32_IMM(BPF_MOV, R0, match);
1541 
1542 		i += __bpf_ld_imm64(&insns[i], R1, dst);
1543 		insns[i++] = BPF_JMP_IMM(op, R1, imm, 1);
1544 		if (!match)
1545 			insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
1546 		insns[i++] = BPF_EXIT_INSN();
1547 
1548 		return i;
1549 	}
1550 
1551 	return 5 + 1;
1552 }
1553 
1554 static int __bpf_emit_jmp32_imm(struct bpf_test *self, void *arg,
1555 				struct bpf_insn *insns, s64 dst, s64 imm)
1556 {
1557 	int op = *(int *)arg;
1558 
1559 	if (insns) {
1560 		bool match = __bpf_match_jmp_cond((s32)dst, (s32)imm, op);
1561 		int i = 0;
1562 
1563 		i += __bpf_ld_imm64(&insns[i], R1, dst);
1564 		insns[i++] = BPF_JMP32_IMM(op, R1, imm, 1);
1565 		if (!match)
1566 			insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
1567 		insns[i++] = BPF_EXIT_INSN();
1568 
1569 		return i;
1570 	}
1571 
1572 	return 5;
1573 }
1574 
1575 static int __bpf_emit_jmp_reg(struct bpf_test *self, void *arg,
1576 			      struct bpf_insn *insns, s64 dst, s64 src)
1577 {
1578 	int op = *(int *)arg;
1579 
1580 	if (insns) {
1581 		bool match = __bpf_match_jmp_cond(dst, src, op);
1582 		int i = 0;
1583 
1584 		i += __bpf_ld_imm64(&insns[i], R1, dst);
1585 		i += __bpf_ld_imm64(&insns[i], R2, src);
1586 		insns[i++] = BPF_JMP_REG(op, R1, R2, 1);
1587 		if (!match)
1588 			insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
1589 		insns[i++] = BPF_EXIT_INSN();
1590 
1591 		return i;
1592 	}
1593 
1594 	return 7;
1595 }
1596 
1597 static int __bpf_emit_jmp32_reg(struct bpf_test *self, void *arg,
1598 				struct bpf_insn *insns, s64 dst, s64 src)
1599 {
1600 	int op = *(int *)arg;
1601 
1602 	if (insns) {
1603 		bool match = __bpf_match_jmp_cond((s32)dst, (s32)src, op);
1604 		int i = 0;
1605 
1606 		i += __bpf_ld_imm64(&insns[i], R1, dst);
1607 		i += __bpf_ld_imm64(&insns[i], R2, src);
1608 		insns[i++] = BPF_JMP32_REG(op, R1, R2, 1);
1609 		if (!match)
1610 			insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
1611 		insns[i++] = BPF_EXIT_INSN();
1612 
1613 		return i;
1614 	}
1615 
1616 	return 7;
1617 }
1618 
1619 static int __bpf_fill_jmp_imm(struct bpf_test *self, int op)
1620 {
1621 	return __bpf_fill_pattern(self, &op, 64, 32,
1622 				  PATTERN_BLOCK1, PATTERN_BLOCK2,
1623 				  &__bpf_emit_jmp_imm);
1624 }
1625 
1626 static int __bpf_fill_jmp32_imm(struct bpf_test *self, int op)
1627 {
1628 	return __bpf_fill_pattern(self, &op, 64, 32,
1629 				  PATTERN_BLOCK1, PATTERN_BLOCK2,
1630 				  &__bpf_emit_jmp32_imm);
1631 }
1632 
1633 static int __bpf_fill_jmp_reg(struct bpf_test *self, int op)
1634 {
1635 	return __bpf_fill_pattern(self, &op, 64, 64,
1636 				  PATTERN_BLOCK1, PATTERN_BLOCK2,
1637 				  &__bpf_emit_jmp_reg);
1638 }
1639 
1640 static int __bpf_fill_jmp32_reg(struct bpf_test *self, int op)
1641 {
1642 	return __bpf_fill_pattern(self, &op, 64, 64,
1643 				  PATTERN_BLOCK1, PATTERN_BLOCK2,
1644 				  &__bpf_emit_jmp32_reg);
1645 }
1646 
1647 /* JMP immediate tests */
1648 static int bpf_fill_jmp_jset_imm(struct bpf_test *self)
1649 {
1650 	return __bpf_fill_jmp_imm(self, BPF_JSET);
1651 }
1652 
1653 static int bpf_fill_jmp_jeq_imm(struct bpf_test *self)
1654 {
1655 	return __bpf_fill_jmp_imm(self, BPF_JEQ);
1656 }
1657 
1658 static int bpf_fill_jmp_jne_imm(struct bpf_test *self)
1659 {
1660 	return __bpf_fill_jmp_imm(self, BPF_JNE);
1661 }
1662 
1663 static int bpf_fill_jmp_jgt_imm(struct bpf_test *self)
1664 {
1665 	return __bpf_fill_jmp_imm(self, BPF_JGT);
1666 }
1667 
1668 static int bpf_fill_jmp_jge_imm(struct bpf_test *self)
1669 {
1670 	return __bpf_fill_jmp_imm(self, BPF_JGE);
1671 }
1672 
1673 static int bpf_fill_jmp_jlt_imm(struct bpf_test *self)
1674 {
1675 	return __bpf_fill_jmp_imm(self, BPF_JLT);
1676 }
1677 
1678 static int bpf_fill_jmp_jle_imm(struct bpf_test *self)
1679 {
1680 	return __bpf_fill_jmp_imm(self, BPF_JLE);
1681 }
1682 
1683 static int bpf_fill_jmp_jsgt_imm(struct bpf_test *self)
1684 {
1685 	return __bpf_fill_jmp_imm(self, BPF_JSGT);
1686 }
1687 
1688 static int bpf_fill_jmp_jsge_imm(struct bpf_test *self)
1689 {
1690 	return __bpf_fill_jmp_imm(self, BPF_JSGE);
1691 }
1692 
1693 static int bpf_fill_jmp_jslt_imm(struct bpf_test *self)
1694 {
1695 	return __bpf_fill_jmp_imm(self, BPF_JSLT);
1696 }
1697 
1698 static int bpf_fill_jmp_jsle_imm(struct bpf_test *self)
1699 {
1700 	return __bpf_fill_jmp_imm(self, BPF_JSLE);
1701 }
1702 
1703 /* JMP32 immediate tests */
1704 static int bpf_fill_jmp32_jset_imm(struct bpf_test *self)
1705 {
1706 	return __bpf_fill_jmp32_imm(self, BPF_JSET);
1707 }
1708 
1709 static int bpf_fill_jmp32_jeq_imm(struct bpf_test *self)
1710 {
1711 	return __bpf_fill_jmp32_imm(self, BPF_JEQ);
1712 }
1713 
1714 static int bpf_fill_jmp32_jne_imm(struct bpf_test *self)
1715 {
1716 	return __bpf_fill_jmp32_imm(self, BPF_JNE);
1717 }
1718 
1719 static int bpf_fill_jmp32_jgt_imm(struct bpf_test *self)
1720 {
1721 	return __bpf_fill_jmp32_imm(self, BPF_JGT);
1722 }
1723 
1724 static int bpf_fill_jmp32_jge_imm(struct bpf_test *self)
1725 {
1726 	return __bpf_fill_jmp32_imm(self, BPF_JGE);
1727 }
1728 
1729 static int bpf_fill_jmp32_jlt_imm(struct bpf_test *self)
1730 {
1731 	return __bpf_fill_jmp32_imm(self, BPF_JLT);
1732 }
1733 
1734 static int bpf_fill_jmp32_jle_imm(struct bpf_test *self)
1735 {
1736 	return __bpf_fill_jmp32_imm(self, BPF_JLE);
1737 }
1738 
1739 static int bpf_fill_jmp32_jsgt_imm(struct bpf_test *self)
1740 {
1741 	return __bpf_fill_jmp32_imm(self, BPF_JSGT);
1742 }
1743 
1744 static int bpf_fill_jmp32_jsge_imm(struct bpf_test *self)
1745 {
1746 	return __bpf_fill_jmp32_imm(self, BPF_JSGE);
1747 }
1748 
1749 static int bpf_fill_jmp32_jslt_imm(struct bpf_test *self)
1750 {
1751 	return __bpf_fill_jmp32_imm(self, BPF_JSLT);
1752 }
1753 
1754 static int bpf_fill_jmp32_jsle_imm(struct bpf_test *self)
1755 {
1756 	return __bpf_fill_jmp32_imm(self, BPF_JSLE);
1757 }
1758 
1759 /* JMP register tests */
1760 static int bpf_fill_jmp_jset_reg(struct bpf_test *self)
1761 {
1762 	return __bpf_fill_jmp_reg(self, BPF_JSET);
1763 }
1764 
1765 static int bpf_fill_jmp_jeq_reg(struct bpf_test *self)
1766 {
1767 	return __bpf_fill_jmp_reg(self, BPF_JEQ);
1768 }
1769 
1770 static int bpf_fill_jmp_jne_reg(struct bpf_test *self)
1771 {
1772 	return __bpf_fill_jmp_reg(self, BPF_JNE);
1773 }
1774 
1775 static int bpf_fill_jmp_jgt_reg(struct bpf_test *self)
1776 {
1777 	return __bpf_fill_jmp_reg(self, BPF_JGT);
1778 }
1779 
1780 static int bpf_fill_jmp_jge_reg(struct bpf_test *self)
1781 {
1782 	return __bpf_fill_jmp_reg(self, BPF_JGE);
1783 }
1784 
1785 static int bpf_fill_jmp_jlt_reg(struct bpf_test *self)
1786 {
1787 	return __bpf_fill_jmp_reg(self, BPF_JLT);
1788 }
1789 
1790 static int bpf_fill_jmp_jle_reg(struct bpf_test *self)
1791 {
1792 	return __bpf_fill_jmp_reg(self, BPF_JLE);
1793 }
1794 
1795 static int bpf_fill_jmp_jsgt_reg(struct bpf_test *self)
1796 {
1797 	return __bpf_fill_jmp_reg(self, BPF_JSGT);
1798 }
1799 
1800 static int bpf_fill_jmp_jsge_reg(struct bpf_test *self)
1801 {
1802 	return __bpf_fill_jmp_reg(self, BPF_JSGE);
1803 }
1804 
1805 static int bpf_fill_jmp_jslt_reg(struct bpf_test *self)
1806 {
1807 	return __bpf_fill_jmp_reg(self, BPF_JSLT);
1808 }
1809 
1810 static int bpf_fill_jmp_jsle_reg(struct bpf_test *self)
1811 {
1812 	return __bpf_fill_jmp_reg(self, BPF_JSLE);
1813 }
1814 
1815 /* JMP32 register tests */
1816 static int bpf_fill_jmp32_jset_reg(struct bpf_test *self)
1817 {
1818 	return __bpf_fill_jmp32_reg(self, BPF_JSET);
1819 }
1820 
1821 static int bpf_fill_jmp32_jeq_reg(struct bpf_test *self)
1822 {
1823 	return __bpf_fill_jmp32_reg(self, BPF_JEQ);
1824 }
1825 
1826 static int bpf_fill_jmp32_jne_reg(struct bpf_test *self)
1827 {
1828 	return __bpf_fill_jmp32_reg(self, BPF_JNE);
1829 }
1830 
1831 static int bpf_fill_jmp32_jgt_reg(struct bpf_test *self)
1832 {
1833 	return __bpf_fill_jmp32_reg(self, BPF_JGT);
1834 }
1835 
1836 static int bpf_fill_jmp32_jge_reg(struct bpf_test *self)
1837 {
1838 	return __bpf_fill_jmp32_reg(self, BPF_JGE);
1839 }
1840 
1841 static int bpf_fill_jmp32_jlt_reg(struct bpf_test *self)
1842 {
1843 	return __bpf_fill_jmp32_reg(self, BPF_JLT);
1844 }
1845 
1846 static int bpf_fill_jmp32_jle_reg(struct bpf_test *self)
1847 {
1848 	return __bpf_fill_jmp32_reg(self, BPF_JLE);
1849 }
1850 
1851 static int bpf_fill_jmp32_jsgt_reg(struct bpf_test *self)
1852 {
1853 	return __bpf_fill_jmp32_reg(self, BPF_JSGT);
1854 }
1855 
1856 static int bpf_fill_jmp32_jsge_reg(struct bpf_test *self)
1857 {
1858 	return __bpf_fill_jmp32_reg(self, BPF_JSGE);
1859 }
1860 
1861 static int bpf_fill_jmp32_jslt_reg(struct bpf_test *self)
1862 {
1863 	return __bpf_fill_jmp32_reg(self, BPF_JSLT);
1864 }
1865 
1866 static int bpf_fill_jmp32_jsle_reg(struct bpf_test *self)
1867 {
1868 	return __bpf_fill_jmp32_reg(self, BPF_JSLE);
1869 }
1870 
1871 /*
1872  * Set up a sequence of staggered jumps, forwards and backwards with
1873  * increasing offset. This tests the conversion of relative jumps to
1874  * JITed native jumps. On some architectures, for example MIPS, a large
1875  * PC-relative jump offset may overflow the immediate field of the native
1876  * conditional branch instruction, triggering a conversion to use an
1877  * absolute jump instead. Since this changes the jump offsets, another
1878  * offset computation pass is necessary, and that may in turn trigger
1879  * another branch conversion. This jump sequence is particularly nasty
1880  * in that regard.
1881  *
1882  * The sequence generation is parameterized by size and jump type.
1883  * The size must be even, and the expected result is always size + 1.
1884  * Below is an example with size=8 and result=9.
1885  *
1886  *                     ________________________Start
1887  *                     R0 = 0
1888  *                     R1 = r1
1889  *                     R2 = r2
1890  *            ,------- JMP +4 * 3______________Preamble: 4 insns
1891  * ,----------|-ind 0- if R0 != 7 JMP 8 * 3 + 1 <--------------------.
1892  * |          |        R0 = 8                                        |
1893  * |          |        JMP +7 * 3               ------------------------.
1894  * | ,--------|-----1- if R0 != 5 JMP 7 * 3 + 1 <--------------.     |  |
1895  * | |        |        R0 = 6                                  |     |  |
1896  * | |        |        JMP +5 * 3               ------------------.  |  |
1897  * | | ,------|-----2- if R0 != 3 JMP 6 * 3 + 1 <--------.     |  |  |  |
1898  * | | |      |        R0 = 4                            |     |  |  |  |
1899  * | | |      |        JMP +3 * 3               ------------.  |  |  |  |
1900  * | | | ,----|-----3- if R0 != 1 JMP 5 * 3 + 1 <--.     |  |  |  |  |  |
1901  * | | | |    |        R0 = 2                      |     |  |  |  |  |  |
1902  * | | | |    |        JMP +1 * 3               ------.  |  |  |  |  |  |
1903  * | | | | ,--t=====4> if R0 != 0 JMP 4 * 3 + 1    1  2  3  4  5  6  7  8 loc
1904  * | | | | |           R0 = 1                     -1 +2 -3 +4 -5 +6 -7 +8 off
1905  * | | | | |           JMP -2 * 3               ---'  |  |  |  |  |  |  |
1906  * | | | | | ,------5- if R0 != 2 JMP 3 * 3 + 1 <-----'  |  |  |  |  |  |
1907  * | | | | | |         R0 = 3                            |  |  |  |  |  |
1908  * | | | | | |         JMP -4 * 3               ---------'  |  |  |  |  |
1909  * | | | | | | ,----6- if R0 != 4 JMP 2 * 3 + 1 <-----------'  |  |  |  |
1910  * | | | | | | |       R0 = 5                                  |  |  |  |
1911  * | | | | | | |       JMP -6 * 3               ---------------'  |  |  |
1912  * | | | | | | | ,--7- if R0 != 6 JMP 1 * 3 + 1 <-----------------'  |  |
1913  * | | | | | | | |     R0 = 7                                        |  |
1914  * | | Error | | |     JMP -8 * 3               ---------------------'  |
1915  * | | paths | | | ,8- if R0 != 8 JMP 0 * 3 + 1 <-----------------------'
1916  * | | | | | | | | |   R0 = 9__________________Sequence: 3 * size - 1 insns
1917  * `-+-+-+-+-+-+-+-+-> EXIT____________________Return: 1 insn
1918  *
1919  */
1920 
1921 /* The maximum size parameter */
1922 #define MAX_STAGGERED_JMP_SIZE ((0x7fff / 3) & ~1)
1923 
1924 /* We use a reduced number of iterations to get a reasonable execution time */
1925 #define NR_STAGGERED_JMP_RUNS 10
1926 
1927 static int __bpf_fill_staggered_jumps(struct bpf_test *self,
1928 				      const struct bpf_insn *jmp,
1929 				      u64 r1, u64 r2)
1930 {
1931 	int size = self->test[0].result - 1;
1932 	int len = 4 + 3 * (size + 1);
1933 	struct bpf_insn *insns;
1934 	int off, ind;
1935 
1936 	insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL);
1937 	if (!insns)
1938 		return -ENOMEM;
1939 
1940 	/* Preamble */
1941 	insns[0] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
1942 	insns[1] = BPF_ALU64_IMM(BPF_MOV, R1, r1);
1943 	insns[2] = BPF_ALU64_IMM(BPF_MOV, R2, r2);
1944 	insns[3] = BPF_JMP_IMM(BPF_JA, 0, 0, 3 * size / 2);
1945 
1946 	/* Sequence */
1947 	for (ind = 0, off = size; ind <= size; ind++, off -= 2) {
1948 		struct bpf_insn *ins = &insns[4 + 3 * ind];
1949 		int loc;
1950 
1951 		if (off == 0)
1952 			off--;
1953 
1954 		loc = abs(off);
1955 		ins[0] = BPF_JMP_IMM(BPF_JNE, R0, loc - 1,
1956 				     3 * (size - ind) + 1);
1957 		ins[1] = BPF_ALU64_IMM(BPF_MOV, R0, loc);
1958 		ins[2] = *jmp;
1959 		ins[2].off = 3 * (off - 1);
1960 	}
1961 
1962 	/* Return */
1963 	insns[len - 1] = BPF_EXIT_INSN();
1964 
1965 	self->u.ptr.insns = insns;
1966 	self->u.ptr.len = len;
1967 
1968 	return 0;
1969 }
1970 
1971 /* 64-bit unconditional jump */
1972 static int bpf_fill_staggered_ja(struct bpf_test *self)
1973 {
1974 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JA, 0, 0, 0);
1975 
1976 	return __bpf_fill_staggered_jumps(self, &jmp, 0, 0);
1977 }
1978 
1979 /* 64-bit immediate jumps */
1980 static int bpf_fill_staggered_jeq_imm(struct bpf_test *self)
1981 {
1982 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JEQ, R1, 1234, 0);
1983 
1984 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
1985 }
1986 
1987 static int bpf_fill_staggered_jne_imm(struct bpf_test *self)
1988 {
1989 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JNE, R1, 1234, 0);
1990 
1991 	return __bpf_fill_staggered_jumps(self, &jmp, 4321, 0);
1992 }
1993 
1994 static int bpf_fill_staggered_jset_imm(struct bpf_test *self)
1995 {
1996 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSET, R1, 0x82, 0);
1997 
1998 	return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0);
1999 }
2000 
2001 static int bpf_fill_staggered_jgt_imm(struct bpf_test *self)
2002 {
2003 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JGT, R1, 1234, 0);
2004 
2005 	return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 0);
2006 }
2007 
2008 static int bpf_fill_staggered_jge_imm(struct bpf_test *self)
2009 {
2010 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JGE, R1, 1234, 0);
2011 
2012 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2013 }
2014 
2015 static int bpf_fill_staggered_jlt_imm(struct bpf_test *self)
2016 {
2017 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JLT, R1, 0x80000000, 0);
2018 
2019 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2020 }
2021 
2022 static int bpf_fill_staggered_jle_imm(struct bpf_test *self)
2023 {
2024 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JLE, R1, 1234, 0);
2025 
2026 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2027 }
2028 
2029 static int bpf_fill_staggered_jsgt_imm(struct bpf_test *self)
2030 {
2031 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSGT, R1, -2, 0);
2032 
2033 	return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
2034 }
2035 
2036 static int bpf_fill_staggered_jsge_imm(struct bpf_test *self)
2037 {
2038 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSGE, R1, -2, 0);
2039 
2040 	return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
2041 }
2042 
2043 static int bpf_fill_staggered_jslt_imm(struct bpf_test *self)
2044 {
2045 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSLT, R1, -1, 0);
2046 
2047 	return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
2048 }
2049 
2050 static int bpf_fill_staggered_jsle_imm(struct bpf_test *self)
2051 {
2052 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSLE, R1, -1, 0);
2053 
2054 	return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
2055 }
2056 
2057 /* 64-bit register jumps */
2058 static int bpf_fill_staggered_jeq_reg(struct bpf_test *self)
2059 {
2060 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JEQ, R1, R2, 0);
2061 
2062 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
2063 }
2064 
2065 static int bpf_fill_staggered_jne_reg(struct bpf_test *self)
2066 {
2067 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JNE, R1, R2, 0);
2068 
2069 	return __bpf_fill_staggered_jumps(self, &jmp, 4321, 1234);
2070 }
2071 
2072 static int bpf_fill_staggered_jset_reg(struct bpf_test *self)
2073 {
2074 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JSET, R1, R2, 0);
2075 
2076 	return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0x82);
2077 }
2078 
2079 static int bpf_fill_staggered_jgt_reg(struct bpf_test *self)
2080 {
2081 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JGT, R1, R2, 0);
2082 
2083 	return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 1234);
2084 }
2085 
2086 static int bpf_fill_staggered_jge_reg(struct bpf_test *self)
2087 {
2088 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JGE, R1, R2, 0);
2089 
2090 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
2091 }
2092 
2093 static int bpf_fill_staggered_jlt_reg(struct bpf_test *self)
2094 {
2095 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JLT, R1, R2, 0);
2096 
2097 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0x80000000);
2098 }
2099 
2100 static int bpf_fill_staggered_jle_reg(struct bpf_test *self)
2101 {
2102 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JLE, R1, R2, 0);
2103 
2104 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
2105 }
2106 
2107 static int bpf_fill_staggered_jsgt_reg(struct bpf_test *self)
2108 {
2109 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JSGT, R1, R2, 0);
2110 
2111 	return __bpf_fill_staggered_jumps(self, &jmp, -1, -2);
2112 }
2113 
2114 static int bpf_fill_staggered_jsge_reg(struct bpf_test *self)
2115 {
2116 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JSGE, R1, R2, 0);
2117 
2118 	return __bpf_fill_staggered_jumps(self, &jmp, -2, -2);
2119 }
2120 
2121 static int bpf_fill_staggered_jslt_reg(struct bpf_test *self)
2122 {
2123 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JSLT, R1, R2, 0);
2124 
2125 	return __bpf_fill_staggered_jumps(self, &jmp, -2, -1);
2126 }
2127 
2128 static int bpf_fill_staggered_jsle_reg(struct bpf_test *self)
2129 {
2130 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JSLE, R1, R2, 0);
2131 
2132 	return __bpf_fill_staggered_jumps(self, &jmp, -1, -1);
2133 }
2134 
2135 /* 32-bit immediate jumps */
2136 static int bpf_fill_staggered_jeq32_imm(struct bpf_test *self)
2137 {
2138 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JEQ, R1, 1234, 0);
2139 
2140 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2141 }
2142 
2143 static int bpf_fill_staggered_jne32_imm(struct bpf_test *self)
2144 {
2145 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JNE, R1, 1234, 0);
2146 
2147 	return __bpf_fill_staggered_jumps(self, &jmp, 4321, 0);
2148 }
2149 
2150 static int bpf_fill_staggered_jset32_imm(struct bpf_test *self)
2151 {
2152 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSET, R1, 0x82, 0);
2153 
2154 	return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0);
2155 }
2156 
2157 static int bpf_fill_staggered_jgt32_imm(struct bpf_test *self)
2158 {
2159 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JGT, R1, 1234, 0);
2160 
2161 	return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 0);
2162 }
2163 
2164 static int bpf_fill_staggered_jge32_imm(struct bpf_test *self)
2165 {
2166 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JGE, R1, 1234, 0);
2167 
2168 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2169 }
2170 
2171 static int bpf_fill_staggered_jlt32_imm(struct bpf_test *self)
2172 {
2173 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JLT, R1, 0x80000000, 0);
2174 
2175 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2176 }
2177 
2178 static int bpf_fill_staggered_jle32_imm(struct bpf_test *self)
2179 {
2180 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JLE, R1, 1234, 0);
2181 
2182 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2183 }
2184 
2185 static int bpf_fill_staggered_jsgt32_imm(struct bpf_test *self)
2186 {
2187 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSGT, R1, -2, 0);
2188 
2189 	return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
2190 }
2191 
2192 static int bpf_fill_staggered_jsge32_imm(struct bpf_test *self)
2193 {
2194 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSGE, R1, -2, 0);
2195 
2196 	return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
2197 }
2198 
2199 static int bpf_fill_staggered_jslt32_imm(struct bpf_test *self)
2200 {
2201 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSLT, R1, -1, 0);
2202 
2203 	return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
2204 }
2205 
2206 static int bpf_fill_staggered_jsle32_imm(struct bpf_test *self)
2207 {
2208 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSLE, R1, -1, 0);
2209 
2210 	return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
2211 }
2212 
2213 /* 32-bit register jumps */
2214 static int bpf_fill_staggered_jeq32_reg(struct bpf_test *self)
2215 {
2216 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JEQ, R1, R2, 0);
2217 
2218 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
2219 }
2220 
2221 static int bpf_fill_staggered_jne32_reg(struct bpf_test *self)
2222 {
2223 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JNE, R1, R2, 0);
2224 
2225 	return __bpf_fill_staggered_jumps(self, &jmp, 4321, 1234);
2226 }
2227 
2228 static int bpf_fill_staggered_jset32_reg(struct bpf_test *self)
2229 {
2230 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSET, R1, R2, 0);
2231 
2232 	return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0x82);
2233 }
2234 
2235 static int bpf_fill_staggered_jgt32_reg(struct bpf_test *self)
2236 {
2237 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JGT, R1, R2, 0);
2238 
2239 	return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 1234);
2240 }
2241 
2242 static int bpf_fill_staggered_jge32_reg(struct bpf_test *self)
2243 {
2244 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JGE, R1, R2, 0);
2245 
2246 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
2247 }
2248 
2249 static int bpf_fill_staggered_jlt32_reg(struct bpf_test *self)
2250 {
2251 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JLT, R1, R2, 0);
2252 
2253 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0x80000000);
2254 }
2255 
2256 static int bpf_fill_staggered_jle32_reg(struct bpf_test *self)
2257 {
2258 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JLE, R1, R2, 0);
2259 
2260 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
2261 }
2262 
2263 static int bpf_fill_staggered_jsgt32_reg(struct bpf_test *self)
2264 {
2265 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSGT, R1, R2, 0);
2266 
2267 	return __bpf_fill_staggered_jumps(self, &jmp, -1, -2);
2268 }
2269 
2270 static int bpf_fill_staggered_jsge32_reg(struct bpf_test *self)
2271 {
2272 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSGE, R1, R2, 0);
2273 
2274 	return __bpf_fill_staggered_jumps(self, &jmp, -2, -2);
2275 }
2276 
2277 static int bpf_fill_staggered_jslt32_reg(struct bpf_test *self)
2278 {
2279 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSLT, R1, R2, 0);
2280 
2281 	return __bpf_fill_staggered_jumps(self, &jmp, -2, -1);
2282 }
2283 
2284 static int bpf_fill_staggered_jsle32_reg(struct bpf_test *self)
2285 {
2286 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSLE, R1, R2, 0);
2287 
2288 	return __bpf_fill_staggered_jumps(self, &jmp, -1, -1);
2289 }
2290 
2291 
2292 static struct bpf_test tests[] = {
2293 	{
2294 		"TAX",
2295 		.u.insns = {
2296 			BPF_STMT(BPF_LD | BPF_IMM, 1),
2297 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
2298 			BPF_STMT(BPF_LD | BPF_IMM, 2),
2299 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2300 			BPF_STMT(BPF_ALU | BPF_NEG, 0), /* A == -3 */
2301 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
2302 			BPF_STMT(BPF_LD | BPF_LEN, 0),
2303 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2304 			BPF_STMT(BPF_MISC | BPF_TAX, 0), /* X == len - 3 */
2305 			BPF_STMT(BPF_LD | BPF_B | BPF_IND, 1),
2306 			BPF_STMT(BPF_RET | BPF_A, 0)
2307 		},
2308 		CLASSIC,
2309 		{ 10, 20, 30, 40, 50 },
2310 		{ { 2, 10 }, { 3, 20 }, { 4, 30 } },
2311 	},
2312 	{
2313 		"TXA",
2314 		.u.insns = {
2315 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
2316 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
2317 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2318 			BPF_STMT(BPF_RET | BPF_A, 0) /* A == len * 2 */
2319 		},
2320 		CLASSIC,
2321 		{ 10, 20, 30, 40, 50 },
2322 		{ { 1, 2 }, { 3, 6 }, { 4, 8 } },
2323 	},
2324 	{
2325 		"ADD_SUB_MUL_K",
2326 		.u.insns = {
2327 			BPF_STMT(BPF_LD | BPF_IMM, 1),
2328 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 2),
2329 			BPF_STMT(BPF_LDX | BPF_IMM, 3),
2330 			BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
2331 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0xffffffff),
2332 			BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 3),
2333 			BPF_STMT(BPF_RET | BPF_A, 0)
2334 		},
2335 		CLASSIC | FLAG_NO_DATA,
2336 		{ },
2337 		{ { 0, 0xfffffffd } }
2338 	},
2339 	{
2340 		"DIV_MOD_KX",
2341 		.u.insns = {
2342 			BPF_STMT(BPF_LD | BPF_IMM, 8),
2343 			BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 2),
2344 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
2345 			BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
2346 			BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
2347 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
2348 			BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
2349 			BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x70000000),
2350 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
2351 			BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
2352 			BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
2353 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
2354 			BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
2355 			BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x70000000),
2356 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2357 			BPF_STMT(BPF_RET | BPF_A, 0)
2358 		},
2359 		CLASSIC | FLAG_NO_DATA,
2360 		{ },
2361 		{ { 0, 0x20000000 } }
2362 	},
2363 	{
2364 		"AND_OR_LSH_K",
2365 		.u.insns = {
2366 			BPF_STMT(BPF_LD | BPF_IMM, 0xff),
2367 			BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
2368 			BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 27),
2369 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
2370 			BPF_STMT(BPF_LD | BPF_IMM, 0xf),
2371 			BPF_STMT(BPF_ALU | BPF_OR | BPF_K, 0xf0),
2372 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2373 			BPF_STMT(BPF_RET | BPF_A, 0)
2374 		},
2375 		CLASSIC | FLAG_NO_DATA,
2376 		{ },
2377 		{ { 0, 0x800000ff }, { 1, 0x800000ff } },
2378 	},
2379 	{
2380 		"LD_IMM_0",
2381 		.u.insns = {
2382 			BPF_STMT(BPF_LD | BPF_IMM, 0), /* ld #0 */
2383 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0, 1, 0),
2384 			BPF_STMT(BPF_RET | BPF_K, 0),
2385 			BPF_STMT(BPF_RET | BPF_K, 1),
2386 		},
2387 		CLASSIC,
2388 		{ },
2389 		{ { 1, 1 } },
2390 	},
2391 	{
2392 		"LD_IND",
2393 		.u.insns = {
2394 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
2395 			BPF_STMT(BPF_LD | BPF_H | BPF_IND, MAX_K),
2396 			BPF_STMT(BPF_RET | BPF_K, 1)
2397 		},
2398 		CLASSIC,
2399 		{ },
2400 		{ { 1, 0 }, { 10, 0 }, { 60, 0 } },
2401 	},
2402 	{
2403 		"LD_ABS",
2404 		.u.insns = {
2405 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1000),
2406 			BPF_STMT(BPF_RET | BPF_K, 1)
2407 		},
2408 		CLASSIC,
2409 		{ },
2410 		{ { 1, 0 }, { 10, 0 }, { 60, 0 } },
2411 	},
2412 	{
2413 		"LD_ABS_LL",
2414 		.u.insns = {
2415 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF),
2416 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
2417 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF + 1),
2418 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2419 			BPF_STMT(BPF_RET | BPF_A, 0)
2420 		},
2421 		CLASSIC,
2422 		{ 1, 2, 3 },
2423 		{ { 1, 0 }, { 2, 3 } },
2424 	},
2425 	{
2426 		"LD_IND_LL",
2427 		.u.insns = {
2428 			BPF_STMT(BPF_LD | BPF_IMM, SKF_LL_OFF - 1),
2429 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
2430 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2431 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
2432 			BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
2433 			BPF_STMT(BPF_RET | BPF_A, 0)
2434 		},
2435 		CLASSIC,
2436 		{ 1, 2, 3, 0xff },
2437 		{ { 1, 1 }, { 3, 3 }, { 4, 0xff } },
2438 	},
2439 	{
2440 		"LD_ABS_NET",
2441 		.u.insns = {
2442 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF),
2443 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
2444 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF + 1),
2445 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2446 			BPF_STMT(BPF_RET | BPF_A, 0)
2447 		},
2448 		CLASSIC,
2449 		{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
2450 		{ { 15, 0 }, { 16, 3 } },
2451 	},
2452 	{
2453 		"LD_IND_NET",
2454 		.u.insns = {
2455 			BPF_STMT(BPF_LD | BPF_IMM, SKF_NET_OFF - 15),
2456 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
2457 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2458 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
2459 			BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
2460 			BPF_STMT(BPF_RET | BPF_A, 0)
2461 		},
2462 		CLASSIC,
2463 		{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
2464 		{ { 14, 0 }, { 15, 1 }, { 17, 3 } },
2465 	},
2466 	{
2467 		"LD_PKTTYPE",
2468 		.u.insns = {
2469 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2470 				 SKF_AD_OFF + SKF_AD_PKTTYPE),
2471 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
2472 			BPF_STMT(BPF_RET | BPF_K, 1),
2473 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2474 				 SKF_AD_OFF + SKF_AD_PKTTYPE),
2475 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
2476 			BPF_STMT(BPF_RET | BPF_K, 1),
2477 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2478 				 SKF_AD_OFF + SKF_AD_PKTTYPE),
2479 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
2480 			BPF_STMT(BPF_RET | BPF_K, 1),
2481 			BPF_STMT(BPF_RET | BPF_A, 0)
2482 		},
2483 		CLASSIC,
2484 		{ },
2485 		{ { 1, 3 }, { 10, 3 } },
2486 	},
2487 	{
2488 		"LD_MARK",
2489 		.u.insns = {
2490 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2491 				 SKF_AD_OFF + SKF_AD_MARK),
2492 			BPF_STMT(BPF_RET | BPF_A, 0)
2493 		},
2494 		CLASSIC,
2495 		{ },
2496 		{ { 1, SKB_MARK}, { 10, SKB_MARK} },
2497 	},
2498 	{
2499 		"LD_RXHASH",
2500 		.u.insns = {
2501 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2502 				 SKF_AD_OFF + SKF_AD_RXHASH),
2503 			BPF_STMT(BPF_RET | BPF_A, 0)
2504 		},
2505 		CLASSIC,
2506 		{ },
2507 		{ { 1, SKB_HASH}, { 10, SKB_HASH} },
2508 	},
2509 	{
2510 		"LD_QUEUE",
2511 		.u.insns = {
2512 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2513 				 SKF_AD_OFF + SKF_AD_QUEUE),
2514 			BPF_STMT(BPF_RET | BPF_A, 0)
2515 		},
2516 		CLASSIC,
2517 		{ },
2518 		{ { 1, SKB_QUEUE_MAP }, { 10, SKB_QUEUE_MAP } },
2519 	},
2520 	{
2521 		"LD_PROTOCOL",
2522 		.u.insns = {
2523 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 1),
2524 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 20, 1, 0),
2525 			BPF_STMT(BPF_RET | BPF_K, 0),
2526 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2527 				 SKF_AD_OFF + SKF_AD_PROTOCOL),
2528 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
2529 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
2530 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 30, 1, 0),
2531 			BPF_STMT(BPF_RET | BPF_K, 0),
2532 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
2533 			BPF_STMT(BPF_RET | BPF_A, 0)
2534 		},
2535 		CLASSIC,
2536 		{ 10, 20, 30 },
2537 		{ { 10, ETH_P_IP }, { 100, ETH_P_IP } },
2538 	},
2539 	{
2540 		"LD_VLAN_TAG",
2541 		.u.insns = {
2542 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2543 				 SKF_AD_OFF + SKF_AD_VLAN_TAG),
2544 			BPF_STMT(BPF_RET | BPF_A, 0)
2545 		},
2546 		CLASSIC,
2547 		{ },
2548 		{
2549 			{ 1, SKB_VLAN_TCI },
2550 			{ 10, SKB_VLAN_TCI }
2551 		},
2552 	},
2553 	{
2554 		"LD_VLAN_TAG_PRESENT",
2555 		.u.insns = {
2556 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2557 				 SKF_AD_OFF + SKF_AD_VLAN_TAG_PRESENT),
2558 			BPF_STMT(BPF_RET | BPF_A, 0)
2559 		},
2560 		CLASSIC,
2561 		{ },
2562 		{
2563 			{ 1, SKB_VLAN_PRESENT },
2564 			{ 10, SKB_VLAN_PRESENT }
2565 		},
2566 	},
2567 	{
2568 		"LD_IFINDEX",
2569 		.u.insns = {
2570 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2571 				 SKF_AD_OFF + SKF_AD_IFINDEX),
2572 			BPF_STMT(BPF_RET | BPF_A, 0)
2573 		},
2574 		CLASSIC,
2575 		{ },
2576 		{ { 1, SKB_DEV_IFINDEX }, { 10, SKB_DEV_IFINDEX } },
2577 	},
2578 	{
2579 		"LD_HATYPE",
2580 		.u.insns = {
2581 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2582 				 SKF_AD_OFF + SKF_AD_HATYPE),
2583 			BPF_STMT(BPF_RET | BPF_A, 0)
2584 		},
2585 		CLASSIC,
2586 		{ },
2587 		{ { 1, SKB_DEV_TYPE }, { 10, SKB_DEV_TYPE } },
2588 	},
2589 	{
2590 		"LD_CPU",
2591 		.u.insns = {
2592 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2593 				 SKF_AD_OFF + SKF_AD_CPU),
2594 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
2595 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2596 				 SKF_AD_OFF + SKF_AD_CPU),
2597 			BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
2598 			BPF_STMT(BPF_RET | BPF_A, 0)
2599 		},
2600 		CLASSIC,
2601 		{ },
2602 		{ { 1, 0 }, { 10, 0 } },
2603 	},
2604 	{
2605 		"LD_NLATTR",
2606 		.u.insns = {
2607 			BPF_STMT(BPF_LDX | BPF_IMM, 2),
2608 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
2609 			BPF_STMT(BPF_LDX | BPF_IMM, 3),
2610 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2611 				 SKF_AD_OFF + SKF_AD_NLATTR),
2612 			BPF_STMT(BPF_RET | BPF_A, 0)
2613 		},
2614 		CLASSIC,
2615 #ifdef __BIG_ENDIAN
2616 		{ 0xff, 0xff, 0, 4, 0, 2, 0, 4, 0, 3 },
2617 #else
2618 		{ 0xff, 0xff, 4, 0, 2, 0, 4, 0, 3, 0 },
2619 #endif
2620 		{ { 4, 0 }, { 20, 6 } },
2621 	},
2622 	{
2623 		"LD_NLATTR_NEST",
2624 		.u.insns = {
2625 			BPF_STMT(BPF_LD | BPF_IMM, 2),
2626 			BPF_STMT(BPF_LDX | BPF_IMM, 3),
2627 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2628 				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
2629 			BPF_STMT(BPF_LD | BPF_IMM, 2),
2630 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2631 				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
2632 			BPF_STMT(BPF_LD | BPF_IMM, 2),
2633 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2634 				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
2635 			BPF_STMT(BPF_LD | BPF_IMM, 2),
2636 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2637 				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
2638 			BPF_STMT(BPF_LD | BPF_IMM, 2),
2639 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2640 				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
2641 			BPF_STMT(BPF_LD | BPF_IMM, 2),
2642 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2643 				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
2644 			BPF_STMT(BPF_LD | BPF_IMM, 2),
2645 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2646 				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
2647 			BPF_STMT(BPF_LD | BPF_IMM, 2),
2648 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2649 				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
2650 			BPF_STMT(BPF_RET | BPF_A, 0)
2651 		},
2652 		CLASSIC,
2653 #ifdef __BIG_ENDIAN
2654 		{ 0xff, 0xff, 0, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3 },
2655 #else
2656 		{ 0xff, 0xff, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3, 0 },
2657 #endif
2658 		{ { 4, 0 }, { 20, 10 } },
2659 	},
2660 	{
2661 		"LD_PAYLOAD_OFF",
2662 		.u.insns = {
2663 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2664 				 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
2665 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2666 				 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
2667 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2668 				 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
2669 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2670 				 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
2671 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2672 				 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
2673 			BPF_STMT(BPF_RET | BPF_A, 0)
2674 		},
2675 		CLASSIC,
2676 		/* 00:00:00:00:00:00 > 00:00:00:00:00:00, ethtype IPv4 (0x0800),
2677 		 * length 98: 127.0.0.1 > 127.0.0.1: ICMP echo request,
2678 		 * id 9737, seq 1, length 64
2679 		 */
2680 		{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2681 		  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2682 		  0x08, 0x00,
2683 		  0x45, 0x00, 0x00, 0x54, 0xac, 0x8b, 0x40, 0x00, 0x40,
2684 		  0x01, 0x90, 0x1b, 0x7f, 0x00, 0x00, 0x01 },
2685 		{ { 30, 0 }, { 100, 42 } },
2686 	},
2687 	{
2688 		"LD_ANC_XOR",
2689 		.u.insns = {
2690 			BPF_STMT(BPF_LD | BPF_IMM, 10),
2691 			BPF_STMT(BPF_LDX | BPF_IMM, 300),
2692 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2693 				 SKF_AD_OFF + SKF_AD_ALU_XOR_X),
2694 			BPF_STMT(BPF_RET | BPF_A, 0)
2695 		},
2696 		CLASSIC,
2697 		{ },
2698 		{ { 4, 0xA ^ 300 }, { 20, 0xA ^ 300 } },
2699 	},
2700 	{
2701 		"SPILL_FILL",
2702 		.u.insns = {
2703 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
2704 			BPF_STMT(BPF_LD | BPF_IMM, 2),
2705 			BPF_STMT(BPF_ALU | BPF_RSH, 1),
2706 			BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
2707 			BPF_STMT(BPF_ST, 1), /* M1 = 1 ^ len */
2708 			BPF_STMT(BPF_ALU | BPF_XOR | BPF_K, 0x80000000),
2709 			BPF_STMT(BPF_ST, 2), /* M2 = 1 ^ len ^ 0x80000000 */
2710 			BPF_STMT(BPF_STX, 15), /* M3 = len */
2711 			BPF_STMT(BPF_LDX | BPF_MEM, 1),
2712 			BPF_STMT(BPF_LD | BPF_MEM, 2),
2713 			BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
2714 			BPF_STMT(BPF_LDX | BPF_MEM, 15),
2715 			BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
2716 			BPF_STMT(BPF_RET | BPF_A, 0)
2717 		},
2718 		CLASSIC,
2719 		{ },
2720 		{ { 1, 0x80000001 }, { 2, 0x80000002 }, { 60, 0x80000000 ^ 60 } }
2721 	},
2722 	{
2723 		"JEQ",
2724 		.u.insns = {
2725 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
2726 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
2727 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 0, 1),
2728 			BPF_STMT(BPF_RET | BPF_K, 1),
2729 			BPF_STMT(BPF_RET | BPF_K, MAX_K)
2730 		},
2731 		CLASSIC,
2732 		{ 3, 3, 3, 3, 3 },
2733 		{ { 1, 0 }, { 3, 1 }, { 4, MAX_K } },
2734 	},
2735 	{
2736 		"JGT",
2737 		.u.insns = {
2738 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
2739 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
2740 			BPF_JUMP(BPF_JMP | BPF_JGT | BPF_X, 0, 0, 1),
2741 			BPF_STMT(BPF_RET | BPF_K, 1),
2742 			BPF_STMT(BPF_RET | BPF_K, MAX_K)
2743 		},
2744 		CLASSIC,
2745 		{ 4, 4, 4, 3, 3 },
2746 		{ { 2, 0 }, { 3, 1 }, { 4, MAX_K } },
2747 	},
2748 	{
2749 		"JGE (jt 0), test 1",
2750 		.u.insns = {
2751 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
2752 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
2753 			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 1),
2754 			BPF_STMT(BPF_RET | BPF_K, 1),
2755 			BPF_STMT(BPF_RET | BPF_K, MAX_K)
2756 		},
2757 		CLASSIC,
2758 		{ 4, 4, 4, 3, 3 },
2759 		{ { 2, 0 }, { 3, 1 }, { 4, 1 } },
2760 	},
2761 	{
2762 		"JGE (jt 0), test 2",
2763 		.u.insns = {
2764 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
2765 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
2766 			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 1),
2767 			BPF_STMT(BPF_RET | BPF_K, 1),
2768 			BPF_STMT(BPF_RET | BPF_K, MAX_K)
2769 		},
2770 		CLASSIC,
2771 		{ 4, 4, 5, 3, 3 },
2772 		{ { 4, 1 }, { 5, 1 }, { 6, MAX_K } },
2773 	},
2774 	{
2775 		"JGE",
2776 		.u.insns = {
2777 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
2778 			BPF_STMT(BPF_LD | BPF_B | BPF_IND, MAX_K),
2779 			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 1, 1, 0),
2780 			BPF_STMT(BPF_RET | BPF_K, 10),
2781 			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 2, 1, 0),
2782 			BPF_STMT(BPF_RET | BPF_K, 20),
2783 			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 3, 1, 0),
2784 			BPF_STMT(BPF_RET | BPF_K, 30),
2785 			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 4, 1, 0),
2786 			BPF_STMT(BPF_RET | BPF_K, 40),
2787 			BPF_STMT(BPF_RET | BPF_K, MAX_K)
2788 		},
2789 		CLASSIC,
2790 		{ 1, 2, 3, 4, 5 },
2791 		{ { 1, 20 }, { 3, 40 }, { 5, MAX_K } },
2792 	},
2793 	{
2794 		"JSET",
2795 		.u.insns = {
2796 			BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
2797 			BPF_JUMP(BPF_JMP | BPF_JA, 1, 1, 1),
2798 			BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
2799 			BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
2800 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
2801 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
2802 			BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, 4),
2803 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
2804 			BPF_STMT(BPF_LD | BPF_W | BPF_IND, 0),
2805 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 1, 0, 1),
2806 			BPF_STMT(BPF_RET | BPF_K, 10),
2807 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x80000000, 0, 1),
2808 			BPF_STMT(BPF_RET | BPF_K, 20),
2809 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
2810 			BPF_STMT(BPF_RET | BPF_K, 30),
2811 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
2812 			BPF_STMT(BPF_RET | BPF_K, 30),
2813 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
2814 			BPF_STMT(BPF_RET | BPF_K, 30),
2815 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
2816 			BPF_STMT(BPF_RET | BPF_K, 30),
2817 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
2818 			BPF_STMT(BPF_RET | BPF_K, 30),
2819 			BPF_STMT(BPF_RET | BPF_K, MAX_K)
2820 		},
2821 		CLASSIC,
2822 		{ 0, 0xAA, 0x55, 1 },
2823 		{ { 4, 10 }, { 5, 20 }, { 6, MAX_K } },
2824 	},
2825 	{
2826 		"tcpdump port 22",
2827 		.u.insns = {
2828 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
2829 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 0, 8), /* IPv6 */
2830 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 20),
2831 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
2832 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
2833 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 17),
2834 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 54),
2835 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 14, 0),
2836 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 56),
2837 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 12, 13),
2838 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0800, 0, 12), /* IPv4 */
2839 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
2840 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
2841 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
2842 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 8),
2843 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
2844 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 6, 0),
2845 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
2846 			BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
2847 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
2848 			BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
2849 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 1),
2850 			BPF_STMT(BPF_RET | BPF_K, 0xffff),
2851 			BPF_STMT(BPF_RET | BPF_K, 0),
2852 		},
2853 		CLASSIC,
2854 		/* 3c:07:54:43:e5:76 > 10:bf:48:d6:43:d6, ethertype IPv4(0x0800)
2855 		 * length 114: 10.1.1.149.49700 > 10.1.2.10.22: Flags [P.],
2856 		 * seq 1305692979:1305693027, ack 3650467037, win 65535,
2857 		 * options [nop,nop,TS val 2502645400 ecr 3971138], length 48
2858 		 */
2859 		{ 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
2860 		  0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
2861 		  0x08, 0x00,
2862 		  0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
2863 		  0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
2864 		  0x0a, 0x01, 0x01, 0x95, /* ip src */
2865 		  0x0a, 0x01, 0x02, 0x0a, /* ip dst */
2866 		  0xc2, 0x24,
2867 		  0x00, 0x16 /* dst port */ },
2868 		{ { 10, 0 }, { 30, 0 }, { 100, 65535 } },
2869 	},
2870 	{
2871 		"tcpdump complex",
2872 		.u.insns = {
2873 			/* tcpdump -nei eth0 'tcp port 22 and (((ip[2:2] -
2874 			 * ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0) and
2875 			 * (len > 115 or len < 30000000000)' -d
2876 			 */
2877 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
2878 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 30, 0),
2879 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x800, 0, 29),
2880 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
2881 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 0, 27),
2882 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
2883 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 25, 0),
2884 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
2885 			BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
2886 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
2887 			BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
2888 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 20),
2889 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 16),
2890 			BPF_STMT(BPF_ST, 1),
2891 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 14),
2892 			BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf),
2893 			BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 2),
2894 			BPF_STMT(BPF_MISC | BPF_TAX, 0x5), /* libpcap emits K on TAX */
2895 			BPF_STMT(BPF_LD | BPF_MEM, 1),
2896 			BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
2897 			BPF_STMT(BPF_ST, 5),
2898 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
2899 			BPF_STMT(BPF_LD | BPF_B | BPF_IND, 26),
2900 			BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
2901 			BPF_STMT(BPF_ALU | BPF_RSH | BPF_K, 2),
2902 			BPF_STMT(BPF_MISC | BPF_TAX, 0x9), /* libpcap emits K on TAX */
2903 			BPF_STMT(BPF_LD | BPF_MEM, 5),
2904 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 4, 0),
2905 			BPF_STMT(BPF_LD | BPF_LEN, 0),
2906 			BPF_JUMP(BPF_JMP | BPF_JGT | BPF_K, 0x73, 1, 0),
2907 			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 0xfc23ac00, 1, 0),
2908 			BPF_STMT(BPF_RET | BPF_K, 0xffff),
2909 			BPF_STMT(BPF_RET | BPF_K, 0),
2910 		},
2911 		CLASSIC,
2912 		{ 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
2913 		  0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
2914 		  0x08, 0x00,
2915 		  0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
2916 		  0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
2917 		  0x0a, 0x01, 0x01, 0x95, /* ip src */
2918 		  0x0a, 0x01, 0x02, 0x0a, /* ip dst */
2919 		  0xc2, 0x24,
2920 		  0x00, 0x16 /* dst port */ },
2921 		{ { 10, 0 }, { 30, 0 }, { 100, 65535 } },
2922 	},
2923 	{
2924 		"RET_A",
2925 		.u.insns = {
2926 			/* check that uninitialized X and A contain zeros */
2927 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
2928 			BPF_STMT(BPF_RET | BPF_A, 0)
2929 		},
2930 		CLASSIC,
2931 		{ },
2932 		{ {1, 0}, {2, 0} },
2933 	},
2934 	{
2935 		"INT: ADD trivial",
2936 		.u.insns_int = {
2937 			BPF_ALU64_IMM(BPF_MOV, R1, 1),
2938 			BPF_ALU64_IMM(BPF_ADD, R1, 2),
2939 			BPF_ALU64_IMM(BPF_MOV, R2, 3),
2940 			BPF_ALU64_REG(BPF_SUB, R1, R2),
2941 			BPF_ALU64_IMM(BPF_ADD, R1, -1),
2942 			BPF_ALU64_IMM(BPF_MUL, R1, 3),
2943 			BPF_ALU64_REG(BPF_MOV, R0, R1),
2944 			BPF_EXIT_INSN(),
2945 		},
2946 		INTERNAL,
2947 		{ },
2948 		{ { 0, 0xfffffffd } }
2949 	},
2950 	{
2951 		"INT: MUL_X",
2952 		.u.insns_int = {
2953 			BPF_ALU64_IMM(BPF_MOV, R0, -1),
2954 			BPF_ALU64_IMM(BPF_MOV, R1, -1),
2955 			BPF_ALU64_IMM(BPF_MOV, R2, 3),
2956 			BPF_ALU64_REG(BPF_MUL, R1, R2),
2957 			BPF_JMP_IMM(BPF_JEQ, R1, 0xfffffffd, 1),
2958 			BPF_EXIT_INSN(),
2959 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
2960 			BPF_EXIT_INSN(),
2961 		},
2962 		INTERNAL,
2963 		{ },
2964 		{ { 0, 1 } }
2965 	},
2966 	{
2967 		"INT: MUL_X2",
2968 		.u.insns_int = {
2969 			BPF_ALU32_IMM(BPF_MOV, R0, -1),
2970 			BPF_ALU32_IMM(BPF_MOV, R1, -1),
2971 			BPF_ALU32_IMM(BPF_MOV, R2, 3),
2972 			BPF_ALU64_REG(BPF_MUL, R1, R2),
2973 			BPF_ALU64_IMM(BPF_RSH, R1, 8),
2974 			BPF_JMP_IMM(BPF_JEQ, R1, 0x2ffffff, 1),
2975 			BPF_EXIT_INSN(),
2976 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
2977 			BPF_EXIT_INSN(),
2978 		},
2979 		INTERNAL,
2980 		{ },
2981 		{ { 0, 1 } }
2982 	},
2983 	{
2984 		"INT: MUL32_X",
2985 		.u.insns_int = {
2986 			BPF_ALU32_IMM(BPF_MOV, R0, -1),
2987 			BPF_ALU64_IMM(BPF_MOV, R1, -1),
2988 			BPF_ALU32_IMM(BPF_MOV, R2, 3),
2989 			BPF_ALU32_REG(BPF_MUL, R1, R2),
2990 			BPF_ALU64_IMM(BPF_RSH, R1, 8),
2991 			BPF_JMP_IMM(BPF_JEQ, R1, 0xffffff, 1),
2992 			BPF_EXIT_INSN(),
2993 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
2994 			BPF_EXIT_INSN(),
2995 		},
2996 		INTERNAL,
2997 		{ },
2998 		{ { 0, 1 } }
2999 	},
3000 	{
3001 		/* Have to test all register combinations, since
3002 		 * JITing of different registers will produce
3003 		 * different asm code.
3004 		 */
3005 		"INT: ADD 64-bit",
3006 		.u.insns_int = {
3007 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
3008 			BPF_ALU64_IMM(BPF_MOV, R1, 1),
3009 			BPF_ALU64_IMM(BPF_MOV, R2, 2),
3010 			BPF_ALU64_IMM(BPF_MOV, R3, 3),
3011 			BPF_ALU64_IMM(BPF_MOV, R4, 4),
3012 			BPF_ALU64_IMM(BPF_MOV, R5, 5),
3013 			BPF_ALU64_IMM(BPF_MOV, R6, 6),
3014 			BPF_ALU64_IMM(BPF_MOV, R7, 7),
3015 			BPF_ALU64_IMM(BPF_MOV, R8, 8),
3016 			BPF_ALU64_IMM(BPF_MOV, R9, 9),
3017 			BPF_ALU64_IMM(BPF_ADD, R0, 20),
3018 			BPF_ALU64_IMM(BPF_ADD, R1, 20),
3019 			BPF_ALU64_IMM(BPF_ADD, R2, 20),
3020 			BPF_ALU64_IMM(BPF_ADD, R3, 20),
3021 			BPF_ALU64_IMM(BPF_ADD, R4, 20),
3022 			BPF_ALU64_IMM(BPF_ADD, R5, 20),
3023 			BPF_ALU64_IMM(BPF_ADD, R6, 20),
3024 			BPF_ALU64_IMM(BPF_ADD, R7, 20),
3025 			BPF_ALU64_IMM(BPF_ADD, R8, 20),
3026 			BPF_ALU64_IMM(BPF_ADD, R9, 20),
3027 			BPF_ALU64_IMM(BPF_SUB, R0, 10),
3028 			BPF_ALU64_IMM(BPF_SUB, R1, 10),
3029 			BPF_ALU64_IMM(BPF_SUB, R2, 10),
3030 			BPF_ALU64_IMM(BPF_SUB, R3, 10),
3031 			BPF_ALU64_IMM(BPF_SUB, R4, 10),
3032 			BPF_ALU64_IMM(BPF_SUB, R5, 10),
3033 			BPF_ALU64_IMM(BPF_SUB, R6, 10),
3034 			BPF_ALU64_IMM(BPF_SUB, R7, 10),
3035 			BPF_ALU64_IMM(BPF_SUB, R8, 10),
3036 			BPF_ALU64_IMM(BPF_SUB, R9, 10),
3037 			BPF_ALU64_REG(BPF_ADD, R0, R0),
3038 			BPF_ALU64_REG(BPF_ADD, R0, R1),
3039 			BPF_ALU64_REG(BPF_ADD, R0, R2),
3040 			BPF_ALU64_REG(BPF_ADD, R0, R3),
3041 			BPF_ALU64_REG(BPF_ADD, R0, R4),
3042 			BPF_ALU64_REG(BPF_ADD, R0, R5),
3043 			BPF_ALU64_REG(BPF_ADD, R0, R6),
3044 			BPF_ALU64_REG(BPF_ADD, R0, R7),
3045 			BPF_ALU64_REG(BPF_ADD, R0, R8),
3046 			BPF_ALU64_REG(BPF_ADD, R0, R9), /* R0 == 155 */
3047 			BPF_JMP_IMM(BPF_JEQ, R0, 155, 1),
3048 			BPF_EXIT_INSN(),
3049 			BPF_ALU64_REG(BPF_ADD, R1, R0),
3050 			BPF_ALU64_REG(BPF_ADD, R1, R1),
3051 			BPF_ALU64_REG(BPF_ADD, R1, R2),
3052 			BPF_ALU64_REG(BPF_ADD, R1, R3),
3053 			BPF_ALU64_REG(BPF_ADD, R1, R4),
3054 			BPF_ALU64_REG(BPF_ADD, R1, R5),
3055 			BPF_ALU64_REG(BPF_ADD, R1, R6),
3056 			BPF_ALU64_REG(BPF_ADD, R1, R7),
3057 			BPF_ALU64_REG(BPF_ADD, R1, R8),
3058 			BPF_ALU64_REG(BPF_ADD, R1, R9), /* R1 == 456 */
3059 			BPF_JMP_IMM(BPF_JEQ, R1, 456, 1),
3060 			BPF_EXIT_INSN(),
3061 			BPF_ALU64_REG(BPF_ADD, R2, R0),
3062 			BPF_ALU64_REG(BPF_ADD, R2, R1),
3063 			BPF_ALU64_REG(BPF_ADD, R2, R2),
3064 			BPF_ALU64_REG(BPF_ADD, R2, R3),
3065 			BPF_ALU64_REG(BPF_ADD, R2, R4),
3066 			BPF_ALU64_REG(BPF_ADD, R2, R5),
3067 			BPF_ALU64_REG(BPF_ADD, R2, R6),
3068 			BPF_ALU64_REG(BPF_ADD, R2, R7),
3069 			BPF_ALU64_REG(BPF_ADD, R2, R8),
3070 			BPF_ALU64_REG(BPF_ADD, R2, R9), /* R2 == 1358 */
3071 			BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1),
3072 			BPF_EXIT_INSN(),
3073 			BPF_ALU64_REG(BPF_ADD, R3, R0),
3074 			BPF_ALU64_REG(BPF_ADD, R3, R1),
3075 			BPF_ALU64_REG(BPF_ADD, R3, R2),
3076 			BPF_ALU64_REG(BPF_ADD, R3, R3),
3077 			BPF_ALU64_REG(BPF_ADD, R3, R4),
3078 			BPF_ALU64_REG(BPF_ADD, R3, R5),
3079 			BPF_ALU64_REG(BPF_ADD, R3, R6),
3080 			BPF_ALU64_REG(BPF_ADD, R3, R7),
3081 			BPF_ALU64_REG(BPF_ADD, R3, R8),
3082 			BPF_ALU64_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
3083 			BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
3084 			BPF_EXIT_INSN(),
3085 			BPF_ALU64_REG(BPF_ADD, R4, R0),
3086 			BPF_ALU64_REG(BPF_ADD, R4, R1),
3087 			BPF_ALU64_REG(BPF_ADD, R4, R2),
3088 			BPF_ALU64_REG(BPF_ADD, R4, R3),
3089 			BPF_ALU64_REG(BPF_ADD, R4, R4),
3090 			BPF_ALU64_REG(BPF_ADD, R4, R5),
3091 			BPF_ALU64_REG(BPF_ADD, R4, R6),
3092 			BPF_ALU64_REG(BPF_ADD, R4, R7),
3093 			BPF_ALU64_REG(BPF_ADD, R4, R8),
3094 			BPF_ALU64_REG(BPF_ADD, R4, R9), /* R4 == 12177 */
3095 			BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1),
3096 			BPF_EXIT_INSN(),
3097 			BPF_ALU64_REG(BPF_ADD, R5, R0),
3098 			BPF_ALU64_REG(BPF_ADD, R5, R1),
3099 			BPF_ALU64_REG(BPF_ADD, R5, R2),
3100 			BPF_ALU64_REG(BPF_ADD, R5, R3),
3101 			BPF_ALU64_REG(BPF_ADD, R5, R4),
3102 			BPF_ALU64_REG(BPF_ADD, R5, R5),
3103 			BPF_ALU64_REG(BPF_ADD, R5, R6),
3104 			BPF_ALU64_REG(BPF_ADD, R5, R7),
3105 			BPF_ALU64_REG(BPF_ADD, R5, R8),
3106 			BPF_ALU64_REG(BPF_ADD, R5, R9), /* R5 == 36518 */
3107 			BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1),
3108 			BPF_EXIT_INSN(),
3109 			BPF_ALU64_REG(BPF_ADD, R6, R0),
3110 			BPF_ALU64_REG(BPF_ADD, R6, R1),
3111 			BPF_ALU64_REG(BPF_ADD, R6, R2),
3112 			BPF_ALU64_REG(BPF_ADD, R6, R3),
3113 			BPF_ALU64_REG(BPF_ADD, R6, R4),
3114 			BPF_ALU64_REG(BPF_ADD, R6, R5),
3115 			BPF_ALU64_REG(BPF_ADD, R6, R6),
3116 			BPF_ALU64_REG(BPF_ADD, R6, R7),
3117 			BPF_ALU64_REG(BPF_ADD, R6, R8),
3118 			BPF_ALU64_REG(BPF_ADD, R6, R9), /* R6 == 109540 */
3119 			BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1),
3120 			BPF_EXIT_INSN(),
3121 			BPF_ALU64_REG(BPF_ADD, R7, R0),
3122 			BPF_ALU64_REG(BPF_ADD, R7, R1),
3123 			BPF_ALU64_REG(BPF_ADD, R7, R2),
3124 			BPF_ALU64_REG(BPF_ADD, R7, R3),
3125 			BPF_ALU64_REG(BPF_ADD, R7, R4),
3126 			BPF_ALU64_REG(BPF_ADD, R7, R5),
3127 			BPF_ALU64_REG(BPF_ADD, R7, R6),
3128 			BPF_ALU64_REG(BPF_ADD, R7, R7),
3129 			BPF_ALU64_REG(BPF_ADD, R7, R8),
3130 			BPF_ALU64_REG(BPF_ADD, R7, R9), /* R7 == 328605 */
3131 			BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1),
3132 			BPF_EXIT_INSN(),
3133 			BPF_ALU64_REG(BPF_ADD, R8, R0),
3134 			BPF_ALU64_REG(BPF_ADD, R8, R1),
3135 			BPF_ALU64_REG(BPF_ADD, R8, R2),
3136 			BPF_ALU64_REG(BPF_ADD, R8, R3),
3137 			BPF_ALU64_REG(BPF_ADD, R8, R4),
3138 			BPF_ALU64_REG(BPF_ADD, R8, R5),
3139 			BPF_ALU64_REG(BPF_ADD, R8, R6),
3140 			BPF_ALU64_REG(BPF_ADD, R8, R7),
3141 			BPF_ALU64_REG(BPF_ADD, R8, R8),
3142 			BPF_ALU64_REG(BPF_ADD, R8, R9), /* R8 == 985799 */
3143 			BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1),
3144 			BPF_EXIT_INSN(),
3145 			BPF_ALU64_REG(BPF_ADD, R9, R0),
3146 			BPF_ALU64_REG(BPF_ADD, R9, R1),
3147 			BPF_ALU64_REG(BPF_ADD, R9, R2),
3148 			BPF_ALU64_REG(BPF_ADD, R9, R3),
3149 			BPF_ALU64_REG(BPF_ADD, R9, R4),
3150 			BPF_ALU64_REG(BPF_ADD, R9, R5),
3151 			BPF_ALU64_REG(BPF_ADD, R9, R6),
3152 			BPF_ALU64_REG(BPF_ADD, R9, R7),
3153 			BPF_ALU64_REG(BPF_ADD, R9, R8),
3154 			BPF_ALU64_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */
3155 			BPF_ALU64_REG(BPF_MOV, R0, R9),
3156 			BPF_EXIT_INSN(),
3157 		},
3158 		INTERNAL,
3159 		{ },
3160 		{ { 0, 2957380 } }
3161 	},
3162 	{
3163 		"INT: ADD 32-bit",
3164 		.u.insns_int = {
3165 			BPF_ALU32_IMM(BPF_MOV, R0, 20),
3166 			BPF_ALU32_IMM(BPF_MOV, R1, 1),
3167 			BPF_ALU32_IMM(BPF_MOV, R2, 2),
3168 			BPF_ALU32_IMM(BPF_MOV, R3, 3),
3169 			BPF_ALU32_IMM(BPF_MOV, R4, 4),
3170 			BPF_ALU32_IMM(BPF_MOV, R5, 5),
3171 			BPF_ALU32_IMM(BPF_MOV, R6, 6),
3172 			BPF_ALU32_IMM(BPF_MOV, R7, 7),
3173 			BPF_ALU32_IMM(BPF_MOV, R8, 8),
3174 			BPF_ALU32_IMM(BPF_MOV, R9, 9),
3175 			BPF_ALU64_IMM(BPF_ADD, R1, 10),
3176 			BPF_ALU64_IMM(BPF_ADD, R2, 10),
3177 			BPF_ALU64_IMM(BPF_ADD, R3, 10),
3178 			BPF_ALU64_IMM(BPF_ADD, R4, 10),
3179 			BPF_ALU64_IMM(BPF_ADD, R5, 10),
3180 			BPF_ALU64_IMM(BPF_ADD, R6, 10),
3181 			BPF_ALU64_IMM(BPF_ADD, R7, 10),
3182 			BPF_ALU64_IMM(BPF_ADD, R8, 10),
3183 			BPF_ALU64_IMM(BPF_ADD, R9, 10),
3184 			BPF_ALU32_REG(BPF_ADD, R0, R1),
3185 			BPF_ALU32_REG(BPF_ADD, R0, R2),
3186 			BPF_ALU32_REG(BPF_ADD, R0, R3),
3187 			BPF_ALU32_REG(BPF_ADD, R0, R4),
3188 			BPF_ALU32_REG(BPF_ADD, R0, R5),
3189 			BPF_ALU32_REG(BPF_ADD, R0, R6),
3190 			BPF_ALU32_REG(BPF_ADD, R0, R7),
3191 			BPF_ALU32_REG(BPF_ADD, R0, R8),
3192 			BPF_ALU32_REG(BPF_ADD, R0, R9), /* R0 == 155 */
3193 			BPF_JMP_IMM(BPF_JEQ, R0, 155, 1),
3194 			BPF_EXIT_INSN(),
3195 			BPF_ALU32_REG(BPF_ADD, R1, R0),
3196 			BPF_ALU32_REG(BPF_ADD, R1, R1),
3197 			BPF_ALU32_REG(BPF_ADD, R1, R2),
3198 			BPF_ALU32_REG(BPF_ADD, R1, R3),
3199 			BPF_ALU32_REG(BPF_ADD, R1, R4),
3200 			BPF_ALU32_REG(BPF_ADD, R1, R5),
3201 			BPF_ALU32_REG(BPF_ADD, R1, R6),
3202 			BPF_ALU32_REG(BPF_ADD, R1, R7),
3203 			BPF_ALU32_REG(BPF_ADD, R1, R8),
3204 			BPF_ALU32_REG(BPF_ADD, R1, R9), /* R1 == 456 */
3205 			BPF_JMP_IMM(BPF_JEQ, R1, 456, 1),
3206 			BPF_EXIT_INSN(),
3207 			BPF_ALU32_REG(BPF_ADD, R2, R0),
3208 			BPF_ALU32_REG(BPF_ADD, R2, R1),
3209 			BPF_ALU32_REG(BPF_ADD, R2, R2),
3210 			BPF_ALU32_REG(BPF_ADD, R2, R3),
3211 			BPF_ALU32_REG(BPF_ADD, R2, R4),
3212 			BPF_ALU32_REG(BPF_ADD, R2, R5),
3213 			BPF_ALU32_REG(BPF_ADD, R2, R6),
3214 			BPF_ALU32_REG(BPF_ADD, R2, R7),
3215 			BPF_ALU32_REG(BPF_ADD, R2, R8),
3216 			BPF_ALU32_REG(BPF_ADD, R2, R9), /* R2 == 1358 */
3217 			BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1),
3218 			BPF_EXIT_INSN(),
3219 			BPF_ALU32_REG(BPF_ADD, R3, R0),
3220 			BPF_ALU32_REG(BPF_ADD, R3, R1),
3221 			BPF_ALU32_REG(BPF_ADD, R3, R2),
3222 			BPF_ALU32_REG(BPF_ADD, R3, R3),
3223 			BPF_ALU32_REG(BPF_ADD, R3, R4),
3224 			BPF_ALU32_REG(BPF_ADD, R3, R5),
3225 			BPF_ALU32_REG(BPF_ADD, R3, R6),
3226 			BPF_ALU32_REG(BPF_ADD, R3, R7),
3227 			BPF_ALU32_REG(BPF_ADD, R3, R8),
3228 			BPF_ALU32_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
3229 			BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
3230 			BPF_EXIT_INSN(),
3231 			BPF_ALU32_REG(BPF_ADD, R4, R0),
3232 			BPF_ALU32_REG(BPF_ADD, R4, R1),
3233 			BPF_ALU32_REG(BPF_ADD, R4, R2),
3234 			BPF_ALU32_REG(BPF_ADD, R4, R3),
3235 			BPF_ALU32_REG(BPF_ADD, R4, R4),
3236 			BPF_ALU32_REG(BPF_ADD, R4, R5),
3237 			BPF_ALU32_REG(BPF_ADD, R4, R6),
3238 			BPF_ALU32_REG(BPF_ADD, R4, R7),
3239 			BPF_ALU32_REG(BPF_ADD, R4, R8),
3240 			BPF_ALU32_REG(BPF_ADD, R4, R9), /* R4 == 12177 */
3241 			BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1),
3242 			BPF_EXIT_INSN(),
3243 			BPF_ALU32_REG(BPF_ADD, R5, R0),
3244 			BPF_ALU32_REG(BPF_ADD, R5, R1),
3245 			BPF_ALU32_REG(BPF_ADD, R5, R2),
3246 			BPF_ALU32_REG(BPF_ADD, R5, R3),
3247 			BPF_ALU32_REG(BPF_ADD, R5, R4),
3248 			BPF_ALU32_REG(BPF_ADD, R5, R5),
3249 			BPF_ALU32_REG(BPF_ADD, R5, R6),
3250 			BPF_ALU32_REG(BPF_ADD, R5, R7),
3251 			BPF_ALU32_REG(BPF_ADD, R5, R8),
3252 			BPF_ALU32_REG(BPF_ADD, R5, R9), /* R5 == 36518 */
3253 			BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1),
3254 			BPF_EXIT_INSN(),
3255 			BPF_ALU32_REG(BPF_ADD, R6, R0),
3256 			BPF_ALU32_REG(BPF_ADD, R6, R1),
3257 			BPF_ALU32_REG(BPF_ADD, R6, R2),
3258 			BPF_ALU32_REG(BPF_ADD, R6, R3),
3259 			BPF_ALU32_REG(BPF_ADD, R6, R4),
3260 			BPF_ALU32_REG(BPF_ADD, R6, R5),
3261 			BPF_ALU32_REG(BPF_ADD, R6, R6),
3262 			BPF_ALU32_REG(BPF_ADD, R6, R7),
3263 			BPF_ALU32_REG(BPF_ADD, R6, R8),
3264 			BPF_ALU32_REG(BPF_ADD, R6, R9), /* R6 == 109540 */
3265 			BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1),
3266 			BPF_EXIT_INSN(),
3267 			BPF_ALU32_REG(BPF_ADD, R7, R0),
3268 			BPF_ALU32_REG(BPF_ADD, R7, R1),
3269 			BPF_ALU32_REG(BPF_ADD, R7, R2),
3270 			BPF_ALU32_REG(BPF_ADD, R7, R3),
3271 			BPF_ALU32_REG(BPF_ADD, R7, R4),
3272 			BPF_ALU32_REG(BPF_ADD, R7, R5),
3273 			BPF_ALU32_REG(BPF_ADD, R7, R6),
3274 			BPF_ALU32_REG(BPF_ADD, R7, R7),
3275 			BPF_ALU32_REG(BPF_ADD, R7, R8),
3276 			BPF_ALU32_REG(BPF_ADD, R7, R9), /* R7 == 328605 */
3277 			BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1),
3278 			BPF_EXIT_INSN(),
3279 			BPF_ALU32_REG(BPF_ADD, R8, R0),
3280 			BPF_ALU32_REG(BPF_ADD, R8, R1),
3281 			BPF_ALU32_REG(BPF_ADD, R8, R2),
3282 			BPF_ALU32_REG(BPF_ADD, R8, R3),
3283 			BPF_ALU32_REG(BPF_ADD, R8, R4),
3284 			BPF_ALU32_REG(BPF_ADD, R8, R5),
3285 			BPF_ALU32_REG(BPF_ADD, R8, R6),
3286 			BPF_ALU32_REG(BPF_ADD, R8, R7),
3287 			BPF_ALU32_REG(BPF_ADD, R8, R8),
3288 			BPF_ALU32_REG(BPF_ADD, R8, R9), /* R8 == 985799 */
3289 			BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1),
3290 			BPF_EXIT_INSN(),
3291 			BPF_ALU32_REG(BPF_ADD, R9, R0),
3292 			BPF_ALU32_REG(BPF_ADD, R9, R1),
3293 			BPF_ALU32_REG(BPF_ADD, R9, R2),
3294 			BPF_ALU32_REG(BPF_ADD, R9, R3),
3295 			BPF_ALU32_REG(BPF_ADD, R9, R4),
3296 			BPF_ALU32_REG(BPF_ADD, R9, R5),
3297 			BPF_ALU32_REG(BPF_ADD, R9, R6),
3298 			BPF_ALU32_REG(BPF_ADD, R9, R7),
3299 			BPF_ALU32_REG(BPF_ADD, R9, R8),
3300 			BPF_ALU32_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */
3301 			BPF_ALU32_REG(BPF_MOV, R0, R9),
3302 			BPF_EXIT_INSN(),
3303 		},
3304 		INTERNAL,
3305 		{ },
3306 		{ { 0, 2957380 } }
3307 	},
3308 	{	/* Mainly checking JIT here. */
3309 		"INT: SUB",
3310 		.u.insns_int = {
3311 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
3312 			BPF_ALU64_IMM(BPF_MOV, R1, 1),
3313 			BPF_ALU64_IMM(BPF_MOV, R2, 2),
3314 			BPF_ALU64_IMM(BPF_MOV, R3, 3),
3315 			BPF_ALU64_IMM(BPF_MOV, R4, 4),
3316 			BPF_ALU64_IMM(BPF_MOV, R5, 5),
3317 			BPF_ALU64_IMM(BPF_MOV, R6, 6),
3318 			BPF_ALU64_IMM(BPF_MOV, R7, 7),
3319 			BPF_ALU64_IMM(BPF_MOV, R8, 8),
3320 			BPF_ALU64_IMM(BPF_MOV, R9, 9),
3321 			BPF_ALU64_REG(BPF_SUB, R0, R0),
3322 			BPF_ALU64_REG(BPF_SUB, R0, R1),
3323 			BPF_ALU64_REG(BPF_SUB, R0, R2),
3324 			BPF_ALU64_REG(BPF_SUB, R0, R3),
3325 			BPF_ALU64_REG(BPF_SUB, R0, R4),
3326 			BPF_ALU64_REG(BPF_SUB, R0, R5),
3327 			BPF_ALU64_REG(BPF_SUB, R0, R6),
3328 			BPF_ALU64_REG(BPF_SUB, R0, R7),
3329 			BPF_ALU64_REG(BPF_SUB, R0, R8),
3330 			BPF_ALU64_REG(BPF_SUB, R0, R9),
3331 			BPF_ALU64_IMM(BPF_SUB, R0, 10),
3332 			BPF_JMP_IMM(BPF_JEQ, R0, -55, 1),
3333 			BPF_EXIT_INSN(),
3334 			BPF_ALU64_REG(BPF_SUB, R1, R0),
3335 			BPF_ALU64_REG(BPF_SUB, R1, R2),
3336 			BPF_ALU64_REG(BPF_SUB, R1, R3),
3337 			BPF_ALU64_REG(BPF_SUB, R1, R4),
3338 			BPF_ALU64_REG(BPF_SUB, R1, R5),
3339 			BPF_ALU64_REG(BPF_SUB, R1, R6),
3340 			BPF_ALU64_REG(BPF_SUB, R1, R7),
3341 			BPF_ALU64_REG(BPF_SUB, R1, R8),
3342 			BPF_ALU64_REG(BPF_SUB, R1, R9),
3343 			BPF_ALU64_IMM(BPF_SUB, R1, 10),
3344 			BPF_ALU64_REG(BPF_SUB, R2, R0),
3345 			BPF_ALU64_REG(BPF_SUB, R2, R1),
3346 			BPF_ALU64_REG(BPF_SUB, R2, R3),
3347 			BPF_ALU64_REG(BPF_SUB, R2, R4),
3348 			BPF_ALU64_REG(BPF_SUB, R2, R5),
3349 			BPF_ALU64_REG(BPF_SUB, R2, R6),
3350 			BPF_ALU64_REG(BPF_SUB, R2, R7),
3351 			BPF_ALU64_REG(BPF_SUB, R2, R8),
3352 			BPF_ALU64_REG(BPF_SUB, R2, R9),
3353 			BPF_ALU64_IMM(BPF_SUB, R2, 10),
3354 			BPF_ALU64_REG(BPF_SUB, R3, R0),
3355 			BPF_ALU64_REG(BPF_SUB, R3, R1),
3356 			BPF_ALU64_REG(BPF_SUB, R3, R2),
3357 			BPF_ALU64_REG(BPF_SUB, R3, R4),
3358 			BPF_ALU64_REG(BPF_SUB, R3, R5),
3359 			BPF_ALU64_REG(BPF_SUB, R3, R6),
3360 			BPF_ALU64_REG(BPF_SUB, R3, R7),
3361 			BPF_ALU64_REG(BPF_SUB, R3, R8),
3362 			BPF_ALU64_REG(BPF_SUB, R3, R9),
3363 			BPF_ALU64_IMM(BPF_SUB, R3, 10),
3364 			BPF_ALU64_REG(BPF_SUB, R4, R0),
3365 			BPF_ALU64_REG(BPF_SUB, R4, R1),
3366 			BPF_ALU64_REG(BPF_SUB, R4, R2),
3367 			BPF_ALU64_REG(BPF_SUB, R4, R3),
3368 			BPF_ALU64_REG(BPF_SUB, R4, R5),
3369 			BPF_ALU64_REG(BPF_SUB, R4, R6),
3370 			BPF_ALU64_REG(BPF_SUB, R4, R7),
3371 			BPF_ALU64_REG(BPF_SUB, R4, R8),
3372 			BPF_ALU64_REG(BPF_SUB, R4, R9),
3373 			BPF_ALU64_IMM(BPF_SUB, R4, 10),
3374 			BPF_ALU64_REG(BPF_SUB, R5, R0),
3375 			BPF_ALU64_REG(BPF_SUB, R5, R1),
3376 			BPF_ALU64_REG(BPF_SUB, R5, R2),
3377 			BPF_ALU64_REG(BPF_SUB, R5, R3),
3378 			BPF_ALU64_REG(BPF_SUB, R5, R4),
3379 			BPF_ALU64_REG(BPF_SUB, R5, R6),
3380 			BPF_ALU64_REG(BPF_SUB, R5, R7),
3381 			BPF_ALU64_REG(BPF_SUB, R5, R8),
3382 			BPF_ALU64_REG(BPF_SUB, R5, R9),
3383 			BPF_ALU64_IMM(BPF_SUB, R5, 10),
3384 			BPF_ALU64_REG(BPF_SUB, R6, R0),
3385 			BPF_ALU64_REG(BPF_SUB, R6, R1),
3386 			BPF_ALU64_REG(BPF_SUB, R6, R2),
3387 			BPF_ALU64_REG(BPF_SUB, R6, R3),
3388 			BPF_ALU64_REG(BPF_SUB, R6, R4),
3389 			BPF_ALU64_REG(BPF_SUB, R6, R5),
3390 			BPF_ALU64_REG(BPF_SUB, R6, R7),
3391 			BPF_ALU64_REG(BPF_SUB, R6, R8),
3392 			BPF_ALU64_REG(BPF_SUB, R6, R9),
3393 			BPF_ALU64_IMM(BPF_SUB, R6, 10),
3394 			BPF_ALU64_REG(BPF_SUB, R7, R0),
3395 			BPF_ALU64_REG(BPF_SUB, R7, R1),
3396 			BPF_ALU64_REG(BPF_SUB, R7, R2),
3397 			BPF_ALU64_REG(BPF_SUB, R7, R3),
3398 			BPF_ALU64_REG(BPF_SUB, R7, R4),
3399 			BPF_ALU64_REG(BPF_SUB, R7, R5),
3400 			BPF_ALU64_REG(BPF_SUB, R7, R6),
3401 			BPF_ALU64_REG(BPF_SUB, R7, R8),
3402 			BPF_ALU64_REG(BPF_SUB, R7, R9),
3403 			BPF_ALU64_IMM(BPF_SUB, R7, 10),
3404 			BPF_ALU64_REG(BPF_SUB, R8, R0),
3405 			BPF_ALU64_REG(BPF_SUB, R8, R1),
3406 			BPF_ALU64_REG(BPF_SUB, R8, R2),
3407 			BPF_ALU64_REG(BPF_SUB, R8, R3),
3408 			BPF_ALU64_REG(BPF_SUB, R8, R4),
3409 			BPF_ALU64_REG(BPF_SUB, R8, R5),
3410 			BPF_ALU64_REG(BPF_SUB, R8, R6),
3411 			BPF_ALU64_REG(BPF_SUB, R8, R7),
3412 			BPF_ALU64_REG(BPF_SUB, R8, R9),
3413 			BPF_ALU64_IMM(BPF_SUB, R8, 10),
3414 			BPF_ALU64_REG(BPF_SUB, R9, R0),
3415 			BPF_ALU64_REG(BPF_SUB, R9, R1),
3416 			BPF_ALU64_REG(BPF_SUB, R9, R2),
3417 			BPF_ALU64_REG(BPF_SUB, R9, R3),
3418 			BPF_ALU64_REG(BPF_SUB, R9, R4),
3419 			BPF_ALU64_REG(BPF_SUB, R9, R5),
3420 			BPF_ALU64_REG(BPF_SUB, R9, R6),
3421 			BPF_ALU64_REG(BPF_SUB, R9, R7),
3422 			BPF_ALU64_REG(BPF_SUB, R9, R8),
3423 			BPF_ALU64_IMM(BPF_SUB, R9, 10),
3424 			BPF_ALU64_IMM(BPF_SUB, R0, 10),
3425 			BPF_ALU64_IMM(BPF_NEG, R0, 0),
3426 			BPF_ALU64_REG(BPF_SUB, R0, R1),
3427 			BPF_ALU64_REG(BPF_SUB, R0, R2),
3428 			BPF_ALU64_REG(BPF_SUB, R0, R3),
3429 			BPF_ALU64_REG(BPF_SUB, R0, R4),
3430 			BPF_ALU64_REG(BPF_SUB, R0, R5),
3431 			BPF_ALU64_REG(BPF_SUB, R0, R6),
3432 			BPF_ALU64_REG(BPF_SUB, R0, R7),
3433 			BPF_ALU64_REG(BPF_SUB, R0, R8),
3434 			BPF_ALU64_REG(BPF_SUB, R0, R9),
3435 			BPF_EXIT_INSN(),
3436 		},
3437 		INTERNAL,
3438 		{ },
3439 		{ { 0, 11 } }
3440 	},
3441 	{	/* Mainly checking JIT here. */
3442 		"INT: XOR",
3443 		.u.insns_int = {
3444 			BPF_ALU64_REG(BPF_SUB, R0, R0),
3445 			BPF_ALU64_REG(BPF_XOR, R1, R1),
3446 			BPF_JMP_REG(BPF_JEQ, R0, R1, 1),
3447 			BPF_EXIT_INSN(),
3448 			BPF_ALU64_IMM(BPF_MOV, R0, 10),
3449 			BPF_ALU64_IMM(BPF_MOV, R1, -1),
3450 			BPF_ALU64_REG(BPF_SUB, R1, R1),
3451 			BPF_ALU64_REG(BPF_XOR, R2, R2),
3452 			BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
3453 			BPF_EXIT_INSN(),
3454 			BPF_ALU64_REG(BPF_SUB, R2, R2),
3455 			BPF_ALU64_REG(BPF_XOR, R3, R3),
3456 			BPF_ALU64_IMM(BPF_MOV, R0, 10),
3457 			BPF_ALU64_IMM(BPF_MOV, R1, -1),
3458 			BPF_JMP_REG(BPF_JEQ, R2, R3, 1),
3459 			BPF_EXIT_INSN(),
3460 			BPF_ALU64_REG(BPF_SUB, R3, R3),
3461 			BPF_ALU64_REG(BPF_XOR, R4, R4),
3462 			BPF_ALU64_IMM(BPF_MOV, R2, 1),
3463 			BPF_ALU64_IMM(BPF_MOV, R5, -1),
3464 			BPF_JMP_REG(BPF_JEQ, R3, R4, 1),
3465 			BPF_EXIT_INSN(),
3466 			BPF_ALU64_REG(BPF_SUB, R4, R4),
3467 			BPF_ALU64_REG(BPF_XOR, R5, R5),
3468 			BPF_ALU64_IMM(BPF_MOV, R3, 1),
3469 			BPF_ALU64_IMM(BPF_MOV, R7, -1),
3470 			BPF_JMP_REG(BPF_JEQ, R5, R4, 1),
3471 			BPF_EXIT_INSN(),
3472 			BPF_ALU64_IMM(BPF_MOV, R5, 1),
3473 			BPF_ALU64_REG(BPF_SUB, R5, R5),
3474 			BPF_ALU64_REG(BPF_XOR, R6, R6),
3475 			BPF_ALU64_IMM(BPF_MOV, R1, 1),
3476 			BPF_ALU64_IMM(BPF_MOV, R8, -1),
3477 			BPF_JMP_REG(BPF_JEQ, R5, R6, 1),
3478 			BPF_EXIT_INSN(),
3479 			BPF_ALU64_REG(BPF_SUB, R6, R6),
3480 			BPF_ALU64_REG(BPF_XOR, R7, R7),
3481 			BPF_JMP_REG(BPF_JEQ, R7, R6, 1),
3482 			BPF_EXIT_INSN(),
3483 			BPF_ALU64_REG(BPF_SUB, R7, R7),
3484 			BPF_ALU64_REG(BPF_XOR, R8, R8),
3485 			BPF_JMP_REG(BPF_JEQ, R7, R8, 1),
3486 			BPF_EXIT_INSN(),
3487 			BPF_ALU64_REG(BPF_SUB, R8, R8),
3488 			BPF_ALU64_REG(BPF_XOR, R9, R9),
3489 			BPF_JMP_REG(BPF_JEQ, R9, R8, 1),
3490 			BPF_EXIT_INSN(),
3491 			BPF_ALU64_REG(BPF_SUB, R9, R9),
3492 			BPF_ALU64_REG(BPF_XOR, R0, R0),
3493 			BPF_JMP_REG(BPF_JEQ, R9, R0, 1),
3494 			BPF_EXIT_INSN(),
3495 			BPF_ALU64_REG(BPF_SUB, R1, R1),
3496 			BPF_ALU64_REG(BPF_XOR, R0, R0),
3497 			BPF_JMP_REG(BPF_JEQ, R9, R0, 2),
3498 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
3499 			BPF_EXIT_INSN(),
3500 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
3501 			BPF_EXIT_INSN(),
3502 		},
3503 		INTERNAL,
3504 		{ },
3505 		{ { 0, 1 } }
3506 	},
3507 	{	/* Mainly checking JIT here. */
3508 		"INT: MUL",
3509 		.u.insns_int = {
3510 			BPF_ALU64_IMM(BPF_MOV, R0, 11),
3511 			BPF_ALU64_IMM(BPF_MOV, R1, 1),
3512 			BPF_ALU64_IMM(BPF_MOV, R2, 2),
3513 			BPF_ALU64_IMM(BPF_MOV, R3, 3),
3514 			BPF_ALU64_IMM(BPF_MOV, R4, 4),
3515 			BPF_ALU64_IMM(BPF_MOV, R5, 5),
3516 			BPF_ALU64_IMM(BPF_MOV, R6, 6),
3517 			BPF_ALU64_IMM(BPF_MOV, R7, 7),
3518 			BPF_ALU64_IMM(BPF_MOV, R8, 8),
3519 			BPF_ALU64_IMM(BPF_MOV, R9, 9),
3520 			BPF_ALU64_REG(BPF_MUL, R0, R0),
3521 			BPF_ALU64_REG(BPF_MUL, R0, R1),
3522 			BPF_ALU64_REG(BPF_MUL, R0, R2),
3523 			BPF_ALU64_REG(BPF_MUL, R0, R3),
3524 			BPF_ALU64_REG(BPF_MUL, R0, R4),
3525 			BPF_ALU64_REG(BPF_MUL, R0, R5),
3526 			BPF_ALU64_REG(BPF_MUL, R0, R6),
3527 			BPF_ALU64_REG(BPF_MUL, R0, R7),
3528 			BPF_ALU64_REG(BPF_MUL, R0, R8),
3529 			BPF_ALU64_REG(BPF_MUL, R0, R9),
3530 			BPF_ALU64_IMM(BPF_MUL, R0, 10),
3531 			BPF_JMP_IMM(BPF_JEQ, R0, 439084800, 1),
3532 			BPF_EXIT_INSN(),
3533 			BPF_ALU64_REG(BPF_MUL, R1, R0),
3534 			BPF_ALU64_REG(BPF_MUL, R1, R2),
3535 			BPF_ALU64_REG(BPF_MUL, R1, R3),
3536 			BPF_ALU64_REG(BPF_MUL, R1, R4),
3537 			BPF_ALU64_REG(BPF_MUL, R1, R5),
3538 			BPF_ALU64_REG(BPF_MUL, R1, R6),
3539 			BPF_ALU64_REG(BPF_MUL, R1, R7),
3540 			BPF_ALU64_REG(BPF_MUL, R1, R8),
3541 			BPF_ALU64_REG(BPF_MUL, R1, R9),
3542 			BPF_ALU64_IMM(BPF_MUL, R1, 10),
3543 			BPF_ALU64_REG(BPF_MOV, R2, R1),
3544 			BPF_ALU64_IMM(BPF_RSH, R2, 32),
3545 			BPF_JMP_IMM(BPF_JEQ, R2, 0x5a924, 1),
3546 			BPF_EXIT_INSN(),
3547 			BPF_ALU64_IMM(BPF_LSH, R1, 32),
3548 			BPF_ALU64_IMM(BPF_ARSH, R1, 32),
3549 			BPF_JMP_IMM(BPF_JEQ, R1, 0xebb90000, 1),
3550 			BPF_EXIT_INSN(),
3551 			BPF_ALU64_REG(BPF_MUL, R2, R0),
3552 			BPF_ALU64_REG(BPF_MUL, R2, R1),
3553 			BPF_ALU64_REG(BPF_MUL, R2, R3),
3554 			BPF_ALU64_REG(BPF_MUL, R2, R4),
3555 			BPF_ALU64_REG(BPF_MUL, R2, R5),
3556 			BPF_ALU64_REG(BPF_MUL, R2, R6),
3557 			BPF_ALU64_REG(BPF_MUL, R2, R7),
3558 			BPF_ALU64_REG(BPF_MUL, R2, R8),
3559 			BPF_ALU64_REG(BPF_MUL, R2, R9),
3560 			BPF_ALU64_IMM(BPF_MUL, R2, 10),
3561 			BPF_ALU64_IMM(BPF_RSH, R2, 32),
3562 			BPF_ALU64_REG(BPF_MOV, R0, R2),
3563 			BPF_EXIT_INSN(),
3564 		},
3565 		INTERNAL,
3566 		{ },
3567 		{ { 0, 0x35d97ef2 } }
3568 	},
3569 	{	/* Mainly checking JIT here. */
3570 		"MOV REG64",
3571 		.u.insns_int = {
3572 			BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
3573 			BPF_MOV64_REG(R1, R0),
3574 			BPF_MOV64_REG(R2, R1),
3575 			BPF_MOV64_REG(R3, R2),
3576 			BPF_MOV64_REG(R4, R3),
3577 			BPF_MOV64_REG(R5, R4),
3578 			BPF_MOV64_REG(R6, R5),
3579 			BPF_MOV64_REG(R7, R6),
3580 			BPF_MOV64_REG(R8, R7),
3581 			BPF_MOV64_REG(R9, R8),
3582 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
3583 			BPF_ALU64_IMM(BPF_MOV, R1, 0),
3584 			BPF_ALU64_IMM(BPF_MOV, R2, 0),
3585 			BPF_ALU64_IMM(BPF_MOV, R3, 0),
3586 			BPF_ALU64_IMM(BPF_MOV, R4, 0),
3587 			BPF_ALU64_IMM(BPF_MOV, R5, 0),
3588 			BPF_ALU64_IMM(BPF_MOV, R6, 0),
3589 			BPF_ALU64_IMM(BPF_MOV, R7, 0),
3590 			BPF_ALU64_IMM(BPF_MOV, R8, 0),
3591 			BPF_ALU64_IMM(BPF_MOV, R9, 0),
3592 			BPF_ALU64_REG(BPF_ADD, R0, R0),
3593 			BPF_ALU64_REG(BPF_ADD, R0, R1),
3594 			BPF_ALU64_REG(BPF_ADD, R0, R2),
3595 			BPF_ALU64_REG(BPF_ADD, R0, R3),
3596 			BPF_ALU64_REG(BPF_ADD, R0, R4),
3597 			BPF_ALU64_REG(BPF_ADD, R0, R5),
3598 			BPF_ALU64_REG(BPF_ADD, R0, R6),
3599 			BPF_ALU64_REG(BPF_ADD, R0, R7),
3600 			BPF_ALU64_REG(BPF_ADD, R0, R8),
3601 			BPF_ALU64_REG(BPF_ADD, R0, R9),
3602 			BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
3603 			BPF_EXIT_INSN(),
3604 		},
3605 		INTERNAL,
3606 		{ },
3607 		{ { 0, 0xfefe } }
3608 	},
3609 	{	/* Mainly checking JIT here. */
3610 		"MOV REG32",
3611 		.u.insns_int = {
3612 			BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
3613 			BPF_MOV64_REG(R1, R0),
3614 			BPF_MOV64_REG(R2, R1),
3615 			BPF_MOV64_REG(R3, R2),
3616 			BPF_MOV64_REG(R4, R3),
3617 			BPF_MOV64_REG(R5, R4),
3618 			BPF_MOV64_REG(R6, R5),
3619 			BPF_MOV64_REG(R7, R6),
3620 			BPF_MOV64_REG(R8, R7),
3621 			BPF_MOV64_REG(R9, R8),
3622 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
3623 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
3624 			BPF_ALU32_IMM(BPF_MOV, R2, 0),
3625 			BPF_ALU32_IMM(BPF_MOV, R3, 0),
3626 			BPF_ALU32_IMM(BPF_MOV, R4, 0),
3627 			BPF_ALU32_IMM(BPF_MOV, R5, 0),
3628 			BPF_ALU32_IMM(BPF_MOV, R6, 0),
3629 			BPF_ALU32_IMM(BPF_MOV, R7, 0),
3630 			BPF_ALU32_IMM(BPF_MOV, R8, 0),
3631 			BPF_ALU32_IMM(BPF_MOV, R9, 0),
3632 			BPF_ALU64_REG(BPF_ADD, R0, R0),
3633 			BPF_ALU64_REG(BPF_ADD, R0, R1),
3634 			BPF_ALU64_REG(BPF_ADD, R0, R2),
3635 			BPF_ALU64_REG(BPF_ADD, R0, R3),
3636 			BPF_ALU64_REG(BPF_ADD, R0, R4),
3637 			BPF_ALU64_REG(BPF_ADD, R0, R5),
3638 			BPF_ALU64_REG(BPF_ADD, R0, R6),
3639 			BPF_ALU64_REG(BPF_ADD, R0, R7),
3640 			BPF_ALU64_REG(BPF_ADD, R0, R8),
3641 			BPF_ALU64_REG(BPF_ADD, R0, R9),
3642 			BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
3643 			BPF_EXIT_INSN(),
3644 		},
3645 		INTERNAL,
3646 		{ },
3647 		{ { 0, 0xfefe } }
3648 	},
3649 	{	/* Mainly checking JIT here. */
3650 		"LD IMM64",
3651 		.u.insns_int = {
3652 			BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
3653 			BPF_MOV64_REG(R1, R0),
3654 			BPF_MOV64_REG(R2, R1),
3655 			BPF_MOV64_REG(R3, R2),
3656 			BPF_MOV64_REG(R4, R3),
3657 			BPF_MOV64_REG(R5, R4),
3658 			BPF_MOV64_REG(R6, R5),
3659 			BPF_MOV64_REG(R7, R6),
3660 			BPF_MOV64_REG(R8, R7),
3661 			BPF_MOV64_REG(R9, R8),
3662 			BPF_LD_IMM64(R0, 0x0LL),
3663 			BPF_LD_IMM64(R1, 0x0LL),
3664 			BPF_LD_IMM64(R2, 0x0LL),
3665 			BPF_LD_IMM64(R3, 0x0LL),
3666 			BPF_LD_IMM64(R4, 0x0LL),
3667 			BPF_LD_IMM64(R5, 0x0LL),
3668 			BPF_LD_IMM64(R6, 0x0LL),
3669 			BPF_LD_IMM64(R7, 0x0LL),
3670 			BPF_LD_IMM64(R8, 0x0LL),
3671 			BPF_LD_IMM64(R9, 0x0LL),
3672 			BPF_ALU64_REG(BPF_ADD, R0, R0),
3673 			BPF_ALU64_REG(BPF_ADD, R0, R1),
3674 			BPF_ALU64_REG(BPF_ADD, R0, R2),
3675 			BPF_ALU64_REG(BPF_ADD, R0, R3),
3676 			BPF_ALU64_REG(BPF_ADD, R0, R4),
3677 			BPF_ALU64_REG(BPF_ADD, R0, R5),
3678 			BPF_ALU64_REG(BPF_ADD, R0, R6),
3679 			BPF_ALU64_REG(BPF_ADD, R0, R7),
3680 			BPF_ALU64_REG(BPF_ADD, R0, R8),
3681 			BPF_ALU64_REG(BPF_ADD, R0, R9),
3682 			BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
3683 			BPF_EXIT_INSN(),
3684 		},
3685 		INTERNAL,
3686 		{ },
3687 		{ { 0, 0xfefe } }
3688 	},
3689 	{
3690 		"INT: ALU MIX",
3691 		.u.insns_int = {
3692 			BPF_ALU64_IMM(BPF_MOV, R0, 11),
3693 			BPF_ALU64_IMM(BPF_ADD, R0, -1),
3694 			BPF_ALU64_IMM(BPF_MOV, R2, 2),
3695 			BPF_ALU64_IMM(BPF_XOR, R2, 3),
3696 			BPF_ALU64_REG(BPF_DIV, R0, R2),
3697 			BPF_JMP_IMM(BPF_JEQ, R0, 10, 1),
3698 			BPF_EXIT_INSN(),
3699 			BPF_ALU64_IMM(BPF_MOD, R0, 3),
3700 			BPF_JMP_IMM(BPF_JEQ, R0, 1, 1),
3701 			BPF_EXIT_INSN(),
3702 			BPF_ALU64_IMM(BPF_MOV, R0, -1),
3703 			BPF_EXIT_INSN(),
3704 		},
3705 		INTERNAL,
3706 		{ },
3707 		{ { 0, -1 } }
3708 	},
3709 	{
3710 		"INT: shifts by register",
3711 		.u.insns_int = {
3712 			BPF_MOV64_IMM(R0, -1234),
3713 			BPF_MOV64_IMM(R1, 1),
3714 			BPF_ALU32_REG(BPF_RSH, R0, R1),
3715 			BPF_JMP_IMM(BPF_JEQ, R0, 0x7ffffd97, 1),
3716 			BPF_EXIT_INSN(),
3717 			BPF_MOV64_IMM(R2, 1),
3718 			BPF_ALU64_REG(BPF_LSH, R0, R2),
3719 			BPF_MOV32_IMM(R4, -1234),
3720 			BPF_JMP_REG(BPF_JEQ, R0, R4, 1),
3721 			BPF_EXIT_INSN(),
3722 			BPF_ALU64_IMM(BPF_AND, R4, 63),
3723 			BPF_ALU64_REG(BPF_LSH, R0, R4), /* R0 <= 46 */
3724 			BPF_MOV64_IMM(R3, 47),
3725 			BPF_ALU64_REG(BPF_ARSH, R0, R3),
3726 			BPF_JMP_IMM(BPF_JEQ, R0, -617, 1),
3727 			BPF_EXIT_INSN(),
3728 			BPF_MOV64_IMM(R2, 1),
3729 			BPF_ALU64_REG(BPF_LSH, R4, R2), /* R4 = 46 << 1 */
3730 			BPF_JMP_IMM(BPF_JEQ, R4, 92, 1),
3731 			BPF_EXIT_INSN(),
3732 			BPF_MOV64_IMM(R4, 4),
3733 			BPF_ALU64_REG(BPF_LSH, R4, R4), /* R4 = 4 << 4 */
3734 			BPF_JMP_IMM(BPF_JEQ, R4, 64, 1),
3735 			BPF_EXIT_INSN(),
3736 			BPF_MOV64_IMM(R4, 5),
3737 			BPF_ALU32_REG(BPF_LSH, R4, R4), /* R4 = 5 << 5 */
3738 			BPF_JMP_IMM(BPF_JEQ, R4, 160, 1),
3739 			BPF_EXIT_INSN(),
3740 			BPF_MOV64_IMM(R0, -1),
3741 			BPF_EXIT_INSN(),
3742 		},
3743 		INTERNAL,
3744 		{ },
3745 		{ { 0, -1 } }
3746 	},
3747 	{
3748 		/*
3749 		 * Register (non-)clobbering test, in the case where a 32-bit
3750 		 * JIT implements complex ALU64 operations via function calls.
3751 		 * If so, the function call must be invisible in the eBPF
3752 		 * registers. The JIT must then save and restore relevant
3753 		 * registers during the call. The following tests check that
3754 		 * the eBPF registers retain their values after such a call.
3755 		 */
3756 		"INT: Register clobbering, R1 updated",
3757 		.u.insns_int = {
3758 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
3759 			BPF_ALU32_IMM(BPF_MOV, R1, 123456789),
3760 			BPF_ALU32_IMM(BPF_MOV, R2, 2),
3761 			BPF_ALU32_IMM(BPF_MOV, R3, 3),
3762 			BPF_ALU32_IMM(BPF_MOV, R4, 4),
3763 			BPF_ALU32_IMM(BPF_MOV, R5, 5),
3764 			BPF_ALU32_IMM(BPF_MOV, R6, 6),
3765 			BPF_ALU32_IMM(BPF_MOV, R7, 7),
3766 			BPF_ALU32_IMM(BPF_MOV, R8, 8),
3767 			BPF_ALU32_IMM(BPF_MOV, R9, 9),
3768 			BPF_ALU64_IMM(BPF_DIV, R1, 123456789),
3769 			BPF_JMP_IMM(BPF_JNE, R0, 0, 10),
3770 			BPF_JMP_IMM(BPF_JNE, R1, 1, 9),
3771 			BPF_JMP_IMM(BPF_JNE, R2, 2, 8),
3772 			BPF_JMP_IMM(BPF_JNE, R3, 3, 7),
3773 			BPF_JMP_IMM(BPF_JNE, R4, 4, 6),
3774 			BPF_JMP_IMM(BPF_JNE, R5, 5, 5),
3775 			BPF_JMP_IMM(BPF_JNE, R6, 6, 4),
3776 			BPF_JMP_IMM(BPF_JNE, R7, 7, 3),
3777 			BPF_JMP_IMM(BPF_JNE, R8, 8, 2),
3778 			BPF_JMP_IMM(BPF_JNE, R9, 9, 1),
3779 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
3780 			BPF_EXIT_INSN(),
3781 		},
3782 		INTERNAL,
3783 		{ },
3784 		{ { 0, 1 } }
3785 	},
3786 	{
3787 		"INT: Register clobbering, R2 updated",
3788 		.u.insns_int = {
3789 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
3790 			BPF_ALU32_IMM(BPF_MOV, R1, 1),
3791 			BPF_ALU32_IMM(BPF_MOV, R2, 2 * 123456789),
3792 			BPF_ALU32_IMM(BPF_MOV, R3, 3),
3793 			BPF_ALU32_IMM(BPF_MOV, R4, 4),
3794 			BPF_ALU32_IMM(BPF_MOV, R5, 5),
3795 			BPF_ALU32_IMM(BPF_MOV, R6, 6),
3796 			BPF_ALU32_IMM(BPF_MOV, R7, 7),
3797 			BPF_ALU32_IMM(BPF_MOV, R8, 8),
3798 			BPF_ALU32_IMM(BPF_MOV, R9, 9),
3799 			BPF_ALU64_IMM(BPF_DIV, R2, 123456789),
3800 			BPF_JMP_IMM(BPF_JNE, R0, 0, 10),
3801 			BPF_JMP_IMM(BPF_JNE, R1, 1, 9),
3802 			BPF_JMP_IMM(BPF_JNE, R2, 2, 8),
3803 			BPF_JMP_IMM(BPF_JNE, R3, 3, 7),
3804 			BPF_JMP_IMM(BPF_JNE, R4, 4, 6),
3805 			BPF_JMP_IMM(BPF_JNE, R5, 5, 5),
3806 			BPF_JMP_IMM(BPF_JNE, R6, 6, 4),
3807 			BPF_JMP_IMM(BPF_JNE, R7, 7, 3),
3808 			BPF_JMP_IMM(BPF_JNE, R8, 8, 2),
3809 			BPF_JMP_IMM(BPF_JNE, R9, 9, 1),
3810 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
3811 			BPF_EXIT_INSN(),
3812 		},
3813 		INTERNAL,
3814 		{ },
3815 		{ { 0, 1 } }
3816 	},
3817 	{
3818 		/*
3819 		 * Test 32-bit JITs that implement complex ALU64 operations as
3820 		 * function calls R0 = f(R1, R2), and must re-arrange operands.
3821 		 */
3822 #define NUMER 0xfedcba9876543210ULL
3823 #define DENOM 0x0123456789abcdefULL
3824 		"ALU64_DIV X: Operand register permutations",
3825 		.u.insns_int = {
3826 			/* R0 / R2 */
3827 			BPF_LD_IMM64(R0, NUMER),
3828 			BPF_LD_IMM64(R2, DENOM),
3829 			BPF_ALU64_REG(BPF_DIV, R0, R2),
3830 			BPF_JMP_IMM(BPF_JEQ, R0, NUMER / DENOM, 1),
3831 			BPF_EXIT_INSN(),
3832 			/* R1 / R0 */
3833 			BPF_LD_IMM64(R1, NUMER),
3834 			BPF_LD_IMM64(R0, DENOM),
3835 			BPF_ALU64_REG(BPF_DIV, R1, R0),
3836 			BPF_JMP_IMM(BPF_JEQ, R1, NUMER / DENOM, 1),
3837 			BPF_EXIT_INSN(),
3838 			/* R0 / R1 */
3839 			BPF_LD_IMM64(R0, NUMER),
3840 			BPF_LD_IMM64(R1, DENOM),
3841 			BPF_ALU64_REG(BPF_DIV, R0, R1),
3842 			BPF_JMP_IMM(BPF_JEQ, R0, NUMER / DENOM, 1),
3843 			BPF_EXIT_INSN(),
3844 			/* R2 / R0 */
3845 			BPF_LD_IMM64(R2, NUMER),
3846 			BPF_LD_IMM64(R0, DENOM),
3847 			BPF_ALU64_REG(BPF_DIV, R2, R0),
3848 			BPF_JMP_IMM(BPF_JEQ, R2, NUMER / DENOM, 1),
3849 			BPF_EXIT_INSN(),
3850 			/* R2 / R1 */
3851 			BPF_LD_IMM64(R2, NUMER),
3852 			BPF_LD_IMM64(R1, DENOM),
3853 			BPF_ALU64_REG(BPF_DIV, R2, R1),
3854 			BPF_JMP_IMM(BPF_JEQ, R2, NUMER / DENOM, 1),
3855 			BPF_EXIT_INSN(),
3856 			/* R1 / R2 */
3857 			BPF_LD_IMM64(R1, NUMER),
3858 			BPF_LD_IMM64(R2, DENOM),
3859 			BPF_ALU64_REG(BPF_DIV, R1, R2),
3860 			BPF_JMP_IMM(BPF_JEQ, R1, NUMER / DENOM, 1),
3861 			BPF_EXIT_INSN(),
3862 			/* R1 / R1 */
3863 			BPF_LD_IMM64(R1, NUMER),
3864 			BPF_ALU64_REG(BPF_DIV, R1, R1),
3865 			BPF_JMP_IMM(BPF_JEQ, R1, 1, 1),
3866 			BPF_EXIT_INSN(),
3867 			/* R2 / R2 */
3868 			BPF_LD_IMM64(R2, DENOM),
3869 			BPF_ALU64_REG(BPF_DIV, R2, R2),
3870 			BPF_JMP_IMM(BPF_JEQ, R2, 1, 1),
3871 			BPF_EXIT_INSN(),
3872 			/* R3 / R4 */
3873 			BPF_LD_IMM64(R3, NUMER),
3874 			BPF_LD_IMM64(R4, DENOM),
3875 			BPF_ALU64_REG(BPF_DIV, R3, R4),
3876 			BPF_JMP_IMM(BPF_JEQ, R3, NUMER / DENOM, 1),
3877 			BPF_EXIT_INSN(),
3878 			/* Successful return */
3879 			BPF_LD_IMM64(R0, 1),
3880 			BPF_EXIT_INSN(),
3881 		},
3882 		INTERNAL,
3883 		{ },
3884 		{ { 0, 1 } },
3885 #undef NUMER
3886 #undef DENOM
3887 	},
3888 #ifdef CONFIG_32BIT
3889 	{
3890 		"INT: 32-bit context pointer word order and zero-extension",
3891 		.u.insns_int = {
3892 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
3893 			BPF_JMP32_IMM(BPF_JEQ, R1, 0, 3),
3894 			BPF_ALU64_IMM(BPF_RSH, R1, 32),
3895 			BPF_JMP32_IMM(BPF_JNE, R1, 0, 1),
3896 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
3897 			BPF_EXIT_INSN(),
3898 		},
3899 		INTERNAL,
3900 		{ },
3901 		{ { 0, 1 } }
3902 	},
3903 #endif
3904 	{
3905 		"check: missing ret",
3906 		.u.insns = {
3907 			BPF_STMT(BPF_LD | BPF_IMM, 1),
3908 		},
3909 		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
3910 		{ },
3911 		{ },
3912 		.fill_helper = NULL,
3913 		.expected_errcode = -EINVAL,
3914 	},
3915 	{
3916 		"check: div_k_0",
3917 		.u.insns = {
3918 			BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0),
3919 			BPF_STMT(BPF_RET | BPF_K, 0)
3920 		},
3921 		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
3922 		{ },
3923 		{ },
3924 		.fill_helper = NULL,
3925 		.expected_errcode = -EINVAL,
3926 	},
3927 	{
3928 		"check: unknown insn",
3929 		.u.insns = {
3930 			/* seccomp insn, rejected in socket filter */
3931 			BPF_STMT(BPF_LDX | BPF_W | BPF_ABS, 0),
3932 			BPF_STMT(BPF_RET | BPF_K, 0)
3933 		},
3934 		CLASSIC | FLAG_EXPECTED_FAIL,
3935 		{ },
3936 		{ },
3937 		.fill_helper = NULL,
3938 		.expected_errcode = -EINVAL,
3939 	},
3940 	{
3941 		"check: out of range spill/fill",
3942 		.u.insns = {
3943 			BPF_STMT(BPF_STX, 16),
3944 			BPF_STMT(BPF_RET | BPF_K, 0)
3945 		},
3946 		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
3947 		{ },
3948 		{ },
3949 		.fill_helper = NULL,
3950 		.expected_errcode = -EINVAL,
3951 	},
3952 	{
3953 		"JUMPS + HOLES",
3954 		.u.insns = {
3955 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3956 			BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 15),
3957 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3958 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3959 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3960 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3961 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3962 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3963 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3964 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3965 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3966 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3967 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3968 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3969 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3970 			BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 3, 4),
3971 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3972 			BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 1, 2),
3973 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3974 			BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
3975 			BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
3976 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3977 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3978 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3979 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3980 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3981 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3982 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3983 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3984 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3985 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3986 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3987 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3988 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3989 			BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 2, 3),
3990 			BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 1, 2),
3991 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3992 			BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
3993 			BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
3994 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3995 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3996 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3997 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3998 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3999 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4000 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4001 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4002 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4003 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4004 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4005 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4006 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4007 			BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 2, 3),
4008 			BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 1, 2),
4009 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4010 			BPF_STMT(BPF_RET | BPF_A, 0),
4011 			BPF_STMT(BPF_RET | BPF_A, 0),
4012 		},
4013 		CLASSIC,
4014 		{ 0x00, 0x1b, 0x21, 0x3c, 0x9d, 0xf8,
4015 		  0x90, 0xe2, 0xba, 0x0a, 0x56, 0xb4,
4016 		  0x08, 0x00,
4017 		  0x45, 0x00, 0x00, 0x28, 0x00, 0x00,
4018 		  0x20, 0x00, 0x40, 0x11, 0x00, 0x00, /* IP header */
4019 		  0xc0, 0xa8, 0x33, 0x01,
4020 		  0xc0, 0xa8, 0x33, 0x02,
4021 		  0xbb, 0xb6,
4022 		  0xa9, 0xfa,
4023 		  0x00, 0x14, 0x00, 0x00,
4024 		  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4025 		  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4026 		  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4027 		  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4028 		  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4029 		  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4030 		  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4031 		  0xcc, 0xcc, 0xcc, 0xcc },
4032 		{ { 88, 0x001b } }
4033 	},
4034 	{
4035 		"check: RET X",
4036 		.u.insns = {
4037 			BPF_STMT(BPF_RET | BPF_X, 0),
4038 		},
4039 		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4040 		{ },
4041 		{ },
4042 		.fill_helper = NULL,
4043 		.expected_errcode = -EINVAL,
4044 	},
4045 	{
4046 		"check: LDX + RET X",
4047 		.u.insns = {
4048 			BPF_STMT(BPF_LDX | BPF_IMM, 42),
4049 			BPF_STMT(BPF_RET | BPF_X, 0),
4050 		},
4051 		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4052 		{ },
4053 		{ },
4054 		.fill_helper = NULL,
4055 		.expected_errcode = -EINVAL,
4056 	},
4057 	{	/* Mainly checking JIT here. */
4058 		"M[]: alt STX + LDX",
4059 		.u.insns = {
4060 			BPF_STMT(BPF_LDX | BPF_IMM, 100),
4061 			BPF_STMT(BPF_STX, 0),
4062 			BPF_STMT(BPF_LDX | BPF_MEM, 0),
4063 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4064 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4065 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4066 			BPF_STMT(BPF_STX, 1),
4067 			BPF_STMT(BPF_LDX | BPF_MEM, 1),
4068 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4069 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4070 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4071 			BPF_STMT(BPF_STX, 2),
4072 			BPF_STMT(BPF_LDX | BPF_MEM, 2),
4073 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4074 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4075 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4076 			BPF_STMT(BPF_STX, 3),
4077 			BPF_STMT(BPF_LDX | BPF_MEM, 3),
4078 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4079 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4080 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4081 			BPF_STMT(BPF_STX, 4),
4082 			BPF_STMT(BPF_LDX | BPF_MEM, 4),
4083 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4084 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4085 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4086 			BPF_STMT(BPF_STX, 5),
4087 			BPF_STMT(BPF_LDX | BPF_MEM, 5),
4088 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4089 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4090 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4091 			BPF_STMT(BPF_STX, 6),
4092 			BPF_STMT(BPF_LDX | BPF_MEM, 6),
4093 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4094 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4095 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4096 			BPF_STMT(BPF_STX, 7),
4097 			BPF_STMT(BPF_LDX | BPF_MEM, 7),
4098 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4099 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4100 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4101 			BPF_STMT(BPF_STX, 8),
4102 			BPF_STMT(BPF_LDX | BPF_MEM, 8),
4103 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4104 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4105 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4106 			BPF_STMT(BPF_STX, 9),
4107 			BPF_STMT(BPF_LDX | BPF_MEM, 9),
4108 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4109 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4110 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4111 			BPF_STMT(BPF_STX, 10),
4112 			BPF_STMT(BPF_LDX | BPF_MEM, 10),
4113 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4114 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4115 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4116 			BPF_STMT(BPF_STX, 11),
4117 			BPF_STMT(BPF_LDX | BPF_MEM, 11),
4118 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4119 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4120 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4121 			BPF_STMT(BPF_STX, 12),
4122 			BPF_STMT(BPF_LDX | BPF_MEM, 12),
4123 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4124 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4125 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4126 			BPF_STMT(BPF_STX, 13),
4127 			BPF_STMT(BPF_LDX | BPF_MEM, 13),
4128 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4129 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4130 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4131 			BPF_STMT(BPF_STX, 14),
4132 			BPF_STMT(BPF_LDX | BPF_MEM, 14),
4133 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4134 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4135 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4136 			BPF_STMT(BPF_STX, 15),
4137 			BPF_STMT(BPF_LDX | BPF_MEM, 15),
4138 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4139 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4140 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4141 			BPF_STMT(BPF_RET | BPF_A, 0),
4142 		},
4143 		CLASSIC | FLAG_NO_DATA,
4144 		{ },
4145 		{ { 0, 116 } },
4146 	},
4147 	{	/* Mainly checking JIT here. */
4148 		"M[]: full STX + full LDX",
4149 		.u.insns = {
4150 			BPF_STMT(BPF_LDX | BPF_IMM, 0xbadfeedb),
4151 			BPF_STMT(BPF_STX, 0),
4152 			BPF_STMT(BPF_LDX | BPF_IMM, 0xecabedae),
4153 			BPF_STMT(BPF_STX, 1),
4154 			BPF_STMT(BPF_LDX | BPF_IMM, 0xafccfeaf),
4155 			BPF_STMT(BPF_STX, 2),
4156 			BPF_STMT(BPF_LDX | BPF_IMM, 0xbffdcedc),
4157 			BPF_STMT(BPF_STX, 3),
4158 			BPF_STMT(BPF_LDX | BPF_IMM, 0xfbbbdccb),
4159 			BPF_STMT(BPF_STX, 4),
4160 			BPF_STMT(BPF_LDX | BPF_IMM, 0xfbabcbda),
4161 			BPF_STMT(BPF_STX, 5),
4162 			BPF_STMT(BPF_LDX | BPF_IMM, 0xaedecbdb),
4163 			BPF_STMT(BPF_STX, 6),
4164 			BPF_STMT(BPF_LDX | BPF_IMM, 0xadebbade),
4165 			BPF_STMT(BPF_STX, 7),
4166 			BPF_STMT(BPF_LDX | BPF_IMM, 0xfcfcfaec),
4167 			BPF_STMT(BPF_STX, 8),
4168 			BPF_STMT(BPF_LDX | BPF_IMM, 0xbcdddbdc),
4169 			BPF_STMT(BPF_STX, 9),
4170 			BPF_STMT(BPF_LDX | BPF_IMM, 0xfeefdfac),
4171 			BPF_STMT(BPF_STX, 10),
4172 			BPF_STMT(BPF_LDX | BPF_IMM, 0xcddcdeea),
4173 			BPF_STMT(BPF_STX, 11),
4174 			BPF_STMT(BPF_LDX | BPF_IMM, 0xaccfaebb),
4175 			BPF_STMT(BPF_STX, 12),
4176 			BPF_STMT(BPF_LDX | BPF_IMM, 0xbdcccdcf),
4177 			BPF_STMT(BPF_STX, 13),
4178 			BPF_STMT(BPF_LDX | BPF_IMM, 0xaaedecde),
4179 			BPF_STMT(BPF_STX, 14),
4180 			BPF_STMT(BPF_LDX | BPF_IMM, 0xfaeacdad),
4181 			BPF_STMT(BPF_STX, 15),
4182 			BPF_STMT(BPF_LDX | BPF_MEM, 0),
4183 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4184 			BPF_STMT(BPF_LDX | BPF_MEM, 1),
4185 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4186 			BPF_STMT(BPF_LDX | BPF_MEM, 2),
4187 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4188 			BPF_STMT(BPF_LDX | BPF_MEM, 3),
4189 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4190 			BPF_STMT(BPF_LDX | BPF_MEM, 4),
4191 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4192 			BPF_STMT(BPF_LDX | BPF_MEM, 5),
4193 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4194 			BPF_STMT(BPF_LDX | BPF_MEM, 6),
4195 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4196 			BPF_STMT(BPF_LDX | BPF_MEM, 7),
4197 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4198 			BPF_STMT(BPF_LDX | BPF_MEM, 8),
4199 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4200 			BPF_STMT(BPF_LDX | BPF_MEM, 9),
4201 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4202 			BPF_STMT(BPF_LDX | BPF_MEM, 10),
4203 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4204 			BPF_STMT(BPF_LDX | BPF_MEM, 11),
4205 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4206 			BPF_STMT(BPF_LDX | BPF_MEM, 12),
4207 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4208 			BPF_STMT(BPF_LDX | BPF_MEM, 13),
4209 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4210 			BPF_STMT(BPF_LDX | BPF_MEM, 14),
4211 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4212 			BPF_STMT(BPF_LDX | BPF_MEM, 15),
4213 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4214 			BPF_STMT(BPF_RET | BPF_A, 0),
4215 		},
4216 		CLASSIC | FLAG_NO_DATA,
4217 		{ },
4218 		{ { 0, 0x2a5a5e5 } },
4219 	},
4220 	{
4221 		"check: SKF_AD_MAX",
4222 		.u.insns = {
4223 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
4224 				 SKF_AD_OFF + SKF_AD_MAX),
4225 			BPF_STMT(BPF_RET | BPF_A, 0),
4226 		},
4227 		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4228 		{ },
4229 		{ },
4230 		.fill_helper = NULL,
4231 		.expected_errcode = -EINVAL,
4232 	},
4233 	{	/* Passes checker but fails during runtime. */
4234 		"LD [SKF_AD_OFF-1]",
4235 		.u.insns = {
4236 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
4237 				 SKF_AD_OFF - 1),
4238 			BPF_STMT(BPF_RET | BPF_K, 1),
4239 		},
4240 		CLASSIC,
4241 		{ },
4242 		{ { 1, 0 } },
4243 	},
4244 	{
4245 		"load 64-bit immediate",
4246 		.u.insns_int = {
4247 			BPF_LD_IMM64(R1, 0x567800001234LL),
4248 			BPF_MOV64_REG(R2, R1),
4249 			BPF_MOV64_REG(R3, R2),
4250 			BPF_ALU64_IMM(BPF_RSH, R2, 32),
4251 			BPF_ALU64_IMM(BPF_LSH, R3, 32),
4252 			BPF_ALU64_IMM(BPF_RSH, R3, 32),
4253 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
4254 			BPF_JMP_IMM(BPF_JEQ, R2, 0x5678, 1),
4255 			BPF_EXIT_INSN(),
4256 			BPF_JMP_IMM(BPF_JEQ, R3, 0x1234, 1),
4257 			BPF_EXIT_INSN(),
4258 			BPF_LD_IMM64(R0, 0x1ffffffffLL),
4259 			BPF_ALU64_IMM(BPF_RSH, R0, 32), /* R0 = 1 */
4260 			BPF_EXIT_INSN(),
4261 		},
4262 		INTERNAL,
4263 		{ },
4264 		{ { 0, 1 } }
4265 	},
4266 	/* BPF_ALU | BPF_MOV | BPF_X */
4267 	{
4268 		"ALU_MOV_X: dst = 2",
4269 		.u.insns_int = {
4270 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
4271 			BPF_ALU32_REG(BPF_MOV, R0, R1),
4272 			BPF_EXIT_INSN(),
4273 		},
4274 		INTERNAL,
4275 		{ },
4276 		{ { 0, 2 } },
4277 	},
4278 	{
4279 		"ALU_MOV_X: dst = 4294967295",
4280 		.u.insns_int = {
4281 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
4282 			BPF_ALU32_REG(BPF_MOV, R0, R1),
4283 			BPF_EXIT_INSN(),
4284 		},
4285 		INTERNAL,
4286 		{ },
4287 		{ { 0, 4294967295U } },
4288 	},
4289 	{
4290 		"ALU64_MOV_X: dst = 2",
4291 		.u.insns_int = {
4292 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
4293 			BPF_ALU64_REG(BPF_MOV, R0, R1),
4294 			BPF_EXIT_INSN(),
4295 		},
4296 		INTERNAL,
4297 		{ },
4298 		{ { 0, 2 } },
4299 	},
4300 	{
4301 		"ALU64_MOV_X: dst = 4294967295",
4302 		.u.insns_int = {
4303 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
4304 			BPF_ALU64_REG(BPF_MOV, R0, R1),
4305 			BPF_EXIT_INSN(),
4306 		},
4307 		INTERNAL,
4308 		{ },
4309 		{ { 0, 4294967295U } },
4310 	},
4311 	/* BPF_ALU | BPF_MOV | BPF_K */
4312 	{
4313 		"ALU_MOV_K: dst = 2",
4314 		.u.insns_int = {
4315 			BPF_ALU32_IMM(BPF_MOV, R0, 2),
4316 			BPF_EXIT_INSN(),
4317 		},
4318 		INTERNAL,
4319 		{ },
4320 		{ { 0, 2 } },
4321 	},
4322 	{
4323 		"ALU_MOV_K: dst = 4294967295",
4324 		.u.insns_int = {
4325 			BPF_ALU32_IMM(BPF_MOV, R0, 4294967295U),
4326 			BPF_EXIT_INSN(),
4327 		},
4328 		INTERNAL,
4329 		{ },
4330 		{ { 0, 4294967295U } },
4331 	},
4332 	{
4333 		"ALU_MOV_K: 0x0000ffffffff0000 = 0x00000000ffffffff",
4334 		.u.insns_int = {
4335 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
4336 			BPF_LD_IMM64(R3, 0x00000000ffffffffLL),
4337 			BPF_ALU32_IMM(BPF_MOV, R2, 0xffffffff),
4338 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4339 			BPF_MOV32_IMM(R0, 2),
4340 			BPF_EXIT_INSN(),
4341 			BPF_MOV32_IMM(R0, 1),
4342 			BPF_EXIT_INSN(),
4343 		},
4344 		INTERNAL,
4345 		{ },
4346 		{ { 0, 0x1 } },
4347 	},
4348 	{
4349 		"ALU_MOV_K: small negative",
4350 		.u.insns_int = {
4351 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
4352 			BPF_EXIT_INSN(),
4353 		},
4354 		INTERNAL,
4355 		{ },
4356 		{ { 0, -123 } }
4357 	},
4358 	{
4359 		"ALU_MOV_K: small negative zero extension",
4360 		.u.insns_int = {
4361 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
4362 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
4363 			BPF_EXIT_INSN(),
4364 		},
4365 		INTERNAL,
4366 		{ },
4367 		{ { 0, 0 } }
4368 	},
4369 	{
4370 		"ALU_MOV_K: large negative",
4371 		.u.insns_int = {
4372 			BPF_ALU32_IMM(BPF_MOV, R0, -123456789),
4373 			BPF_EXIT_INSN(),
4374 		},
4375 		INTERNAL,
4376 		{ },
4377 		{ { 0, -123456789 } }
4378 	},
4379 	{
4380 		"ALU_MOV_K: large negative zero extension",
4381 		.u.insns_int = {
4382 			BPF_ALU32_IMM(BPF_MOV, R0, -123456789),
4383 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
4384 			BPF_EXIT_INSN(),
4385 		},
4386 		INTERNAL,
4387 		{ },
4388 		{ { 0, 0 } }
4389 	},
4390 	{
4391 		"ALU64_MOV_K: dst = 2",
4392 		.u.insns_int = {
4393 			BPF_ALU64_IMM(BPF_MOV, R0, 2),
4394 			BPF_EXIT_INSN(),
4395 		},
4396 		INTERNAL,
4397 		{ },
4398 		{ { 0, 2 } },
4399 	},
4400 	{
4401 		"ALU64_MOV_K: dst = 2147483647",
4402 		.u.insns_int = {
4403 			BPF_ALU64_IMM(BPF_MOV, R0, 2147483647),
4404 			BPF_EXIT_INSN(),
4405 		},
4406 		INTERNAL,
4407 		{ },
4408 		{ { 0, 2147483647 } },
4409 	},
4410 	{
4411 		"ALU64_OR_K: dst = 0x0",
4412 		.u.insns_int = {
4413 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
4414 			BPF_LD_IMM64(R3, 0x0),
4415 			BPF_ALU64_IMM(BPF_MOV, R2, 0x0),
4416 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4417 			BPF_MOV32_IMM(R0, 2),
4418 			BPF_EXIT_INSN(),
4419 			BPF_MOV32_IMM(R0, 1),
4420 			BPF_EXIT_INSN(),
4421 		},
4422 		INTERNAL,
4423 		{ },
4424 		{ { 0, 0x1 } },
4425 	},
4426 	{
4427 		"ALU64_MOV_K: dst = -1",
4428 		.u.insns_int = {
4429 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
4430 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
4431 			BPF_ALU64_IMM(BPF_MOV, R2, 0xffffffff),
4432 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4433 			BPF_MOV32_IMM(R0, 2),
4434 			BPF_EXIT_INSN(),
4435 			BPF_MOV32_IMM(R0, 1),
4436 			BPF_EXIT_INSN(),
4437 		},
4438 		INTERNAL,
4439 		{ },
4440 		{ { 0, 0x1 } },
4441 	},
4442 	{
4443 		"ALU64_MOV_K: small negative",
4444 		.u.insns_int = {
4445 			BPF_ALU64_IMM(BPF_MOV, R0, -123),
4446 			BPF_EXIT_INSN(),
4447 		},
4448 		INTERNAL,
4449 		{ },
4450 		{ { 0, -123 } }
4451 	},
4452 	{
4453 		"ALU64_MOV_K: small negative sign extension",
4454 		.u.insns_int = {
4455 			BPF_ALU64_IMM(BPF_MOV, R0, -123),
4456 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
4457 			BPF_EXIT_INSN(),
4458 		},
4459 		INTERNAL,
4460 		{ },
4461 		{ { 0, 0xffffffff } }
4462 	},
4463 	{
4464 		"ALU64_MOV_K: large negative",
4465 		.u.insns_int = {
4466 			BPF_ALU64_IMM(BPF_MOV, R0, -123456789),
4467 			BPF_EXIT_INSN(),
4468 		},
4469 		INTERNAL,
4470 		{ },
4471 		{ { 0, -123456789 } }
4472 	},
4473 	{
4474 		"ALU64_MOV_K: large negative sign extension",
4475 		.u.insns_int = {
4476 			BPF_ALU64_IMM(BPF_MOV, R0, -123456789),
4477 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
4478 			BPF_EXIT_INSN(),
4479 		},
4480 		INTERNAL,
4481 		{ },
4482 		{ { 0, 0xffffffff } }
4483 	},
4484 	/* BPF_ALU | BPF_ADD | BPF_X */
4485 	{
4486 		"ALU_ADD_X: 1 + 2 = 3",
4487 		.u.insns_int = {
4488 			BPF_LD_IMM64(R0, 1),
4489 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
4490 			BPF_ALU32_REG(BPF_ADD, R0, R1),
4491 			BPF_EXIT_INSN(),
4492 		},
4493 		INTERNAL,
4494 		{ },
4495 		{ { 0, 3 } },
4496 	},
4497 	{
4498 		"ALU_ADD_X: 1 + 4294967294 = 4294967295",
4499 		.u.insns_int = {
4500 			BPF_LD_IMM64(R0, 1),
4501 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
4502 			BPF_ALU32_REG(BPF_ADD, R0, R1),
4503 			BPF_EXIT_INSN(),
4504 		},
4505 		INTERNAL,
4506 		{ },
4507 		{ { 0, 4294967295U } },
4508 	},
4509 	{
4510 		"ALU_ADD_X: 2 + 4294967294 = 0",
4511 		.u.insns_int = {
4512 			BPF_LD_IMM64(R0, 2),
4513 			BPF_LD_IMM64(R1, 4294967294U),
4514 			BPF_ALU32_REG(BPF_ADD, R0, R1),
4515 			BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
4516 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
4517 			BPF_EXIT_INSN(),
4518 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
4519 			BPF_EXIT_INSN(),
4520 		},
4521 		INTERNAL,
4522 		{ },
4523 		{ { 0, 1 } },
4524 	},
4525 	{
4526 		"ALU64_ADD_X: 1 + 2 = 3",
4527 		.u.insns_int = {
4528 			BPF_LD_IMM64(R0, 1),
4529 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
4530 			BPF_ALU64_REG(BPF_ADD, R0, R1),
4531 			BPF_EXIT_INSN(),
4532 		},
4533 		INTERNAL,
4534 		{ },
4535 		{ { 0, 3 } },
4536 	},
4537 	{
4538 		"ALU64_ADD_X: 1 + 4294967294 = 4294967295",
4539 		.u.insns_int = {
4540 			BPF_LD_IMM64(R0, 1),
4541 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
4542 			BPF_ALU64_REG(BPF_ADD, R0, R1),
4543 			BPF_EXIT_INSN(),
4544 		},
4545 		INTERNAL,
4546 		{ },
4547 		{ { 0, 4294967295U } },
4548 	},
4549 	{
4550 		"ALU64_ADD_X: 2 + 4294967294 = 4294967296",
4551 		.u.insns_int = {
4552 			BPF_LD_IMM64(R0, 2),
4553 			BPF_LD_IMM64(R1, 4294967294U),
4554 			BPF_LD_IMM64(R2, 4294967296ULL),
4555 			BPF_ALU64_REG(BPF_ADD, R0, R1),
4556 			BPF_JMP_REG(BPF_JEQ, R0, R2, 2),
4557 			BPF_MOV32_IMM(R0, 0),
4558 			BPF_EXIT_INSN(),
4559 			BPF_MOV32_IMM(R0, 1),
4560 			BPF_EXIT_INSN(),
4561 		},
4562 		INTERNAL,
4563 		{ },
4564 		{ { 0, 1 } },
4565 	},
4566 	/* BPF_ALU | BPF_ADD | BPF_K */
4567 	{
4568 		"ALU_ADD_K: 1 + 2 = 3",
4569 		.u.insns_int = {
4570 			BPF_LD_IMM64(R0, 1),
4571 			BPF_ALU32_IMM(BPF_ADD, R0, 2),
4572 			BPF_EXIT_INSN(),
4573 		},
4574 		INTERNAL,
4575 		{ },
4576 		{ { 0, 3 } },
4577 	},
4578 	{
4579 		"ALU_ADD_K: 3 + 0 = 3",
4580 		.u.insns_int = {
4581 			BPF_LD_IMM64(R0, 3),
4582 			BPF_ALU32_IMM(BPF_ADD, R0, 0),
4583 			BPF_EXIT_INSN(),
4584 		},
4585 		INTERNAL,
4586 		{ },
4587 		{ { 0, 3 } },
4588 	},
4589 	{
4590 		"ALU_ADD_K: 1 + 4294967294 = 4294967295",
4591 		.u.insns_int = {
4592 			BPF_LD_IMM64(R0, 1),
4593 			BPF_ALU32_IMM(BPF_ADD, R0, 4294967294U),
4594 			BPF_EXIT_INSN(),
4595 		},
4596 		INTERNAL,
4597 		{ },
4598 		{ { 0, 4294967295U } },
4599 	},
4600 	{
4601 		"ALU_ADD_K: 4294967294 + 2 = 0",
4602 		.u.insns_int = {
4603 			BPF_LD_IMM64(R0, 4294967294U),
4604 			BPF_ALU32_IMM(BPF_ADD, R0, 2),
4605 			BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
4606 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
4607 			BPF_EXIT_INSN(),
4608 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
4609 			BPF_EXIT_INSN(),
4610 		},
4611 		INTERNAL,
4612 		{ },
4613 		{ { 0, 1 } },
4614 	},
4615 	{
4616 		"ALU_ADD_K: 0 + (-1) = 0x00000000ffffffff",
4617 		.u.insns_int = {
4618 			BPF_LD_IMM64(R2, 0x0),
4619 			BPF_LD_IMM64(R3, 0x00000000ffffffff),
4620 			BPF_ALU32_IMM(BPF_ADD, R2, 0xffffffff),
4621 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4622 			BPF_MOV32_IMM(R0, 2),
4623 			BPF_EXIT_INSN(),
4624 			BPF_MOV32_IMM(R0, 1),
4625 			BPF_EXIT_INSN(),
4626 		},
4627 		INTERNAL,
4628 		{ },
4629 		{ { 0, 0x1 } },
4630 	},
4631 	{
4632 		"ALU_ADD_K: 0 + 0xffff = 0xffff",
4633 		.u.insns_int = {
4634 			BPF_LD_IMM64(R2, 0x0),
4635 			BPF_LD_IMM64(R3, 0xffff),
4636 			BPF_ALU32_IMM(BPF_ADD, R2, 0xffff),
4637 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4638 			BPF_MOV32_IMM(R0, 2),
4639 			BPF_EXIT_INSN(),
4640 			BPF_MOV32_IMM(R0, 1),
4641 			BPF_EXIT_INSN(),
4642 		},
4643 		INTERNAL,
4644 		{ },
4645 		{ { 0, 0x1 } },
4646 	},
4647 	{
4648 		"ALU_ADD_K: 0 + 0x7fffffff = 0x7fffffff",
4649 		.u.insns_int = {
4650 			BPF_LD_IMM64(R2, 0x0),
4651 			BPF_LD_IMM64(R3, 0x7fffffff),
4652 			BPF_ALU32_IMM(BPF_ADD, R2, 0x7fffffff),
4653 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4654 			BPF_MOV32_IMM(R0, 2),
4655 			BPF_EXIT_INSN(),
4656 			BPF_MOV32_IMM(R0, 1),
4657 			BPF_EXIT_INSN(),
4658 		},
4659 		INTERNAL,
4660 		{ },
4661 		{ { 0, 0x1 } },
4662 	},
4663 	{
4664 		"ALU_ADD_K: 0 + 0x80000000 = 0x80000000",
4665 		.u.insns_int = {
4666 			BPF_LD_IMM64(R2, 0x0),
4667 			BPF_LD_IMM64(R3, 0x80000000),
4668 			BPF_ALU32_IMM(BPF_ADD, R2, 0x80000000),
4669 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4670 			BPF_MOV32_IMM(R0, 2),
4671 			BPF_EXIT_INSN(),
4672 			BPF_MOV32_IMM(R0, 1),
4673 			BPF_EXIT_INSN(),
4674 		},
4675 		INTERNAL,
4676 		{ },
4677 		{ { 0, 0x1 } },
4678 	},
4679 	{
4680 		"ALU_ADD_K: 0 + 0x80008000 = 0x80008000",
4681 		.u.insns_int = {
4682 			BPF_LD_IMM64(R2, 0x0),
4683 			BPF_LD_IMM64(R3, 0x80008000),
4684 			BPF_ALU32_IMM(BPF_ADD, R2, 0x80008000),
4685 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4686 			BPF_MOV32_IMM(R0, 2),
4687 			BPF_EXIT_INSN(),
4688 			BPF_MOV32_IMM(R0, 1),
4689 			BPF_EXIT_INSN(),
4690 		},
4691 		INTERNAL,
4692 		{ },
4693 		{ { 0, 0x1 } },
4694 	},
4695 	{
4696 		"ALU64_ADD_K: 1 + 2 = 3",
4697 		.u.insns_int = {
4698 			BPF_LD_IMM64(R0, 1),
4699 			BPF_ALU64_IMM(BPF_ADD, R0, 2),
4700 			BPF_EXIT_INSN(),
4701 		},
4702 		INTERNAL,
4703 		{ },
4704 		{ { 0, 3 } },
4705 	},
4706 	{
4707 		"ALU64_ADD_K: 3 + 0 = 3",
4708 		.u.insns_int = {
4709 			BPF_LD_IMM64(R0, 3),
4710 			BPF_ALU64_IMM(BPF_ADD, R0, 0),
4711 			BPF_EXIT_INSN(),
4712 		},
4713 		INTERNAL,
4714 		{ },
4715 		{ { 0, 3 } },
4716 	},
4717 	{
4718 		"ALU64_ADD_K: 1 + 2147483646 = 2147483647",
4719 		.u.insns_int = {
4720 			BPF_LD_IMM64(R0, 1),
4721 			BPF_ALU64_IMM(BPF_ADD, R0, 2147483646),
4722 			BPF_EXIT_INSN(),
4723 		},
4724 		INTERNAL,
4725 		{ },
4726 		{ { 0, 2147483647 } },
4727 	},
4728 	{
4729 		"ALU64_ADD_K: 4294967294 + 2 = 4294967296",
4730 		.u.insns_int = {
4731 			BPF_LD_IMM64(R0, 4294967294U),
4732 			BPF_LD_IMM64(R1, 4294967296ULL),
4733 			BPF_ALU64_IMM(BPF_ADD, R0, 2),
4734 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
4735 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
4736 			BPF_EXIT_INSN(),
4737 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
4738 			BPF_EXIT_INSN(),
4739 		},
4740 		INTERNAL,
4741 		{ },
4742 		{ { 0, 1 } },
4743 	},
4744 	{
4745 		"ALU64_ADD_K: 2147483646 + -2147483647 = -1",
4746 		.u.insns_int = {
4747 			BPF_LD_IMM64(R0, 2147483646),
4748 			BPF_ALU64_IMM(BPF_ADD, R0, -2147483647),
4749 			BPF_EXIT_INSN(),
4750 		},
4751 		INTERNAL,
4752 		{ },
4753 		{ { 0, -1 } },
4754 	},
4755 	{
4756 		"ALU64_ADD_K: 1 + 0 = 1",
4757 		.u.insns_int = {
4758 			BPF_LD_IMM64(R2, 0x1),
4759 			BPF_LD_IMM64(R3, 0x1),
4760 			BPF_ALU64_IMM(BPF_ADD, R2, 0x0),
4761 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4762 			BPF_MOV32_IMM(R0, 2),
4763 			BPF_EXIT_INSN(),
4764 			BPF_MOV32_IMM(R0, 1),
4765 			BPF_EXIT_INSN(),
4766 		},
4767 		INTERNAL,
4768 		{ },
4769 		{ { 0, 0x1 } },
4770 	},
4771 	{
4772 		"ALU64_ADD_K: 0 + (-1) = 0xffffffffffffffff",
4773 		.u.insns_int = {
4774 			BPF_LD_IMM64(R2, 0x0),
4775 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
4776 			BPF_ALU64_IMM(BPF_ADD, R2, 0xffffffff),
4777 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4778 			BPF_MOV32_IMM(R0, 2),
4779 			BPF_EXIT_INSN(),
4780 			BPF_MOV32_IMM(R0, 1),
4781 			BPF_EXIT_INSN(),
4782 		},
4783 		INTERNAL,
4784 		{ },
4785 		{ { 0, 0x1 } },
4786 	},
4787 	{
4788 		"ALU64_ADD_K: 0 + 0xffff = 0xffff",
4789 		.u.insns_int = {
4790 			BPF_LD_IMM64(R2, 0x0),
4791 			BPF_LD_IMM64(R3, 0xffff),
4792 			BPF_ALU64_IMM(BPF_ADD, R2, 0xffff),
4793 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4794 			BPF_MOV32_IMM(R0, 2),
4795 			BPF_EXIT_INSN(),
4796 			BPF_MOV32_IMM(R0, 1),
4797 			BPF_EXIT_INSN(),
4798 		},
4799 		INTERNAL,
4800 		{ },
4801 		{ { 0, 0x1 } },
4802 	},
4803 	{
4804 		"ALU64_ADD_K: 0 + 0x7fffffff = 0x7fffffff",
4805 		.u.insns_int = {
4806 			BPF_LD_IMM64(R2, 0x0),
4807 			BPF_LD_IMM64(R3, 0x7fffffff),
4808 			BPF_ALU64_IMM(BPF_ADD, R2, 0x7fffffff),
4809 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4810 			BPF_MOV32_IMM(R0, 2),
4811 			BPF_EXIT_INSN(),
4812 			BPF_MOV32_IMM(R0, 1),
4813 			BPF_EXIT_INSN(),
4814 		},
4815 		INTERNAL,
4816 		{ },
4817 		{ { 0, 0x1 } },
4818 	},
4819 	{
4820 		"ALU64_ADD_K: 0 + 0x80000000 = 0xffffffff80000000",
4821 		.u.insns_int = {
4822 			BPF_LD_IMM64(R2, 0x0),
4823 			BPF_LD_IMM64(R3, 0xffffffff80000000LL),
4824 			BPF_ALU64_IMM(BPF_ADD, R2, 0x80000000),
4825 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4826 			BPF_MOV32_IMM(R0, 2),
4827 			BPF_EXIT_INSN(),
4828 			BPF_MOV32_IMM(R0, 1),
4829 			BPF_EXIT_INSN(),
4830 		},
4831 		INTERNAL,
4832 		{ },
4833 		{ { 0, 0x1 } },
4834 	},
4835 	{
4836 		"ALU_ADD_K: 0 + 0x80008000 = 0xffffffff80008000",
4837 		.u.insns_int = {
4838 			BPF_LD_IMM64(R2, 0x0),
4839 			BPF_LD_IMM64(R3, 0xffffffff80008000LL),
4840 			BPF_ALU64_IMM(BPF_ADD, R2, 0x80008000),
4841 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4842 			BPF_MOV32_IMM(R0, 2),
4843 			BPF_EXIT_INSN(),
4844 			BPF_MOV32_IMM(R0, 1),
4845 			BPF_EXIT_INSN(),
4846 		},
4847 		INTERNAL,
4848 		{ },
4849 		{ { 0, 0x1 } },
4850 	},
4851 	/* BPF_ALU | BPF_SUB | BPF_X */
4852 	{
4853 		"ALU_SUB_X: 3 - 1 = 2",
4854 		.u.insns_int = {
4855 			BPF_LD_IMM64(R0, 3),
4856 			BPF_ALU32_IMM(BPF_MOV, R1, 1),
4857 			BPF_ALU32_REG(BPF_SUB, R0, R1),
4858 			BPF_EXIT_INSN(),
4859 		},
4860 		INTERNAL,
4861 		{ },
4862 		{ { 0, 2 } },
4863 	},
4864 	{
4865 		"ALU_SUB_X: 4294967295 - 4294967294 = 1",
4866 		.u.insns_int = {
4867 			BPF_LD_IMM64(R0, 4294967295U),
4868 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
4869 			BPF_ALU32_REG(BPF_SUB, R0, R1),
4870 			BPF_EXIT_INSN(),
4871 		},
4872 		INTERNAL,
4873 		{ },
4874 		{ { 0, 1 } },
4875 	},
4876 	{
4877 		"ALU64_SUB_X: 3 - 1 = 2",
4878 		.u.insns_int = {
4879 			BPF_LD_IMM64(R0, 3),
4880 			BPF_ALU32_IMM(BPF_MOV, R1, 1),
4881 			BPF_ALU64_REG(BPF_SUB, R0, R1),
4882 			BPF_EXIT_INSN(),
4883 		},
4884 		INTERNAL,
4885 		{ },
4886 		{ { 0, 2 } },
4887 	},
4888 	{
4889 		"ALU64_SUB_X: 4294967295 - 4294967294 = 1",
4890 		.u.insns_int = {
4891 			BPF_LD_IMM64(R0, 4294967295U),
4892 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
4893 			BPF_ALU64_REG(BPF_SUB, R0, R1),
4894 			BPF_EXIT_INSN(),
4895 		},
4896 		INTERNAL,
4897 		{ },
4898 		{ { 0, 1 } },
4899 	},
4900 	/* BPF_ALU | BPF_SUB | BPF_K */
4901 	{
4902 		"ALU_SUB_K: 3 - 1 = 2",
4903 		.u.insns_int = {
4904 			BPF_LD_IMM64(R0, 3),
4905 			BPF_ALU32_IMM(BPF_SUB, R0, 1),
4906 			BPF_EXIT_INSN(),
4907 		},
4908 		INTERNAL,
4909 		{ },
4910 		{ { 0, 2 } },
4911 	},
4912 	{
4913 		"ALU_SUB_K: 3 - 0 = 3",
4914 		.u.insns_int = {
4915 			BPF_LD_IMM64(R0, 3),
4916 			BPF_ALU32_IMM(BPF_SUB, R0, 0),
4917 			BPF_EXIT_INSN(),
4918 		},
4919 		INTERNAL,
4920 		{ },
4921 		{ { 0, 3 } },
4922 	},
4923 	{
4924 		"ALU_SUB_K: 4294967295 - 4294967294 = 1",
4925 		.u.insns_int = {
4926 			BPF_LD_IMM64(R0, 4294967295U),
4927 			BPF_ALU32_IMM(BPF_SUB, R0, 4294967294U),
4928 			BPF_EXIT_INSN(),
4929 		},
4930 		INTERNAL,
4931 		{ },
4932 		{ { 0, 1 } },
4933 	},
4934 	{
4935 		"ALU64_SUB_K: 3 - 1 = 2",
4936 		.u.insns_int = {
4937 			BPF_LD_IMM64(R0, 3),
4938 			BPF_ALU64_IMM(BPF_SUB, R0, 1),
4939 			BPF_EXIT_INSN(),
4940 		},
4941 		INTERNAL,
4942 		{ },
4943 		{ { 0, 2 } },
4944 	},
4945 	{
4946 		"ALU64_SUB_K: 3 - 0 = 3",
4947 		.u.insns_int = {
4948 			BPF_LD_IMM64(R0, 3),
4949 			BPF_ALU64_IMM(BPF_SUB, R0, 0),
4950 			BPF_EXIT_INSN(),
4951 		},
4952 		INTERNAL,
4953 		{ },
4954 		{ { 0, 3 } },
4955 	},
4956 	{
4957 		"ALU64_SUB_K: 4294967294 - 4294967295 = -1",
4958 		.u.insns_int = {
4959 			BPF_LD_IMM64(R0, 4294967294U),
4960 			BPF_ALU64_IMM(BPF_SUB, R0, 4294967295U),
4961 			BPF_EXIT_INSN(),
4962 		},
4963 		INTERNAL,
4964 		{ },
4965 		{ { 0, -1 } },
4966 	},
4967 	{
4968 		"ALU64_ADD_K: 2147483646 - 2147483647 = -1",
4969 		.u.insns_int = {
4970 			BPF_LD_IMM64(R0, 2147483646),
4971 			BPF_ALU64_IMM(BPF_SUB, R0, 2147483647),
4972 			BPF_EXIT_INSN(),
4973 		},
4974 		INTERNAL,
4975 		{ },
4976 		{ { 0, -1 } },
4977 	},
4978 	/* BPF_ALU | BPF_MUL | BPF_X */
4979 	{
4980 		"ALU_MUL_X: 2 * 3 = 6",
4981 		.u.insns_int = {
4982 			BPF_LD_IMM64(R0, 2),
4983 			BPF_ALU32_IMM(BPF_MOV, R1, 3),
4984 			BPF_ALU32_REG(BPF_MUL, R0, R1),
4985 			BPF_EXIT_INSN(),
4986 		},
4987 		INTERNAL,
4988 		{ },
4989 		{ { 0, 6 } },
4990 	},
4991 	{
4992 		"ALU_MUL_X: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
4993 		.u.insns_int = {
4994 			BPF_LD_IMM64(R0, 2),
4995 			BPF_ALU32_IMM(BPF_MOV, R1, 0x7FFFFFF8),
4996 			BPF_ALU32_REG(BPF_MUL, R0, R1),
4997 			BPF_EXIT_INSN(),
4998 		},
4999 		INTERNAL,
5000 		{ },
5001 		{ { 0, 0xFFFFFFF0 } },
5002 	},
5003 	{
5004 		"ALU_MUL_X: -1 * -1 = 1",
5005 		.u.insns_int = {
5006 			BPF_LD_IMM64(R0, -1),
5007 			BPF_ALU32_IMM(BPF_MOV, R1, -1),
5008 			BPF_ALU32_REG(BPF_MUL, R0, R1),
5009 			BPF_EXIT_INSN(),
5010 		},
5011 		INTERNAL,
5012 		{ },
5013 		{ { 0, 1 } },
5014 	},
5015 	{
5016 		"ALU64_MUL_X: 2 * 3 = 6",
5017 		.u.insns_int = {
5018 			BPF_LD_IMM64(R0, 2),
5019 			BPF_ALU32_IMM(BPF_MOV, R1, 3),
5020 			BPF_ALU64_REG(BPF_MUL, R0, R1),
5021 			BPF_EXIT_INSN(),
5022 		},
5023 		INTERNAL,
5024 		{ },
5025 		{ { 0, 6 } },
5026 	},
5027 	{
5028 		"ALU64_MUL_X: 1 * 2147483647 = 2147483647",
5029 		.u.insns_int = {
5030 			BPF_LD_IMM64(R0, 1),
5031 			BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
5032 			BPF_ALU64_REG(BPF_MUL, R0, R1),
5033 			BPF_EXIT_INSN(),
5034 		},
5035 		INTERNAL,
5036 		{ },
5037 		{ { 0, 2147483647 } },
5038 	},
5039 	{
5040 		"ALU64_MUL_X: 64x64 multiply, low word",
5041 		.u.insns_int = {
5042 			BPF_LD_IMM64(R0, 0x0fedcba987654321LL),
5043 			BPF_LD_IMM64(R1, 0x123456789abcdef0LL),
5044 			BPF_ALU64_REG(BPF_MUL, R0, R1),
5045 			BPF_EXIT_INSN(),
5046 		},
5047 		INTERNAL,
5048 		{ },
5049 		{ { 0, 0xe5618cf0 } }
5050 	},
5051 	{
5052 		"ALU64_MUL_X: 64x64 multiply, high word",
5053 		.u.insns_int = {
5054 			BPF_LD_IMM64(R0, 0x0fedcba987654321LL),
5055 			BPF_LD_IMM64(R1, 0x123456789abcdef0LL),
5056 			BPF_ALU64_REG(BPF_MUL, R0, R1),
5057 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
5058 			BPF_EXIT_INSN(),
5059 		},
5060 		INTERNAL,
5061 		{ },
5062 		{ { 0, 0x2236d88f } }
5063 	},
5064 	/* BPF_ALU | BPF_MUL | BPF_K */
5065 	{
5066 		"ALU_MUL_K: 2 * 3 = 6",
5067 		.u.insns_int = {
5068 			BPF_LD_IMM64(R0, 2),
5069 			BPF_ALU32_IMM(BPF_MUL, R0, 3),
5070 			BPF_EXIT_INSN(),
5071 		},
5072 		INTERNAL,
5073 		{ },
5074 		{ { 0, 6 } },
5075 	},
5076 	{
5077 		"ALU_MUL_K: 3 * 1 = 3",
5078 		.u.insns_int = {
5079 			BPF_LD_IMM64(R0, 3),
5080 			BPF_ALU32_IMM(BPF_MUL, R0, 1),
5081 			BPF_EXIT_INSN(),
5082 		},
5083 		INTERNAL,
5084 		{ },
5085 		{ { 0, 3 } },
5086 	},
5087 	{
5088 		"ALU_MUL_K: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
5089 		.u.insns_int = {
5090 			BPF_LD_IMM64(R0, 2),
5091 			BPF_ALU32_IMM(BPF_MUL, R0, 0x7FFFFFF8),
5092 			BPF_EXIT_INSN(),
5093 		},
5094 		INTERNAL,
5095 		{ },
5096 		{ { 0, 0xFFFFFFF0 } },
5097 	},
5098 	{
5099 		"ALU_MUL_K: 1 * (-1) = 0x00000000ffffffff",
5100 		.u.insns_int = {
5101 			BPF_LD_IMM64(R2, 0x1),
5102 			BPF_LD_IMM64(R3, 0x00000000ffffffff),
5103 			BPF_ALU32_IMM(BPF_MUL, R2, 0xffffffff),
5104 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5105 			BPF_MOV32_IMM(R0, 2),
5106 			BPF_EXIT_INSN(),
5107 			BPF_MOV32_IMM(R0, 1),
5108 			BPF_EXIT_INSN(),
5109 		},
5110 		INTERNAL,
5111 		{ },
5112 		{ { 0, 0x1 } },
5113 	},
5114 	{
5115 		"ALU64_MUL_K: 2 * 3 = 6",
5116 		.u.insns_int = {
5117 			BPF_LD_IMM64(R0, 2),
5118 			BPF_ALU64_IMM(BPF_MUL, R0, 3),
5119 			BPF_EXIT_INSN(),
5120 		},
5121 		INTERNAL,
5122 		{ },
5123 		{ { 0, 6 } },
5124 	},
5125 	{
5126 		"ALU64_MUL_K: 3 * 1 = 3",
5127 		.u.insns_int = {
5128 			BPF_LD_IMM64(R0, 3),
5129 			BPF_ALU64_IMM(BPF_MUL, R0, 1),
5130 			BPF_EXIT_INSN(),
5131 		},
5132 		INTERNAL,
5133 		{ },
5134 		{ { 0, 3 } },
5135 	},
5136 	{
5137 		"ALU64_MUL_K: 1 * 2147483647 = 2147483647",
5138 		.u.insns_int = {
5139 			BPF_LD_IMM64(R0, 1),
5140 			BPF_ALU64_IMM(BPF_MUL, R0, 2147483647),
5141 			BPF_EXIT_INSN(),
5142 		},
5143 		INTERNAL,
5144 		{ },
5145 		{ { 0, 2147483647 } },
5146 	},
5147 	{
5148 		"ALU64_MUL_K: 1 * -2147483647 = -2147483647",
5149 		.u.insns_int = {
5150 			BPF_LD_IMM64(R0, 1),
5151 			BPF_ALU64_IMM(BPF_MUL, R0, -2147483647),
5152 			BPF_EXIT_INSN(),
5153 		},
5154 		INTERNAL,
5155 		{ },
5156 		{ { 0, -2147483647 } },
5157 	},
5158 	{
5159 		"ALU64_MUL_K: 1 * (-1) = 0xffffffffffffffff",
5160 		.u.insns_int = {
5161 			BPF_LD_IMM64(R2, 0x1),
5162 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
5163 			BPF_ALU64_IMM(BPF_MUL, R2, 0xffffffff),
5164 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5165 			BPF_MOV32_IMM(R0, 2),
5166 			BPF_EXIT_INSN(),
5167 			BPF_MOV32_IMM(R0, 1),
5168 			BPF_EXIT_INSN(),
5169 		},
5170 		INTERNAL,
5171 		{ },
5172 		{ { 0, 0x1 } },
5173 	},
5174 	{
5175 		"ALU64_MUL_K: 64x32 multiply, low word",
5176 		.u.insns_int = {
5177 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5178 			BPF_ALU64_IMM(BPF_MUL, R0, 0x12345678),
5179 			BPF_EXIT_INSN(),
5180 		},
5181 		INTERNAL,
5182 		{ },
5183 		{ { 0, 0xe242d208 } }
5184 	},
5185 	{
5186 		"ALU64_MUL_K: 64x32 multiply, high word",
5187 		.u.insns_int = {
5188 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5189 			BPF_ALU64_IMM(BPF_MUL, R0, 0x12345678),
5190 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
5191 			BPF_EXIT_INSN(),
5192 		},
5193 		INTERNAL,
5194 		{ },
5195 		{ { 0, 0xc28f5c28 } }
5196 	},
5197 	/* BPF_ALU | BPF_DIV | BPF_X */
5198 	{
5199 		"ALU_DIV_X: 6 / 2 = 3",
5200 		.u.insns_int = {
5201 			BPF_LD_IMM64(R0, 6),
5202 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
5203 			BPF_ALU32_REG(BPF_DIV, R0, R1),
5204 			BPF_EXIT_INSN(),
5205 		},
5206 		INTERNAL,
5207 		{ },
5208 		{ { 0, 3 } },
5209 	},
5210 	{
5211 		"ALU_DIV_X: 4294967295 / 4294967295 = 1",
5212 		.u.insns_int = {
5213 			BPF_LD_IMM64(R0, 4294967295U),
5214 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
5215 			BPF_ALU32_REG(BPF_DIV, R0, R1),
5216 			BPF_EXIT_INSN(),
5217 		},
5218 		INTERNAL,
5219 		{ },
5220 		{ { 0, 1 } },
5221 	},
5222 	{
5223 		"ALU64_DIV_X: 6 / 2 = 3",
5224 		.u.insns_int = {
5225 			BPF_LD_IMM64(R0, 6),
5226 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
5227 			BPF_ALU64_REG(BPF_DIV, R0, R1),
5228 			BPF_EXIT_INSN(),
5229 		},
5230 		INTERNAL,
5231 		{ },
5232 		{ { 0, 3 } },
5233 	},
5234 	{
5235 		"ALU64_DIV_X: 2147483647 / 2147483647 = 1",
5236 		.u.insns_int = {
5237 			BPF_LD_IMM64(R0, 2147483647),
5238 			BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
5239 			BPF_ALU64_REG(BPF_DIV, R0, R1),
5240 			BPF_EXIT_INSN(),
5241 		},
5242 		INTERNAL,
5243 		{ },
5244 		{ { 0, 1 } },
5245 	},
5246 	{
5247 		"ALU64_DIV_X: 0xffffffffffffffff / (-1) = 0x0000000000000001",
5248 		.u.insns_int = {
5249 			BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
5250 			BPF_LD_IMM64(R4, 0xffffffffffffffffLL),
5251 			BPF_LD_IMM64(R3, 0x0000000000000001LL),
5252 			BPF_ALU64_REG(BPF_DIV, R2, R4),
5253 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5254 			BPF_MOV32_IMM(R0, 2),
5255 			BPF_EXIT_INSN(),
5256 			BPF_MOV32_IMM(R0, 1),
5257 			BPF_EXIT_INSN(),
5258 		},
5259 		INTERNAL,
5260 		{ },
5261 		{ { 0, 0x1 } },
5262 	},
5263 	/* BPF_ALU | BPF_DIV | BPF_K */
5264 	{
5265 		"ALU_DIV_K: 6 / 2 = 3",
5266 		.u.insns_int = {
5267 			BPF_LD_IMM64(R0, 6),
5268 			BPF_ALU32_IMM(BPF_DIV, R0, 2),
5269 			BPF_EXIT_INSN(),
5270 		},
5271 		INTERNAL,
5272 		{ },
5273 		{ { 0, 3 } },
5274 	},
5275 	{
5276 		"ALU_DIV_K: 3 / 1 = 3",
5277 		.u.insns_int = {
5278 			BPF_LD_IMM64(R0, 3),
5279 			BPF_ALU32_IMM(BPF_DIV, R0, 1),
5280 			BPF_EXIT_INSN(),
5281 		},
5282 		INTERNAL,
5283 		{ },
5284 		{ { 0, 3 } },
5285 	},
5286 	{
5287 		"ALU_DIV_K: 4294967295 / 4294967295 = 1",
5288 		.u.insns_int = {
5289 			BPF_LD_IMM64(R0, 4294967295U),
5290 			BPF_ALU32_IMM(BPF_DIV, R0, 4294967295U),
5291 			BPF_EXIT_INSN(),
5292 		},
5293 		INTERNAL,
5294 		{ },
5295 		{ { 0, 1 } },
5296 	},
5297 	{
5298 		"ALU_DIV_K: 0xffffffffffffffff / (-1) = 0x1",
5299 		.u.insns_int = {
5300 			BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
5301 			BPF_LD_IMM64(R3, 0x1UL),
5302 			BPF_ALU32_IMM(BPF_DIV, R2, 0xffffffff),
5303 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5304 			BPF_MOV32_IMM(R0, 2),
5305 			BPF_EXIT_INSN(),
5306 			BPF_MOV32_IMM(R0, 1),
5307 			BPF_EXIT_INSN(),
5308 		},
5309 		INTERNAL,
5310 		{ },
5311 		{ { 0, 0x1 } },
5312 	},
5313 	{
5314 		"ALU64_DIV_K: 6 / 2 = 3",
5315 		.u.insns_int = {
5316 			BPF_LD_IMM64(R0, 6),
5317 			BPF_ALU64_IMM(BPF_DIV, R0, 2),
5318 			BPF_EXIT_INSN(),
5319 		},
5320 		INTERNAL,
5321 		{ },
5322 		{ { 0, 3 } },
5323 	},
5324 	{
5325 		"ALU64_DIV_K: 3 / 1 = 3",
5326 		.u.insns_int = {
5327 			BPF_LD_IMM64(R0, 3),
5328 			BPF_ALU64_IMM(BPF_DIV, R0, 1),
5329 			BPF_EXIT_INSN(),
5330 		},
5331 		INTERNAL,
5332 		{ },
5333 		{ { 0, 3 } },
5334 	},
5335 	{
5336 		"ALU64_DIV_K: 2147483647 / 2147483647 = 1",
5337 		.u.insns_int = {
5338 			BPF_LD_IMM64(R0, 2147483647),
5339 			BPF_ALU64_IMM(BPF_DIV, R0, 2147483647),
5340 			BPF_EXIT_INSN(),
5341 		},
5342 		INTERNAL,
5343 		{ },
5344 		{ { 0, 1 } },
5345 	},
5346 	{
5347 		"ALU64_DIV_K: 0xffffffffffffffff / (-1) = 0x0000000000000001",
5348 		.u.insns_int = {
5349 			BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
5350 			BPF_LD_IMM64(R3, 0x0000000000000001LL),
5351 			BPF_ALU64_IMM(BPF_DIV, R2, 0xffffffff),
5352 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5353 			BPF_MOV32_IMM(R0, 2),
5354 			BPF_EXIT_INSN(),
5355 			BPF_MOV32_IMM(R0, 1),
5356 			BPF_EXIT_INSN(),
5357 		},
5358 		INTERNAL,
5359 		{ },
5360 		{ { 0, 0x1 } },
5361 	},
5362 	/* BPF_ALU | BPF_MOD | BPF_X */
5363 	{
5364 		"ALU_MOD_X: 3 % 2 = 1",
5365 		.u.insns_int = {
5366 			BPF_LD_IMM64(R0, 3),
5367 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
5368 			BPF_ALU32_REG(BPF_MOD, R0, R1),
5369 			BPF_EXIT_INSN(),
5370 		},
5371 		INTERNAL,
5372 		{ },
5373 		{ { 0, 1 } },
5374 	},
5375 	{
5376 		"ALU_MOD_X: 4294967295 % 4294967293 = 2",
5377 		.u.insns_int = {
5378 			BPF_LD_IMM64(R0, 4294967295U),
5379 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967293U),
5380 			BPF_ALU32_REG(BPF_MOD, R0, R1),
5381 			BPF_EXIT_INSN(),
5382 		},
5383 		INTERNAL,
5384 		{ },
5385 		{ { 0, 2 } },
5386 	},
5387 	{
5388 		"ALU64_MOD_X: 3 % 2 = 1",
5389 		.u.insns_int = {
5390 			BPF_LD_IMM64(R0, 3),
5391 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
5392 			BPF_ALU64_REG(BPF_MOD, R0, R1),
5393 			BPF_EXIT_INSN(),
5394 		},
5395 		INTERNAL,
5396 		{ },
5397 		{ { 0, 1 } },
5398 	},
5399 	{
5400 		"ALU64_MOD_X: 2147483647 % 2147483645 = 2",
5401 		.u.insns_int = {
5402 			BPF_LD_IMM64(R0, 2147483647),
5403 			BPF_ALU32_IMM(BPF_MOV, R1, 2147483645),
5404 			BPF_ALU64_REG(BPF_MOD, R0, R1),
5405 			BPF_EXIT_INSN(),
5406 		},
5407 		INTERNAL,
5408 		{ },
5409 		{ { 0, 2 } },
5410 	},
5411 	/* BPF_ALU | BPF_MOD | BPF_K */
5412 	{
5413 		"ALU_MOD_K: 3 % 2 = 1",
5414 		.u.insns_int = {
5415 			BPF_LD_IMM64(R0, 3),
5416 			BPF_ALU32_IMM(BPF_MOD, R0, 2),
5417 			BPF_EXIT_INSN(),
5418 		},
5419 		INTERNAL,
5420 		{ },
5421 		{ { 0, 1 } },
5422 	},
5423 	{
5424 		"ALU_MOD_K: 3 % 1 = 0",
5425 		.u.insns_int = {
5426 			BPF_LD_IMM64(R0, 3),
5427 			BPF_ALU32_IMM(BPF_MOD, R0, 1),
5428 			BPF_EXIT_INSN(),
5429 		},
5430 		INTERNAL,
5431 		{ },
5432 		{ { 0, 0 } },
5433 	},
5434 	{
5435 		"ALU_MOD_K: 4294967295 % 4294967293 = 2",
5436 		.u.insns_int = {
5437 			BPF_LD_IMM64(R0, 4294967295U),
5438 			BPF_ALU32_IMM(BPF_MOD, R0, 4294967293U),
5439 			BPF_EXIT_INSN(),
5440 		},
5441 		INTERNAL,
5442 		{ },
5443 		{ { 0, 2 } },
5444 	},
5445 	{
5446 		"ALU64_MOD_K: 3 % 2 = 1",
5447 		.u.insns_int = {
5448 			BPF_LD_IMM64(R0, 3),
5449 			BPF_ALU64_IMM(BPF_MOD, R0, 2),
5450 			BPF_EXIT_INSN(),
5451 		},
5452 		INTERNAL,
5453 		{ },
5454 		{ { 0, 1 } },
5455 	},
5456 	{
5457 		"ALU64_MOD_K: 3 % 1 = 0",
5458 		.u.insns_int = {
5459 			BPF_LD_IMM64(R0, 3),
5460 			BPF_ALU64_IMM(BPF_MOD, R0, 1),
5461 			BPF_EXIT_INSN(),
5462 		},
5463 		INTERNAL,
5464 		{ },
5465 		{ { 0, 0 } },
5466 	},
5467 	{
5468 		"ALU64_MOD_K: 2147483647 % 2147483645 = 2",
5469 		.u.insns_int = {
5470 			BPF_LD_IMM64(R0, 2147483647),
5471 			BPF_ALU64_IMM(BPF_MOD, R0, 2147483645),
5472 			BPF_EXIT_INSN(),
5473 		},
5474 		INTERNAL,
5475 		{ },
5476 		{ { 0, 2 } },
5477 	},
5478 	/* BPF_ALU | BPF_AND | BPF_X */
5479 	{
5480 		"ALU_AND_X: 3 & 2 = 2",
5481 		.u.insns_int = {
5482 			BPF_LD_IMM64(R0, 3),
5483 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
5484 			BPF_ALU32_REG(BPF_AND, R0, R1),
5485 			BPF_EXIT_INSN(),
5486 		},
5487 		INTERNAL,
5488 		{ },
5489 		{ { 0, 2 } },
5490 	},
5491 	{
5492 		"ALU_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
5493 		.u.insns_int = {
5494 			BPF_LD_IMM64(R0, 0xffffffff),
5495 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
5496 			BPF_ALU32_REG(BPF_AND, R0, R1),
5497 			BPF_EXIT_INSN(),
5498 		},
5499 		INTERNAL,
5500 		{ },
5501 		{ { 0, 0xffffffff } },
5502 	},
5503 	{
5504 		"ALU64_AND_X: 3 & 2 = 2",
5505 		.u.insns_int = {
5506 			BPF_LD_IMM64(R0, 3),
5507 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
5508 			BPF_ALU64_REG(BPF_AND, R0, R1),
5509 			BPF_EXIT_INSN(),
5510 		},
5511 		INTERNAL,
5512 		{ },
5513 		{ { 0, 2 } },
5514 	},
5515 	{
5516 		"ALU64_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
5517 		.u.insns_int = {
5518 			BPF_LD_IMM64(R0, 0xffffffff),
5519 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
5520 			BPF_ALU64_REG(BPF_AND, R0, R1),
5521 			BPF_EXIT_INSN(),
5522 		},
5523 		INTERNAL,
5524 		{ },
5525 		{ { 0, 0xffffffff } },
5526 	},
5527 	/* BPF_ALU | BPF_AND | BPF_K */
5528 	{
5529 		"ALU_AND_K: 3 & 2 = 2",
5530 		.u.insns_int = {
5531 			BPF_LD_IMM64(R0, 3),
5532 			BPF_ALU32_IMM(BPF_AND, R0, 2),
5533 			BPF_EXIT_INSN(),
5534 		},
5535 		INTERNAL,
5536 		{ },
5537 		{ { 0, 2 } },
5538 	},
5539 	{
5540 		"ALU_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
5541 		.u.insns_int = {
5542 			BPF_LD_IMM64(R0, 0xffffffff),
5543 			BPF_ALU32_IMM(BPF_AND, R0, 0xffffffff),
5544 			BPF_EXIT_INSN(),
5545 		},
5546 		INTERNAL,
5547 		{ },
5548 		{ { 0, 0xffffffff } },
5549 	},
5550 	{
5551 		"ALU_AND_K: Small immediate",
5552 		.u.insns_int = {
5553 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
5554 			BPF_ALU32_IMM(BPF_AND, R0, 15),
5555 			BPF_EXIT_INSN(),
5556 		},
5557 		INTERNAL,
5558 		{ },
5559 		{ { 0, 4 } }
5560 	},
5561 	{
5562 		"ALU_AND_K: Large immediate",
5563 		.u.insns_int = {
5564 			BPF_ALU32_IMM(BPF_MOV, R0, 0xf1f2f3f4),
5565 			BPF_ALU32_IMM(BPF_AND, R0, 0xafbfcfdf),
5566 			BPF_EXIT_INSN(),
5567 		},
5568 		INTERNAL,
5569 		{ },
5570 		{ { 0, 0xa1b2c3d4 } }
5571 	},
5572 	{
5573 		"ALU_AND_K: Zero extension",
5574 		.u.insns_int = {
5575 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5576 			BPF_LD_IMM64(R1, 0x0000000080a0c0e0LL),
5577 			BPF_ALU32_IMM(BPF_AND, R0, 0xf0f0f0f0),
5578 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
5579 			BPF_MOV32_IMM(R0, 2),
5580 			BPF_EXIT_INSN(),
5581 			BPF_MOV32_IMM(R0, 1),
5582 			BPF_EXIT_INSN(),
5583 		},
5584 		INTERNAL,
5585 		{ },
5586 		{ { 0, 1 } }
5587 	},
5588 	{
5589 		"ALU64_AND_K: 3 & 2 = 2",
5590 		.u.insns_int = {
5591 			BPF_LD_IMM64(R0, 3),
5592 			BPF_ALU64_IMM(BPF_AND, R0, 2),
5593 			BPF_EXIT_INSN(),
5594 		},
5595 		INTERNAL,
5596 		{ },
5597 		{ { 0, 2 } },
5598 	},
5599 	{
5600 		"ALU64_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
5601 		.u.insns_int = {
5602 			BPF_LD_IMM64(R0, 0xffffffff),
5603 			BPF_ALU64_IMM(BPF_AND, R0, 0xffffffff),
5604 			BPF_EXIT_INSN(),
5605 		},
5606 		INTERNAL,
5607 		{ },
5608 		{ { 0, 0xffffffff } },
5609 	},
5610 	{
5611 		"ALU64_AND_K: 0x0000ffffffff0000 & 0x0 = 0x0000000000000000",
5612 		.u.insns_int = {
5613 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
5614 			BPF_LD_IMM64(R3, 0x0000000000000000LL),
5615 			BPF_ALU64_IMM(BPF_AND, R2, 0x0),
5616 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5617 			BPF_MOV32_IMM(R0, 2),
5618 			BPF_EXIT_INSN(),
5619 			BPF_MOV32_IMM(R0, 1),
5620 			BPF_EXIT_INSN(),
5621 		},
5622 		INTERNAL,
5623 		{ },
5624 		{ { 0, 0x1 } },
5625 	},
5626 	{
5627 		"ALU64_AND_K: 0x0000ffffffff0000 & -1 = 0x0000ffffffff0000",
5628 		.u.insns_int = {
5629 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
5630 			BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
5631 			BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
5632 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5633 			BPF_MOV32_IMM(R0, 2),
5634 			BPF_EXIT_INSN(),
5635 			BPF_MOV32_IMM(R0, 1),
5636 			BPF_EXIT_INSN(),
5637 		},
5638 		INTERNAL,
5639 		{ },
5640 		{ { 0, 0x1 } },
5641 	},
5642 	{
5643 		"ALU64_AND_K: 0xffffffffffffffff & -1 = 0xffffffffffffffff",
5644 		.u.insns_int = {
5645 			BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
5646 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
5647 			BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
5648 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5649 			BPF_MOV32_IMM(R0, 2),
5650 			BPF_EXIT_INSN(),
5651 			BPF_MOV32_IMM(R0, 1),
5652 			BPF_EXIT_INSN(),
5653 		},
5654 		INTERNAL,
5655 		{ },
5656 		{ { 0, 0x1 } },
5657 	},
5658 	{
5659 		"ALU64_AND_K: Sign extension 1",
5660 		.u.insns_int = {
5661 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5662 			BPF_LD_IMM64(R1, 0x00000000090b0d0fLL),
5663 			BPF_ALU64_IMM(BPF_AND, R0, 0x0f0f0f0f),
5664 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
5665 			BPF_MOV32_IMM(R0, 2),
5666 			BPF_EXIT_INSN(),
5667 			BPF_MOV32_IMM(R0, 1),
5668 			BPF_EXIT_INSN(),
5669 		},
5670 		INTERNAL,
5671 		{ },
5672 		{ { 0, 1 } }
5673 	},
5674 	{
5675 		"ALU64_AND_K: Sign extension 2",
5676 		.u.insns_int = {
5677 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5678 			BPF_LD_IMM64(R1, 0x0123456780a0c0e0LL),
5679 			BPF_ALU64_IMM(BPF_AND, R0, 0xf0f0f0f0),
5680 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
5681 			BPF_MOV32_IMM(R0, 2),
5682 			BPF_EXIT_INSN(),
5683 			BPF_MOV32_IMM(R0, 1),
5684 			BPF_EXIT_INSN(),
5685 		},
5686 		INTERNAL,
5687 		{ },
5688 		{ { 0, 1 } }
5689 	},
5690 	/* BPF_ALU | BPF_OR | BPF_X */
5691 	{
5692 		"ALU_OR_X: 1 | 2 = 3",
5693 		.u.insns_int = {
5694 			BPF_LD_IMM64(R0, 1),
5695 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
5696 			BPF_ALU32_REG(BPF_OR, R0, R1),
5697 			BPF_EXIT_INSN(),
5698 		},
5699 		INTERNAL,
5700 		{ },
5701 		{ { 0, 3 } },
5702 	},
5703 	{
5704 		"ALU_OR_X: 0x0 | 0xffffffff = 0xffffffff",
5705 		.u.insns_int = {
5706 			BPF_LD_IMM64(R0, 0),
5707 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
5708 			BPF_ALU32_REG(BPF_OR, R0, R1),
5709 			BPF_EXIT_INSN(),
5710 		},
5711 		INTERNAL,
5712 		{ },
5713 		{ { 0, 0xffffffff } },
5714 	},
5715 	{
5716 		"ALU64_OR_X: 1 | 2 = 3",
5717 		.u.insns_int = {
5718 			BPF_LD_IMM64(R0, 1),
5719 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
5720 			BPF_ALU64_REG(BPF_OR, R0, R1),
5721 			BPF_EXIT_INSN(),
5722 		},
5723 		INTERNAL,
5724 		{ },
5725 		{ { 0, 3 } },
5726 	},
5727 	{
5728 		"ALU64_OR_X: 0 | 0xffffffff = 0xffffffff",
5729 		.u.insns_int = {
5730 			BPF_LD_IMM64(R0, 0),
5731 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
5732 			BPF_ALU64_REG(BPF_OR, R0, R1),
5733 			BPF_EXIT_INSN(),
5734 		},
5735 		INTERNAL,
5736 		{ },
5737 		{ { 0, 0xffffffff } },
5738 	},
5739 	/* BPF_ALU | BPF_OR | BPF_K */
5740 	{
5741 		"ALU_OR_K: 1 | 2 = 3",
5742 		.u.insns_int = {
5743 			BPF_LD_IMM64(R0, 1),
5744 			BPF_ALU32_IMM(BPF_OR, R0, 2),
5745 			BPF_EXIT_INSN(),
5746 		},
5747 		INTERNAL,
5748 		{ },
5749 		{ { 0, 3 } },
5750 	},
5751 	{
5752 		"ALU_OR_K: 0 & 0xffffffff = 0xffffffff",
5753 		.u.insns_int = {
5754 			BPF_LD_IMM64(R0, 0),
5755 			BPF_ALU32_IMM(BPF_OR, R0, 0xffffffff),
5756 			BPF_EXIT_INSN(),
5757 		},
5758 		INTERNAL,
5759 		{ },
5760 		{ { 0, 0xffffffff } },
5761 	},
5762 	{
5763 		"ALU_OR_K: Small immediate",
5764 		.u.insns_int = {
5765 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
5766 			BPF_ALU32_IMM(BPF_OR, R0, 1),
5767 			BPF_EXIT_INSN(),
5768 		},
5769 		INTERNAL,
5770 		{ },
5771 		{ { 0, 0x01020305 } }
5772 	},
5773 	{
5774 		"ALU_OR_K: Large immediate",
5775 		.u.insns_int = {
5776 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
5777 			BPF_ALU32_IMM(BPF_OR, R0, 0xa0b0c0d0),
5778 			BPF_EXIT_INSN(),
5779 		},
5780 		INTERNAL,
5781 		{ },
5782 		{ { 0, 0xa1b2c3d4 } }
5783 	},
5784 	{
5785 		"ALU_OR_K: Zero extension",
5786 		.u.insns_int = {
5787 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5788 			BPF_LD_IMM64(R1, 0x00000000f9fbfdffLL),
5789 			BPF_ALU32_IMM(BPF_OR, R0, 0xf0f0f0f0),
5790 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
5791 			BPF_MOV32_IMM(R0, 2),
5792 			BPF_EXIT_INSN(),
5793 			BPF_MOV32_IMM(R0, 1),
5794 			BPF_EXIT_INSN(),
5795 		},
5796 		INTERNAL,
5797 		{ },
5798 		{ { 0, 1 } }
5799 	},
5800 	{
5801 		"ALU64_OR_K: 1 | 2 = 3",
5802 		.u.insns_int = {
5803 			BPF_LD_IMM64(R0, 1),
5804 			BPF_ALU64_IMM(BPF_OR, R0, 2),
5805 			BPF_EXIT_INSN(),
5806 		},
5807 		INTERNAL,
5808 		{ },
5809 		{ { 0, 3 } },
5810 	},
5811 	{
5812 		"ALU64_OR_K: 0 & 0xffffffff = 0xffffffff",
5813 		.u.insns_int = {
5814 			BPF_LD_IMM64(R0, 0),
5815 			BPF_ALU64_IMM(BPF_OR, R0, 0xffffffff),
5816 			BPF_EXIT_INSN(),
5817 		},
5818 		INTERNAL,
5819 		{ },
5820 		{ { 0, 0xffffffff } },
5821 	},
5822 	{
5823 		"ALU64_OR_K: 0x0000ffffffff0000 | 0x0 = 0x0000ffffffff0000",
5824 		.u.insns_int = {
5825 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
5826 			BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
5827 			BPF_ALU64_IMM(BPF_OR, R2, 0x0),
5828 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5829 			BPF_MOV32_IMM(R0, 2),
5830 			BPF_EXIT_INSN(),
5831 			BPF_MOV32_IMM(R0, 1),
5832 			BPF_EXIT_INSN(),
5833 		},
5834 		INTERNAL,
5835 		{ },
5836 		{ { 0, 0x1 } },
5837 	},
5838 	{
5839 		"ALU64_OR_K: 0x0000ffffffff0000 | -1 = 0xffffffffffffffff",
5840 		.u.insns_int = {
5841 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
5842 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
5843 			BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
5844 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5845 			BPF_MOV32_IMM(R0, 2),
5846 			BPF_EXIT_INSN(),
5847 			BPF_MOV32_IMM(R0, 1),
5848 			BPF_EXIT_INSN(),
5849 		},
5850 		INTERNAL,
5851 		{ },
5852 		{ { 0, 0x1 } },
5853 	},
5854 	{
5855 		"ALU64_OR_K: 0x000000000000000 | -1 = 0xffffffffffffffff",
5856 		.u.insns_int = {
5857 			BPF_LD_IMM64(R2, 0x0000000000000000LL),
5858 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
5859 			BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
5860 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5861 			BPF_MOV32_IMM(R0, 2),
5862 			BPF_EXIT_INSN(),
5863 			BPF_MOV32_IMM(R0, 1),
5864 			BPF_EXIT_INSN(),
5865 		},
5866 		INTERNAL,
5867 		{ },
5868 		{ { 0, 0x1 } },
5869 	},
5870 	{
5871 		"ALU64_OR_K: Sign extension 1",
5872 		.u.insns_int = {
5873 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5874 			BPF_LD_IMM64(R1, 0x012345678fafcfefLL),
5875 			BPF_ALU64_IMM(BPF_OR, R0, 0x0f0f0f0f),
5876 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
5877 			BPF_MOV32_IMM(R0, 2),
5878 			BPF_EXIT_INSN(),
5879 			BPF_MOV32_IMM(R0, 1),
5880 			BPF_EXIT_INSN(),
5881 		},
5882 		INTERNAL,
5883 		{ },
5884 		{ { 0, 1 } }
5885 	},
5886 	{
5887 		"ALU64_OR_K: Sign extension 2",
5888 		.u.insns_int = {
5889 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5890 			BPF_LD_IMM64(R1, 0xfffffffff9fbfdffLL),
5891 			BPF_ALU64_IMM(BPF_OR, R0, 0xf0f0f0f0),
5892 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
5893 			BPF_MOV32_IMM(R0, 2),
5894 			BPF_EXIT_INSN(),
5895 			BPF_MOV32_IMM(R0, 1),
5896 			BPF_EXIT_INSN(),
5897 		},
5898 		INTERNAL,
5899 		{ },
5900 		{ { 0, 1 } }
5901 	},
5902 	/* BPF_ALU | BPF_XOR | BPF_X */
5903 	{
5904 		"ALU_XOR_X: 5 ^ 6 = 3",
5905 		.u.insns_int = {
5906 			BPF_LD_IMM64(R0, 5),
5907 			BPF_ALU32_IMM(BPF_MOV, R1, 6),
5908 			BPF_ALU32_REG(BPF_XOR, R0, R1),
5909 			BPF_EXIT_INSN(),
5910 		},
5911 		INTERNAL,
5912 		{ },
5913 		{ { 0, 3 } },
5914 	},
5915 	{
5916 		"ALU_XOR_X: 0x1 ^ 0xffffffff = 0xfffffffe",
5917 		.u.insns_int = {
5918 			BPF_LD_IMM64(R0, 1),
5919 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
5920 			BPF_ALU32_REG(BPF_XOR, R0, R1),
5921 			BPF_EXIT_INSN(),
5922 		},
5923 		INTERNAL,
5924 		{ },
5925 		{ { 0, 0xfffffffe } },
5926 	},
5927 	{
5928 		"ALU64_XOR_X: 5 ^ 6 = 3",
5929 		.u.insns_int = {
5930 			BPF_LD_IMM64(R0, 5),
5931 			BPF_ALU32_IMM(BPF_MOV, R1, 6),
5932 			BPF_ALU64_REG(BPF_XOR, R0, R1),
5933 			BPF_EXIT_INSN(),
5934 		},
5935 		INTERNAL,
5936 		{ },
5937 		{ { 0, 3 } },
5938 	},
5939 	{
5940 		"ALU64_XOR_X: 1 ^ 0xffffffff = 0xfffffffe",
5941 		.u.insns_int = {
5942 			BPF_LD_IMM64(R0, 1),
5943 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
5944 			BPF_ALU64_REG(BPF_XOR, R0, R1),
5945 			BPF_EXIT_INSN(),
5946 		},
5947 		INTERNAL,
5948 		{ },
5949 		{ { 0, 0xfffffffe } },
5950 	},
5951 	/* BPF_ALU | BPF_XOR | BPF_K */
5952 	{
5953 		"ALU_XOR_K: 5 ^ 6 = 3",
5954 		.u.insns_int = {
5955 			BPF_LD_IMM64(R0, 5),
5956 			BPF_ALU32_IMM(BPF_XOR, R0, 6),
5957 			BPF_EXIT_INSN(),
5958 		},
5959 		INTERNAL,
5960 		{ },
5961 		{ { 0, 3 } },
5962 	},
5963 	{
5964 		"ALU_XOR_K: 1 ^ 0xffffffff = 0xfffffffe",
5965 		.u.insns_int = {
5966 			BPF_LD_IMM64(R0, 1),
5967 			BPF_ALU32_IMM(BPF_XOR, R0, 0xffffffff),
5968 			BPF_EXIT_INSN(),
5969 		},
5970 		INTERNAL,
5971 		{ },
5972 		{ { 0, 0xfffffffe } },
5973 	},
5974 	{
5975 		"ALU_XOR_K: Small immediate",
5976 		.u.insns_int = {
5977 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
5978 			BPF_ALU32_IMM(BPF_XOR, R0, 15),
5979 			BPF_EXIT_INSN(),
5980 		},
5981 		INTERNAL,
5982 		{ },
5983 		{ { 0, 0x0102030b } }
5984 	},
5985 	{
5986 		"ALU_XOR_K: Large immediate",
5987 		.u.insns_int = {
5988 			BPF_ALU32_IMM(BPF_MOV, R0, 0xf1f2f3f4),
5989 			BPF_ALU32_IMM(BPF_XOR, R0, 0xafbfcfdf),
5990 			BPF_EXIT_INSN(),
5991 		},
5992 		INTERNAL,
5993 		{ },
5994 		{ { 0, 0x5e4d3c2b } }
5995 	},
5996 	{
5997 		"ALU_XOR_K: Zero extension",
5998 		.u.insns_int = {
5999 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6000 			BPF_LD_IMM64(R1, 0x00000000795b3d1fLL),
6001 			BPF_ALU32_IMM(BPF_XOR, R0, 0xf0f0f0f0),
6002 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6003 			BPF_MOV32_IMM(R0, 2),
6004 			BPF_EXIT_INSN(),
6005 			BPF_MOV32_IMM(R0, 1),
6006 			BPF_EXIT_INSN(),
6007 		},
6008 		INTERNAL,
6009 		{ },
6010 		{ { 0, 1 } }
6011 	},
6012 	{
6013 		"ALU64_XOR_K: 5 ^ 6 = 3",
6014 		.u.insns_int = {
6015 			BPF_LD_IMM64(R0, 5),
6016 			BPF_ALU64_IMM(BPF_XOR, R0, 6),
6017 			BPF_EXIT_INSN(),
6018 		},
6019 		INTERNAL,
6020 		{ },
6021 		{ { 0, 3 } },
6022 	},
6023 	{
6024 		"ALU64_XOR_K: 1 ^ 0xffffffff = 0xfffffffe",
6025 		.u.insns_int = {
6026 			BPF_LD_IMM64(R0, 1),
6027 			BPF_ALU64_IMM(BPF_XOR, R0, 0xffffffff),
6028 			BPF_EXIT_INSN(),
6029 		},
6030 		INTERNAL,
6031 		{ },
6032 		{ { 0, 0xfffffffe } },
6033 	},
6034 	{
6035 		"ALU64_XOR_K: 0x0000ffffffff0000 ^ 0x0 = 0x0000ffffffff0000",
6036 		.u.insns_int = {
6037 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6038 			BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
6039 			BPF_ALU64_IMM(BPF_XOR, R2, 0x0),
6040 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6041 			BPF_MOV32_IMM(R0, 2),
6042 			BPF_EXIT_INSN(),
6043 			BPF_MOV32_IMM(R0, 1),
6044 			BPF_EXIT_INSN(),
6045 		},
6046 		INTERNAL,
6047 		{ },
6048 		{ { 0, 0x1 } },
6049 	},
6050 	{
6051 		"ALU64_XOR_K: 0x0000ffffffff0000 ^ -1 = 0xffff00000000ffff",
6052 		.u.insns_int = {
6053 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6054 			BPF_LD_IMM64(R3, 0xffff00000000ffffLL),
6055 			BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
6056 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6057 			BPF_MOV32_IMM(R0, 2),
6058 			BPF_EXIT_INSN(),
6059 			BPF_MOV32_IMM(R0, 1),
6060 			BPF_EXIT_INSN(),
6061 		},
6062 		INTERNAL,
6063 		{ },
6064 		{ { 0, 0x1 } },
6065 	},
6066 	{
6067 		"ALU64_XOR_K: 0x000000000000000 ^ -1 = 0xffffffffffffffff",
6068 		.u.insns_int = {
6069 			BPF_LD_IMM64(R2, 0x0000000000000000LL),
6070 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
6071 			BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
6072 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6073 			BPF_MOV32_IMM(R0, 2),
6074 			BPF_EXIT_INSN(),
6075 			BPF_MOV32_IMM(R0, 1),
6076 			BPF_EXIT_INSN(),
6077 		},
6078 		INTERNAL,
6079 		{ },
6080 		{ { 0, 0x1 } },
6081 	},
6082 	{
6083 		"ALU64_XOR_K: Sign extension 1",
6084 		.u.insns_int = {
6085 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6086 			BPF_LD_IMM64(R1, 0x0123456786a4c2e0LL),
6087 			BPF_ALU64_IMM(BPF_XOR, R0, 0x0f0f0f0f),
6088 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6089 			BPF_MOV32_IMM(R0, 2),
6090 			BPF_EXIT_INSN(),
6091 			BPF_MOV32_IMM(R0, 1),
6092 			BPF_EXIT_INSN(),
6093 		},
6094 		INTERNAL,
6095 		{ },
6096 		{ { 0, 1 } }
6097 	},
6098 	{
6099 		"ALU64_XOR_K: Sign extension 2",
6100 		.u.insns_int = {
6101 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6102 			BPF_LD_IMM64(R1, 0xfedcba98795b3d1fLL),
6103 			BPF_ALU64_IMM(BPF_XOR, R0, 0xf0f0f0f0),
6104 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6105 			BPF_MOV32_IMM(R0, 2),
6106 			BPF_EXIT_INSN(),
6107 			BPF_MOV32_IMM(R0, 1),
6108 			BPF_EXIT_INSN(),
6109 		},
6110 		INTERNAL,
6111 		{ },
6112 		{ { 0, 1 } }
6113 	},
6114 	/* BPF_ALU | BPF_LSH | BPF_X */
6115 	{
6116 		"ALU_LSH_X: 1 << 1 = 2",
6117 		.u.insns_int = {
6118 			BPF_LD_IMM64(R0, 1),
6119 			BPF_ALU32_IMM(BPF_MOV, R1, 1),
6120 			BPF_ALU32_REG(BPF_LSH, R0, R1),
6121 			BPF_EXIT_INSN(),
6122 		},
6123 		INTERNAL,
6124 		{ },
6125 		{ { 0, 2 } },
6126 	},
6127 	{
6128 		"ALU_LSH_X: 1 << 31 = 0x80000000",
6129 		.u.insns_int = {
6130 			BPF_LD_IMM64(R0, 1),
6131 			BPF_ALU32_IMM(BPF_MOV, R1, 31),
6132 			BPF_ALU32_REG(BPF_LSH, R0, R1),
6133 			BPF_EXIT_INSN(),
6134 		},
6135 		INTERNAL,
6136 		{ },
6137 		{ { 0, 0x80000000 } },
6138 	},
6139 	{
6140 		"ALU_LSH_X: 0x12345678 << 12 = 0x45678000",
6141 		.u.insns_int = {
6142 			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
6143 			BPF_ALU32_IMM(BPF_MOV, R1, 12),
6144 			BPF_ALU32_REG(BPF_LSH, R0, R1),
6145 			BPF_EXIT_INSN(),
6146 		},
6147 		INTERNAL,
6148 		{ },
6149 		{ { 0, 0x45678000 } }
6150 	},
6151 	{
6152 		"ALU64_LSH_X: 1 << 1 = 2",
6153 		.u.insns_int = {
6154 			BPF_LD_IMM64(R0, 1),
6155 			BPF_ALU32_IMM(BPF_MOV, R1, 1),
6156 			BPF_ALU64_REG(BPF_LSH, R0, R1),
6157 			BPF_EXIT_INSN(),
6158 		},
6159 		INTERNAL,
6160 		{ },
6161 		{ { 0, 2 } },
6162 	},
6163 	{
6164 		"ALU64_LSH_X: 1 << 31 = 0x80000000",
6165 		.u.insns_int = {
6166 			BPF_LD_IMM64(R0, 1),
6167 			BPF_ALU32_IMM(BPF_MOV, R1, 31),
6168 			BPF_ALU64_REG(BPF_LSH, R0, R1),
6169 			BPF_EXIT_INSN(),
6170 		},
6171 		INTERNAL,
6172 		{ },
6173 		{ { 0, 0x80000000 } },
6174 	},
6175 	{
6176 		"ALU64_LSH_X: Shift < 32, low word",
6177 		.u.insns_int = {
6178 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6179 			BPF_ALU32_IMM(BPF_MOV, R1, 12),
6180 			BPF_ALU64_REG(BPF_LSH, R0, R1),
6181 			BPF_EXIT_INSN(),
6182 		},
6183 		INTERNAL,
6184 		{ },
6185 		{ { 0, 0xbcdef000 } }
6186 	},
6187 	{
6188 		"ALU64_LSH_X: Shift < 32, high word",
6189 		.u.insns_int = {
6190 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6191 			BPF_ALU32_IMM(BPF_MOV, R1, 12),
6192 			BPF_ALU64_REG(BPF_LSH, R0, R1),
6193 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6194 			BPF_EXIT_INSN(),
6195 		},
6196 		INTERNAL,
6197 		{ },
6198 		{ { 0, 0x3456789a } }
6199 	},
6200 	{
6201 		"ALU64_LSH_X: Shift > 32, low word",
6202 		.u.insns_int = {
6203 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6204 			BPF_ALU32_IMM(BPF_MOV, R1, 36),
6205 			BPF_ALU64_REG(BPF_LSH, R0, R1),
6206 			BPF_EXIT_INSN(),
6207 		},
6208 		INTERNAL,
6209 		{ },
6210 		{ { 0, 0 } }
6211 	},
6212 	{
6213 		"ALU64_LSH_X: Shift > 32, high word",
6214 		.u.insns_int = {
6215 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6216 			BPF_ALU32_IMM(BPF_MOV, R1, 36),
6217 			BPF_ALU64_REG(BPF_LSH, R0, R1),
6218 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6219 			BPF_EXIT_INSN(),
6220 		},
6221 		INTERNAL,
6222 		{ },
6223 		{ { 0, 0x9abcdef0 } }
6224 	},
6225 	{
6226 		"ALU64_LSH_X: Shift == 32, low word",
6227 		.u.insns_int = {
6228 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6229 			BPF_ALU32_IMM(BPF_MOV, R1, 32),
6230 			BPF_ALU64_REG(BPF_LSH, R0, R1),
6231 			BPF_EXIT_INSN(),
6232 		},
6233 		INTERNAL,
6234 		{ },
6235 		{ { 0, 0 } }
6236 	},
6237 	{
6238 		"ALU64_LSH_X: Shift == 32, high word",
6239 		.u.insns_int = {
6240 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6241 			BPF_ALU32_IMM(BPF_MOV, R1, 32),
6242 			BPF_ALU64_REG(BPF_LSH, R0, R1),
6243 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6244 			BPF_EXIT_INSN(),
6245 		},
6246 		INTERNAL,
6247 		{ },
6248 		{ { 0, 0x89abcdef } }
6249 	},
6250 	{
6251 		"ALU64_LSH_X: Zero shift, low word",
6252 		.u.insns_int = {
6253 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6254 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
6255 			BPF_ALU64_REG(BPF_LSH, R0, R1),
6256 			BPF_EXIT_INSN(),
6257 		},
6258 		INTERNAL,
6259 		{ },
6260 		{ { 0, 0x89abcdef } }
6261 	},
6262 	{
6263 		"ALU64_LSH_X: Zero shift, high word",
6264 		.u.insns_int = {
6265 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6266 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
6267 			BPF_ALU64_REG(BPF_LSH, R0, R1),
6268 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6269 			BPF_EXIT_INSN(),
6270 		},
6271 		INTERNAL,
6272 		{ },
6273 		{ { 0, 0x01234567 } }
6274 	},
6275 	/* BPF_ALU | BPF_LSH | BPF_K */
6276 	{
6277 		"ALU_LSH_K: 1 << 1 = 2",
6278 		.u.insns_int = {
6279 			BPF_LD_IMM64(R0, 1),
6280 			BPF_ALU32_IMM(BPF_LSH, R0, 1),
6281 			BPF_EXIT_INSN(),
6282 		},
6283 		INTERNAL,
6284 		{ },
6285 		{ { 0, 2 } },
6286 	},
6287 	{
6288 		"ALU_LSH_K: 1 << 31 = 0x80000000",
6289 		.u.insns_int = {
6290 			BPF_LD_IMM64(R0, 1),
6291 			BPF_ALU32_IMM(BPF_LSH, R0, 31),
6292 			BPF_EXIT_INSN(),
6293 		},
6294 		INTERNAL,
6295 		{ },
6296 		{ { 0, 0x80000000 } },
6297 	},
6298 	{
6299 		"ALU_LSH_K: 0x12345678 << 12 = 0x45678000",
6300 		.u.insns_int = {
6301 			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
6302 			BPF_ALU32_IMM(BPF_LSH, R0, 12),
6303 			BPF_EXIT_INSN(),
6304 		},
6305 		INTERNAL,
6306 		{ },
6307 		{ { 0, 0x45678000 } }
6308 	},
6309 	{
6310 		"ALU_LSH_K: 0x12345678 << 0 = 0x12345678",
6311 		.u.insns_int = {
6312 			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
6313 			BPF_ALU32_IMM(BPF_LSH, R0, 0),
6314 			BPF_EXIT_INSN(),
6315 		},
6316 		INTERNAL,
6317 		{ },
6318 		{ { 0, 0x12345678 } }
6319 	},
6320 	{
6321 		"ALU64_LSH_K: 1 << 1 = 2",
6322 		.u.insns_int = {
6323 			BPF_LD_IMM64(R0, 1),
6324 			BPF_ALU64_IMM(BPF_LSH, R0, 1),
6325 			BPF_EXIT_INSN(),
6326 		},
6327 		INTERNAL,
6328 		{ },
6329 		{ { 0, 2 } },
6330 	},
6331 	{
6332 		"ALU64_LSH_K: 1 << 31 = 0x80000000",
6333 		.u.insns_int = {
6334 			BPF_LD_IMM64(R0, 1),
6335 			BPF_ALU64_IMM(BPF_LSH, R0, 31),
6336 			BPF_EXIT_INSN(),
6337 		},
6338 		INTERNAL,
6339 		{ },
6340 		{ { 0, 0x80000000 } },
6341 	},
6342 	{
6343 		"ALU64_LSH_K: Shift < 32, low word",
6344 		.u.insns_int = {
6345 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6346 			BPF_ALU64_IMM(BPF_LSH, R0, 12),
6347 			BPF_EXIT_INSN(),
6348 		},
6349 		INTERNAL,
6350 		{ },
6351 		{ { 0, 0xbcdef000 } }
6352 	},
6353 	{
6354 		"ALU64_LSH_K: Shift < 32, high word",
6355 		.u.insns_int = {
6356 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6357 			BPF_ALU64_IMM(BPF_LSH, R0, 12),
6358 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6359 			BPF_EXIT_INSN(),
6360 		},
6361 		INTERNAL,
6362 		{ },
6363 		{ { 0, 0x3456789a } }
6364 	},
6365 	{
6366 		"ALU64_LSH_K: Shift > 32, low word",
6367 		.u.insns_int = {
6368 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6369 			BPF_ALU64_IMM(BPF_LSH, R0, 36),
6370 			BPF_EXIT_INSN(),
6371 		},
6372 		INTERNAL,
6373 		{ },
6374 		{ { 0, 0 } }
6375 	},
6376 	{
6377 		"ALU64_LSH_K: Shift > 32, high word",
6378 		.u.insns_int = {
6379 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6380 			BPF_ALU64_IMM(BPF_LSH, R0, 36),
6381 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6382 			BPF_EXIT_INSN(),
6383 		},
6384 		INTERNAL,
6385 		{ },
6386 		{ { 0, 0x9abcdef0 } }
6387 	},
6388 	{
6389 		"ALU64_LSH_K: Shift == 32, low word",
6390 		.u.insns_int = {
6391 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6392 			BPF_ALU64_IMM(BPF_LSH, R0, 32),
6393 			BPF_EXIT_INSN(),
6394 		},
6395 		INTERNAL,
6396 		{ },
6397 		{ { 0, 0 } }
6398 	},
6399 	{
6400 		"ALU64_LSH_K: Shift == 32, high word",
6401 		.u.insns_int = {
6402 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6403 			BPF_ALU64_IMM(BPF_LSH, R0, 32),
6404 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6405 			BPF_EXIT_INSN(),
6406 		},
6407 		INTERNAL,
6408 		{ },
6409 		{ { 0, 0x89abcdef } }
6410 	},
6411 	{
6412 		"ALU64_LSH_K: Zero shift",
6413 		.u.insns_int = {
6414 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6415 			BPF_ALU64_IMM(BPF_LSH, R0, 0),
6416 			BPF_EXIT_INSN(),
6417 		},
6418 		INTERNAL,
6419 		{ },
6420 		{ { 0, 0x89abcdef } }
6421 	},
6422 	/* BPF_ALU | BPF_RSH | BPF_X */
6423 	{
6424 		"ALU_RSH_X: 2 >> 1 = 1",
6425 		.u.insns_int = {
6426 			BPF_LD_IMM64(R0, 2),
6427 			BPF_ALU32_IMM(BPF_MOV, R1, 1),
6428 			BPF_ALU32_REG(BPF_RSH, R0, R1),
6429 			BPF_EXIT_INSN(),
6430 		},
6431 		INTERNAL,
6432 		{ },
6433 		{ { 0, 1 } },
6434 	},
6435 	{
6436 		"ALU_RSH_X: 0x80000000 >> 31 = 1",
6437 		.u.insns_int = {
6438 			BPF_LD_IMM64(R0, 0x80000000),
6439 			BPF_ALU32_IMM(BPF_MOV, R1, 31),
6440 			BPF_ALU32_REG(BPF_RSH, R0, R1),
6441 			BPF_EXIT_INSN(),
6442 		},
6443 		INTERNAL,
6444 		{ },
6445 		{ { 0, 1 } },
6446 	},
6447 	{
6448 		"ALU_RSH_X: 0x12345678 >> 20 = 0x123",
6449 		.u.insns_int = {
6450 			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
6451 			BPF_ALU32_IMM(BPF_MOV, R1, 20),
6452 			BPF_ALU32_REG(BPF_RSH, R0, R1),
6453 			BPF_EXIT_INSN(),
6454 		},
6455 		INTERNAL,
6456 		{ },
6457 		{ { 0, 0x123 } }
6458 	},
6459 	{
6460 		"ALU64_RSH_X: 2 >> 1 = 1",
6461 		.u.insns_int = {
6462 			BPF_LD_IMM64(R0, 2),
6463 			BPF_ALU32_IMM(BPF_MOV, R1, 1),
6464 			BPF_ALU64_REG(BPF_RSH, R0, R1),
6465 			BPF_EXIT_INSN(),
6466 		},
6467 		INTERNAL,
6468 		{ },
6469 		{ { 0, 1 } },
6470 	},
6471 	{
6472 		"ALU64_RSH_X: 0x80000000 >> 31 = 1",
6473 		.u.insns_int = {
6474 			BPF_LD_IMM64(R0, 0x80000000),
6475 			BPF_ALU32_IMM(BPF_MOV, R1, 31),
6476 			BPF_ALU64_REG(BPF_RSH, R0, R1),
6477 			BPF_EXIT_INSN(),
6478 		},
6479 		INTERNAL,
6480 		{ },
6481 		{ { 0, 1 } },
6482 	},
6483 	{
6484 		"ALU64_RSH_X: Shift < 32, low word",
6485 		.u.insns_int = {
6486 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6487 			BPF_ALU32_IMM(BPF_MOV, R1, 12),
6488 			BPF_ALU64_REG(BPF_RSH, R0, R1),
6489 			BPF_EXIT_INSN(),
6490 		},
6491 		INTERNAL,
6492 		{ },
6493 		{ { 0, 0x56789abc } }
6494 	},
6495 	{
6496 		"ALU64_RSH_X: Shift < 32, high word",
6497 		.u.insns_int = {
6498 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6499 			BPF_ALU32_IMM(BPF_MOV, R1, 12),
6500 			BPF_ALU64_REG(BPF_RSH, R0, R1),
6501 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6502 			BPF_EXIT_INSN(),
6503 		},
6504 		INTERNAL,
6505 		{ },
6506 		{ { 0, 0x00081234 } }
6507 	},
6508 	{
6509 		"ALU64_RSH_X: Shift > 32, low word",
6510 		.u.insns_int = {
6511 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6512 			BPF_ALU32_IMM(BPF_MOV, R1, 36),
6513 			BPF_ALU64_REG(BPF_RSH, R0, R1),
6514 			BPF_EXIT_INSN(),
6515 		},
6516 		INTERNAL,
6517 		{ },
6518 		{ { 0, 0x08123456 } }
6519 	},
6520 	{
6521 		"ALU64_RSH_X: Shift > 32, high word",
6522 		.u.insns_int = {
6523 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6524 			BPF_ALU32_IMM(BPF_MOV, R1, 36),
6525 			BPF_ALU64_REG(BPF_RSH, R0, R1),
6526 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6527 			BPF_EXIT_INSN(),
6528 		},
6529 		INTERNAL,
6530 		{ },
6531 		{ { 0, 0 } }
6532 	},
6533 	{
6534 		"ALU64_RSH_X: Shift == 32, low word",
6535 		.u.insns_int = {
6536 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6537 			BPF_ALU32_IMM(BPF_MOV, R1, 32),
6538 			BPF_ALU64_REG(BPF_RSH, R0, R1),
6539 			BPF_EXIT_INSN(),
6540 		},
6541 		INTERNAL,
6542 		{ },
6543 		{ { 0, 0x81234567 } }
6544 	},
6545 	{
6546 		"ALU64_RSH_X: Shift == 32, high word",
6547 		.u.insns_int = {
6548 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6549 			BPF_ALU32_IMM(BPF_MOV, R1, 32),
6550 			BPF_ALU64_REG(BPF_RSH, R0, R1),
6551 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6552 			BPF_EXIT_INSN(),
6553 		},
6554 		INTERNAL,
6555 		{ },
6556 		{ { 0, 0 } }
6557 	},
6558 	{
6559 		"ALU64_RSH_X: Zero shift, low word",
6560 		.u.insns_int = {
6561 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6562 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
6563 			BPF_ALU64_REG(BPF_RSH, R0, R1),
6564 			BPF_EXIT_INSN(),
6565 		},
6566 		INTERNAL,
6567 		{ },
6568 		{ { 0, 0x89abcdef } }
6569 	},
6570 	{
6571 		"ALU64_RSH_X: Zero shift, high word",
6572 		.u.insns_int = {
6573 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6574 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
6575 			BPF_ALU64_REG(BPF_RSH, R0, R1),
6576 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6577 			BPF_EXIT_INSN(),
6578 		},
6579 		INTERNAL,
6580 		{ },
6581 		{ { 0, 0x81234567 } }
6582 	},
6583 	/* BPF_ALU | BPF_RSH | BPF_K */
6584 	{
6585 		"ALU_RSH_K: 2 >> 1 = 1",
6586 		.u.insns_int = {
6587 			BPF_LD_IMM64(R0, 2),
6588 			BPF_ALU32_IMM(BPF_RSH, R0, 1),
6589 			BPF_EXIT_INSN(),
6590 		},
6591 		INTERNAL,
6592 		{ },
6593 		{ { 0, 1 } },
6594 	},
6595 	{
6596 		"ALU_RSH_K: 0x80000000 >> 31 = 1",
6597 		.u.insns_int = {
6598 			BPF_LD_IMM64(R0, 0x80000000),
6599 			BPF_ALU32_IMM(BPF_RSH, R0, 31),
6600 			BPF_EXIT_INSN(),
6601 		},
6602 		INTERNAL,
6603 		{ },
6604 		{ { 0, 1 } },
6605 	},
6606 	{
6607 		"ALU_RSH_K: 0x12345678 >> 20 = 0x123",
6608 		.u.insns_int = {
6609 			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
6610 			BPF_ALU32_IMM(BPF_RSH, R0, 20),
6611 			BPF_EXIT_INSN(),
6612 		},
6613 		INTERNAL,
6614 		{ },
6615 		{ { 0, 0x123 } }
6616 	},
6617 	{
6618 		"ALU_RSH_K: 0x12345678 >> 0 = 0x12345678",
6619 		.u.insns_int = {
6620 			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
6621 			BPF_ALU32_IMM(BPF_RSH, R0, 0),
6622 			BPF_EXIT_INSN(),
6623 		},
6624 		INTERNAL,
6625 		{ },
6626 		{ { 0, 0x12345678 } }
6627 	},
6628 	{
6629 		"ALU64_RSH_K: 2 >> 1 = 1",
6630 		.u.insns_int = {
6631 			BPF_LD_IMM64(R0, 2),
6632 			BPF_ALU64_IMM(BPF_RSH, R0, 1),
6633 			BPF_EXIT_INSN(),
6634 		},
6635 		INTERNAL,
6636 		{ },
6637 		{ { 0, 1 } },
6638 	},
6639 	{
6640 		"ALU64_RSH_K: 0x80000000 >> 31 = 1",
6641 		.u.insns_int = {
6642 			BPF_LD_IMM64(R0, 0x80000000),
6643 			BPF_ALU64_IMM(BPF_RSH, R0, 31),
6644 			BPF_EXIT_INSN(),
6645 		},
6646 		INTERNAL,
6647 		{ },
6648 		{ { 0, 1 } },
6649 	},
6650 	{
6651 		"ALU64_RSH_K: Shift < 32, low word",
6652 		.u.insns_int = {
6653 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6654 			BPF_ALU64_IMM(BPF_RSH, R0, 12),
6655 			BPF_EXIT_INSN(),
6656 		},
6657 		INTERNAL,
6658 		{ },
6659 		{ { 0, 0x56789abc } }
6660 	},
6661 	{
6662 		"ALU64_RSH_K: Shift < 32, high word",
6663 		.u.insns_int = {
6664 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6665 			BPF_ALU64_IMM(BPF_RSH, R0, 12),
6666 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6667 			BPF_EXIT_INSN(),
6668 		},
6669 		INTERNAL,
6670 		{ },
6671 		{ { 0, 0x00081234 } }
6672 	},
6673 	{
6674 		"ALU64_RSH_K: Shift > 32, low word",
6675 		.u.insns_int = {
6676 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6677 			BPF_ALU64_IMM(BPF_RSH, R0, 36),
6678 			BPF_EXIT_INSN(),
6679 		},
6680 		INTERNAL,
6681 		{ },
6682 		{ { 0, 0x08123456 } }
6683 	},
6684 	{
6685 		"ALU64_RSH_K: Shift > 32, high word",
6686 		.u.insns_int = {
6687 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6688 			BPF_ALU64_IMM(BPF_RSH, R0, 36),
6689 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6690 			BPF_EXIT_INSN(),
6691 		},
6692 		INTERNAL,
6693 		{ },
6694 		{ { 0, 0 } }
6695 	},
6696 	{
6697 		"ALU64_RSH_K: Shift == 32, low word",
6698 		.u.insns_int = {
6699 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6700 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6701 			BPF_EXIT_INSN(),
6702 		},
6703 		INTERNAL,
6704 		{ },
6705 		{ { 0, 0x81234567 } }
6706 	},
6707 	{
6708 		"ALU64_RSH_K: Shift == 32, high word",
6709 		.u.insns_int = {
6710 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6711 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6712 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6713 			BPF_EXIT_INSN(),
6714 		},
6715 		INTERNAL,
6716 		{ },
6717 		{ { 0, 0 } }
6718 	},
6719 	{
6720 		"ALU64_RSH_K: Zero shift",
6721 		.u.insns_int = {
6722 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6723 			BPF_ALU64_IMM(BPF_RSH, R0, 0),
6724 			BPF_EXIT_INSN(),
6725 		},
6726 		INTERNAL,
6727 		{ },
6728 		{ { 0, 0x89abcdef } }
6729 	},
6730 	/* BPF_ALU | BPF_ARSH | BPF_X */
6731 	{
6732 		"ALU32_ARSH_X: -1234 >> 7 = -10",
6733 		.u.insns_int = {
6734 			BPF_ALU32_IMM(BPF_MOV, R0, -1234),
6735 			BPF_ALU32_IMM(BPF_MOV, R1, 7),
6736 			BPF_ALU32_REG(BPF_ARSH, R0, R1),
6737 			BPF_EXIT_INSN(),
6738 		},
6739 		INTERNAL,
6740 		{ },
6741 		{ { 0, -10 } }
6742 	},
6743 	{
6744 		"ALU64_ARSH_X: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
6745 		.u.insns_int = {
6746 			BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
6747 			BPF_ALU32_IMM(BPF_MOV, R1, 40),
6748 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
6749 			BPF_EXIT_INSN(),
6750 		},
6751 		INTERNAL,
6752 		{ },
6753 		{ { 0, 0xffff00ff } },
6754 	},
6755 	{
6756 		"ALU64_ARSH_X: Shift < 32, low word",
6757 		.u.insns_int = {
6758 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6759 			BPF_ALU32_IMM(BPF_MOV, R1, 12),
6760 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
6761 			BPF_EXIT_INSN(),
6762 		},
6763 		INTERNAL,
6764 		{ },
6765 		{ { 0, 0x56789abc } }
6766 	},
6767 	{
6768 		"ALU64_ARSH_X: Shift < 32, high word",
6769 		.u.insns_int = {
6770 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6771 			BPF_ALU32_IMM(BPF_MOV, R1, 12),
6772 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
6773 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6774 			BPF_EXIT_INSN(),
6775 		},
6776 		INTERNAL,
6777 		{ },
6778 		{ { 0, 0xfff81234 } }
6779 	},
6780 	{
6781 		"ALU64_ARSH_X: Shift > 32, low word",
6782 		.u.insns_int = {
6783 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6784 			BPF_ALU32_IMM(BPF_MOV, R1, 36),
6785 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
6786 			BPF_EXIT_INSN(),
6787 		},
6788 		INTERNAL,
6789 		{ },
6790 		{ { 0, 0xf8123456 } }
6791 	},
6792 	{
6793 		"ALU64_ARSH_X: Shift > 32, high word",
6794 		.u.insns_int = {
6795 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6796 			BPF_ALU32_IMM(BPF_MOV, R1, 36),
6797 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
6798 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6799 			BPF_EXIT_INSN(),
6800 		},
6801 		INTERNAL,
6802 		{ },
6803 		{ { 0, -1 } }
6804 	},
6805 	{
6806 		"ALU64_ARSH_X: Shift == 32, low word",
6807 		.u.insns_int = {
6808 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6809 			BPF_ALU32_IMM(BPF_MOV, R1, 32),
6810 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
6811 			BPF_EXIT_INSN(),
6812 		},
6813 		INTERNAL,
6814 		{ },
6815 		{ { 0, 0x81234567 } }
6816 	},
6817 	{
6818 		"ALU64_ARSH_X: Shift == 32, high word",
6819 		.u.insns_int = {
6820 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6821 			BPF_ALU32_IMM(BPF_MOV, R1, 32),
6822 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
6823 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6824 			BPF_EXIT_INSN(),
6825 		},
6826 		INTERNAL,
6827 		{ },
6828 		{ { 0, -1 } }
6829 	},
6830 	{
6831 		"ALU64_ARSH_X: Zero shift, low word",
6832 		.u.insns_int = {
6833 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6834 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
6835 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
6836 			BPF_EXIT_INSN(),
6837 		},
6838 		INTERNAL,
6839 		{ },
6840 		{ { 0, 0x89abcdef } }
6841 	},
6842 	{
6843 		"ALU64_ARSH_X: Zero shift, high word",
6844 		.u.insns_int = {
6845 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6846 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
6847 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
6848 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6849 			BPF_EXIT_INSN(),
6850 		},
6851 		INTERNAL,
6852 		{ },
6853 		{ { 0, 0x81234567 } }
6854 	},
6855 	/* BPF_ALU | BPF_ARSH | BPF_K */
6856 	{
6857 		"ALU32_ARSH_K: -1234 >> 7 = -10",
6858 		.u.insns_int = {
6859 			BPF_ALU32_IMM(BPF_MOV, R0, -1234),
6860 			BPF_ALU32_IMM(BPF_ARSH, R0, 7),
6861 			BPF_EXIT_INSN(),
6862 		},
6863 		INTERNAL,
6864 		{ },
6865 		{ { 0, -10 } }
6866 	},
6867 	{
6868 		"ALU32_ARSH_K: -1234 >> 0 = -1234",
6869 		.u.insns_int = {
6870 			BPF_ALU32_IMM(BPF_MOV, R0, -1234),
6871 			BPF_ALU32_IMM(BPF_ARSH, R0, 0),
6872 			BPF_EXIT_INSN(),
6873 		},
6874 		INTERNAL,
6875 		{ },
6876 		{ { 0, -1234 } }
6877 	},
6878 	{
6879 		"ALU64_ARSH_K: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
6880 		.u.insns_int = {
6881 			BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
6882 			BPF_ALU64_IMM(BPF_ARSH, R0, 40),
6883 			BPF_EXIT_INSN(),
6884 		},
6885 		INTERNAL,
6886 		{ },
6887 		{ { 0, 0xffff00ff } },
6888 	},
6889 	{
6890 		"ALU64_ARSH_K: Shift < 32, low word",
6891 		.u.insns_int = {
6892 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6893 			BPF_ALU64_IMM(BPF_RSH, R0, 12),
6894 			BPF_EXIT_INSN(),
6895 		},
6896 		INTERNAL,
6897 		{ },
6898 		{ { 0, 0x56789abc } }
6899 	},
6900 	{
6901 		"ALU64_ARSH_K: Shift < 32, high word",
6902 		.u.insns_int = {
6903 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6904 			BPF_ALU64_IMM(BPF_ARSH, R0, 12),
6905 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6906 			BPF_EXIT_INSN(),
6907 		},
6908 		INTERNAL,
6909 		{ },
6910 		{ { 0, 0xfff81234 } }
6911 	},
6912 	{
6913 		"ALU64_ARSH_K: Shift > 32, low word",
6914 		.u.insns_int = {
6915 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6916 			BPF_ALU64_IMM(BPF_ARSH, R0, 36),
6917 			BPF_EXIT_INSN(),
6918 		},
6919 		INTERNAL,
6920 		{ },
6921 		{ { 0, 0xf8123456 } }
6922 	},
6923 	{
6924 		"ALU64_ARSH_K: Shift > 32, high word",
6925 		.u.insns_int = {
6926 			BPF_LD_IMM64(R0, 0xf123456789abcdefLL),
6927 			BPF_ALU64_IMM(BPF_ARSH, R0, 36),
6928 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6929 			BPF_EXIT_INSN(),
6930 		},
6931 		INTERNAL,
6932 		{ },
6933 		{ { 0, -1 } }
6934 	},
6935 	{
6936 		"ALU64_ARSH_K: Shift == 32, low word",
6937 		.u.insns_int = {
6938 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6939 			BPF_ALU64_IMM(BPF_ARSH, R0, 32),
6940 			BPF_EXIT_INSN(),
6941 		},
6942 		INTERNAL,
6943 		{ },
6944 		{ { 0, 0x81234567 } }
6945 	},
6946 	{
6947 		"ALU64_ARSH_K: Shift == 32, high word",
6948 		.u.insns_int = {
6949 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6950 			BPF_ALU64_IMM(BPF_ARSH, R0, 32),
6951 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6952 			BPF_EXIT_INSN(),
6953 		},
6954 		INTERNAL,
6955 		{ },
6956 		{ { 0, -1 } }
6957 	},
6958 	{
6959 		"ALU64_ARSH_K: Zero shift",
6960 		.u.insns_int = {
6961 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6962 			BPF_ALU64_IMM(BPF_ARSH, R0, 0),
6963 			BPF_EXIT_INSN(),
6964 		},
6965 		INTERNAL,
6966 		{ },
6967 		{ { 0, 0x89abcdef } }
6968 	},
6969 	/* BPF_ALU | BPF_NEG */
6970 	{
6971 		"ALU_NEG: -(3) = -3",
6972 		.u.insns_int = {
6973 			BPF_ALU32_IMM(BPF_MOV, R0, 3),
6974 			BPF_ALU32_IMM(BPF_NEG, R0, 0),
6975 			BPF_EXIT_INSN(),
6976 		},
6977 		INTERNAL,
6978 		{ },
6979 		{ { 0, -3 } },
6980 	},
6981 	{
6982 		"ALU_NEG: -(-3) = 3",
6983 		.u.insns_int = {
6984 			BPF_ALU32_IMM(BPF_MOV, R0, -3),
6985 			BPF_ALU32_IMM(BPF_NEG, R0, 0),
6986 			BPF_EXIT_INSN(),
6987 		},
6988 		INTERNAL,
6989 		{ },
6990 		{ { 0, 3 } },
6991 	},
6992 	{
6993 		"ALU64_NEG: -(3) = -3",
6994 		.u.insns_int = {
6995 			BPF_LD_IMM64(R0, 3),
6996 			BPF_ALU64_IMM(BPF_NEG, R0, 0),
6997 			BPF_EXIT_INSN(),
6998 		},
6999 		INTERNAL,
7000 		{ },
7001 		{ { 0, -3 } },
7002 	},
7003 	{
7004 		"ALU64_NEG: -(-3) = 3",
7005 		.u.insns_int = {
7006 			BPF_LD_IMM64(R0, -3),
7007 			BPF_ALU64_IMM(BPF_NEG, R0, 0),
7008 			BPF_EXIT_INSN(),
7009 		},
7010 		INTERNAL,
7011 		{ },
7012 		{ { 0, 3 } },
7013 	},
7014 	/* BPF_ALU | BPF_END | BPF_FROM_BE */
7015 	{
7016 		"ALU_END_FROM_BE 16: 0x0123456789abcdef -> 0xcdef",
7017 		.u.insns_int = {
7018 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7019 			BPF_ENDIAN(BPF_FROM_BE, R0, 16),
7020 			BPF_EXIT_INSN(),
7021 		},
7022 		INTERNAL,
7023 		{ },
7024 		{ { 0,  cpu_to_be16(0xcdef) } },
7025 	},
7026 	{
7027 		"ALU_END_FROM_BE 32: 0x0123456789abcdef -> 0x89abcdef",
7028 		.u.insns_int = {
7029 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7030 			BPF_ENDIAN(BPF_FROM_BE, R0, 32),
7031 			BPF_ALU64_REG(BPF_MOV, R1, R0),
7032 			BPF_ALU64_IMM(BPF_RSH, R1, 32),
7033 			BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
7034 			BPF_EXIT_INSN(),
7035 		},
7036 		INTERNAL,
7037 		{ },
7038 		{ { 0, cpu_to_be32(0x89abcdef) } },
7039 	},
7040 	{
7041 		"ALU_END_FROM_BE 64: 0x0123456789abcdef -> 0x89abcdef",
7042 		.u.insns_int = {
7043 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7044 			BPF_ENDIAN(BPF_FROM_BE, R0, 64),
7045 			BPF_EXIT_INSN(),
7046 		},
7047 		INTERNAL,
7048 		{ },
7049 		{ { 0, (u32) cpu_to_be64(0x0123456789abcdefLL) } },
7050 	},
7051 	{
7052 		"ALU_END_FROM_BE 64: 0x0123456789abcdef >> 32 -> 0x01234567",
7053 		.u.insns_int = {
7054 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7055 			BPF_ENDIAN(BPF_FROM_BE, R0, 64),
7056 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7057 			BPF_EXIT_INSN(),
7058 		},
7059 		INTERNAL,
7060 		{ },
7061 		{ { 0, (u32) (cpu_to_be64(0x0123456789abcdefLL) >> 32) } },
7062 	},
7063 	/* BPF_ALU | BPF_END | BPF_FROM_BE, reversed */
7064 	{
7065 		"ALU_END_FROM_BE 16: 0xfedcba9876543210 -> 0x3210",
7066 		.u.insns_int = {
7067 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7068 			BPF_ENDIAN(BPF_FROM_BE, R0, 16),
7069 			BPF_EXIT_INSN(),
7070 		},
7071 		INTERNAL,
7072 		{ },
7073 		{ { 0,  cpu_to_be16(0x3210) } },
7074 	},
7075 	{
7076 		"ALU_END_FROM_BE 32: 0xfedcba9876543210 -> 0x76543210",
7077 		.u.insns_int = {
7078 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7079 			BPF_ENDIAN(BPF_FROM_BE, R0, 32),
7080 			BPF_ALU64_REG(BPF_MOV, R1, R0),
7081 			BPF_ALU64_IMM(BPF_RSH, R1, 32),
7082 			BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
7083 			BPF_EXIT_INSN(),
7084 		},
7085 		INTERNAL,
7086 		{ },
7087 		{ { 0, cpu_to_be32(0x76543210) } },
7088 	},
7089 	{
7090 		"ALU_END_FROM_BE 64: 0xfedcba9876543210 -> 0x76543210",
7091 		.u.insns_int = {
7092 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7093 			BPF_ENDIAN(BPF_FROM_BE, R0, 64),
7094 			BPF_EXIT_INSN(),
7095 		},
7096 		INTERNAL,
7097 		{ },
7098 		{ { 0, (u32) cpu_to_be64(0xfedcba9876543210ULL) } },
7099 	},
7100 	{
7101 		"ALU_END_FROM_BE 64: 0xfedcba9876543210 >> 32 -> 0xfedcba98",
7102 		.u.insns_int = {
7103 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7104 			BPF_ENDIAN(BPF_FROM_BE, R0, 64),
7105 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7106 			BPF_EXIT_INSN(),
7107 		},
7108 		INTERNAL,
7109 		{ },
7110 		{ { 0, (u32) (cpu_to_be64(0xfedcba9876543210ULL) >> 32) } },
7111 	},
7112 	/* BPF_ALU | BPF_END | BPF_FROM_LE */
7113 	{
7114 		"ALU_END_FROM_LE 16: 0x0123456789abcdef -> 0xefcd",
7115 		.u.insns_int = {
7116 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7117 			BPF_ENDIAN(BPF_FROM_LE, R0, 16),
7118 			BPF_EXIT_INSN(),
7119 		},
7120 		INTERNAL,
7121 		{ },
7122 		{ { 0, cpu_to_le16(0xcdef) } },
7123 	},
7124 	{
7125 		"ALU_END_FROM_LE 32: 0x0123456789abcdef -> 0xefcdab89",
7126 		.u.insns_int = {
7127 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7128 			BPF_ENDIAN(BPF_FROM_LE, R0, 32),
7129 			BPF_ALU64_REG(BPF_MOV, R1, R0),
7130 			BPF_ALU64_IMM(BPF_RSH, R1, 32),
7131 			BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
7132 			BPF_EXIT_INSN(),
7133 		},
7134 		INTERNAL,
7135 		{ },
7136 		{ { 0, cpu_to_le32(0x89abcdef) } },
7137 	},
7138 	{
7139 		"ALU_END_FROM_LE 64: 0x0123456789abcdef -> 0x67452301",
7140 		.u.insns_int = {
7141 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7142 			BPF_ENDIAN(BPF_FROM_LE, R0, 64),
7143 			BPF_EXIT_INSN(),
7144 		},
7145 		INTERNAL,
7146 		{ },
7147 		{ { 0, (u32) cpu_to_le64(0x0123456789abcdefLL) } },
7148 	},
7149 	{
7150 		"ALU_END_FROM_LE 64: 0x0123456789abcdef >> 32 -> 0xefcdab89",
7151 		.u.insns_int = {
7152 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7153 			BPF_ENDIAN(BPF_FROM_LE, R0, 64),
7154 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7155 			BPF_EXIT_INSN(),
7156 		},
7157 		INTERNAL,
7158 		{ },
7159 		{ { 0, (u32) (cpu_to_le64(0x0123456789abcdefLL) >> 32) } },
7160 	},
7161 	/* BPF_ALU | BPF_END | BPF_FROM_LE, reversed */
7162 	{
7163 		"ALU_END_FROM_LE 16: 0xfedcba9876543210 -> 0x1032",
7164 		.u.insns_int = {
7165 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7166 			BPF_ENDIAN(BPF_FROM_LE, R0, 16),
7167 			BPF_EXIT_INSN(),
7168 		},
7169 		INTERNAL,
7170 		{ },
7171 		{ { 0,  cpu_to_le16(0x3210) } },
7172 	},
7173 	{
7174 		"ALU_END_FROM_LE 32: 0xfedcba9876543210 -> 0x10325476",
7175 		.u.insns_int = {
7176 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7177 			BPF_ENDIAN(BPF_FROM_LE, R0, 32),
7178 			BPF_ALU64_REG(BPF_MOV, R1, R0),
7179 			BPF_ALU64_IMM(BPF_RSH, R1, 32),
7180 			BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
7181 			BPF_EXIT_INSN(),
7182 		},
7183 		INTERNAL,
7184 		{ },
7185 		{ { 0, cpu_to_le32(0x76543210) } },
7186 	},
7187 	{
7188 		"ALU_END_FROM_LE 64: 0xfedcba9876543210 -> 0x10325476",
7189 		.u.insns_int = {
7190 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7191 			BPF_ENDIAN(BPF_FROM_LE, R0, 64),
7192 			BPF_EXIT_INSN(),
7193 		},
7194 		INTERNAL,
7195 		{ },
7196 		{ { 0, (u32) cpu_to_le64(0xfedcba9876543210ULL) } },
7197 	},
7198 	{
7199 		"ALU_END_FROM_LE 64: 0xfedcba9876543210 >> 32 -> 0x98badcfe",
7200 		.u.insns_int = {
7201 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7202 			BPF_ENDIAN(BPF_FROM_LE, R0, 64),
7203 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7204 			BPF_EXIT_INSN(),
7205 		},
7206 		INTERNAL,
7207 		{ },
7208 		{ { 0, (u32) (cpu_to_le64(0xfedcba9876543210ULL) >> 32) } },
7209 	},
7210 	/* BPF_LDX_MEM B/H/W/DW */
7211 	{
7212 		"BPF_LDX_MEM | BPF_B",
7213 		.u.insns_int = {
7214 			BPF_LD_IMM64(R1, 0x0102030405060708ULL),
7215 			BPF_LD_IMM64(R2, 0x0000000000000008ULL),
7216 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
7217 #ifdef __BIG_ENDIAN
7218 			BPF_LDX_MEM(BPF_B, R0, R10, -1),
7219 #else
7220 			BPF_LDX_MEM(BPF_B, R0, R10, -8),
7221 #endif
7222 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
7223 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7224 			BPF_EXIT_INSN(),
7225 		},
7226 		INTERNAL,
7227 		{ },
7228 		{ { 0, 0 } },
7229 		.stack_depth = 8,
7230 	},
7231 	{
7232 		"BPF_LDX_MEM | BPF_B, MSB set",
7233 		.u.insns_int = {
7234 			BPF_LD_IMM64(R1, 0x8182838485868788ULL),
7235 			BPF_LD_IMM64(R2, 0x0000000000000088ULL),
7236 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
7237 #ifdef __BIG_ENDIAN
7238 			BPF_LDX_MEM(BPF_B, R0, R10, -1),
7239 #else
7240 			BPF_LDX_MEM(BPF_B, R0, R10, -8),
7241 #endif
7242 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
7243 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7244 			BPF_EXIT_INSN(),
7245 		},
7246 		INTERNAL,
7247 		{ },
7248 		{ { 0, 0 } },
7249 		.stack_depth = 8,
7250 	},
7251 	{
7252 		"BPF_LDX_MEM | BPF_H",
7253 		.u.insns_int = {
7254 			BPF_LD_IMM64(R1, 0x0102030405060708ULL),
7255 			BPF_LD_IMM64(R2, 0x0000000000000708ULL),
7256 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
7257 #ifdef __BIG_ENDIAN
7258 			BPF_LDX_MEM(BPF_H, R0, R10, -2),
7259 #else
7260 			BPF_LDX_MEM(BPF_H, R0, R10, -8),
7261 #endif
7262 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
7263 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7264 			BPF_EXIT_INSN(),
7265 		},
7266 		INTERNAL,
7267 		{ },
7268 		{ { 0, 0 } },
7269 		.stack_depth = 8,
7270 	},
7271 	{
7272 		"BPF_LDX_MEM | BPF_H, MSB set",
7273 		.u.insns_int = {
7274 			BPF_LD_IMM64(R1, 0x8182838485868788ULL),
7275 			BPF_LD_IMM64(R2, 0x0000000000008788ULL),
7276 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
7277 #ifdef __BIG_ENDIAN
7278 			BPF_LDX_MEM(BPF_H, R0, R10, -2),
7279 #else
7280 			BPF_LDX_MEM(BPF_H, R0, R10, -8),
7281 #endif
7282 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
7283 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7284 			BPF_EXIT_INSN(),
7285 		},
7286 		INTERNAL,
7287 		{ },
7288 		{ { 0, 0 } },
7289 		.stack_depth = 8,
7290 	},
7291 	{
7292 		"BPF_LDX_MEM | BPF_W",
7293 		.u.insns_int = {
7294 			BPF_LD_IMM64(R1, 0x0102030405060708ULL),
7295 			BPF_LD_IMM64(R2, 0x0000000005060708ULL),
7296 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
7297 #ifdef __BIG_ENDIAN
7298 			BPF_LDX_MEM(BPF_W, R0, R10, -4),
7299 #else
7300 			BPF_LDX_MEM(BPF_W, R0, R10, -8),
7301 #endif
7302 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
7303 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7304 			BPF_EXIT_INSN(),
7305 		},
7306 		INTERNAL,
7307 		{ },
7308 		{ { 0, 0 } },
7309 		.stack_depth = 8,
7310 	},
7311 	{
7312 		"BPF_LDX_MEM | BPF_W, MSB set",
7313 		.u.insns_int = {
7314 			BPF_LD_IMM64(R1, 0x8182838485868788ULL),
7315 			BPF_LD_IMM64(R2, 0x0000000085868788ULL),
7316 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
7317 #ifdef __BIG_ENDIAN
7318 			BPF_LDX_MEM(BPF_W, R0, R10, -4),
7319 #else
7320 			BPF_LDX_MEM(BPF_W, R0, R10, -8),
7321 #endif
7322 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
7323 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7324 			BPF_EXIT_INSN(),
7325 		},
7326 		INTERNAL,
7327 		{ },
7328 		{ { 0, 0 } },
7329 		.stack_depth = 8,
7330 	},
7331 	/* BPF_STX_MEM B/H/W/DW */
7332 	{
7333 		"BPF_STX_MEM | BPF_B",
7334 		.u.insns_int = {
7335 			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
7336 			BPF_LD_IMM64(R2, 0x0102030405060708ULL),
7337 			BPF_LD_IMM64(R3, 0x8090a0b0c0d0e008ULL),
7338 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
7339 #ifdef __BIG_ENDIAN
7340 			BPF_STX_MEM(BPF_B, R10, R2, -1),
7341 #else
7342 			BPF_STX_MEM(BPF_B, R10, R2, -8),
7343 #endif
7344 			BPF_LDX_MEM(BPF_DW, R0, R10, -8),
7345 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
7346 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7347 			BPF_EXIT_INSN(),
7348 		},
7349 		INTERNAL,
7350 		{ },
7351 		{ { 0, 0 } },
7352 		.stack_depth = 8,
7353 	},
7354 	{
7355 		"BPF_STX_MEM | BPF_B, MSB set",
7356 		.u.insns_int = {
7357 			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
7358 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
7359 			BPF_LD_IMM64(R3, 0x8090a0b0c0d0e088ULL),
7360 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
7361 #ifdef __BIG_ENDIAN
7362 			BPF_STX_MEM(BPF_B, R10, R2, -1),
7363 #else
7364 			BPF_STX_MEM(BPF_B, R10, R2, -8),
7365 #endif
7366 			BPF_LDX_MEM(BPF_DW, R0, R10, -8),
7367 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
7368 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7369 			BPF_EXIT_INSN(),
7370 		},
7371 		INTERNAL,
7372 		{ },
7373 		{ { 0, 0 } },
7374 		.stack_depth = 8,
7375 	},
7376 	{
7377 		"BPF_STX_MEM | BPF_H",
7378 		.u.insns_int = {
7379 			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
7380 			BPF_LD_IMM64(R2, 0x0102030405060708ULL),
7381 			BPF_LD_IMM64(R3, 0x8090a0b0c0d00708ULL),
7382 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
7383 #ifdef __BIG_ENDIAN
7384 			BPF_STX_MEM(BPF_H, R10, R2, -2),
7385 #else
7386 			BPF_STX_MEM(BPF_H, R10, R2, -8),
7387 #endif
7388 			BPF_LDX_MEM(BPF_DW, R0, R10, -8),
7389 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
7390 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7391 			BPF_EXIT_INSN(),
7392 		},
7393 		INTERNAL,
7394 		{ },
7395 		{ { 0, 0 } },
7396 		.stack_depth = 8,
7397 	},
7398 	{
7399 		"BPF_STX_MEM | BPF_H, MSB set",
7400 		.u.insns_int = {
7401 			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
7402 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
7403 			BPF_LD_IMM64(R3, 0x8090a0b0c0d08788ULL),
7404 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
7405 #ifdef __BIG_ENDIAN
7406 			BPF_STX_MEM(BPF_H, R10, R2, -2),
7407 #else
7408 			BPF_STX_MEM(BPF_H, R10, R2, -8),
7409 #endif
7410 			BPF_LDX_MEM(BPF_DW, R0, R10, -8),
7411 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
7412 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7413 			BPF_EXIT_INSN(),
7414 		},
7415 		INTERNAL,
7416 		{ },
7417 		{ { 0, 0 } },
7418 		.stack_depth = 8,
7419 	},
7420 	{
7421 		"BPF_STX_MEM | BPF_W",
7422 		.u.insns_int = {
7423 			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
7424 			BPF_LD_IMM64(R2, 0x0102030405060708ULL),
7425 			BPF_LD_IMM64(R3, 0x8090a0b005060708ULL),
7426 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
7427 #ifdef __BIG_ENDIAN
7428 			BPF_STX_MEM(BPF_W, R10, R2, -4),
7429 #else
7430 			BPF_STX_MEM(BPF_W, R10, R2, -8),
7431 #endif
7432 			BPF_LDX_MEM(BPF_DW, R0, R10, -8),
7433 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
7434 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7435 			BPF_EXIT_INSN(),
7436 		},
7437 		INTERNAL,
7438 		{ },
7439 		{ { 0, 0 } },
7440 		.stack_depth = 8,
7441 	},
7442 	{
7443 		"BPF_STX_MEM | BPF_W, MSB set",
7444 		.u.insns_int = {
7445 			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
7446 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
7447 			BPF_LD_IMM64(R3, 0x8090a0b085868788ULL),
7448 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
7449 #ifdef __BIG_ENDIAN
7450 			BPF_STX_MEM(BPF_W, R10, R2, -4),
7451 #else
7452 			BPF_STX_MEM(BPF_W, R10, R2, -8),
7453 #endif
7454 			BPF_LDX_MEM(BPF_DW, R0, R10, -8),
7455 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
7456 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7457 			BPF_EXIT_INSN(),
7458 		},
7459 		INTERNAL,
7460 		{ },
7461 		{ { 0, 0 } },
7462 		.stack_depth = 8,
7463 	},
7464 	/* BPF_ST(X) | BPF_MEM | BPF_B/H/W/DW */
7465 	{
7466 		"ST_MEM_B: Store/Load byte: max negative",
7467 		.u.insns_int = {
7468 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
7469 			BPF_ST_MEM(BPF_B, R10, -40, 0xff),
7470 			BPF_LDX_MEM(BPF_B, R0, R10, -40),
7471 			BPF_EXIT_INSN(),
7472 		},
7473 		INTERNAL,
7474 		{ },
7475 		{ { 0, 0xff } },
7476 		.stack_depth = 40,
7477 	},
7478 	{
7479 		"ST_MEM_B: Store/Load byte: max positive",
7480 		.u.insns_int = {
7481 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
7482 			BPF_ST_MEM(BPF_H, R10, -40, 0x7f),
7483 			BPF_LDX_MEM(BPF_H, R0, R10, -40),
7484 			BPF_EXIT_INSN(),
7485 		},
7486 		INTERNAL,
7487 		{ },
7488 		{ { 0, 0x7f } },
7489 		.stack_depth = 40,
7490 	},
7491 	{
7492 		"STX_MEM_B: Store/Load byte: max negative",
7493 		.u.insns_int = {
7494 			BPF_LD_IMM64(R0, 0),
7495 			BPF_LD_IMM64(R1, 0xffLL),
7496 			BPF_STX_MEM(BPF_B, R10, R1, -40),
7497 			BPF_LDX_MEM(BPF_B, R0, R10, -40),
7498 			BPF_EXIT_INSN(),
7499 		},
7500 		INTERNAL,
7501 		{ },
7502 		{ { 0, 0xff } },
7503 		.stack_depth = 40,
7504 	},
7505 	{
7506 		"ST_MEM_H: Store/Load half word: max negative",
7507 		.u.insns_int = {
7508 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
7509 			BPF_ST_MEM(BPF_H, R10, -40, 0xffff),
7510 			BPF_LDX_MEM(BPF_H, R0, R10, -40),
7511 			BPF_EXIT_INSN(),
7512 		},
7513 		INTERNAL,
7514 		{ },
7515 		{ { 0, 0xffff } },
7516 		.stack_depth = 40,
7517 	},
7518 	{
7519 		"ST_MEM_H: Store/Load half word: max positive",
7520 		.u.insns_int = {
7521 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
7522 			BPF_ST_MEM(BPF_H, R10, -40, 0x7fff),
7523 			BPF_LDX_MEM(BPF_H, R0, R10, -40),
7524 			BPF_EXIT_INSN(),
7525 		},
7526 		INTERNAL,
7527 		{ },
7528 		{ { 0, 0x7fff } },
7529 		.stack_depth = 40,
7530 	},
7531 	{
7532 		"STX_MEM_H: Store/Load half word: max negative",
7533 		.u.insns_int = {
7534 			BPF_LD_IMM64(R0, 0),
7535 			BPF_LD_IMM64(R1, 0xffffLL),
7536 			BPF_STX_MEM(BPF_H, R10, R1, -40),
7537 			BPF_LDX_MEM(BPF_H, R0, R10, -40),
7538 			BPF_EXIT_INSN(),
7539 		},
7540 		INTERNAL,
7541 		{ },
7542 		{ { 0, 0xffff } },
7543 		.stack_depth = 40,
7544 	},
7545 	{
7546 		"ST_MEM_W: Store/Load word: max negative",
7547 		.u.insns_int = {
7548 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
7549 			BPF_ST_MEM(BPF_W, R10, -40, 0xffffffff),
7550 			BPF_LDX_MEM(BPF_W, R0, R10, -40),
7551 			BPF_EXIT_INSN(),
7552 		},
7553 		INTERNAL,
7554 		{ },
7555 		{ { 0, 0xffffffff } },
7556 		.stack_depth = 40,
7557 	},
7558 	{
7559 		"ST_MEM_W: Store/Load word: max positive",
7560 		.u.insns_int = {
7561 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
7562 			BPF_ST_MEM(BPF_W, R10, -40, 0x7fffffff),
7563 			BPF_LDX_MEM(BPF_W, R0, R10, -40),
7564 			BPF_EXIT_INSN(),
7565 		},
7566 		INTERNAL,
7567 		{ },
7568 		{ { 0, 0x7fffffff } },
7569 		.stack_depth = 40,
7570 	},
7571 	{
7572 		"STX_MEM_W: Store/Load word: max negative",
7573 		.u.insns_int = {
7574 			BPF_LD_IMM64(R0, 0),
7575 			BPF_LD_IMM64(R1, 0xffffffffLL),
7576 			BPF_STX_MEM(BPF_W, R10, R1, -40),
7577 			BPF_LDX_MEM(BPF_W, R0, R10, -40),
7578 			BPF_EXIT_INSN(),
7579 		},
7580 		INTERNAL,
7581 		{ },
7582 		{ { 0, 0xffffffff } },
7583 		.stack_depth = 40,
7584 	},
7585 	{
7586 		"ST_MEM_DW: Store/Load double word: max negative",
7587 		.u.insns_int = {
7588 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
7589 			BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
7590 			BPF_LDX_MEM(BPF_DW, R0, R10, -40),
7591 			BPF_EXIT_INSN(),
7592 		},
7593 		INTERNAL,
7594 		{ },
7595 		{ { 0, 0xffffffff } },
7596 		.stack_depth = 40,
7597 	},
7598 	{
7599 		"ST_MEM_DW: Store/Load double word: max negative 2",
7600 		.u.insns_int = {
7601 			BPF_LD_IMM64(R2, 0xffff00000000ffffLL),
7602 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
7603 			BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
7604 			BPF_LDX_MEM(BPF_DW, R2, R10, -40),
7605 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
7606 			BPF_MOV32_IMM(R0, 2),
7607 			BPF_EXIT_INSN(),
7608 			BPF_MOV32_IMM(R0, 1),
7609 			BPF_EXIT_INSN(),
7610 		},
7611 		INTERNAL,
7612 		{ },
7613 		{ { 0, 0x1 } },
7614 		.stack_depth = 40,
7615 	},
7616 	{
7617 		"ST_MEM_DW: Store/Load double word: max positive",
7618 		.u.insns_int = {
7619 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
7620 			BPF_ST_MEM(BPF_DW, R10, -40, 0x7fffffff),
7621 			BPF_LDX_MEM(BPF_DW, R0, R10, -40),
7622 			BPF_EXIT_INSN(),
7623 		},
7624 		INTERNAL,
7625 		{ },
7626 		{ { 0, 0x7fffffff } },
7627 		.stack_depth = 40,
7628 	},
7629 	{
7630 		"STX_MEM_DW: Store/Load double word: max negative",
7631 		.u.insns_int = {
7632 			BPF_LD_IMM64(R0, 0),
7633 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
7634 			BPF_STX_MEM(BPF_DW, R10, R1, -40),
7635 			BPF_LDX_MEM(BPF_DW, R0, R10, -40),
7636 			BPF_EXIT_INSN(),
7637 		},
7638 		INTERNAL,
7639 		{ },
7640 		{ { 0, 0xffffffff } },
7641 		.stack_depth = 40,
7642 	},
7643 	{
7644 		"STX_MEM_DW: Store double word: first word in memory",
7645 		.u.insns_int = {
7646 			BPF_LD_IMM64(R0, 0),
7647 			BPF_LD_IMM64(R1, 0x0123456789abcdefLL),
7648 			BPF_STX_MEM(BPF_DW, R10, R1, -40),
7649 			BPF_LDX_MEM(BPF_W, R0, R10, -40),
7650 			BPF_EXIT_INSN(),
7651 		},
7652 		INTERNAL,
7653 		{ },
7654 #ifdef __BIG_ENDIAN
7655 		{ { 0, 0x01234567 } },
7656 #else
7657 		{ { 0, 0x89abcdef } },
7658 #endif
7659 		.stack_depth = 40,
7660 	},
7661 	{
7662 		"STX_MEM_DW: Store double word: second word in memory",
7663 		.u.insns_int = {
7664 			BPF_LD_IMM64(R0, 0),
7665 			BPF_LD_IMM64(R1, 0x0123456789abcdefLL),
7666 			BPF_STX_MEM(BPF_DW, R10, R1, -40),
7667 			BPF_LDX_MEM(BPF_W, R0, R10, -36),
7668 			BPF_EXIT_INSN(),
7669 		},
7670 		INTERNAL,
7671 		{ },
7672 #ifdef __BIG_ENDIAN
7673 		{ { 0, 0x89abcdef } },
7674 #else
7675 		{ { 0, 0x01234567 } },
7676 #endif
7677 		.stack_depth = 40,
7678 	},
7679 	/* BPF_STX | BPF_ATOMIC | BPF_W/DW */
7680 	{
7681 		"STX_XADD_W: X + 1 + 1 + 1 + ...",
7682 		{ },
7683 		INTERNAL,
7684 		{ },
7685 		{ { 0, 4134 } },
7686 		.fill_helper = bpf_fill_stxw,
7687 	},
7688 	{
7689 		"STX_XADD_DW: X + 1 + 1 + 1 + ...",
7690 		{ },
7691 		INTERNAL,
7692 		{ },
7693 		{ { 0, 4134 } },
7694 		.fill_helper = bpf_fill_stxdw,
7695 	},
7696 	/*
7697 	 * Exhaustive tests of atomic operation variants.
7698 	 * Individual tests are expanded from template macros for all
7699 	 * combinations of ALU operation, word size and fetching.
7700 	 */
7701 #define BPF_ATOMIC_POISON(width) ((width) == BPF_W ? (0xbaadf00dULL << 32) : 0)
7702 
7703 #define BPF_ATOMIC_OP_TEST1(width, op, logic, old, update, result)	\
7704 {									\
7705 	"BPF_ATOMIC | " #width ", " #op ": Test: "			\
7706 		#old " " #logic " " #update " = " #result,		\
7707 	.u.insns_int = {						\
7708 		BPF_LD_IMM64(R5, (update) | BPF_ATOMIC_POISON(width)),	\
7709 		BPF_ST_MEM(width, R10, -40, old),			\
7710 		BPF_ATOMIC_OP(width, op, R10, R5, -40),			\
7711 		BPF_LDX_MEM(width, R0, R10, -40),			\
7712 		BPF_ALU64_REG(BPF_MOV, R1, R0),				\
7713 		BPF_ALU64_IMM(BPF_RSH, R1, 32),				\
7714 		BPF_ALU64_REG(BPF_OR, R0, R1),				\
7715 		BPF_EXIT_INSN(),					\
7716 	},								\
7717 	INTERNAL,							\
7718 	{ },								\
7719 	{ { 0, result } },						\
7720 	.stack_depth = 40,						\
7721 }
7722 #define BPF_ATOMIC_OP_TEST2(width, op, logic, old, update, result)	\
7723 {									\
7724 	"BPF_ATOMIC | " #width ", " #op ": Test side effects, r10: "	\
7725 		#old " " #logic " " #update " = " #result,		\
7726 	.u.insns_int = {						\
7727 		BPF_ALU64_REG(BPF_MOV, R1, R10),			\
7728 		BPF_LD_IMM64(R0, (update) | BPF_ATOMIC_POISON(width)),	\
7729 		BPF_ST_MEM(BPF_W, R10, -40, old),			\
7730 		BPF_ATOMIC_OP(width, op, R10, R0, -40),			\
7731 		BPF_ALU64_REG(BPF_MOV, R0, R10),			\
7732 		BPF_ALU64_REG(BPF_SUB, R0, R1),				\
7733 		BPF_ALU64_REG(BPF_MOV, R1, R0),				\
7734 		BPF_ALU64_IMM(BPF_RSH, R1, 32),				\
7735 		BPF_ALU64_REG(BPF_OR, R0, R1),				\
7736 		BPF_EXIT_INSN(),					\
7737 	},								\
7738 	INTERNAL,							\
7739 	{ },								\
7740 	{ { 0, 0 } },							\
7741 	.stack_depth = 40,						\
7742 }
7743 #define BPF_ATOMIC_OP_TEST3(width, op, logic, old, update, result)	\
7744 {									\
7745 	"BPF_ATOMIC | " #width ", " #op ": Test side effects, r0: "	\
7746 		#old " " #logic " " #update " = " #result,		\
7747 	.u.insns_int = {						\
7748 		BPF_ALU64_REG(BPF_MOV, R0, R10),			\
7749 		BPF_LD_IMM64(R1, (update) | BPF_ATOMIC_POISON(width)),	\
7750 		BPF_ST_MEM(width, R10, -40, old),			\
7751 		BPF_ATOMIC_OP(width, op, R10, R1, -40),			\
7752 		BPF_ALU64_REG(BPF_SUB, R0, R10),			\
7753 		BPF_ALU64_REG(BPF_MOV, R1, R0),				\
7754 		BPF_ALU64_IMM(BPF_RSH, R1, 32),				\
7755 		BPF_ALU64_REG(BPF_OR, R0, R1),				\
7756 		BPF_EXIT_INSN(),					\
7757 	},								\
7758 	INTERNAL,                                                       \
7759 	{ },                                                            \
7760 	{ { 0, 0 } },                                                   \
7761 	.stack_depth = 40,                                              \
7762 }
7763 #define BPF_ATOMIC_OP_TEST4(width, op, logic, old, update, result)	\
7764 {									\
7765 	"BPF_ATOMIC | " #width ", " #op ": Test fetch: "		\
7766 		#old " " #logic " " #update " = " #result,		\
7767 	.u.insns_int = {						\
7768 		BPF_LD_IMM64(R3, (update) | BPF_ATOMIC_POISON(width)),	\
7769 		BPF_ST_MEM(width, R10, -40, old),			\
7770 		BPF_ATOMIC_OP(width, op, R10, R3, -40),			\
7771 		BPF_ALU32_REG(BPF_MOV, R0, R3),                         \
7772 		BPF_EXIT_INSN(),					\
7773 	},								\
7774 	INTERNAL,                                                       \
7775 	{ },                                                            \
7776 	{ { 0, (op) & BPF_FETCH ? old : update } },			\
7777 	.stack_depth = 40,                                              \
7778 }
7779 	/* BPF_ATOMIC | BPF_W: BPF_ADD */
7780 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
7781 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
7782 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
7783 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
7784 	/* BPF_ATOMIC | BPF_W: BPF_ADD | BPF_FETCH */
7785 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
7786 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
7787 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
7788 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
7789 	/* BPF_ATOMIC | BPF_DW: BPF_ADD */
7790 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
7791 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
7792 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
7793 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
7794 	/* BPF_ATOMIC | BPF_DW: BPF_ADD | BPF_FETCH */
7795 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
7796 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
7797 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
7798 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
7799 	/* BPF_ATOMIC | BPF_W: BPF_AND */
7800 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
7801 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
7802 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
7803 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
7804 	/* BPF_ATOMIC | BPF_W: BPF_AND | BPF_FETCH */
7805 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
7806 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
7807 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
7808 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
7809 	/* BPF_ATOMIC | BPF_DW: BPF_AND */
7810 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
7811 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
7812 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
7813 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
7814 	/* BPF_ATOMIC | BPF_DW: BPF_AND | BPF_FETCH */
7815 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
7816 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
7817 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
7818 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
7819 	/* BPF_ATOMIC | BPF_W: BPF_OR */
7820 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
7821 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
7822 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
7823 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
7824 	/* BPF_ATOMIC | BPF_W: BPF_OR | BPF_FETCH */
7825 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
7826 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
7827 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
7828 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
7829 	/* BPF_ATOMIC | BPF_DW: BPF_OR */
7830 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
7831 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
7832 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
7833 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
7834 	/* BPF_ATOMIC | BPF_DW: BPF_OR | BPF_FETCH */
7835 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
7836 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
7837 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
7838 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
7839 	/* BPF_ATOMIC | BPF_W: BPF_XOR */
7840 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
7841 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
7842 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
7843 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
7844 	/* BPF_ATOMIC | BPF_W: BPF_XOR | BPF_FETCH */
7845 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
7846 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
7847 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
7848 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
7849 	/* BPF_ATOMIC | BPF_DW: BPF_XOR */
7850 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
7851 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
7852 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
7853 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
7854 	/* BPF_ATOMIC | BPF_DW: BPF_XOR | BPF_FETCH */
7855 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
7856 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
7857 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
7858 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
7859 	/* BPF_ATOMIC | BPF_W: BPF_XCHG */
7860 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
7861 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
7862 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
7863 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
7864 	/* BPF_ATOMIC | BPF_DW: BPF_XCHG */
7865 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
7866 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
7867 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
7868 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
7869 #undef BPF_ATOMIC_POISON
7870 #undef BPF_ATOMIC_OP_TEST1
7871 #undef BPF_ATOMIC_OP_TEST2
7872 #undef BPF_ATOMIC_OP_TEST3
7873 #undef BPF_ATOMIC_OP_TEST4
7874 	/* BPF_ATOMIC | BPF_W, BPF_CMPXCHG */
7875 	{
7876 		"BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test successful return",
7877 		.u.insns_int = {
7878 			BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
7879 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
7880 			BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
7881 			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
7882 			BPF_EXIT_INSN(),
7883 		},
7884 		INTERNAL,
7885 		{ },
7886 		{ { 0, 0x01234567 } },
7887 		.stack_depth = 40,
7888 	},
7889 	{
7890 		"BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test successful store",
7891 		.u.insns_int = {
7892 			BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
7893 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
7894 			BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
7895 			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
7896 			BPF_LDX_MEM(BPF_W, R0, R10, -40),
7897 			BPF_EXIT_INSN(),
7898 		},
7899 		INTERNAL,
7900 		{ },
7901 		{ { 0, 0x89abcdef } },
7902 		.stack_depth = 40,
7903 	},
7904 	{
7905 		"BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test failure return",
7906 		.u.insns_int = {
7907 			BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
7908 			BPF_ALU32_IMM(BPF_MOV, R0, 0x76543210),
7909 			BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
7910 			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
7911 			BPF_EXIT_INSN(),
7912 		},
7913 		INTERNAL,
7914 		{ },
7915 		{ { 0, 0x01234567 } },
7916 		.stack_depth = 40,
7917 	},
7918 	{
7919 		"BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test failure store",
7920 		.u.insns_int = {
7921 			BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
7922 			BPF_ALU32_IMM(BPF_MOV, R0, 0x76543210),
7923 			BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
7924 			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
7925 			BPF_LDX_MEM(BPF_W, R0, R10, -40),
7926 			BPF_EXIT_INSN(),
7927 		},
7928 		INTERNAL,
7929 		{ },
7930 		{ { 0, 0x01234567 } },
7931 		.stack_depth = 40,
7932 	},
7933 	{
7934 		"BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test side effects",
7935 		.u.insns_int = {
7936 			BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
7937 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
7938 			BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
7939 			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
7940 			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
7941 			BPF_ALU32_REG(BPF_MOV, R0, R3),
7942 			BPF_EXIT_INSN(),
7943 		},
7944 		INTERNAL,
7945 		{ },
7946 		{ { 0, 0x89abcdef } },
7947 		.stack_depth = 40,
7948 	},
7949 	/* BPF_ATOMIC | BPF_DW, BPF_CMPXCHG */
7950 	{
7951 		"BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test successful return",
7952 		.u.insns_int = {
7953 			BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
7954 			BPF_LD_IMM64(R2, 0xfecdba9876543210ULL),
7955 			BPF_ALU64_REG(BPF_MOV, R0, R1),
7956 			BPF_STX_MEM(BPF_DW, R10, R1, -40),
7957 			BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
7958 			BPF_JMP_REG(BPF_JNE, R0, R1, 1),
7959 			BPF_ALU64_REG(BPF_SUB, R0, R1),
7960 			BPF_EXIT_INSN(),
7961 		},
7962 		INTERNAL,
7963 		{ },
7964 		{ { 0, 0 } },
7965 		.stack_depth = 40,
7966 	},
7967 	{
7968 		"BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test successful store",
7969 		.u.insns_int = {
7970 			BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
7971 			BPF_LD_IMM64(R2, 0xfecdba9876543210ULL),
7972 			BPF_ALU64_REG(BPF_MOV, R0, R1),
7973 			BPF_STX_MEM(BPF_DW, R10, R0, -40),
7974 			BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
7975 			BPF_LDX_MEM(BPF_DW, R0, R10, -40),
7976 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
7977 			BPF_ALU64_REG(BPF_SUB, R0, R2),
7978 			BPF_EXIT_INSN(),
7979 		},
7980 		INTERNAL,
7981 		{ },
7982 		{ { 0, 0 } },
7983 		.stack_depth = 40,
7984 	},
7985 	{
7986 		"BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test failure return",
7987 		.u.insns_int = {
7988 			BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
7989 			BPF_LD_IMM64(R2, 0xfecdba9876543210ULL),
7990 			BPF_ALU64_REG(BPF_MOV, R0, R1),
7991 			BPF_ALU64_IMM(BPF_ADD, R0, 1),
7992 			BPF_STX_MEM(BPF_DW, R10, R1, -40),
7993 			BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
7994 			BPF_JMP_REG(BPF_JNE, R0, R1, 1),
7995 			BPF_ALU64_REG(BPF_SUB, R0, R1),
7996 			BPF_EXIT_INSN(),
7997 		},
7998 		INTERNAL,
7999 		{ },
8000 		{ { 0, 0 } },
8001 		.stack_depth = 40,
8002 	},
8003 	{
8004 		"BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test failure store",
8005 		.u.insns_int = {
8006 			BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
8007 			BPF_LD_IMM64(R2, 0xfecdba9876543210ULL),
8008 			BPF_ALU64_REG(BPF_MOV, R0, R1),
8009 			BPF_ALU64_IMM(BPF_ADD, R0, 1),
8010 			BPF_STX_MEM(BPF_DW, R10, R1, -40),
8011 			BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
8012 			BPF_LDX_MEM(BPF_DW, R0, R10, -40),
8013 			BPF_JMP_REG(BPF_JNE, R0, R1, 1),
8014 			BPF_ALU64_REG(BPF_SUB, R0, R1),
8015 			BPF_EXIT_INSN(),
8016 		},
8017 		INTERNAL,
8018 		{ },
8019 		{ { 0, 0 } },
8020 		.stack_depth = 40,
8021 	},
8022 	{
8023 		"BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test side effects",
8024 		.u.insns_int = {
8025 			BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
8026 			BPF_LD_IMM64(R2, 0xfecdba9876543210ULL),
8027 			BPF_ALU64_REG(BPF_MOV, R0, R1),
8028 			BPF_STX_MEM(BPF_DW, R10, R1, -40),
8029 			BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
8030 			BPF_LD_IMM64(R0, 0xfecdba9876543210ULL),
8031 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8032 			BPF_ALU64_REG(BPF_SUB, R0, R2),
8033 			BPF_EXIT_INSN(),
8034 		},
8035 		INTERNAL,
8036 		{ },
8037 		{ { 0, 0 } },
8038 		.stack_depth = 40,
8039 	},
8040 	/* BPF_JMP32 | BPF_JEQ | BPF_K */
8041 	{
8042 		"JMP32_JEQ_K: Small immediate",
8043 		.u.insns_int = {
8044 			BPF_ALU32_IMM(BPF_MOV, R0, 123),
8045 			BPF_JMP32_IMM(BPF_JEQ, R0, 321, 1),
8046 			BPF_JMP32_IMM(BPF_JEQ, R0, 123, 1),
8047 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8048 			BPF_EXIT_INSN(),
8049 		},
8050 		INTERNAL,
8051 		{ },
8052 		{ { 0, 123 } }
8053 	},
8054 	{
8055 		"JMP32_JEQ_K: Large immediate",
8056 		.u.insns_int = {
8057 			BPF_ALU32_IMM(BPF_MOV, R0, 12345678),
8058 			BPF_JMP32_IMM(BPF_JEQ, R0, 12345678 & 0xffff, 1),
8059 			BPF_JMP32_IMM(BPF_JEQ, R0, 12345678, 1),
8060 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8061 			BPF_EXIT_INSN(),
8062 		},
8063 		INTERNAL,
8064 		{ },
8065 		{ { 0, 12345678 } }
8066 	},
8067 	{
8068 		"JMP32_JEQ_K: negative immediate",
8069 		.u.insns_int = {
8070 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
8071 			BPF_JMP32_IMM(BPF_JEQ, R0,  123, 1),
8072 			BPF_JMP32_IMM(BPF_JEQ, R0, -123, 1),
8073 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8074 			BPF_EXIT_INSN(),
8075 		},
8076 		INTERNAL,
8077 		{ },
8078 		{ { 0, -123 } }
8079 	},
8080 	/* BPF_JMP32 | BPF_JEQ | BPF_X */
8081 	{
8082 		"JMP32_JEQ_X",
8083 		.u.insns_int = {
8084 			BPF_ALU32_IMM(BPF_MOV, R0, 1234),
8085 			BPF_ALU32_IMM(BPF_MOV, R1, 4321),
8086 			BPF_JMP32_REG(BPF_JEQ, R0, R1, 2),
8087 			BPF_ALU32_IMM(BPF_MOV, R1, 1234),
8088 			BPF_JMP32_REG(BPF_JEQ, R0, R1, 1),
8089 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8090 			BPF_EXIT_INSN(),
8091 		},
8092 		INTERNAL,
8093 		{ },
8094 		{ { 0, 1234 } }
8095 	},
8096 	/* BPF_JMP32 | BPF_JNE | BPF_K */
8097 	{
8098 		"JMP32_JNE_K: Small immediate",
8099 		.u.insns_int = {
8100 			BPF_ALU32_IMM(BPF_MOV, R0, 123),
8101 			BPF_JMP32_IMM(BPF_JNE, R0, 123, 1),
8102 			BPF_JMP32_IMM(BPF_JNE, R0, 321, 1),
8103 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8104 			BPF_EXIT_INSN(),
8105 		},
8106 		INTERNAL,
8107 		{ },
8108 		{ { 0, 123 } }
8109 	},
8110 	{
8111 		"JMP32_JNE_K: Large immediate",
8112 		.u.insns_int = {
8113 			BPF_ALU32_IMM(BPF_MOV, R0, 12345678),
8114 			BPF_JMP32_IMM(BPF_JNE, R0, 12345678, 1),
8115 			BPF_JMP32_IMM(BPF_JNE, R0, 12345678 & 0xffff, 1),
8116 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8117 			BPF_EXIT_INSN(),
8118 		},
8119 		INTERNAL,
8120 		{ },
8121 		{ { 0, 12345678 } }
8122 	},
8123 	{
8124 		"JMP32_JNE_K: negative immediate",
8125 		.u.insns_int = {
8126 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
8127 			BPF_JMP32_IMM(BPF_JNE, R0, -123, 1),
8128 			BPF_JMP32_IMM(BPF_JNE, R0,  123, 1),
8129 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8130 			BPF_EXIT_INSN(),
8131 		},
8132 		INTERNAL,
8133 		{ },
8134 		{ { 0, -123 } }
8135 	},
8136 	/* BPF_JMP32 | BPF_JNE | BPF_X */
8137 	{
8138 		"JMP32_JNE_X",
8139 		.u.insns_int = {
8140 			BPF_ALU32_IMM(BPF_MOV, R0, 1234),
8141 			BPF_ALU32_IMM(BPF_MOV, R1, 1234),
8142 			BPF_JMP32_REG(BPF_JNE, R0, R1, 2),
8143 			BPF_ALU32_IMM(BPF_MOV, R1, 4321),
8144 			BPF_JMP32_REG(BPF_JNE, R0, R1, 1),
8145 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8146 			BPF_EXIT_INSN(),
8147 		},
8148 		INTERNAL,
8149 		{ },
8150 		{ { 0, 1234 } }
8151 	},
8152 	/* BPF_JMP32 | BPF_JSET | BPF_K */
8153 	{
8154 		"JMP32_JSET_K: Small immediate",
8155 		.u.insns_int = {
8156 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8157 			BPF_JMP32_IMM(BPF_JSET, R0, 2, 1),
8158 			BPF_JMP32_IMM(BPF_JSET, R0, 3, 1),
8159 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8160 			BPF_EXIT_INSN(),
8161 		},
8162 		INTERNAL,
8163 		{ },
8164 		{ { 0, 1 } }
8165 	},
8166 	{
8167 		"JMP32_JSET_K: Large immediate",
8168 		.u.insns_int = {
8169 			BPF_ALU32_IMM(BPF_MOV, R0, 0x40000000),
8170 			BPF_JMP32_IMM(BPF_JSET, R0, 0x3fffffff, 1),
8171 			BPF_JMP32_IMM(BPF_JSET, R0, 0x60000000, 1),
8172 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8173 			BPF_EXIT_INSN(),
8174 		},
8175 		INTERNAL,
8176 		{ },
8177 		{ { 0, 0x40000000 } }
8178 	},
8179 	{
8180 		"JMP32_JSET_K: negative immediate",
8181 		.u.insns_int = {
8182 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
8183 			BPF_JMP32_IMM(BPF_JSET, R0, -1, 1),
8184 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8185 			BPF_EXIT_INSN(),
8186 		},
8187 		INTERNAL,
8188 		{ },
8189 		{ { 0, -123 } }
8190 	},
8191 	/* BPF_JMP32 | BPF_JSET | BPF_X */
8192 	{
8193 		"JMP32_JSET_X",
8194 		.u.insns_int = {
8195 			BPF_ALU32_IMM(BPF_MOV, R0, 8),
8196 			BPF_ALU32_IMM(BPF_MOV, R1, 7),
8197 			BPF_JMP32_REG(BPF_JSET, R0, R1, 2),
8198 			BPF_ALU32_IMM(BPF_MOV, R1, 8 | 2),
8199 			BPF_JMP32_REG(BPF_JNE, R0, R1, 1),
8200 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8201 			BPF_EXIT_INSN(),
8202 		},
8203 		INTERNAL,
8204 		{ },
8205 		{ { 0, 8 } }
8206 	},
8207 	/* BPF_JMP32 | BPF_JGT | BPF_K */
8208 	{
8209 		"JMP32_JGT_K: Small immediate",
8210 		.u.insns_int = {
8211 			BPF_ALU32_IMM(BPF_MOV, R0, 123),
8212 			BPF_JMP32_IMM(BPF_JGT, R0, 123, 1),
8213 			BPF_JMP32_IMM(BPF_JGT, R0, 122, 1),
8214 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8215 			BPF_EXIT_INSN(),
8216 		},
8217 		INTERNAL,
8218 		{ },
8219 		{ { 0, 123 } }
8220 	},
8221 	{
8222 		"JMP32_JGT_K: Large immediate",
8223 		.u.insns_int = {
8224 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
8225 			BPF_JMP32_IMM(BPF_JGT, R0, 0xffffffff, 1),
8226 			BPF_JMP32_IMM(BPF_JGT, R0, 0xfffffffd, 1),
8227 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8228 			BPF_EXIT_INSN(),
8229 		},
8230 		INTERNAL,
8231 		{ },
8232 		{ { 0, 0xfffffffe } }
8233 	},
8234 	/* BPF_JMP32 | BPF_JGT | BPF_X */
8235 	{
8236 		"JMP32_JGT_X",
8237 		.u.insns_int = {
8238 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
8239 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
8240 			BPF_JMP32_REG(BPF_JGT, R0, R1, 2),
8241 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
8242 			BPF_JMP32_REG(BPF_JGT, R0, R1, 1),
8243 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8244 			BPF_EXIT_INSN(),
8245 		},
8246 		INTERNAL,
8247 		{ },
8248 		{ { 0, 0xfffffffe } }
8249 	},
8250 	/* BPF_JMP32 | BPF_JGE | BPF_K */
8251 	{
8252 		"JMP32_JGE_K: Small immediate",
8253 		.u.insns_int = {
8254 			BPF_ALU32_IMM(BPF_MOV, R0, 123),
8255 			BPF_JMP32_IMM(BPF_JGE, R0, 124, 1),
8256 			BPF_JMP32_IMM(BPF_JGE, R0, 123, 1),
8257 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8258 			BPF_EXIT_INSN(),
8259 		},
8260 		INTERNAL,
8261 		{ },
8262 		{ { 0, 123 } }
8263 	},
8264 	{
8265 		"JMP32_JGE_K: Large immediate",
8266 		.u.insns_int = {
8267 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
8268 			BPF_JMP32_IMM(BPF_JGE, R0, 0xffffffff, 1),
8269 			BPF_JMP32_IMM(BPF_JGE, R0, 0xfffffffe, 1),
8270 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8271 			BPF_EXIT_INSN(),
8272 		},
8273 		INTERNAL,
8274 		{ },
8275 		{ { 0, 0xfffffffe } }
8276 	},
8277 	/* BPF_JMP32 | BPF_JGE | BPF_X */
8278 	{
8279 		"JMP32_JGE_X",
8280 		.u.insns_int = {
8281 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
8282 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
8283 			BPF_JMP32_REG(BPF_JGE, R0, R1, 2),
8284 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffe),
8285 			BPF_JMP32_REG(BPF_JGE, R0, R1, 1),
8286 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8287 			BPF_EXIT_INSN(),
8288 		},
8289 		INTERNAL,
8290 		{ },
8291 		{ { 0, 0xfffffffe } }
8292 	},
8293 	/* BPF_JMP32 | BPF_JLT | BPF_K */
8294 	{
8295 		"JMP32_JLT_K: Small immediate",
8296 		.u.insns_int = {
8297 			BPF_ALU32_IMM(BPF_MOV, R0, 123),
8298 			BPF_JMP32_IMM(BPF_JLT, R0, 123, 1),
8299 			BPF_JMP32_IMM(BPF_JLT, R0, 124, 1),
8300 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8301 			BPF_EXIT_INSN(),
8302 		},
8303 		INTERNAL,
8304 		{ },
8305 		{ { 0, 123 } }
8306 	},
8307 	{
8308 		"JMP32_JLT_K: Large immediate",
8309 		.u.insns_int = {
8310 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
8311 			BPF_JMP32_IMM(BPF_JLT, R0, 0xfffffffd, 1),
8312 			BPF_JMP32_IMM(BPF_JLT, R0, 0xffffffff, 1),
8313 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8314 			BPF_EXIT_INSN(),
8315 		},
8316 		INTERNAL,
8317 		{ },
8318 		{ { 0, 0xfffffffe } }
8319 	},
8320 	/* BPF_JMP32 | BPF_JLT | BPF_X */
8321 	{
8322 		"JMP32_JLT_X",
8323 		.u.insns_int = {
8324 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
8325 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
8326 			BPF_JMP32_REG(BPF_JLT, R0, R1, 2),
8327 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
8328 			BPF_JMP32_REG(BPF_JLT, R0, R1, 1),
8329 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8330 			BPF_EXIT_INSN(),
8331 		},
8332 		INTERNAL,
8333 		{ },
8334 		{ { 0, 0xfffffffe } }
8335 	},
8336 	/* BPF_JMP32 | BPF_JLE | BPF_K */
8337 	{
8338 		"JMP32_JLE_K: Small immediate",
8339 		.u.insns_int = {
8340 			BPF_ALU32_IMM(BPF_MOV, R0, 123),
8341 			BPF_JMP32_IMM(BPF_JLE, R0, 122, 1),
8342 			BPF_JMP32_IMM(BPF_JLE, R0, 123, 1),
8343 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8344 			BPF_EXIT_INSN(),
8345 		},
8346 		INTERNAL,
8347 		{ },
8348 		{ { 0, 123 } }
8349 	},
8350 	{
8351 		"JMP32_JLE_K: Large immediate",
8352 		.u.insns_int = {
8353 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
8354 			BPF_JMP32_IMM(BPF_JLE, R0, 0xfffffffd, 1),
8355 			BPF_JMP32_IMM(BPF_JLE, R0, 0xfffffffe, 1),
8356 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8357 			BPF_EXIT_INSN(),
8358 		},
8359 		INTERNAL,
8360 		{ },
8361 		{ { 0, 0xfffffffe } }
8362 	},
8363 	/* BPF_JMP32 | BPF_JLE | BPF_X */
8364 	{
8365 		"JMP32_JLE_X",
8366 		.u.insns_int = {
8367 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
8368 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
8369 			BPF_JMP32_REG(BPF_JLE, R0, R1, 2),
8370 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffe),
8371 			BPF_JMP32_REG(BPF_JLE, R0, R1, 1),
8372 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8373 			BPF_EXIT_INSN(),
8374 		},
8375 		INTERNAL,
8376 		{ },
8377 		{ { 0, 0xfffffffe } }
8378 	},
8379 	/* BPF_JMP32 | BPF_JSGT | BPF_K */
8380 	{
8381 		"JMP32_JSGT_K: Small immediate",
8382 		.u.insns_int = {
8383 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
8384 			BPF_JMP32_IMM(BPF_JSGT, R0, -123, 1),
8385 			BPF_JMP32_IMM(BPF_JSGT, R0, -124, 1),
8386 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8387 			BPF_EXIT_INSN(),
8388 		},
8389 		INTERNAL,
8390 		{ },
8391 		{ { 0, -123 } }
8392 	},
8393 	{
8394 		"JMP32_JSGT_K: Large immediate",
8395 		.u.insns_int = {
8396 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
8397 			BPF_JMP32_IMM(BPF_JSGT, R0, -12345678, 1),
8398 			BPF_JMP32_IMM(BPF_JSGT, R0, -12345679, 1),
8399 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8400 			BPF_EXIT_INSN(),
8401 		},
8402 		INTERNAL,
8403 		{ },
8404 		{ { 0, -12345678 } }
8405 	},
8406 	/* BPF_JMP32 | BPF_JSGT | BPF_X */
8407 	{
8408 		"JMP32_JSGT_X",
8409 		.u.insns_int = {
8410 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
8411 			BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
8412 			BPF_JMP32_REG(BPF_JSGT, R0, R1, 2),
8413 			BPF_ALU32_IMM(BPF_MOV, R1, -12345679),
8414 			BPF_JMP32_REG(BPF_JSGT, R0, R1, 1),
8415 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8416 			BPF_EXIT_INSN(),
8417 		},
8418 		INTERNAL,
8419 		{ },
8420 		{ { 0, -12345678 } }
8421 	},
8422 	/* BPF_JMP32 | BPF_JSGE | BPF_K */
8423 	{
8424 		"JMP32_JSGE_K: Small immediate",
8425 		.u.insns_int = {
8426 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
8427 			BPF_JMP32_IMM(BPF_JSGE, R0, -122, 1),
8428 			BPF_JMP32_IMM(BPF_JSGE, R0, -123, 1),
8429 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8430 			BPF_EXIT_INSN(),
8431 		},
8432 		INTERNAL,
8433 		{ },
8434 		{ { 0, -123 } }
8435 	},
8436 	{
8437 		"JMP32_JSGE_K: Large immediate",
8438 		.u.insns_int = {
8439 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
8440 			BPF_JMP32_IMM(BPF_JSGE, R0, -12345677, 1),
8441 			BPF_JMP32_IMM(BPF_JSGE, R0, -12345678, 1),
8442 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8443 			BPF_EXIT_INSN(),
8444 		},
8445 		INTERNAL,
8446 		{ },
8447 		{ { 0, -12345678 } }
8448 	},
8449 	/* BPF_JMP32 | BPF_JSGE | BPF_X */
8450 	{
8451 		"JMP32_JSGE_X",
8452 		.u.insns_int = {
8453 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
8454 			BPF_ALU32_IMM(BPF_MOV, R1, -12345677),
8455 			BPF_JMP32_REG(BPF_JSGE, R0, R1, 2),
8456 			BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
8457 			BPF_JMP32_REG(BPF_JSGE, R0, R1, 1),
8458 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8459 			BPF_EXIT_INSN(),
8460 		},
8461 		INTERNAL,
8462 		{ },
8463 		{ { 0, -12345678 } }
8464 	},
8465 	/* BPF_JMP32 | BPF_JSLT | BPF_K */
8466 	{
8467 		"JMP32_JSLT_K: Small immediate",
8468 		.u.insns_int = {
8469 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
8470 			BPF_JMP32_IMM(BPF_JSLT, R0, -123, 1),
8471 			BPF_JMP32_IMM(BPF_JSLT, R0, -122, 1),
8472 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8473 			BPF_EXIT_INSN(),
8474 		},
8475 		INTERNAL,
8476 		{ },
8477 		{ { 0, -123 } }
8478 	},
8479 	{
8480 		"JMP32_JSLT_K: Large immediate",
8481 		.u.insns_int = {
8482 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
8483 			BPF_JMP32_IMM(BPF_JSLT, R0, -12345678, 1),
8484 			BPF_JMP32_IMM(BPF_JSLT, R0, -12345677, 1),
8485 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8486 			BPF_EXIT_INSN(),
8487 		},
8488 		INTERNAL,
8489 		{ },
8490 		{ { 0, -12345678 } }
8491 	},
8492 	/* BPF_JMP32 | BPF_JSLT | BPF_X */
8493 	{
8494 		"JMP32_JSLT_X",
8495 		.u.insns_int = {
8496 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
8497 			BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
8498 			BPF_JMP32_REG(BPF_JSLT, R0, R1, 2),
8499 			BPF_ALU32_IMM(BPF_MOV, R1, -12345677),
8500 			BPF_JMP32_REG(BPF_JSLT, R0, R1, 1),
8501 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8502 			BPF_EXIT_INSN(),
8503 		},
8504 		INTERNAL,
8505 		{ },
8506 		{ { 0, -12345678 } }
8507 	},
8508 	/* BPF_JMP32 | BPF_JSLE | BPF_K */
8509 	{
8510 		"JMP32_JSLE_K: Small immediate",
8511 		.u.insns_int = {
8512 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
8513 			BPF_JMP32_IMM(BPF_JSLE, R0, -124, 1),
8514 			BPF_JMP32_IMM(BPF_JSLE, R0, -123, 1),
8515 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8516 			BPF_EXIT_INSN(),
8517 		},
8518 		INTERNAL,
8519 		{ },
8520 		{ { 0, -123 } }
8521 	},
8522 	{
8523 		"JMP32_JSLE_K: Large immediate",
8524 		.u.insns_int = {
8525 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
8526 			BPF_JMP32_IMM(BPF_JSLE, R0, -12345679, 1),
8527 			BPF_JMP32_IMM(BPF_JSLE, R0, -12345678, 1),
8528 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8529 			BPF_EXIT_INSN(),
8530 		},
8531 		INTERNAL,
8532 		{ },
8533 		{ { 0, -12345678 } }
8534 	},
8535 	/* BPF_JMP32 | BPF_JSLE | BPF_K */
8536 	{
8537 		"JMP32_JSLE_X",
8538 		.u.insns_int = {
8539 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
8540 			BPF_ALU32_IMM(BPF_MOV, R1, -12345679),
8541 			BPF_JMP32_REG(BPF_JSLE, R0, R1, 2),
8542 			BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
8543 			BPF_JMP32_REG(BPF_JSLE, R0, R1, 1),
8544 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8545 			BPF_EXIT_INSN(),
8546 		},
8547 		INTERNAL,
8548 		{ },
8549 		{ { 0, -12345678 } }
8550 	},
8551 	/* BPF_JMP | BPF_EXIT */
8552 	{
8553 		"JMP_EXIT",
8554 		.u.insns_int = {
8555 			BPF_ALU32_IMM(BPF_MOV, R0, 0x4711),
8556 			BPF_EXIT_INSN(),
8557 			BPF_ALU32_IMM(BPF_MOV, R0, 0x4712),
8558 		},
8559 		INTERNAL,
8560 		{ },
8561 		{ { 0, 0x4711 } },
8562 	},
8563 	/* BPF_JMP | BPF_JA */
8564 	{
8565 		"JMP_JA: Unconditional jump: if (true) return 1",
8566 		.u.insns_int = {
8567 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8568 			BPF_JMP_IMM(BPF_JA, 0, 0, 1),
8569 			BPF_EXIT_INSN(),
8570 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8571 			BPF_EXIT_INSN(),
8572 		},
8573 		INTERNAL,
8574 		{ },
8575 		{ { 0, 1 } },
8576 	},
8577 	/* BPF_JMP | BPF_JSLT | BPF_K */
8578 	{
8579 		"JMP_JSLT_K: Signed jump: if (-2 < -1) return 1",
8580 		.u.insns_int = {
8581 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8582 			BPF_LD_IMM64(R1, 0xfffffffffffffffeLL),
8583 			BPF_JMP_IMM(BPF_JSLT, R1, -1, 1),
8584 			BPF_EXIT_INSN(),
8585 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8586 			BPF_EXIT_INSN(),
8587 		},
8588 		INTERNAL,
8589 		{ },
8590 		{ { 0, 1 } },
8591 	},
8592 	{
8593 		"JMP_JSLT_K: Signed jump: if (-1 < -1) return 0",
8594 		.u.insns_int = {
8595 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8596 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
8597 			BPF_JMP_IMM(BPF_JSLT, R1, -1, 1),
8598 			BPF_EXIT_INSN(),
8599 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8600 			BPF_EXIT_INSN(),
8601 		},
8602 		INTERNAL,
8603 		{ },
8604 		{ { 0, 1 } },
8605 	},
8606 	/* BPF_JMP | BPF_JSGT | BPF_K */
8607 	{
8608 		"JMP_JSGT_K: Signed jump: if (-1 > -2) return 1",
8609 		.u.insns_int = {
8610 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8611 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
8612 			BPF_JMP_IMM(BPF_JSGT, R1, -2, 1),
8613 			BPF_EXIT_INSN(),
8614 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8615 			BPF_EXIT_INSN(),
8616 		},
8617 		INTERNAL,
8618 		{ },
8619 		{ { 0, 1 } },
8620 	},
8621 	{
8622 		"JMP_JSGT_K: Signed jump: if (-1 > -1) return 0",
8623 		.u.insns_int = {
8624 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8625 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
8626 			BPF_JMP_IMM(BPF_JSGT, R1, -1, 1),
8627 			BPF_EXIT_INSN(),
8628 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8629 			BPF_EXIT_INSN(),
8630 		},
8631 		INTERNAL,
8632 		{ },
8633 		{ { 0, 1 } },
8634 	},
8635 	/* BPF_JMP | BPF_JSLE | BPF_K */
8636 	{
8637 		"JMP_JSLE_K: Signed jump: if (-2 <= -1) return 1",
8638 		.u.insns_int = {
8639 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8640 			BPF_LD_IMM64(R1, 0xfffffffffffffffeLL),
8641 			BPF_JMP_IMM(BPF_JSLE, R1, -1, 1),
8642 			BPF_EXIT_INSN(),
8643 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8644 			BPF_EXIT_INSN(),
8645 		},
8646 		INTERNAL,
8647 		{ },
8648 		{ { 0, 1 } },
8649 	},
8650 	{
8651 		"JMP_JSLE_K: Signed jump: if (-1 <= -1) return 1",
8652 		.u.insns_int = {
8653 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8654 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
8655 			BPF_JMP_IMM(BPF_JSLE, R1, -1, 1),
8656 			BPF_EXIT_INSN(),
8657 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8658 			BPF_EXIT_INSN(),
8659 		},
8660 		INTERNAL,
8661 		{ },
8662 		{ { 0, 1 } },
8663 	},
8664 	{
8665 		"JMP_JSLE_K: Signed jump: value walk 1",
8666 		.u.insns_int = {
8667 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8668 			BPF_LD_IMM64(R1, 3),
8669 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 6),
8670 			BPF_ALU64_IMM(BPF_SUB, R1, 1),
8671 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 4),
8672 			BPF_ALU64_IMM(BPF_SUB, R1, 1),
8673 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 2),
8674 			BPF_ALU64_IMM(BPF_SUB, R1, 1),
8675 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 1),
8676 			BPF_EXIT_INSN(),		/* bad exit */
8677 			BPF_ALU32_IMM(BPF_MOV, R0, 1),	/* good exit */
8678 			BPF_EXIT_INSN(),
8679 		},
8680 		INTERNAL,
8681 		{ },
8682 		{ { 0, 1 } },
8683 	},
8684 	{
8685 		"JMP_JSLE_K: Signed jump: value walk 2",
8686 		.u.insns_int = {
8687 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8688 			BPF_LD_IMM64(R1, 3),
8689 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 4),
8690 			BPF_ALU64_IMM(BPF_SUB, R1, 2),
8691 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 2),
8692 			BPF_ALU64_IMM(BPF_SUB, R1, 2),
8693 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 1),
8694 			BPF_EXIT_INSN(),		/* bad exit */
8695 			BPF_ALU32_IMM(BPF_MOV, R0, 1),	/* good exit */
8696 			BPF_EXIT_INSN(),
8697 		},
8698 		INTERNAL,
8699 		{ },
8700 		{ { 0, 1 } },
8701 	},
8702 	/* BPF_JMP | BPF_JSGE | BPF_K */
8703 	{
8704 		"JMP_JSGE_K: Signed jump: if (-1 >= -2) return 1",
8705 		.u.insns_int = {
8706 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8707 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
8708 			BPF_JMP_IMM(BPF_JSGE, R1, -2, 1),
8709 			BPF_EXIT_INSN(),
8710 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8711 			BPF_EXIT_INSN(),
8712 		},
8713 		INTERNAL,
8714 		{ },
8715 		{ { 0, 1 } },
8716 	},
8717 	{
8718 		"JMP_JSGE_K: Signed jump: if (-1 >= -1) return 1",
8719 		.u.insns_int = {
8720 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8721 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
8722 			BPF_JMP_IMM(BPF_JSGE, R1, -1, 1),
8723 			BPF_EXIT_INSN(),
8724 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8725 			BPF_EXIT_INSN(),
8726 		},
8727 		INTERNAL,
8728 		{ },
8729 		{ { 0, 1 } },
8730 	},
8731 	{
8732 		"JMP_JSGE_K: Signed jump: value walk 1",
8733 		.u.insns_int = {
8734 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8735 			BPF_LD_IMM64(R1, -3),
8736 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 6),
8737 			BPF_ALU64_IMM(BPF_ADD, R1, 1),
8738 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 4),
8739 			BPF_ALU64_IMM(BPF_ADD, R1, 1),
8740 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 2),
8741 			BPF_ALU64_IMM(BPF_ADD, R1, 1),
8742 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 1),
8743 			BPF_EXIT_INSN(),		/* bad exit */
8744 			BPF_ALU32_IMM(BPF_MOV, R0, 1),	/* good exit */
8745 			BPF_EXIT_INSN(),
8746 		},
8747 		INTERNAL,
8748 		{ },
8749 		{ { 0, 1 } },
8750 	},
8751 	{
8752 		"JMP_JSGE_K: Signed jump: value walk 2",
8753 		.u.insns_int = {
8754 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8755 			BPF_LD_IMM64(R1, -3),
8756 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 4),
8757 			BPF_ALU64_IMM(BPF_ADD, R1, 2),
8758 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 2),
8759 			BPF_ALU64_IMM(BPF_ADD, R1, 2),
8760 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 1),
8761 			BPF_EXIT_INSN(),		/* bad exit */
8762 			BPF_ALU32_IMM(BPF_MOV, R0, 1),	/* good exit */
8763 			BPF_EXIT_INSN(),
8764 		},
8765 		INTERNAL,
8766 		{ },
8767 		{ { 0, 1 } },
8768 	},
8769 	/* BPF_JMP | BPF_JGT | BPF_K */
8770 	{
8771 		"JMP_JGT_K: if (3 > 2) return 1",
8772 		.u.insns_int = {
8773 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8774 			BPF_LD_IMM64(R1, 3),
8775 			BPF_JMP_IMM(BPF_JGT, R1, 2, 1),
8776 			BPF_EXIT_INSN(),
8777 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8778 			BPF_EXIT_INSN(),
8779 		},
8780 		INTERNAL,
8781 		{ },
8782 		{ { 0, 1 } },
8783 	},
8784 	{
8785 		"JMP_JGT_K: Unsigned jump: if (-1 > 1) return 1",
8786 		.u.insns_int = {
8787 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8788 			BPF_LD_IMM64(R1, -1),
8789 			BPF_JMP_IMM(BPF_JGT, R1, 1, 1),
8790 			BPF_EXIT_INSN(),
8791 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8792 			BPF_EXIT_INSN(),
8793 		},
8794 		INTERNAL,
8795 		{ },
8796 		{ { 0, 1 } },
8797 	},
8798 	/* BPF_JMP | BPF_JLT | BPF_K */
8799 	{
8800 		"JMP_JLT_K: if (2 < 3) return 1",
8801 		.u.insns_int = {
8802 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8803 			BPF_LD_IMM64(R1, 2),
8804 			BPF_JMP_IMM(BPF_JLT, R1, 3, 1),
8805 			BPF_EXIT_INSN(),
8806 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8807 			BPF_EXIT_INSN(),
8808 		},
8809 		INTERNAL,
8810 		{ },
8811 		{ { 0, 1 } },
8812 	},
8813 	{
8814 		"JMP_JGT_K: Unsigned jump: if (1 < -1) return 1",
8815 		.u.insns_int = {
8816 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8817 			BPF_LD_IMM64(R1, 1),
8818 			BPF_JMP_IMM(BPF_JLT, R1, -1, 1),
8819 			BPF_EXIT_INSN(),
8820 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8821 			BPF_EXIT_INSN(),
8822 		},
8823 		INTERNAL,
8824 		{ },
8825 		{ { 0, 1 } },
8826 	},
8827 	/* BPF_JMP | BPF_JGE | BPF_K */
8828 	{
8829 		"JMP_JGE_K: if (3 >= 2) return 1",
8830 		.u.insns_int = {
8831 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8832 			BPF_LD_IMM64(R1, 3),
8833 			BPF_JMP_IMM(BPF_JGE, R1, 2, 1),
8834 			BPF_EXIT_INSN(),
8835 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8836 			BPF_EXIT_INSN(),
8837 		},
8838 		INTERNAL,
8839 		{ },
8840 		{ { 0, 1 } },
8841 	},
8842 	/* BPF_JMP | BPF_JLE | BPF_K */
8843 	{
8844 		"JMP_JLE_K: if (2 <= 3) return 1",
8845 		.u.insns_int = {
8846 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8847 			BPF_LD_IMM64(R1, 2),
8848 			BPF_JMP_IMM(BPF_JLE, R1, 3, 1),
8849 			BPF_EXIT_INSN(),
8850 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8851 			BPF_EXIT_INSN(),
8852 		},
8853 		INTERNAL,
8854 		{ },
8855 		{ { 0, 1 } },
8856 	},
8857 	/* BPF_JMP | BPF_JGT | BPF_K jump backwards */
8858 	{
8859 		"JMP_JGT_K: if (3 > 2) return 1 (jump backwards)",
8860 		.u.insns_int = {
8861 			BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
8862 			BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */
8863 			BPF_EXIT_INSN(),
8864 			BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
8865 			BPF_LD_IMM64(R1, 3), /* note: this takes 2 insns */
8866 			BPF_JMP_IMM(BPF_JGT, R1, 2, -6), /* goto out */
8867 			BPF_EXIT_INSN(),
8868 		},
8869 		INTERNAL,
8870 		{ },
8871 		{ { 0, 1 } },
8872 	},
8873 	{
8874 		"JMP_JGE_K: if (3 >= 3) return 1",
8875 		.u.insns_int = {
8876 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8877 			BPF_LD_IMM64(R1, 3),
8878 			BPF_JMP_IMM(BPF_JGE, R1, 3, 1),
8879 			BPF_EXIT_INSN(),
8880 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8881 			BPF_EXIT_INSN(),
8882 		},
8883 		INTERNAL,
8884 		{ },
8885 		{ { 0, 1 } },
8886 	},
8887 	/* BPF_JMP | BPF_JLT | BPF_K jump backwards */
8888 	{
8889 		"JMP_JGT_K: if (2 < 3) return 1 (jump backwards)",
8890 		.u.insns_int = {
8891 			BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
8892 			BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */
8893 			BPF_EXIT_INSN(),
8894 			BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
8895 			BPF_LD_IMM64(R1, 2), /* note: this takes 2 insns */
8896 			BPF_JMP_IMM(BPF_JLT, R1, 3, -6), /* goto out */
8897 			BPF_EXIT_INSN(),
8898 		},
8899 		INTERNAL,
8900 		{ },
8901 		{ { 0, 1 } },
8902 	},
8903 	{
8904 		"JMP_JLE_K: if (3 <= 3) return 1",
8905 		.u.insns_int = {
8906 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8907 			BPF_LD_IMM64(R1, 3),
8908 			BPF_JMP_IMM(BPF_JLE, R1, 3, 1),
8909 			BPF_EXIT_INSN(),
8910 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8911 			BPF_EXIT_INSN(),
8912 		},
8913 		INTERNAL,
8914 		{ },
8915 		{ { 0, 1 } },
8916 	},
8917 	/* BPF_JMP | BPF_JNE | BPF_K */
8918 	{
8919 		"JMP_JNE_K: if (3 != 2) return 1",
8920 		.u.insns_int = {
8921 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8922 			BPF_LD_IMM64(R1, 3),
8923 			BPF_JMP_IMM(BPF_JNE, R1, 2, 1),
8924 			BPF_EXIT_INSN(),
8925 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8926 			BPF_EXIT_INSN(),
8927 		},
8928 		INTERNAL,
8929 		{ },
8930 		{ { 0, 1 } },
8931 	},
8932 	/* BPF_JMP | BPF_JEQ | BPF_K */
8933 	{
8934 		"JMP_JEQ_K: if (3 == 3) return 1",
8935 		.u.insns_int = {
8936 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8937 			BPF_LD_IMM64(R1, 3),
8938 			BPF_JMP_IMM(BPF_JEQ, R1, 3, 1),
8939 			BPF_EXIT_INSN(),
8940 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8941 			BPF_EXIT_INSN(),
8942 		},
8943 		INTERNAL,
8944 		{ },
8945 		{ { 0, 1 } },
8946 	},
8947 	/* BPF_JMP | BPF_JSET | BPF_K */
8948 	{
8949 		"JMP_JSET_K: if (0x3 & 0x2) return 1",
8950 		.u.insns_int = {
8951 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8952 			BPF_LD_IMM64(R1, 3),
8953 			BPF_JMP_IMM(BPF_JSET, R1, 2, 1),
8954 			BPF_EXIT_INSN(),
8955 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8956 			BPF_EXIT_INSN(),
8957 		},
8958 		INTERNAL,
8959 		{ },
8960 		{ { 0, 1 } },
8961 	},
8962 	{
8963 		"JMP_JSET_K: if (0x3 & 0xffffffff) return 1",
8964 		.u.insns_int = {
8965 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8966 			BPF_LD_IMM64(R1, 3),
8967 			BPF_JMP_IMM(BPF_JSET, R1, 0xffffffff, 1),
8968 			BPF_EXIT_INSN(),
8969 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8970 			BPF_EXIT_INSN(),
8971 		},
8972 		INTERNAL,
8973 		{ },
8974 		{ { 0, 1 } },
8975 	},
8976 	/* BPF_JMP | BPF_JSGT | BPF_X */
8977 	{
8978 		"JMP_JSGT_X: Signed jump: if (-1 > -2) return 1",
8979 		.u.insns_int = {
8980 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8981 			BPF_LD_IMM64(R1, -1),
8982 			BPF_LD_IMM64(R2, -2),
8983 			BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
8984 			BPF_EXIT_INSN(),
8985 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8986 			BPF_EXIT_INSN(),
8987 		},
8988 		INTERNAL,
8989 		{ },
8990 		{ { 0, 1 } },
8991 	},
8992 	{
8993 		"JMP_JSGT_X: Signed jump: if (-1 > -1) return 0",
8994 		.u.insns_int = {
8995 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8996 			BPF_LD_IMM64(R1, -1),
8997 			BPF_LD_IMM64(R2, -1),
8998 			BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
8999 			BPF_EXIT_INSN(),
9000 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9001 			BPF_EXIT_INSN(),
9002 		},
9003 		INTERNAL,
9004 		{ },
9005 		{ { 0, 1 } },
9006 	},
9007 	/* BPF_JMP | BPF_JSLT | BPF_X */
9008 	{
9009 		"JMP_JSLT_X: Signed jump: if (-2 < -1) return 1",
9010 		.u.insns_int = {
9011 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9012 			BPF_LD_IMM64(R1, -1),
9013 			BPF_LD_IMM64(R2, -2),
9014 			BPF_JMP_REG(BPF_JSLT, R2, R1, 1),
9015 			BPF_EXIT_INSN(),
9016 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9017 			BPF_EXIT_INSN(),
9018 		},
9019 		INTERNAL,
9020 		{ },
9021 		{ { 0, 1 } },
9022 	},
9023 	{
9024 		"JMP_JSLT_X: Signed jump: if (-1 < -1) return 0",
9025 		.u.insns_int = {
9026 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9027 			BPF_LD_IMM64(R1, -1),
9028 			BPF_LD_IMM64(R2, -1),
9029 			BPF_JMP_REG(BPF_JSLT, R1, R2, 1),
9030 			BPF_EXIT_INSN(),
9031 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9032 			BPF_EXIT_INSN(),
9033 		},
9034 		INTERNAL,
9035 		{ },
9036 		{ { 0, 1 } },
9037 	},
9038 	/* BPF_JMP | BPF_JSGE | BPF_X */
9039 	{
9040 		"JMP_JSGE_X: Signed jump: if (-1 >= -2) return 1",
9041 		.u.insns_int = {
9042 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9043 			BPF_LD_IMM64(R1, -1),
9044 			BPF_LD_IMM64(R2, -2),
9045 			BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
9046 			BPF_EXIT_INSN(),
9047 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9048 			BPF_EXIT_INSN(),
9049 		},
9050 		INTERNAL,
9051 		{ },
9052 		{ { 0, 1 } },
9053 	},
9054 	{
9055 		"JMP_JSGE_X: Signed jump: if (-1 >= -1) return 1",
9056 		.u.insns_int = {
9057 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9058 			BPF_LD_IMM64(R1, -1),
9059 			BPF_LD_IMM64(R2, -1),
9060 			BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
9061 			BPF_EXIT_INSN(),
9062 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9063 			BPF_EXIT_INSN(),
9064 		},
9065 		INTERNAL,
9066 		{ },
9067 		{ { 0, 1 } },
9068 	},
9069 	/* BPF_JMP | BPF_JSLE | BPF_X */
9070 	{
9071 		"JMP_JSLE_X: Signed jump: if (-2 <= -1) return 1",
9072 		.u.insns_int = {
9073 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9074 			BPF_LD_IMM64(R1, -1),
9075 			BPF_LD_IMM64(R2, -2),
9076 			BPF_JMP_REG(BPF_JSLE, R2, R1, 1),
9077 			BPF_EXIT_INSN(),
9078 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9079 			BPF_EXIT_INSN(),
9080 		},
9081 		INTERNAL,
9082 		{ },
9083 		{ { 0, 1 } },
9084 	},
9085 	{
9086 		"JMP_JSLE_X: Signed jump: if (-1 <= -1) return 1",
9087 		.u.insns_int = {
9088 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9089 			BPF_LD_IMM64(R1, -1),
9090 			BPF_LD_IMM64(R2, -1),
9091 			BPF_JMP_REG(BPF_JSLE, R1, R2, 1),
9092 			BPF_EXIT_INSN(),
9093 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9094 			BPF_EXIT_INSN(),
9095 		},
9096 		INTERNAL,
9097 		{ },
9098 		{ { 0, 1 } },
9099 	},
9100 	/* BPF_JMP | BPF_JGT | BPF_X */
9101 	{
9102 		"JMP_JGT_X: if (3 > 2) return 1",
9103 		.u.insns_int = {
9104 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9105 			BPF_LD_IMM64(R1, 3),
9106 			BPF_LD_IMM64(R2, 2),
9107 			BPF_JMP_REG(BPF_JGT, R1, R2, 1),
9108 			BPF_EXIT_INSN(),
9109 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9110 			BPF_EXIT_INSN(),
9111 		},
9112 		INTERNAL,
9113 		{ },
9114 		{ { 0, 1 } },
9115 	},
9116 	{
9117 		"JMP_JGT_X: Unsigned jump: if (-1 > 1) return 1",
9118 		.u.insns_int = {
9119 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9120 			BPF_LD_IMM64(R1, -1),
9121 			BPF_LD_IMM64(R2, 1),
9122 			BPF_JMP_REG(BPF_JGT, R1, R2, 1),
9123 			BPF_EXIT_INSN(),
9124 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9125 			BPF_EXIT_INSN(),
9126 		},
9127 		INTERNAL,
9128 		{ },
9129 		{ { 0, 1 } },
9130 	},
9131 	/* BPF_JMP | BPF_JLT | BPF_X */
9132 	{
9133 		"JMP_JLT_X: if (2 < 3) return 1",
9134 		.u.insns_int = {
9135 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9136 			BPF_LD_IMM64(R1, 3),
9137 			BPF_LD_IMM64(R2, 2),
9138 			BPF_JMP_REG(BPF_JLT, R2, R1, 1),
9139 			BPF_EXIT_INSN(),
9140 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9141 			BPF_EXIT_INSN(),
9142 		},
9143 		INTERNAL,
9144 		{ },
9145 		{ { 0, 1 } },
9146 	},
9147 	{
9148 		"JMP_JLT_X: Unsigned jump: if (1 < -1) return 1",
9149 		.u.insns_int = {
9150 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9151 			BPF_LD_IMM64(R1, -1),
9152 			BPF_LD_IMM64(R2, 1),
9153 			BPF_JMP_REG(BPF_JLT, R2, R1, 1),
9154 			BPF_EXIT_INSN(),
9155 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9156 			BPF_EXIT_INSN(),
9157 		},
9158 		INTERNAL,
9159 		{ },
9160 		{ { 0, 1 } },
9161 	},
9162 	/* BPF_JMP | BPF_JGE | BPF_X */
9163 	{
9164 		"JMP_JGE_X: if (3 >= 2) return 1",
9165 		.u.insns_int = {
9166 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9167 			BPF_LD_IMM64(R1, 3),
9168 			BPF_LD_IMM64(R2, 2),
9169 			BPF_JMP_REG(BPF_JGE, R1, R2, 1),
9170 			BPF_EXIT_INSN(),
9171 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9172 			BPF_EXIT_INSN(),
9173 		},
9174 		INTERNAL,
9175 		{ },
9176 		{ { 0, 1 } },
9177 	},
9178 	{
9179 		"JMP_JGE_X: if (3 >= 3) return 1",
9180 		.u.insns_int = {
9181 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9182 			BPF_LD_IMM64(R1, 3),
9183 			BPF_LD_IMM64(R2, 3),
9184 			BPF_JMP_REG(BPF_JGE, R1, R2, 1),
9185 			BPF_EXIT_INSN(),
9186 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9187 			BPF_EXIT_INSN(),
9188 		},
9189 		INTERNAL,
9190 		{ },
9191 		{ { 0, 1 } },
9192 	},
9193 	/* BPF_JMP | BPF_JLE | BPF_X */
9194 	{
9195 		"JMP_JLE_X: if (2 <= 3) return 1",
9196 		.u.insns_int = {
9197 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9198 			BPF_LD_IMM64(R1, 3),
9199 			BPF_LD_IMM64(R2, 2),
9200 			BPF_JMP_REG(BPF_JLE, R2, R1, 1),
9201 			BPF_EXIT_INSN(),
9202 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9203 			BPF_EXIT_INSN(),
9204 		},
9205 		INTERNAL,
9206 		{ },
9207 		{ { 0, 1 } },
9208 	},
9209 	{
9210 		"JMP_JLE_X: if (3 <= 3) return 1",
9211 		.u.insns_int = {
9212 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9213 			BPF_LD_IMM64(R1, 3),
9214 			BPF_LD_IMM64(R2, 3),
9215 			BPF_JMP_REG(BPF_JLE, R1, R2, 1),
9216 			BPF_EXIT_INSN(),
9217 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9218 			BPF_EXIT_INSN(),
9219 		},
9220 		INTERNAL,
9221 		{ },
9222 		{ { 0, 1 } },
9223 	},
9224 	{
9225 		/* Mainly testing JIT + imm64 here. */
9226 		"JMP_JGE_X: ldimm64 test 1",
9227 		.u.insns_int = {
9228 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9229 			BPF_LD_IMM64(R1, 3),
9230 			BPF_LD_IMM64(R2, 2),
9231 			BPF_JMP_REG(BPF_JGE, R1, R2, 2),
9232 			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
9233 			BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
9234 			BPF_EXIT_INSN(),
9235 		},
9236 		INTERNAL,
9237 		{ },
9238 		{ { 0, 0xeeeeeeeeU } },
9239 	},
9240 	{
9241 		"JMP_JGE_X: ldimm64 test 2",
9242 		.u.insns_int = {
9243 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9244 			BPF_LD_IMM64(R1, 3),
9245 			BPF_LD_IMM64(R2, 2),
9246 			BPF_JMP_REG(BPF_JGE, R1, R2, 0),
9247 			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
9248 			BPF_EXIT_INSN(),
9249 		},
9250 		INTERNAL,
9251 		{ },
9252 		{ { 0, 0xffffffffU } },
9253 	},
9254 	{
9255 		"JMP_JGE_X: ldimm64 test 3",
9256 		.u.insns_int = {
9257 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9258 			BPF_LD_IMM64(R1, 3),
9259 			BPF_LD_IMM64(R2, 2),
9260 			BPF_JMP_REG(BPF_JGE, R1, R2, 4),
9261 			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
9262 			BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
9263 			BPF_EXIT_INSN(),
9264 		},
9265 		INTERNAL,
9266 		{ },
9267 		{ { 0, 1 } },
9268 	},
9269 	{
9270 		"JMP_JLE_X: ldimm64 test 1",
9271 		.u.insns_int = {
9272 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9273 			BPF_LD_IMM64(R1, 3),
9274 			BPF_LD_IMM64(R2, 2),
9275 			BPF_JMP_REG(BPF_JLE, R2, R1, 2),
9276 			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
9277 			BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
9278 			BPF_EXIT_INSN(),
9279 		},
9280 		INTERNAL,
9281 		{ },
9282 		{ { 0, 0xeeeeeeeeU } },
9283 	},
9284 	{
9285 		"JMP_JLE_X: ldimm64 test 2",
9286 		.u.insns_int = {
9287 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9288 			BPF_LD_IMM64(R1, 3),
9289 			BPF_LD_IMM64(R2, 2),
9290 			BPF_JMP_REG(BPF_JLE, R2, R1, 0),
9291 			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
9292 			BPF_EXIT_INSN(),
9293 		},
9294 		INTERNAL,
9295 		{ },
9296 		{ { 0, 0xffffffffU } },
9297 	},
9298 	{
9299 		"JMP_JLE_X: ldimm64 test 3",
9300 		.u.insns_int = {
9301 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9302 			BPF_LD_IMM64(R1, 3),
9303 			BPF_LD_IMM64(R2, 2),
9304 			BPF_JMP_REG(BPF_JLE, R2, R1, 4),
9305 			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
9306 			BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
9307 			BPF_EXIT_INSN(),
9308 		},
9309 		INTERNAL,
9310 		{ },
9311 		{ { 0, 1 } },
9312 	},
9313 	/* BPF_JMP | BPF_JNE | BPF_X */
9314 	{
9315 		"JMP_JNE_X: if (3 != 2) return 1",
9316 		.u.insns_int = {
9317 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9318 			BPF_LD_IMM64(R1, 3),
9319 			BPF_LD_IMM64(R2, 2),
9320 			BPF_JMP_REG(BPF_JNE, R1, R2, 1),
9321 			BPF_EXIT_INSN(),
9322 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9323 			BPF_EXIT_INSN(),
9324 		},
9325 		INTERNAL,
9326 		{ },
9327 		{ { 0, 1 } },
9328 	},
9329 	/* BPF_JMP | BPF_JEQ | BPF_X */
9330 	{
9331 		"JMP_JEQ_X: if (3 == 3) return 1",
9332 		.u.insns_int = {
9333 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9334 			BPF_LD_IMM64(R1, 3),
9335 			BPF_LD_IMM64(R2, 3),
9336 			BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
9337 			BPF_EXIT_INSN(),
9338 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9339 			BPF_EXIT_INSN(),
9340 		},
9341 		INTERNAL,
9342 		{ },
9343 		{ { 0, 1 } },
9344 	},
9345 	/* BPF_JMP | BPF_JSET | BPF_X */
9346 	{
9347 		"JMP_JSET_X: if (0x3 & 0x2) return 1",
9348 		.u.insns_int = {
9349 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9350 			BPF_LD_IMM64(R1, 3),
9351 			BPF_LD_IMM64(R2, 2),
9352 			BPF_JMP_REG(BPF_JSET, R1, R2, 1),
9353 			BPF_EXIT_INSN(),
9354 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9355 			BPF_EXIT_INSN(),
9356 		},
9357 		INTERNAL,
9358 		{ },
9359 		{ { 0, 1 } },
9360 	},
9361 	{
9362 		"JMP_JSET_X: if (0x3 & 0xffffffff) return 1",
9363 		.u.insns_int = {
9364 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9365 			BPF_LD_IMM64(R1, 3),
9366 			BPF_LD_IMM64(R2, 0xffffffff),
9367 			BPF_JMP_REG(BPF_JSET, R1, R2, 1),
9368 			BPF_EXIT_INSN(),
9369 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9370 			BPF_EXIT_INSN(),
9371 		},
9372 		INTERNAL,
9373 		{ },
9374 		{ { 0, 1 } },
9375 	},
9376 	{
9377 		"JMP_JA: Jump, gap, jump, ...",
9378 		{ },
9379 		CLASSIC | FLAG_NO_DATA,
9380 		{ },
9381 		{ { 0, 0xababcbac } },
9382 		.fill_helper = bpf_fill_ja,
9383 	},
9384 	{	/* Mainly checking JIT here. */
9385 		"BPF_MAXINSNS: Maximum possible literals",
9386 		{ },
9387 		CLASSIC | FLAG_NO_DATA,
9388 		{ },
9389 		{ { 0, 0xffffffff } },
9390 		.fill_helper = bpf_fill_maxinsns1,
9391 	},
9392 	{	/* Mainly checking JIT here. */
9393 		"BPF_MAXINSNS: Single literal",
9394 		{ },
9395 		CLASSIC | FLAG_NO_DATA,
9396 		{ },
9397 		{ { 0, 0xfefefefe } },
9398 		.fill_helper = bpf_fill_maxinsns2,
9399 	},
9400 	{	/* Mainly checking JIT here. */
9401 		"BPF_MAXINSNS: Run/add until end",
9402 		{ },
9403 		CLASSIC | FLAG_NO_DATA,
9404 		{ },
9405 		{ { 0, 0x947bf368 } },
9406 		.fill_helper = bpf_fill_maxinsns3,
9407 	},
9408 	{
9409 		"BPF_MAXINSNS: Too many instructions",
9410 		{ },
9411 		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
9412 		{ },
9413 		{ },
9414 		.fill_helper = bpf_fill_maxinsns4,
9415 		.expected_errcode = -EINVAL,
9416 	},
9417 	{	/* Mainly checking JIT here. */
9418 		"BPF_MAXINSNS: Very long jump",
9419 		{ },
9420 		CLASSIC | FLAG_NO_DATA,
9421 		{ },
9422 		{ { 0, 0xabababab } },
9423 		.fill_helper = bpf_fill_maxinsns5,
9424 	},
9425 	{	/* Mainly checking JIT here. */
9426 		"BPF_MAXINSNS: Ctx heavy transformations",
9427 		{ },
9428 		CLASSIC,
9429 		{ },
9430 		{
9431 			{  1, SKB_VLAN_PRESENT },
9432 			{ 10, SKB_VLAN_PRESENT }
9433 		},
9434 		.fill_helper = bpf_fill_maxinsns6,
9435 	},
9436 	{	/* Mainly checking JIT here. */
9437 		"BPF_MAXINSNS: Call heavy transformations",
9438 		{ },
9439 		CLASSIC | FLAG_NO_DATA,
9440 		{ },
9441 		{ { 1, 0 }, { 10, 0 } },
9442 		.fill_helper = bpf_fill_maxinsns7,
9443 	},
9444 	{	/* Mainly checking JIT here. */
9445 		"BPF_MAXINSNS: Jump heavy test",
9446 		{ },
9447 		CLASSIC | FLAG_NO_DATA,
9448 		{ },
9449 		{ { 0, 0xffffffff } },
9450 		.fill_helper = bpf_fill_maxinsns8,
9451 	},
9452 	{	/* Mainly checking JIT here. */
9453 		"BPF_MAXINSNS: Very long jump backwards",
9454 		{ },
9455 		INTERNAL | FLAG_NO_DATA,
9456 		{ },
9457 		{ { 0, 0xcbababab } },
9458 		.fill_helper = bpf_fill_maxinsns9,
9459 	},
9460 	{	/* Mainly checking JIT here. */
9461 		"BPF_MAXINSNS: Edge hopping nuthouse",
9462 		{ },
9463 		INTERNAL | FLAG_NO_DATA,
9464 		{ },
9465 		{ { 0, 0xabababac } },
9466 		.fill_helper = bpf_fill_maxinsns10,
9467 	},
9468 	{
9469 		"BPF_MAXINSNS: Jump, gap, jump, ...",
9470 		{ },
9471 		CLASSIC | FLAG_NO_DATA,
9472 		{ },
9473 		{ { 0, 0xababcbac } },
9474 		.fill_helper = bpf_fill_maxinsns11,
9475 	},
9476 	{
9477 		"BPF_MAXINSNS: jump over MSH",
9478 		{ },
9479 		CLASSIC | FLAG_EXPECTED_FAIL,
9480 		{ 0xfa, 0xfb, 0xfc, 0xfd, },
9481 		{ { 4, 0xabababab } },
9482 		.fill_helper = bpf_fill_maxinsns12,
9483 		.expected_errcode = -EINVAL,
9484 	},
9485 	{
9486 		"BPF_MAXINSNS: exec all MSH",
9487 		{ },
9488 		CLASSIC,
9489 		{ 0xfa, 0xfb, 0xfc, 0xfd, },
9490 		{ { 4, 0xababab83 } },
9491 		.fill_helper = bpf_fill_maxinsns13,
9492 	},
9493 	{
9494 		"BPF_MAXINSNS: ld_abs+get_processor_id",
9495 		{ },
9496 		CLASSIC,
9497 		{ },
9498 		{ { 1, 0xbee } },
9499 		.fill_helper = bpf_fill_ld_abs_get_processor_id,
9500 	},
9501 	/*
9502 	 * LD_IND / LD_ABS on fragmented SKBs
9503 	 */
9504 	{
9505 		"LD_IND byte frag",
9506 		.u.insns = {
9507 			BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
9508 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x0),
9509 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9510 		},
9511 		CLASSIC | FLAG_SKB_FRAG,
9512 		{ },
9513 		{ {0x40, 0x42} },
9514 		.frag_data = {
9515 			0x42, 0x00, 0x00, 0x00,
9516 			0x43, 0x44, 0x00, 0x00,
9517 			0x21, 0x07, 0x19, 0x83,
9518 		},
9519 	},
9520 	{
9521 		"LD_IND halfword frag",
9522 		.u.insns = {
9523 			BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
9524 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x4),
9525 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9526 		},
9527 		CLASSIC | FLAG_SKB_FRAG,
9528 		{ },
9529 		{ {0x40, 0x4344} },
9530 		.frag_data = {
9531 			0x42, 0x00, 0x00, 0x00,
9532 			0x43, 0x44, 0x00, 0x00,
9533 			0x21, 0x07, 0x19, 0x83,
9534 		},
9535 	},
9536 	{
9537 		"LD_IND word frag",
9538 		.u.insns = {
9539 			BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
9540 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x8),
9541 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9542 		},
9543 		CLASSIC | FLAG_SKB_FRAG,
9544 		{ },
9545 		{ {0x40, 0x21071983} },
9546 		.frag_data = {
9547 			0x42, 0x00, 0x00, 0x00,
9548 			0x43, 0x44, 0x00, 0x00,
9549 			0x21, 0x07, 0x19, 0x83,
9550 		},
9551 	},
9552 	{
9553 		"LD_IND halfword mixed head/frag",
9554 		.u.insns = {
9555 			BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
9556 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
9557 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9558 		},
9559 		CLASSIC | FLAG_SKB_FRAG,
9560 		{ [0x3e] = 0x25, [0x3f] = 0x05, },
9561 		{ {0x40, 0x0519} },
9562 		.frag_data = { 0x19, 0x82 },
9563 	},
9564 	{
9565 		"LD_IND word mixed head/frag",
9566 		.u.insns = {
9567 			BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
9568 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
9569 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9570 		},
9571 		CLASSIC | FLAG_SKB_FRAG,
9572 		{ [0x3e] = 0x25, [0x3f] = 0x05, },
9573 		{ {0x40, 0x25051982} },
9574 		.frag_data = { 0x19, 0x82 },
9575 	},
9576 	{
9577 		"LD_ABS byte frag",
9578 		.u.insns = {
9579 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x40),
9580 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9581 		},
9582 		CLASSIC | FLAG_SKB_FRAG,
9583 		{ },
9584 		{ {0x40, 0x42} },
9585 		.frag_data = {
9586 			0x42, 0x00, 0x00, 0x00,
9587 			0x43, 0x44, 0x00, 0x00,
9588 			0x21, 0x07, 0x19, 0x83,
9589 		},
9590 	},
9591 	{
9592 		"LD_ABS halfword frag",
9593 		.u.insns = {
9594 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x44),
9595 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9596 		},
9597 		CLASSIC | FLAG_SKB_FRAG,
9598 		{ },
9599 		{ {0x40, 0x4344} },
9600 		.frag_data = {
9601 			0x42, 0x00, 0x00, 0x00,
9602 			0x43, 0x44, 0x00, 0x00,
9603 			0x21, 0x07, 0x19, 0x83,
9604 		},
9605 	},
9606 	{
9607 		"LD_ABS word frag",
9608 		.u.insns = {
9609 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x48),
9610 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9611 		},
9612 		CLASSIC | FLAG_SKB_FRAG,
9613 		{ },
9614 		{ {0x40, 0x21071983} },
9615 		.frag_data = {
9616 			0x42, 0x00, 0x00, 0x00,
9617 			0x43, 0x44, 0x00, 0x00,
9618 			0x21, 0x07, 0x19, 0x83,
9619 		},
9620 	},
9621 	{
9622 		"LD_ABS halfword mixed head/frag",
9623 		.u.insns = {
9624 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f),
9625 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9626 		},
9627 		CLASSIC | FLAG_SKB_FRAG,
9628 		{ [0x3e] = 0x25, [0x3f] = 0x05, },
9629 		{ {0x40, 0x0519} },
9630 		.frag_data = { 0x19, 0x82 },
9631 	},
9632 	{
9633 		"LD_ABS word mixed head/frag",
9634 		.u.insns = {
9635 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3e),
9636 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9637 		},
9638 		CLASSIC | FLAG_SKB_FRAG,
9639 		{ [0x3e] = 0x25, [0x3f] = 0x05, },
9640 		{ {0x40, 0x25051982} },
9641 		.frag_data = { 0x19, 0x82 },
9642 	},
9643 	/*
9644 	 * LD_IND / LD_ABS on non fragmented SKBs
9645 	 */
9646 	{
9647 		/*
9648 		 * this tests that the JIT/interpreter correctly resets X
9649 		 * before using it in an LD_IND instruction.
9650 		 */
9651 		"LD_IND byte default X",
9652 		.u.insns = {
9653 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
9654 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9655 		},
9656 		CLASSIC,
9657 		{ [0x1] = 0x42 },
9658 		{ {0x40, 0x42 } },
9659 	},
9660 	{
9661 		"LD_IND byte positive offset",
9662 		.u.insns = {
9663 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
9664 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
9665 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9666 		},
9667 		CLASSIC,
9668 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
9669 		{ {0x40, 0x82 } },
9670 	},
9671 	{
9672 		"LD_IND byte negative offset",
9673 		.u.insns = {
9674 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
9675 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x1),
9676 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9677 		},
9678 		CLASSIC,
9679 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
9680 		{ {0x40, 0x05 } },
9681 	},
9682 	{
9683 		"LD_IND byte positive offset, all ff",
9684 		.u.insns = {
9685 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
9686 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
9687 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9688 		},
9689 		CLASSIC,
9690 		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
9691 		{ {0x40, 0xff } },
9692 	},
9693 	{
9694 		"LD_IND byte positive offset, out of bounds",
9695 		.u.insns = {
9696 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
9697 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
9698 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9699 		},
9700 		CLASSIC,
9701 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
9702 		{ {0x3f, 0 }, },
9703 	},
9704 	{
9705 		"LD_IND byte negative offset, out of bounds",
9706 		.u.insns = {
9707 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
9708 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x3f),
9709 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9710 		},
9711 		CLASSIC,
9712 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
9713 		{ {0x3f, 0 } },
9714 	},
9715 	{
9716 		"LD_IND byte negative offset, multiple calls",
9717 		.u.insns = {
9718 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3b),
9719 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 1),
9720 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 2),
9721 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 3),
9722 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 4),
9723 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9724 		},
9725 		CLASSIC,
9726 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
9727 		{ {0x40, 0x82 }, },
9728 	},
9729 	{
9730 		"LD_IND halfword positive offset",
9731 		.u.insns = {
9732 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
9733 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x2),
9734 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9735 		},
9736 		CLASSIC,
9737 		{
9738 			[0x1c] = 0xaa, [0x1d] = 0x55,
9739 			[0x1e] = 0xbb, [0x1f] = 0x66,
9740 			[0x20] = 0xcc, [0x21] = 0x77,
9741 			[0x22] = 0xdd, [0x23] = 0x88,
9742 		},
9743 		{ {0x40, 0xdd88 } },
9744 	},
9745 	{
9746 		"LD_IND halfword negative offset",
9747 		.u.insns = {
9748 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
9749 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x2),
9750 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9751 		},
9752 		CLASSIC,
9753 		{
9754 			[0x1c] = 0xaa, [0x1d] = 0x55,
9755 			[0x1e] = 0xbb, [0x1f] = 0x66,
9756 			[0x20] = 0xcc, [0x21] = 0x77,
9757 			[0x22] = 0xdd, [0x23] = 0x88,
9758 		},
9759 		{ {0x40, 0xbb66 } },
9760 	},
9761 	{
9762 		"LD_IND halfword unaligned",
9763 		.u.insns = {
9764 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
9765 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
9766 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9767 		},
9768 		CLASSIC,
9769 		{
9770 			[0x1c] = 0xaa, [0x1d] = 0x55,
9771 			[0x1e] = 0xbb, [0x1f] = 0x66,
9772 			[0x20] = 0xcc, [0x21] = 0x77,
9773 			[0x22] = 0xdd, [0x23] = 0x88,
9774 		},
9775 		{ {0x40, 0x66cc } },
9776 	},
9777 	{
9778 		"LD_IND halfword positive offset, all ff",
9779 		.u.insns = {
9780 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3d),
9781 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1),
9782 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9783 		},
9784 		CLASSIC,
9785 		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
9786 		{ {0x40, 0xffff } },
9787 	},
9788 	{
9789 		"LD_IND halfword positive offset, out of bounds",
9790 		.u.insns = {
9791 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
9792 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1),
9793 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9794 		},
9795 		CLASSIC,
9796 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
9797 		{ {0x3f, 0 }, },
9798 	},
9799 	{
9800 		"LD_IND halfword negative offset, out of bounds",
9801 		.u.insns = {
9802 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
9803 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x3f),
9804 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9805 		},
9806 		CLASSIC,
9807 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
9808 		{ {0x3f, 0 } },
9809 	},
9810 	{
9811 		"LD_IND word positive offset",
9812 		.u.insns = {
9813 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
9814 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x4),
9815 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9816 		},
9817 		CLASSIC,
9818 		{
9819 			[0x1c] = 0xaa, [0x1d] = 0x55,
9820 			[0x1e] = 0xbb, [0x1f] = 0x66,
9821 			[0x20] = 0xcc, [0x21] = 0x77,
9822 			[0x22] = 0xdd, [0x23] = 0x88,
9823 			[0x24] = 0xee, [0x25] = 0x99,
9824 			[0x26] = 0xff, [0x27] = 0xaa,
9825 		},
9826 		{ {0x40, 0xee99ffaa } },
9827 	},
9828 	{
9829 		"LD_IND word negative offset",
9830 		.u.insns = {
9831 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
9832 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x4),
9833 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9834 		},
9835 		CLASSIC,
9836 		{
9837 			[0x1c] = 0xaa, [0x1d] = 0x55,
9838 			[0x1e] = 0xbb, [0x1f] = 0x66,
9839 			[0x20] = 0xcc, [0x21] = 0x77,
9840 			[0x22] = 0xdd, [0x23] = 0x88,
9841 			[0x24] = 0xee, [0x25] = 0x99,
9842 			[0x26] = 0xff, [0x27] = 0xaa,
9843 		},
9844 		{ {0x40, 0xaa55bb66 } },
9845 	},
9846 	{
9847 		"LD_IND word unaligned (addr & 3 == 2)",
9848 		.u.insns = {
9849 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
9850 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
9851 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9852 		},
9853 		CLASSIC,
9854 		{
9855 			[0x1c] = 0xaa, [0x1d] = 0x55,
9856 			[0x1e] = 0xbb, [0x1f] = 0x66,
9857 			[0x20] = 0xcc, [0x21] = 0x77,
9858 			[0x22] = 0xdd, [0x23] = 0x88,
9859 			[0x24] = 0xee, [0x25] = 0x99,
9860 			[0x26] = 0xff, [0x27] = 0xaa,
9861 		},
9862 		{ {0x40, 0xbb66cc77 } },
9863 	},
9864 	{
9865 		"LD_IND word unaligned (addr & 3 == 1)",
9866 		.u.insns = {
9867 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
9868 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3),
9869 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9870 		},
9871 		CLASSIC,
9872 		{
9873 			[0x1c] = 0xaa, [0x1d] = 0x55,
9874 			[0x1e] = 0xbb, [0x1f] = 0x66,
9875 			[0x20] = 0xcc, [0x21] = 0x77,
9876 			[0x22] = 0xdd, [0x23] = 0x88,
9877 			[0x24] = 0xee, [0x25] = 0x99,
9878 			[0x26] = 0xff, [0x27] = 0xaa,
9879 		},
9880 		{ {0x40, 0x55bb66cc } },
9881 	},
9882 	{
9883 		"LD_IND word unaligned (addr & 3 == 3)",
9884 		.u.insns = {
9885 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
9886 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x1),
9887 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9888 		},
9889 		CLASSIC,
9890 		{
9891 			[0x1c] = 0xaa, [0x1d] = 0x55,
9892 			[0x1e] = 0xbb, [0x1f] = 0x66,
9893 			[0x20] = 0xcc, [0x21] = 0x77,
9894 			[0x22] = 0xdd, [0x23] = 0x88,
9895 			[0x24] = 0xee, [0x25] = 0x99,
9896 			[0x26] = 0xff, [0x27] = 0xaa,
9897 		},
9898 		{ {0x40, 0x66cc77dd } },
9899 	},
9900 	{
9901 		"LD_IND word positive offset, all ff",
9902 		.u.insns = {
9903 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3b),
9904 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1),
9905 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9906 		},
9907 		CLASSIC,
9908 		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
9909 		{ {0x40, 0xffffffff } },
9910 	},
9911 	{
9912 		"LD_IND word positive offset, out of bounds",
9913 		.u.insns = {
9914 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
9915 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1),
9916 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9917 		},
9918 		CLASSIC,
9919 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
9920 		{ {0x3f, 0 }, },
9921 	},
9922 	{
9923 		"LD_IND word negative offset, out of bounds",
9924 		.u.insns = {
9925 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
9926 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3f),
9927 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9928 		},
9929 		CLASSIC,
9930 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
9931 		{ {0x3f, 0 } },
9932 	},
9933 	{
9934 		"LD_ABS byte",
9935 		.u.insns = {
9936 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x20),
9937 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9938 		},
9939 		CLASSIC,
9940 		{
9941 			[0x1c] = 0xaa, [0x1d] = 0x55,
9942 			[0x1e] = 0xbb, [0x1f] = 0x66,
9943 			[0x20] = 0xcc, [0x21] = 0x77,
9944 			[0x22] = 0xdd, [0x23] = 0x88,
9945 			[0x24] = 0xee, [0x25] = 0x99,
9946 			[0x26] = 0xff, [0x27] = 0xaa,
9947 		},
9948 		{ {0x40, 0xcc } },
9949 	},
9950 	{
9951 		"LD_ABS byte positive offset, all ff",
9952 		.u.insns = {
9953 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f),
9954 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9955 		},
9956 		CLASSIC,
9957 		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
9958 		{ {0x40, 0xff } },
9959 	},
9960 	{
9961 		"LD_ABS byte positive offset, out of bounds",
9962 		.u.insns = {
9963 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f),
9964 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9965 		},
9966 		CLASSIC,
9967 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
9968 		{ {0x3f, 0 }, },
9969 	},
9970 	{
9971 		"LD_ABS byte negative offset, out of bounds load",
9972 		.u.insns = {
9973 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, -1),
9974 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9975 		},
9976 		CLASSIC | FLAG_EXPECTED_FAIL,
9977 		.expected_errcode = -EINVAL,
9978 	},
9979 	{
9980 		"LD_ABS byte negative offset, in bounds",
9981 		.u.insns = {
9982 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
9983 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9984 		},
9985 		CLASSIC,
9986 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
9987 		{ {0x40, 0x82 }, },
9988 	},
9989 	{
9990 		"LD_ABS byte negative offset, out of bounds",
9991 		.u.insns = {
9992 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
9993 			BPF_STMT(BPF_RET | BPF_A, 0x0),
9994 		},
9995 		CLASSIC,
9996 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
9997 		{ {0x3f, 0 }, },
9998 	},
9999 	{
10000 		"LD_ABS byte negative offset, multiple calls",
10001 		.u.insns = {
10002 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3c),
10003 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3d),
10004 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3e),
10005 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
10006 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10007 		},
10008 		CLASSIC,
10009 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10010 		{ {0x40, 0x82 }, },
10011 	},
10012 	{
10013 		"LD_ABS halfword",
10014 		.u.insns = {
10015 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x22),
10016 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10017 		},
10018 		CLASSIC,
10019 		{
10020 			[0x1c] = 0xaa, [0x1d] = 0x55,
10021 			[0x1e] = 0xbb, [0x1f] = 0x66,
10022 			[0x20] = 0xcc, [0x21] = 0x77,
10023 			[0x22] = 0xdd, [0x23] = 0x88,
10024 			[0x24] = 0xee, [0x25] = 0x99,
10025 			[0x26] = 0xff, [0x27] = 0xaa,
10026 		},
10027 		{ {0x40, 0xdd88 } },
10028 	},
10029 	{
10030 		"LD_ABS halfword unaligned",
10031 		.u.insns = {
10032 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x25),
10033 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10034 		},
10035 		CLASSIC,
10036 		{
10037 			[0x1c] = 0xaa, [0x1d] = 0x55,
10038 			[0x1e] = 0xbb, [0x1f] = 0x66,
10039 			[0x20] = 0xcc, [0x21] = 0x77,
10040 			[0x22] = 0xdd, [0x23] = 0x88,
10041 			[0x24] = 0xee, [0x25] = 0x99,
10042 			[0x26] = 0xff, [0x27] = 0xaa,
10043 		},
10044 		{ {0x40, 0x99ff } },
10045 	},
10046 	{
10047 		"LD_ABS halfword positive offset, all ff",
10048 		.u.insns = {
10049 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3e),
10050 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10051 		},
10052 		CLASSIC,
10053 		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
10054 		{ {0x40, 0xffff } },
10055 	},
10056 	{
10057 		"LD_ABS halfword positive offset, out of bounds",
10058 		.u.insns = {
10059 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f),
10060 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10061 		},
10062 		CLASSIC,
10063 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10064 		{ {0x3f, 0 }, },
10065 	},
10066 	{
10067 		"LD_ABS halfword negative offset, out of bounds load",
10068 		.u.insns = {
10069 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, -1),
10070 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10071 		},
10072 		CLASSIC | FLAG_EXPECTED_FAIL,
10073 		.expected_errcode = -EINVAL,
10074 	},
10075 	{
10076 		"LD_ABS halfword negative offset, in bounds",
10077 		.u.insns = {
10078 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e),
10079 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10080 		},
10081 		CLASSIC,
10082 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10083 		{ {0x40, 0x1982 }, },
10084 	},
10085 	{
10086 		"LD_ABS halfword negative offset, out of bounds",
10087 		.u.insns = {
10088 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e),
10089 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10090 		},
10091 		CLASSIC,
10092 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10093 		{ {0x3f, 0 }, },
10094 	},
10095 	{
10096 		"LD_ABS word",
10097 		.u.insns = {
10098 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x1c),
10099 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10100 		},
10101 		CLASSIC,
10102 		{
10103 			[0x1c] = 0xaa, [0x1d] = 0x55,
10104 			[0x1e] = 0xbb, [0x1f] = 0x66,
10105 			[0x20] = 0xcc, [0x21] = 0x77,
10106 			[0x22] = 0xdd, [0x23] = 0x88,
10107 			[0x24] = 0xee, [0x25] = 0x99,
10108 			[0x26] = 0xff, [0x27] = 0xaa,
10109 		},
10110 		{ {0x40, 0xaa55bb66 } },
10111 	},
10112 	{
10113 		"LD_ABS word unaligned (addr & 3 == 2)",
10114 		.u.insns = {
10115 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x22),
10116 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10117 		},
10118 		CLASSIC,
10119 		{
10120 			[0x1c] = 0xaa, [0x1d] = 0x55,
10121 			[0x1e] = 0xbb, [0x1f] = 0x66,
10122 			[0x20] = 0xcc, [0x21] = 0x77,
10123 			[0x22] = 0xdd, [0x23] = 0x88,
10124 			[0x24] = 0xee, [0x25] = 0x99,
10125 			[0x26] = 0xff, [0x27] = 0xaa,
10126 		},
10127 		{ {0x40, 0xdd88ee99 } },
10128 	},
10129 	{
10130 		"LD_ABS word unaligned (addr & 3 == 1)",
10131 		.u.insns = {
10132 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x21),
10133 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10134 		},
10135 		CLASSIC,
10136 		{
10137 			[0x1c] = 0xaa, [0x1d] = 0x55,
10138 			[0x1e] = 0xbb, [0x1f] = 0x66,
10139 			[0x20] = 0xcc, [0x21] = 0x77,
10140 			[0x22] = 0xdd, [0x23] = 0x88,
10141 			[0x24] = 0xee, [0x25] = 0x99,
10142 			[0x26] = 0xff, [0x27] = 0xaa,
10143 		},
10144 		{ {0x40, 0x77dd88ee } },
10145 	},
10146 	{
10147 		"LD_ABS word unaligned (addr & 3 == 3)",
10148 		.u.insns = {
10149 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x23),
10150 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10151 		},
10152 		CLASSIC,
10153 		{
10154 			[0x1c] = 0xaa, [0x1d] = 0x55,
10155 			[0x1e] = 0xbb, [0x1f] = 0x66,
10156 			[0x20] = 0xcc, [0x21] = 0x77,
10157 			[0x22] = 0xdd, [0x23] = 0x88,
10158 			[0x24] = 0xee, [0x25] = 0x99,
10159 			[0x26] = 0xff, [0x27] = 0xaa,
10160 		},
10161 		{ {0x40, 0x88ee99ff } },
10162 	},
10163 	{
10164 		"LD_ABS word positive offset, all ff",
10165 		.u.insns = {
10166 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3c),
10167 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10168 		},
10169 		CLASSIC,
10170 		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
10171 		{ {0x40, 0xffffffff } },
10172 	},
10173 	{
10174 		"LD_ABS word positive offset, out of bounds",
10175 		.u.insns = {
10176 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3f),
10177 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10178 		},
10179 		CLASSIC,
10180 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10181 		{ {0x3f, 0 }, },
10182 	},
10183 	{
10184 		"LD_ABS word negative offset, out of bounds load",
10185 		.u.insns = {
10186 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, -1),
10187 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10188 		},
10189 		CLASSIC | FLAG_EXPECTED_FAIL,
10190 		.expected_errcode = -EINVAL,
10191 	},
10192 	{
10193 		"LD_ABS word negative offset, in bounds",
10194 		.u.insns = {
10195 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c),
10196 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10197 		},
10198 		CLASSIC,
10199 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10200 		{ {0x40, 0x25051982 }, },
10201 	},
10202 	{
10203 		"LD_ABS word negative offset, out of bounds",
10204 		.u.insns = {
10205 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c),
10206 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10207 		},
10208 		CLASSIC,
10209 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10210 		{ {0x3f, 0 }, },
10211 	},
10212 	{
10213 		"LDX_MSH standalone, preserved A",
10214 		.u.insns = {
10215 			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
10216 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
10217 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10218 		},
10219 		CLASSIC,
10220 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10221 		{ {0x40, 0xffeebbaa }, },
10222 	},
10223 	{
10224 		"LDX_MSH standalone, preserved A 2",
10225 		.u.insns = {
10226 			BPF_STMT(BPF_LD | BPF_IMM, 0x175e9d63),
10227 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
10228 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3d),
10229 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e),
10230 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3f),
10231 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10232 		},
10233 		CLASSIC,
10234 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10235 		{ {0x40, 0x175e9d63 }, },
10236 	},
10237 	{
10238 		"LDX_MSH standalone, test result 1",
10239 		.u.insns = {
10240 			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
10241 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
10242 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
10243 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10244 		},
10245 		CLASSIC,
10246 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10247 		{ {0x40, 0x14 }, },
10248 	},
10249 	{
10250 		"LDX_MSH standalone, test result 2",
10251 		.u.insns = {
10252 			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
10253 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e),
10254 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
10255 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10256 		},
10257 		CLASSIC,
10258 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10259 		{ {0x40, 0x24 }, },
10260 	},
10261 	{
10262 		"LDX_MSH standalone, negative offset",
10263 		.u.insns = {
10264 			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
10265 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, -1),
10266 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
10267 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10268 		},
10269 		CLASSIC,
10270 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10271 		{ {0x40, 0 }, },
10272 	},
10273 	{
10274 		"LDX_MSH standalone, negative offset 2",
10275 		.u.insns = {
10276 			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
10277 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, SKF_LL_OFF + 0x3e),
10278 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
10279 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10280 		},
10281 		CLASSIC,
10282 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10283 		{ {0x40, 0x24 }, },
10284 	},
10285 	{
10286 		"LDX_MSH standalone, out of bounds",
10287 		.u.insns = {
10288 			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
10289 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x40),
10290 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
10291 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10292 		},
10293 		CLASSIC,
10294 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10295 		{ {0x40, 0 }, },
10296 	},
10297 	/*
10298 	 * verify that the interpreter or JIT correctly sets A and X
10299 	 * to 0.
10300 	 */
10301 	{
10302 		"ADD default X",
10303 		.u.insns = {
10304 			/*
10305 			 * A = 0x42
10306 			 * A = A + X
10307 			 * ret A
10308 			 */
10309 			BPF_STMT(BPF_LD | BPF_IMM, 0x42),
10310 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
10311 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10312 		},
10313 		CLASSIC | FLAG_NO_DATA,
10314 		{},
10315 		{ {0x1, 0x42 } },
10316 	},
10317 	{
10318 		"ADD default A",
10319 		.u.insns = {
10320 			/*
10321 			 * A = A + 0x42
10322 			 * ret A
10323 			 */
10324 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0x42),
10325 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10326 		},
10327 		CLASSIC | FLAG_NO_DATA,
10328 		{},
10329 		{ {0x1, 0x42 } },
10330 	},
10331 	{
10332 		"SUB default X",
10333 		.u.insns = {
10334 			/*
10335 			 * A = 0x66
10336 			 * A = A - X
10337 			 * ret A
10338 			 */
10339 			BPF_STMT(BPF_LD | BPF_IMM, 0x66),
10340 			BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
10341 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10342 		},
10343 		CLASSIC | FLAG_NO_DATA,
10344 		{},
10345 		{ {0x1, 0x66 } },
10346 	},
10347 	{
10348 		"SUB default A",
10349 		.u.insns = {
10350 			/*
10351 			 * A = A - -0x66
10352 			 * ret A
10353 			 */
10354 			BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, -0x66),
10355 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10356 		},
10357 		CLASSIC | FLAG_NO_DATA,
10358 		{},
10359 		{ {0x1, 0x66 } },
10360 	},
10361 	{
10362 		"MUL default X",
10363 		.u.insns = {
10364 			/*
10365 			 * A = 0x42
10366 			 * A = A * X
10367 			 * ret A
10368 			 */
10369 			BPF_STMT(BPF_LD | BPF_IMM, 0x42),
10370 			BPF_STMT(BPF_ALU | BPF_MUL | BPF_X, 0),
10371 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10372 		},
10373 		CLASSIC | FLAG_NO_DATA,
10374 		{},
10375 		{ {0x1, 0x0 } },
10376 	},
10377 	{
10378 		"MUL default A",
10379 		.u.insns = {
10380 			/*
10381 			 * A = A * 0x66
10382 			 * ret A
10383 			 */
10384 			BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 0x66),
10385 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10386 		},
10387 		CLASSIC | FLAG_NO_DATA,
10388 		{},
10389 		{ {0x1, 0x0 } },
10390 	},
10391 	{
10392 		"DIV default X",
10393 		.u.insns = {
10394 			/*
10395 			 * A = 0x42
10396 			 * A = A / X ; this halt the filter execution if X is 0
10397 			 * ret 0x42
10398 			 */
10399 			BPF_STMT(BPF_LD | BPF_IMM, 0x42),
10400 			BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
10401 			BPF_STMT(BPF_RET | BPF_K, 0x42),
10402 		},
10403 		CLASSIC | FLAG_NO_DATA,
10404 		{},
10405 		{ {0x1, 0x0 } },
10406 	},
10407 	{
10408 		"DIV default A",
10409 		.u.insns = {
10410 			/*
10411 			 * A = A / 1
10412 			 * ret A
10413 			 */
10414 			BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x1),
10415 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10416 		},
10417 		CLASSIC | FLAG_NO_DATA,
10418 		{},
10419 		{ {0x1, 0x0 } },
10420 	},
10421 	{
10422 		"MOD default X",
10423 		.u.insns = {
10424 			/*
10425 			 * A = 0x42
10426 			 * A = A mod X ; this halt the filter execution if X is 0
10427 			 * ret 0x42
10428 			 */
10429 			BPF_STMT(BPF_LD | BPF_IMM, 0x42),
10430 			BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
10431 			BPF_STMT(BPF_RET | BPF_K, 0x42),
10432 		},
10433 		CLASSIC | FLAG_NO_DATA,
10434 		{},
10435 		{ {0x1, 0x0 } },
10436 	},
10437 	{
10438 		"MOD default A",
10439 		.u.insns = {
10440 			/*
10441 			 * A = A mod 1
10442 			 * ret A
10443 			 */
10444 			BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x1),
10445 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10446 		},
10447 		CLASSIC | FLAG_NO_DATA,
10448 		{},
10449 		{ {0x1, 0x0 } },
10450 	},
10451 	{
10452 		"JMP EQ default A",
10453 		.u.insns = {
10454 			/*
10455 			 * cmp A, 0x0, 0, 1
10456 			 * ret 0x42
10457 			 * ret 0x66
10458 			 */
10459 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0, 0, 1),
10460 			BPF_STMT(BPF_RET | BPF_K, 0x42),
10461 			BPF_STMT(BPF_RET | BPF_K, 0x66),
10462 		},
10463 		CLASSIC | FLAG_NO_DATA,
10464 		{},
10465 		{ {0x1, 0x42 } },
10466 	},
10467 	{
10468 		"JMP EQ default X",
10469 		.u.insns = {
10470 			/*
10471 			 * A = 0x0
10472 			 * cmp A, X, 0, 1
10473 			 * ret 0x42
10474 			 * ret 0x66
10475 			 */
10476 			BPF_STMT(BPF_LD | BPF_IMM, 0x0),
10477 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0x0, 0, 1),
10478 			BPF_STMT(BPF_RET | BPF_K, 0x42),
10479 			BPF_STMT(BPF_RET | BPF_K, 0x66),
10480 		},
10481 		CLASSIC | FLAG_NO_DATA,
10482 		{},
10483 		{ {0x1, 0x42 } },
10484 	},
10485 	/* Checking interpreter vs JIT wrt signed extended imms. */
10486 	{
10487 		"JNE signed compare, test 1",
10488 		.u.insns_int = {
10489 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
10490 			BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
10491 			BPF_MOV64_REG(R2, R1),
10492 			BPF_ALU64_REG(BPF_AND, R2, R3),
10493 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10494 			BPF_JMP_IMM(BPF_JNE, R2, -17104896, 1),
10495 			BPF_ALU32_IMM(BPF_MOV, R0, 2),
10496 			BPF_EXIT_INSN(),
10497 		},
10498 		INTERNAL,
10499 		{ },
10500 		{ { 0, 1 } },
10501 	},
10502 	{
10503 		"JNE signed compare, test 2",
10504 		.u.insns_int = {
10505 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
10506 			BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
10507 			BPF_MOV64_REG(R2, R1),
10508 			BPF_ALU64_REG(BPF_AND, R2, R3),
10509 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10510 			BPF_JMP_IMM(BPF_JNE, R2, 0xfefb0000, 1),
10511 			BPF_ALU32_IMM(BPF_MOV, R0, 2),
10512 			BPF_EXIT_INSN(),
10513 		},
10514 		INTERNAL,
10515 		{ },
10516 		{ { 0, 1 } },
10517 	},
10518 	{
10519 		"JNE signed compare, test 3",
10520 		.u.insns_int = {
10521 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
10522 			BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
10523 			BPF_ALU32_IMM(BPF_MOV, R4, 0xfefb0000),
10524 			BPF_MOV64_REG(R2, R1),
10525 			BPF_ALU64_REG(BPF_AND, R2, R3),
10526 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10527 			BPF_JMP_REG(BPF_JNE, R2, R4, 1),
10528 			BPF_ALU32_IMM(BPF_MOV, R0, 2),
10529 			BPF_EXIT_INSN(),
10530 		},
10531 		INTERNAL,
10532 		{ },
10533 		{ { 0, 2 } },
10534 	},
10535 	{
10536 		"JNE signed compare, test 4",
10537 		.u.insns_int = {
10538 			BPF_LD_IMM64(R1, -17104896),
10539 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10540 			BPF_JMP_IMM(BPF_JNE, R1, -17104896, 1),
10541 			BPF_ALU32_IMM(BPF_MOV, R0, 2),
10542 			BPF_EXIT_INSN(),
10543 		},
10544 		INTERNAL,
10545 		{ },
10546 		{ { 0, 2 } },
10547 	},
10548 	{
10549 		"JNE signed compare, test 5",
10550 		.u.insns_int = {
10551 			BPF_LD_IMM64(R1, 0xfefb0000),
10552 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10553 			BPF_JMP_IMM(BPF_JNE, R1, 0xfefb0000, 1),
10554 			BPF_ALU32_IMM(BPF_MOV, R0, 2),
10555 			BPF_EXIT_INSN(),
10556 		},
10557 		INTERNAL,
10558 		{ },
10559 		{ { 0, 1 } },
10560 	},
10561 	{
10562 		"JNE signed compare, test 6",
10563 		.u.insns_int = {
10564 			BPF_LD_IMM64(R1, 0x7efb0000),
10565 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10566 			BPF_JMP_IMM(BPF_JNE, R1, 0x7efb0000, 1),
10567 			BPF_ALU32_IMM(BPF_MOV, R0, 2),
10568 			BPF_EXIT_INSN(),
10569 		},
10570 		INTERNAL,
10571 		{ },
10572 		{ { 0, 2 } },
10573 	},
10574 	{
10575 		"JNE signed compare, test 7",
10576 		.u.insns = {
10577 			BPF_STMT(BPF_LD | BPF_IMM, 0xffff0000),
10578 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
10579 			BPF_STMT(BPF_LD | BPF_IMM, 0xfefbbc12),
10580 			BPF_STMT(BPF_ALU | BPF_AND | BPF_X, 0),
10581 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0xfefb0000, 1, 0),
10582 			BPF_STMT(BPF_RET | BPF_K, 1),
10583 			BPF_STMT(BPF_RET | BPF_K, 2),
10584 		},
10585 		CLASSIC | FLAG_NO_DATA,
10586 		{},
10587 		{ { 0, 2 } },
10588 	},
10589 	/* Checking that ALU32 src is not zero extended in place */
10590 #define BPF_ALU32_SRC_ZEXT(op)					\
10591 	{							\
10592 		"ALU32_" #op "_X: src preserved in zext",	\
10593 		.u.insns_int = {				\
10594 			BPF_LD_IMM64(R1, 0x0123456789acbdefULL),\
10595 			BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),\
10596 			BPF_ALU64_REG(BPF_MOV, R0, R1),		\
10597 			BPF_ALU32_REG(BPF_##op, R2, R1),	\
10598 			BPF_ALU64_REG(BPF_SUB, R0, R1),		\
10599 			BPF_ALU64_REG(BPF_MOV, R1, R0),		\
10600 			BPF_ALU64_IMM(BPF_RSH, R1, 32),		\
10601 			BPF_ALU64_REG(BPF_OR, R0, R1),		\
10602 			BPF_EXIT_INSN(),			\
10603 		},						\
10604 		INTERNAL,					\
10605 		{ },						\
10606 		{ { 0, 0 } },					\
10607 	}
10608 	BPF_ALU32_SRC_ZEXT(MOV),
10609 	BPF_ALU32_SRC_ZEXT(AND),
10610 	BPF_ALU32_SRC_ZEXT(OR),
10611 	BPF_ALU32_SRC_ZEXT(XOR),
10612 	BPF_ALU32_SRC_ZEXT(ADD),
10613 	BPF_ALU32_SRC_ZEXT(SUB),
10614 	BPF_ALU32_SRC_ZEXT(MUL),
10615 	BPF_ALU32_SRC_ZEXT(DIV),
10616 	BPF_ALU32_SRC_ZEXT(MOD),
10617 #undef BPF_ALU32_SRC_ZEXT
10618 	/* Checking that ATOMIC32 src is not zero extended in place */
10619 #define BPF_ATOMIC32_SRC_ZEXT(op)					\
10620 	{								\
10621 		"ATOMIC_W_" #op ": src preserved in zext",		\
10622 		.u.insns_int = {					\
10623 			BPF_LD_IMM64(R0, 0x0123456789acbdefULL),	\
10624 			BPF_ALU64_REG(BPF_MOV, R1, R0),			\
10625 			BPF_ST_MEM(BPF_W, R10, -4, 0),			\
10626 			BPF_ATOMIC_OP(BPF_W, BPF_##op, R10, R1, -4),	\
10627 			BPF_ALU64_REG(BPF_SUB, R0, R1),			\
10628 			BPF_ALU64_REG(BPF_MOV, R1, R0),			\
10629 			BPF_ALU64_IMM(BPF_RSH, R1, 32),			\
10630 			BPF_ALU64_REG(BPF_OR, R0, R1),			\
10631 			BPF_EXIT_INSN(),				\
10632 		},							\
10633 		INTERNAL,						\
10634 		{ },							\
10635 		{ { 0, 0 } },						\
10636 		.stack_depth = 8,					\
10637 	}
10638 	BPF_ATOMIC32_SRC_ZEXT(ADD),
10639 	BPF_ATOMIC32_SRC_ZEXT(AND),
10640 	BPF_ATOMIC32_SRC_ZEXT(OR),
10641 	BPF_ATOMIC32_SRC_ZEXT(XOR),
10642 #undef BPF_ATOMIC32_SRC_ZEXT
10643 	/* Checking that CMPXCHG32 src is not zero extended in place */
10644 	{
10645 		"ATOMIC_W_CMPXCHG: src preserved in zext",
10646 		.u.insns_int = {
10647 			BPF_LD_IMM64(R1, 0x0123456789acbdefULL),
10648 			BPF_ALU64_REG(BPF_MOV, R2, R1),
10649 			BPF_ALU64_REG(BPF_MOV, R0, 0),
10650 			BPF_ST_MEM(BPF_W, R10, -4, 0),
10651 			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R1, -4),
10652 			BPF_ALU64_REG(BPF_SUB, R1, R2),
10653 			BPF_ALU64_REG(BPF_MOV, R2, R1),
10654 			BPF_ALU64_IMM(BPF_RSH, R2, 32),
10655 			BPF_ALU64_REG(BPF_OR, R1, R2),
10656 			BPF_ALU64_REG(BPF_MOV, R0, R1),
10657 			BPF_EXIT_INSN(),
10658 		},
10659 		INTERNAL,
10660 		{ },
10661 		{ { 0, 0 } },
10662 		.stack_depth = 8,
10663 	},
10664 	/* Checking that JMP32 immediate src is not zero extended in place */
10665 #define BPF_JMP32_IMM_ZEXT(op)					\
10666 	{							\
10667 		"JMP32_" #op "_K: operand preserved in zext",	\
10668 		.u.insns_int = {				\
10669 			BPF_LD_IMM64(R0, 0x0123456789acbdefULL),\
10670 			BPF_ALU64_REG(BPF_MOV, R1, R0),		\
10671 			BPF_JMP32_IMM(BPF_##op, R0, 1234, 1),	\
10672 			BPF_JMP_A(0), /* Nop */			\
10673 			BPF_ALU64_REG(BPF_SUB, R0, R1),		\
10674 			BPF_ALU64_REG(BPF_MOV, R1, R0),		\
10675 			BPF_ALU64_IMM(BPF_RSH, R1, 32),		\
10676 			BPF_ALU64_REG(BPF_OR, R0, R1),		\
10677 			BPF_EXIT_INSN(),			\
10678 		},						\
10679 		INTERNAL,					\
10680 		{ },						\
10681 		{ { 0, 0 } },					\
10682 	}
10683 	BPF_JMP32_IMM_ZEXT(JEQ),
10684 	BPF_JMP32_IMM_ZEXT(JNE),
10685 	BPF_JMP32_IMM_ZEXT(JSET),
10686 	BPF_JMP32_IMM_ZEXT(JGT),
10687 	BPF_JMP32_IMM_ZEXT(JGE),
10688 	BPF_JMP32_IMM_ZEXT(JLT),
10689 	BPF_JMP32_IMM_ZEXT(JLE),
10690 	BPF_JMP32_IMM_ZEXT(JSGT),
10691 	BPF_JMP32_IMM_ZEXT(JSGE),
10692 	BPF_JMP32_IMM_ZEXT(JSGT),
10693 	BPF_JMP32_IMM_ZEXT(JSLT),
10694 	BPF_JMP32_IMM_ZEXT(JSLE),
10695 #undef BPF_JMP2_IMM_ZEXT
10696 	/* Checking that JMP32 dst & src are not zero extended in place */
10697 #define BPF_JMP32_REG_ZEXT(op)					\
10698 	{							\
10699 		"JMP32_" #op "_X: operands preserved in zext",	\
10700 		.u.insns_int = {				\
10701 			BPF_LD_IMM64(R0, 0x0123456789acbdefULL),\
10702 			BPF_LD_IMM64(R1, 0xfedcba9876543210ULL),\
10703 			BPF_ALU64_REG(BPF_MOV, R2, R0),		\
10704 			BPF_ALU64_REG(BPF_MOV, R3, R1),		\
10705 			BPF_JMP32_IMM(BPF_##op, R0, R1, 1),	\
10706 			BPF_JMP_A(0), /* Nop */			\
10707 			BPF_ALU64_REG(BPF_SUB, R0, R2),		\
10708 			BPF_ALU64_REG(BPF_SUB, R1, R3),		\
10709 			BPF_ALU64_REG(BPF_OR, R0, R1),		\
10710 			BPF_ALU64_REG(BPF_MOV, R1, R0),		\
10711 			BPF_ALU64_IMM(BPF_RSH, R1, 32),		\
10712 			BPF_ALU64_REG(BPF_OR, R0, R1),		\
10713 			BPF_EXIT_INSN(),			\
10714 		},						\
10715 		INTERNAL,					\
10716 		{ },						\
10717 		{ { 0, 0 } },					\
10718 	}
10719 	BPF_JMP32_REG_ZEXT(JEQ),
10720 	BPF_JMP32_REG_ZEXT(JNE),
10721 	BPF_JMP32_REG_ZEXT(JSET),
10722 	BPF_JMP32_REG_ZEXT(JGT),
10723 	BPF_JMP32_REG_ZEXT(JGE),
10724 	BPF_JMP32_REG_ZEXT(JLT),
10725 	BPF_JMP32_REG_ZEXT(JLE),
10726 	BPF_JMP32_REG_ZEXT(JSGT),
10727 	BPF_JMP32_REG_ZEXT(JSGE),
10728 	BPF_JMP32_REG_ZEXT(JSGT),
10729 	BPF_JMP32_REG_ZEXT(JSLT),
10730 	BPF_JMP32_REG_ZEXT(JSLE),
10731 #undef BPF_JMP2_REG_ZEXT
10732 	/* Exhaustive test of ALU64 shift operations */
10733 	{
10734 		"ALU64_LSH_K: all shift values",
10735 		{ },
10736 		INTERNAL | FLAG_NO_DATA,
10737 		{ },
10738 		{ { 0, 1 } },
10739 		.fill_helper = bpf_fill_alu_lsh_imm,
10740 	},
10741 	{
10742 		"ALU64_RSH_K: all shift values",
10743 		{ },
10744 		INTERNAL | FLAG_NO_DATA,
10745 		{ },
10746 		{ { 0, 1 } },
10747 		.fill_helper = bpf_fill_alu_rsh_imm,
10748 	},
10749 	{
10750 		"ALU64_ARSH_K: all shift values",
10751 		{ },
10752 		INTERNAL | FLAG_NO_DATA,
10753 		{ },
10754 		{ { 0, 1 } },
10755 		.fill_helper = bpf_fill_alu_arsh_imm,
10756 	},
10757 	{
10758 		"ALU64_LSH_X: all shift values",
10759 		{ },
10760 		INTERNAL | FLAG_NO_DATA,
10761 		{ },
10762 		{ { 0, 1 } },
10763 		.fill_helper = bpf_fill_alu_lsh_reg,
10764 	},
10765 	{
10766 		"ALU64_RSH_X: all shift values",
10767 		{ },
10768 		INTERNAL | FLAG_NO_DATA,
10769 		{ },
10770 		{ { 0, 1 } },
10771 		.fill_helper = bpf_fill_alu_rsh_reg,
10772 	},
10773 	{
10774 		"ALU64_ARSH_X: all shift values",
10775 		{ },
10776 		INTERNAL | FLAG_NO_DATA,
10777 		{ },
10778 		{ { 0, 1 } },
10779 		.fill_helper = bpf_fill_alu_arsh_reg,
10780 	},
10781 	/* Exhaustive test of ALU32 shift operations */
10782 	{
10783 		"ALU32_LSH_K: all shift values",
10784 		{ },
10785 		INTERNAL | FLAG_NO_DATA,
10786 		{ },
10787 		{ { 0, 1 } },
10788 		.fill_helper = bpf_fill_alu32_lsh_imm,
10789 	},
10790 	{
10791 		"ALU32_RSH_K: all shift values",
10792 		{ },
10793 		INTERNAL | FLAG_NO_DATA,
10794 		{ },
10795 		{ { 0, 1 } },
10796 		.fill_helper = bpf_fill_alu32_rsh_imm,
10797 	},
10798 	{
10799 		"ALU32_ARSH_K: all shift values",
10800 		{ },
10801 		INTERNAL | FLAG_NO_DATA,
10802 		{ },
10803 		{ { 0, 1 } },
10804 		.fill_helper = bpf_fill_alu32_arsh_imm,
10805 	},
10806 	{
10807 		"ALU32_LSH_X: all shift values",
10808 		{ },
10809 		INTERNAL | FLAG_NO_DATA,
10810 		{ },
10811 		{ { 0, 1 } },
10812 		.fill_helper = bpf_fill_alu32_lsh_reg,
10813 	},
10814 	{
10815 		"ALU32_RSH_X: all shift values",
10816 		{ },
10817 		INTERNAL | FLAG_NO_DATA,
10818 		{ },
10819 		{ { 0, 1 } },
10820 		.fill_helper = bpf_fill_alu32_rsh_reg,
10821 	},
10822 	{
10823 		"ALU32_ARSH_X: all shift values",
10824 		{ },
10825 		INTERNAL | FLAG_NO_DATA,
10826 		{ },
10827 		{ { 0, 1 } },
10828 		.fill_helper = bpf_fill_alu32_arsh_reg,
10829 	},
10830 	/* ALU64 immediate magnitudes */
10831 	{
10832 		"ALU64_MOV_K: all immediate value magnitudes",
10833 		{ },
10834 		INTERNAL | FLAG_NO_DATA,
10835 		{ },
10836 		{ { 0, 1 } },
10837 		.fill_helper = bpf_fill_alu64_mov_imm,
10838 		.nr_testruns = NR_PATTERN_RUNS,
10839 	},
10840 	{
10841 		"ALU64_AND_K: all immediate value magnitudes",
10842 		{ },
10843 		INTERNAL | FLAG_NO_DATA,
10844 		{ },
10845 		{ { 0, 1 } },
10846 		.fill_helper = bpf_fill_alu64_and_imm,
10847 		.nr_testruns = NR_PATTERN_RUNS,
10848 	},
10849 	{
10850 		"ALU64_OR_K: all immediate value magnitudes",
10851 		{ },
10852 		INTERNAL | FLAG_NO_DATA,
10853 		{ },
10854 		{ { 0, 1 } },
10855 		.fill_helper = bpf_fill_alu64_or_imm,
10856 		.nr_testruns = NR_PATTERN_RUNS,
10857 	},
10858 	{
10859 		"ALU64_XOR_K: all immediate value magnitudes",
10860 		{ },
10861 		INTERNAL | FLAG_NO_DATA,
10862 		{ },
10863 		{ { 0, 1 } },
10864 		.fill_helper = bpf_fill_alu64_xor_imm,
10865 		.nr_testruns = NR_PATTERN_RUNS,
10866 	},
10867 	{
10868 		"ALU64_ADD_K: all immediate value magnitudes",
10869 		{ },
10870 		INTERNAL | FLAG_NO_DATA,
10871 		{ },
10872 		{ { 0, 1 } },
10873 		.fill_helper = bpf_fill_alu64_add_imm,
10874 		.nr_testruns = NR_PATTERN_RUNS,
10875 	},
10876 	{
10877 		"ALU64_SUB_K: all immediate value magnitudes",
10878 		{ },
10879 		INTERNAL | FLAG_NO_DATA,
10880 		{ },
10881 		{ { 0, 1 } },
10882 		.fill_helper = bpf_fill_alu64_sub_imm,
10883 		.nr_testruns = NR_PATTERN_RUNS,
10884 	},
10885 	{
10886 		"ALU64_MUL_K: all immediate value magnitudes",
10887 		{ },
10888 		INTERNAL | FLAG_NO_DATA,
10889 		{ },
10890 		{ { 0, 1 } },
10891 		.fill_helper = bpf_fill_alu64_mul_imm,
10892 		.nr_testruns = NR_PATTERN_RUNS,
10893 	},
10894 	{
10895 		"ALU64_DIV_K: all immediate value magnitudes",
10896 		{ },
10897 		INTERNAL | FLAG_NO_DATA,
10898 		{ },
10899 		{ { 0, 1 } },
10900 		.fill_helper = bpf_fill_alu64_div_imm,
10901 		.nr_testruns = NR_PATTERN_RUNS,
10902 	},
10903 	{
10904 		"ALU64_MOD_K: all immediate value magnitudes",
10905 		{ },
10906 		INTERNAL | FLAG_NO_DATA,
10907 		{ },
10908 		{ { 0, 1 } },
10909 		.fill_helper = bpf_fill_alu64_mod_imm,
10910 		.nr_testruns = NR_PATTERN_RUNS,
10911 	},
10912 	/* ALU32 immediate magnitudes */
10913 	{
10914 		"ALU32_MOV_K: all immediate value magnitudes",
10915 		{ },
10916 		INTERNAL | FLAG_NO_DATA,
10917 		{ },
10918 		{ { 0, 1 } },
10919 		.fill_helper = bpf_fill_alu32_mov_imm,
10920 		.nr_testruns = NR_PATTERN_RUNS,
10921 	},
10922 	{
10923 		"ALU32_AND_K: all immediate value magnitudes",
10924 		{ },
10925 		INTERNAL | FLAG_NO_DATA,
10926 		{ },
10927 		{ { 0, 1 } },
10928 		.fill_helper = bpf_fill_alu32_and_imm,
10929 		.nr_testruns = NR_PATTERN_RUNS,
10930 	},
10931 	{
10932 		"ALU32_OR_K: all immediate value magnitudes",
10933 		{ },
10934 		INTERNAL | FLAG_NO_DATA,
10935 		{ },
10936 		{ { 0, 1 } },
10937 		.fill_helper = bpf_fill_alu32_or_imm,
10938 		.nr_testruns = NR_PATTERN_RUNS,
10939 	},
10940 	{
10941 		"ALU32_XOR_K: all immediate value magnitudes",
10942 		{ },
10943 		INTERNAL | FLAG_NO_DATA,
10944 		{ },
10945 		{ { 0, 1 } },
10946 		.fill_helper = bpf_fill_alu32_xor_imm,
10947 		.nr_testruns = NR_PATTERN_RUNS,
10948 	},
10949 	{
10950 		"ALU32_ADD_K: all immediate value magnitudes",
10951 		{ },
10952 		INTERNAL | FLAG_NO_DATA,
10953 		{ },
10954 		{ { 0, 1 } },
10955 		.fill_helper = bpf_fill_alu32_add_imm,
10956 		.nr_testruns = NR_PATTERN_RUNS,
10957 	},
10958 	{
10959 		"ALU32_SUB_K: all immediate value magnitudes",
10960 		{ },
10961 		INTERNAL | FLAG_NO_DATA,
10962 		{ },
10963 		{ { 0, 1 } },
10964 		.fill_helper = bpf_fill_alu32_sub_imm,
10965 		.nr_testruns = NR_PATTERN_RUNS,
10966 	},
10967 	{
10968 		"ALU32_MUL_K: all immediate value magnitudes",
10969 		{ },
10970 		INTERNAL | FLAG_NO_DATA,
10971 		{ },
10972 		{ { 0, 1 } },
10973 		.fill_helper = bpf_fill_alu32_mul_imm,
10974 		.nr_testruns = NR_PATTERN_RUNS,
10975 	},
10976 	{
10977 		"ALU32_DIV_K: all immediate value magnitudes",
10978 		{ },
10979 		INTERNAL | FLAG_NO_DATA,
10980 		{ },
10981 		{ { 0, 1 } },
10982 		.fill_helper = bpf_fill_alu32_div_imm,
10983 		.nr_testruns = NR_PATTERN_RUNS,
10984 	},
10985 	{
10986 		"ALU32_MOD_K: all immediate value magnitudes",
10987 		{ },
10988 		INTERNAL | FLAG_NO_DATA,
10989 		{ },
10990 		{ { 0, 1 } },
10991 		.fill_helper = bpf_fill_alu32_mod_imm,
10992 		.nr_testruns = NR_PATTERN_RUNS,
10993 	},
10994 	/* ALU64 register magnitudes */
10995 	{
10996 		"ALU64_MOV_X: all register value magnitudes",
10997 		{ },
10998 		INTERNAL | FLAG_NO_DATA,
10999 		{ },
11000 		{ { 0, 1 } },
11001 		.fill_helper = bpf_fill_alu64_mov_reg,
11002 		.nr_testruns = NR_PATTERN_RUNS,
11003 	},
11004 	{
11005 		"ALU64_AND_X: all register value magnitudes",
11006 		{ },
11007 		INTERNAL | FLAG_NO_DATA,
11008 		{ },
11009 		{ { 0, 1 } },
11010 		.fill_helper = bpf_fill_alu64_and_reg,
11011 		.nr_testruns = NR_PATTERN_RUNS,
11012 	},
11013 	{
11014 		"ALU64_OR_X: all register value magnitudes",
11015 		{ },
11016 		INTERNAL | FLAG_NO_DATA,
11017 		{ },
11018 		{ { 0, 1 } },
11019 		.fill_helper = bpf_fill_alu64_or_reg,
11020 		.nr_testruns = NR_PATTERN_RUNS,
11021 	},
11022 	{
11023 		"ALU64_XOR_X: all register value magnitudes",
11024 		{ },
11025 		INTERNAL | FLAG_NO_DATA,
11026 		{ },
11027 		{ { 0, 1 } },
11028 		.fill_helper = bpf_fill_alu64_xor_reg,
11029 		.nr_testruns = NR_PATTERN_RUNS,
11030 	},
11031 	{
11032 		"ALU64_ADD_X: all register value magnitudes",
11033 		{ },
11034 		INTERNAL | FLAG_NO_DATA,
11035 		{ },
11036 		{ { 0, 1 } },
11037 		.fill_helper = bpf_fill_alu64_add_reg,
11038 		.nr_testruns = NR_PATTERN_RUNS,
11039 	},
11040 	{
11041 		"ALU64_SUB_X: all register value magnitudes",
11042 		{ },
11043 		INTERNAL | FLAG_NO_DATA,
11044 		{ },
11045 		{ { 0, 1 } },
11046 		.fill_helper = bpf_fill_alu64_sub_reg,
11047 		.nr_testruns = NR_PATTERN_RUNS,
11048 	},
11049 	{
11050 		"ALU64_MUL_X: all register value magnitudes",
11051 		{ },
11052 		INTERNAL | FLAG_NO_DATA,
11053 		{ },
11054 		{ { 0, 1 } },
11055 		.fill_helper = bpf_fill_alu64_mul_reg,
11056 		.nr_testruns = NR_PATTERN_RUNS,
11057 	},
11058 	{
11059 		"ALU64_DIV_X: all register value magnitudes",
11060 		{ },
11061 		INTERNAL | FLAG_NO_DATA,
11062 		{ },
11063 		{ { 0, 1 } },
11064 		.fill_helper = bpf_fill_alu64_div_reg,
11065 		.nr_testruns = NR_PATTERN_RUNS,
11066 	},
11067 	{
11068 		"ALU64_MOD_X: all register value magnitudes",
11069 		{ },
11070 		INTERNAL | FLAG_NO_DATA,
11071 		{ },
11072 		{ { 0, 1 } },
11073 		.fill_helper = bpf_fill_alu64_mod_reg,
11074 		.nr_testruns = NR_PATTERN_RUNS,
11075 	},
11076 	/* ALU32 register magnitudes */
11077 	{
11078 		"ALU32_MOV_X: all register value magnitudes",
11079 		{ },
11080 		INTERNAL | FLAG_NO_DATA,
11081 		{ },
11082 		{ { 0, 1 } },
11083 		.fill_helper = bpf_fill_alu32_mov_reg,
11084 		.nr_testruns = NR_PATTERN_RUNS,
11085 	},
11086 	{
11087 		"ALU32_AND_X: all register value magnitudes",
11088 		{ },
11089 		INTERNAL | FLAG_NO_DATA,
11090 		{ },
11091 		{ { 0, 1 } },
11092 		.fill_helper = bpf_fill_alu32_and_reg,
11093 		.nr_testruns = NR_PATTERN_RUNS,
11094 	},
11095 	{
11096 		"ALU32_OR_X: all register value magnitudes",
11097 		{ },
11098 		INTERNAL | FLAG_NO_DATA,
11099 		{ },
11100 		{ { 0, 1 } },
11101 		.fill_helper = bpf_fill_alu32_or_reg,
11102 		.nr_testruns = NR_PATTERN_RUNS,
11103 	},
11104 	{
11105 		"ALU32_XOR_X: all register value magnitudes",
11106 		{ },
11107 		INTERNAL | FLAG_NO_DATA,
11108 		{ },
11109 		{ { 0, 1 } },
11110 		.fill_helper = bpf_fill_alu32_xor_reg,
11111 		.nr_testruns = NR_PATTERN_RUNS,
11112 	},
11113 	{
11114 		"ALU32_ADD_X: all register value magnitudes",
11115 		{ },
11116 		INTERNAL | FLAG_NO_DATA,
11117 		{ },
11118 		{ { 0, 1 } },
11119 		.fill_helper = bpf_fill_alu32_add_reg,
11120 		.nr_testruns = NR_PATTERN_RUNS,
11121 	},
11122 	{
11123 		"ALU32_SUB_X: all register value magnitudes",
11124 		{ },
11125 		INTERNAL | FLAG_NO_DATA,
11126 		{ },
11127 		{ { 0, 1 } },
11128 		.fill_helper = bpf_fill_alu32_sub_reg,
11129 		.nr_testruns = NR_PATTERN_RUNS,
11130 	},
11131 	{
11132 		"ALU32_MUL_X: all register value magnitudes",
11133 		{ },
11134 		INTERNAL | FLAG_NO_DATA,
11135 		{ },
11136 		{ { 0, 1 } },
11137 		.fill_helper = bpf_fill_alu32_mul_reg,
11138 		.nr_testruns = NR_PATTERN_RUNS,
11139 	},
11140 	{
11141 		"ALU32_DIV_X: all register value magnitudes",
11142 		{ },
11143 		INTERNAL | FLAG_NO_DATA,
11144 		{ },
11145 		{ { 0, 1 } },
11146 		.fill_helper = bpf_fill_alu32_div_reg,
11147 		.nr_testruns = NR_PATTERN_RUNS,
11148 	},
11149 	{
11150 		"ALU32_MOD_X: all register value magnitudes",
11151 		{ },
11152 		INTERNAL | FLAG_NO_DATA,
11153 		{ },
11154 		{ { 0, 1 } },
11155 		.fill_helper = bpf_fill_alu32_mod_reg,
11156 		.nr_testruns = NR_PATTERN_RUNS,
11157 	},
11158 	/* LD_IMM64 immediate magnitudes */
11159 	{
11160 		"LD_IMM64: all immediate value magnitudes",
11161 		{ },
11162 		INTERNAL | FLAG_NO_DATA,
11163 		{ },
11164 		{ { 0, 1 } },
11165 		.fill_helper = bpf_fill_ld_imm64,
11166 	},
11167 	/* 64-bit ATOMIC magnitudes */
11168 	{
11169 		"ATOMIC_DW_ADD: all operand magnitudes",
11170 		{ },
11171 		INTERNAL | FLAG_NO_DATA,
11172 		{ },
11173 		{ { 0, 1 } },
11174 		.fill_helper = bpf_fill_atomic64_add,
11175 		.stack_depth = 8,
11176 		.nr_testruns = NR_PATTERN_RUNS,
11177 	},
11178 	{
11179 		"ATOMIC_DW_AND: all operand magnitudes",
11180 		{ },
11181 		INTERNAL | FLAG_NO_DATA,
11182 		{ },
11183 		{ { 0, 1 } },
11184 		.fill_helper = bpf_fill_atomic64_and,
11185 		.stack_depth = 8,
11186 		.nr_testruns = NR_PATTERN_RUNS,
11187 	},
11188 	{
11189 		"ATOMIC_DW_OR: all operand magnitudes",
11190 		{ },
11191 		INTERNAL | FLAG_NO_DATA,
11192 		{ },
11193 		{ { 0, 1 } },
11194 		.fill_helper = bpf_fill_atomic64_or,
11195 		.stack_depth = 8,
11196 		.nr_testruns = NR_PATTERN_RUNS,
11197 	},
11198 	{
11199 		"ATOMIC_DW_XOR: all operand magnitudes",
11200 		{ },
11201 		INTERNAL | FLAG_NO_DATA,
11202 		{ },
11203 		{ { 0, 1 } },
11204 		.fill_helper = bpf_fill_atomic64_xor,
11205 		.stack_depth = 8,
11206 		.nr_testruns = NR_PATTERN_RUNS,
11207 	},
11208 	{
11209 		"ATOMIC_DW_ADD_FETCH: all operand magnitudes",
11210 		{ },
11211 		INTERNAL | FLAG_NO_DATA,
11212 		{ },
11213 		{ { 0, 1 } },
11214 		.fill_helper = bpf_fill_atomic64_add_fetch,
11215 		.stack_depth = 8,
11216 		.nr_testruns = NR_PATTERN_RUNS,
11217 	},
11218 	{
11219 		"ATOMIC_DW_AND_FETCH: all operand magnitudes",
11220 		{ },
11221 		INTERNAL | FLAG_NO_DATA,
11222 		{ },
11223 		{ { 0, 1 } },
11224 		.fill_helper = bpf_fill_atomic64_and_fetch,
11225 		.stack_depth = 8,
11226 		.nr_testruns = NR_PATTERN_RUNS,
11227 	},
11228 	{
11229 		"ATOMIC_DW_OR_FETCH: all operand magnitudes",
11230 		{ },
11231 		INTERNAL | FLAG_NO_DATA,
11232 		{ },
11233 		{ { 0, 1 } },
11234 		.fill_helper = bpf_fill_atomic64_or_fetch,
11235 		.stack_depth = 8,
11236 		.nr_testruns = NR_PATTERN_RUNS,
11237 	},
11238 	{
11239 		"ATOMIC_DW_XOR_FETCH: all operand magnitudes",
11240 		{ },
11241 		INTERNAL | FLAG_NO_DATA,
11242 		{ },
11243 		{ { 0, 1 } },
11244 		.fill_helper = bpf_fill_atomic64_xor_fetch,
11245 		.stack_depth = 8,
11246 		.nr_testruns = NR_PATTERN_RUNS,
11247 	},
11248 	{
11249 		"ATOMIC_DW_XCHG: all operand magnitudes",
11250 		{ },
11251 		INTERNAL | FLAG_NO_DATA,
11252 		{ },
11253 		{ { 0, 1 } },
11254 		.fill_helper = bpf_fill_atomic64_xchg,
11255 		.stack_depth = 8,
11256 		.nr_testruns = NR_PATTERN_RUNS,
11257 	},
11258 	{
11259 		"ATOMIC_DW_CMPXCHG: all operand magnitudes",
11260 		{ },
11261 		INTERNAL | FLAG_NO_DATA,
11262 		{ },
11263 		{ { 0, 1 } },
11264 		.fill_helper = bpf_fill_cmpxchg64,
11265 		.stack_depth = 8,
11266 		.nr_testruns = NR_PATTERN_RUNS,
11267 	},
11268 	/* 64-bit atomic magnitudes */
11269 	{
11270 		"ATOMIC_W_ADD: all operand magnitudes",
11271 		{ },
11272 		INTERNAL | FLAG_NO_DATA,
11273 		{ },
11274 		{ { 0, 1 } },
11275 		.fill_helper = bpf_fill_atomic32_add,
11276 		.stack_depth = 8,
11277 		.nr_testruns = NR_PATTERN_RUNS,
11278 	},
11279 	{
11280 		"ATOMIC_W_AND: all operand magnitudes",
11281 		{ },
11282 		INTERNAL | FLAG_NO_DATA,
11283 		{ },
11284 		{ { 0, 1 } },
11285 		.fill_helper = bpf_fill_atomic32_and,
11286 		.stack_depth = 8,
11287 		.nr_testruns = NR_PATTERN_RUNS,
11288 	},
11289 	{
11290 		"ATOMIC_W_OR: all operand magnitudes",
11291 		{ },
11292 		INTERNAL | FLAG_NO_DATA,
11293 		{ },
11294 		{ { 0, 1 } },
11295 		.fill_helper = bpf_fill_atomic32_or,
11296 		.stack_depth = 8,
11297 		.nr_testruns = NR_PATTERN_RUNS,
11298 	},
11299 	{
11300 		"ATOMIC_W_XOR: all operand magnitudes",
11301 		{ },
11302 		INTERNAL | FLAG_NO_DATA,
11303 		{ },
11304 		{ { 0, 1 } },
11305 		.fill_helper = bpf_fill_atomic32_xor,
11306 		.stack_depth = 8,
11307 		.nr_testruns = NR_PATTERN_RUNS,
11308 	},
11309 	{
11310 		"ATOMIC_W_ADD_FETCH: all operand magnitudes",
11311 		{ },
11312 		INTERNAL | FLAG_NO_DATA,
11313 		{ },
11314 		{ { 0, 1 } },
11315 		.fill_helper = bpf_fill_atomic32_add_fetch,
11316 		.stack_depth = 8,
11317 		.nr_testruns = NR_PATTERN_RUNS,
11318 	},
11319 	{
11320 		"ATOMIC_W_AND_FETCH: all operand magnitudes",
11321 		{ },
11322 		INTERNAL | FLAG_NO_DATA,
11323 		{ },
11324 		{ { 0, 1 } },
11325 		.fill_helper = bpf_fill_atomic32_and_fetch,
11326 		.stack_depth = 8,
11327 		.nr_testruns = NR_PATTERN_RUNS,
11328 	},
11329 	{
11330 		"ATOMIC_W_OR_FETCH: all operand magnitudes",
11331 		{ },
11332 		INTERNAL | FLAG_NO_DATA,
11333 		{ },
11334 		{ { 0, 1 } },
11335 		.fill_helper = bpf_fill_atomic32_or_fetch,
11336 		.stack_depth = 8,
11337 		.nr_testruns = NR_PATTERN_RUNS,
11338 	},
11339 	{
11340 		"ATOMIC_W_XOR_FETCH: all operand magnitudes",
11341 		{ },
11342 		INTERNAL | FLAG_NO_DATA,
11343 		{ },
11344 		{ { 0, 1 } },
11345 		.fill_helper = bpf_fill_atomic32_xor_fetch,
11346 		.stack_depth = 8,
11347 		.nr_testruns = NR_PATTERN_RUNS,
11348 	},
11349 	{
11350 		"ATOMIC_W_XCHG: all operand magnitudes",
11351 		{ },
11352 		INTERNAL | FLAG_NO_DATA,
11353 		{ },
11354 		{ { 0, 1 } },
11355 		.fill_helper = bpf_fill_atomic32_xchg,
11356 		.stack_depth = 8,
11357 		.nr_testruns = NR_PATTERN_RUNS,
11358 	},
11359 	{
11360 		"ATOMIC_W_CMPXCHG: all operand magnitudes",
11361 		{ },
11362 		INTERNAL | FLAG_NO_DATA,
11363 		{ },
11364 		{ { 0, 1 } },
11365 		.fill_helper = bpf_fill_cmpxchg32,
11366 		.stack_depth = 8,
11367 		.nr_testruns = NR_PATTERN_RUNS,
11368 	},
11369 	/* JMP immediate magnitudes */
11370 	{
11371 		"JMP_JSET_K: all immediate value magnitudes",
11372 		{ },
11373 		INTERNAL | FLAG_NO_DATA,
11374 		{ },
11375 		{ { 0, 1 } },
11376 		.fill_helper = bpf_fill_jmp_jset_imm,
11377 		.nr_testruns = NR_PATTERN_RUNS,
11378 	},
11379 	{
11380 		"JMP_JEQ_K: all immediate value magnitudes",
11381 		{ },
11382 		INTERNAL | FLAG_NO_DATA,
11383 		{ },
11384 		{ { 0, 1 } },
11385 		.fill_helper = bpf_fill_jmp_jeq_imm,
11386 		.nr_testruns = NR_PATTERN_RUNS,
11387 	},
11388 	{
11389 		"JMP_JNE_K: all immediate value magnitudes",
11390 		{ },
11391 		INTERNAL | FLAG_NO_DATA,
11392 		{ },
11393 		{ { 0, 1 } },
11394 		.fill_helper = bpf_fill_jmp_jne_imm,
11395 		.nr_testruns = NR_PATTERN_RUNS,
11396 	},
11397 	{
11398 		"JMP_JGT_K: all immediate value magnitudes",
11399 		{ },
11400 		INTERNAL | FLAG_NO_DATA,
11401 		{ },
11402 		{ { 0, 1 } },
11403 		.fill_helper = bpf_fill_jmp_jgt_imm,
11404 		.nr_testruns = NR_PATTERN_RUNS,
11405 	},
11406 	{
11407 		"JMP_JGE_K: all immediate value magnitudes",
11408 		{ },
11409 		INTERNAL | FLAG_NO_DATA,
11410 		{ },
11411 		{ { 0, 1 } },
11412 		.fill_helper = bpf_fill_jmp_jge_imm,
11413 		.nr_testruns = NR_PATTERN_RUNS,
11414 	},
11415 	{
11416 		"JMP_JLT_K: all immediate value magnitudes",
11417 		{ },
11418 		INTERNAL | FLAG_NO_DATA,
11419 		{ },
11420 		{ { 0, 1 } },
11421 		.fill_helper = bpf_fill_jmp_jlt_imm,
11422 		.nr_testruns = NR_PATTERN_RUNS,
11423 	},
11424 	{
11425 		"JMP_JLE_K: all immediate value magnitudes",
11426 		{ },
11427 		INTERNAL | FLAG_NO_DATA,
11428 		{ },
11429 		{ { 0, 1 } },
11430 		.fill_helper = bpf_fill_jmp_jle_imm,
11431 		.nr_testruns = NR_PATTERN_RUNS,
11432 	},
11433 	{
11434 		"JMP_JSGT_K: all immediate value magnitudes",
11435 		{ },
11436 		INTERNAL | FLAG_NO_DATA,
11437 		{ },
11438 		{ { 0, 1 } },
11439 		.fill_helper = bpf_fill_jmp_jsgt_imm,
11440 		.nr_testruns = NR_PATTERN_RUNS,
11441 	},
11442 	{
11443 		"JMP_JSGE_K: all immediate value magnitudes",
11444 		{ },
11445 		INTERNAL | FLAG_NO_DATA,
11446 		{ },
11447 		{ { 0, 1 } },
11448 		.fill_helper = bpf_fill_jmp_jsge_imm,
11449 		.nr_testruns = NR_PATTERN_RUNS,
11450 	},
11451 	{
11452 		"JMP_JSLT_K: all immediate value magnitudes",
11453 		{ },
11454 		INTERNAL | FLAG_NO_DATA,
11455 		{ },
11456 		{ { 0, 1 } },
11457 		.fill_helper = bpf_fill_jmp_jslt_imm,
11458 		.nr_testruns = NR_PATTERN_RUNS,
11459 	},
11460 	{
11461 		"JMP_JSLE_K: all immediate value magnitudes",
11462 		{ },
11463 		INTERNAL | FLAG_NO_DATA,
11464 		{ },
11465 		{ { 0, 1 } },
11466 		.fill_helper = bpf_fill_jmp_jsle_imm,
11467 		.nr_testruns = NR_PATTERN_RUNS,
11468 	},
11469 	/* JMP register magnitudes */
11470 	{
11471 		"JMP_JSET_X: all register value magnitudes",
11472 		{ },
11473 		INTERNAL | FLAG_NO_DATA,
11474 		{ },
11475 		{ { 0, 1 } },
11476 		.fill_helper = bpf_fill_jmp_jset_reg,
11477 		.nr_testruns = NR_PATTERN_RUNS,
11478 	},
11479 	{
11480 		"JMP_JEQ_X: all register value magnitudes",
11481 		{ },
11482 		INTERNAL | FLAG_NO_DATA,
11483 		{ },
11484 		{ { 0, 1 } },
11485 		.fill_helper = bpf_fill_jmp_jeq_reg,
11486 		.nr_testruns = NR_PATTERN_RUNS,
11487 	},
11488 	{
11489 		"JMP_JNE_X: all register value magnitudes",
11490 		{ },
11491 		INTERNAL | FLAG_NO_DATA,
11492 		{ },
11493 		{ { 0, 1 } },
11494 		.fill_helper = bpf_fill_jmp_jne_reg,
11495 		.nr_testruns = NR_PATTERN_RUNS,
11496 	},
11497 	{
11498 		"JMP_JGT_X: all register value magnitudes",
11499 		{ },
11500 		INTERNAL | FLAG_NO_DATA,
11501 		{ },
11502 		{ { 0, 1 } },
11503 		.fill_helper = bpf_fill_jmp_jgt_reg,
11504 		.nr_testruns = NR_PATTERN_RUNS,
11505 	},
11506 	{
11507 		"JMP_JGE_X: all register value magnitudes",
11508 		{ },
11509 		INTERNAL | FLAG_NO_DATA,
11510 		{ },
11511 		{ { 0, 1 } },
11512 		.fill_helper = bpf_fill_jmp_jge_reg,
11513 		.nr_testruns = NR_PATTERN_RUNS,
11514 	},
11515 	{
11516 		"JMP_JLT_X: all register value magnitudes",
11517 		{ },
11518 		INTERNAL | FLAG_NO_DATA,
11519 		{ },
11520 		{ { 0, 1 } },
11521 		.fill_helper = bpf_fill_jmp_jlt_reg,
11522 		.nr_testruns = NR_PATTERN_RUNS,
11523 	},
11524 	{
11525 		"JMP_JLE_X: all register value magnitudes",
11526 		{ },
11527 		INTERNAL | FLAG_NO_DATA,
11528 		{ },
11529 		{ { 0, 1 } },
11530 		.fill_helper = bpf_fill_jmp_jle_reg,
11531 		.nr_testruns = NR_PATTERN_RUNS,
11532 	},
11533 	{
11534 		"JMP_JSGT_X: all register value magnitudes",
11535 		{ },
11536 		INTERNAL | FLAG_NO_DATA,
11537 		{ },
11538 		{ { 0, 1 } },
11539 		.fill_helper = bpf_fill_jmp_jsgt_reg,
11540 		.nr_testruns = NR_PATTERN_RUNS,
11541 	},
11542 	{
11543 		"JMP_JSGE_X: all register value magnitudes",
11544 		{ },
11545 		INTERNAL | FLAG_NO_DATA,
11546 		{ },
11547 		{ { 0, 1 } },
11548 		.fill_helper = bpf_fill_jmp_jsge_reg,
11549 		.nr_testruns = NR_PATTERN_RUNS,
11550 	},
11551 	{
11552 		"JMP_JSLT_X: all register value magnitudes",
11553 		{ },
11554 		INTERNAL | FLAG_NO_DATA,
11555 		{ },
11556 		{ { 0, 1 } },
11557 		.fill_helper = bpf_fill_jmp_jslt_reg,
11558 		.nr_testruns = NR_PATTERN_RUNS,
11559 	},
11560 	{
11561 		"JMP_JSLE_X: all register value magnitudes",
11562 		{ },
11563 		INTERNAL | FLAG_NO_DATA,
11564 		{ },
11565 		{ { 0, 1 } },
11566 		.fill_helper = bpf_fill_jmp_jsle_reg,
11567 		.nr_testruns = NR_PATTERN_RUNS,
11568 	},
11569 	/* JMP32 immediate magnitudes */
11570 	{
11571 		"JMP32_JSET_K: all immediate value magnitudes",
11572 		{ },
11573 		INTERNAL | FLAG_NO_DATA,
11574 		{ },
11575 		{ { 0, 1 } },
11576 		.fill_helper = bpf_fill_jmp32_jset_imm,
11577 		.nr_testruns = NR_PATTERN_RUNS,
11578 	},
11579 	{
11580 		"JMP32_JEQ_K: all immediate value magnitudes",
11581 		{ },
11582 		INTERNAL | FLAG_NO_DATA,
11583 		{ },
11584 		{ { 0, 1 } },
11585 		.fill_helper = bpf_fill_jmp32_jeq_imm,
11586 		.nr_testruns = NR_PATTERN_RUNS,
11587 	},
11588 	{
11589 		"JMP32_JNE_K: all immediate value magnitudes",
11590 		{ },
11591 		INTERNAL | FLAG_NO_DATA,
11592 		{ },
11593 		{ { 0, 1 } },
11594 		.fill_helper = bpf_fill_jmp32_jne_imm,
11595 		.nr_testruns = NR_PATTERN_RUNS,
11596 	},
11597 	{
11598 		"JMP32_JGT_K: all immediate value magnitudes",
11599 		{ },
11600 		INTERNAL | FLAG_NO_DATA,
11601 		{ },
11602 		{ { 0, 1 } },
11603 		.fill_helper = bpf_fill_jmp32_jgt_imm,
11604 		.nr_testruns = NR_PATTERN_RUNS,
11605 	},
11606 	{
11607 		"JMP32_JGE_K: all immediate value magnitudes",
11608 		{ },
11609 		INTERNAL | FLAG_NO_DATA,
11610 		{ },
11611 		{ { 0, 1 } },
11612 		.fill_helper = bpf_fill_jmp32_jge_imm,
11613 		.nr_testruns = NR_PATTERN_RUNS,
11614 	},
11615 	{
11616 		"JMP32_JLT_K: all immediate value magnitudes",
11617 		{ },
11618 		INTERNAL | FLAG_NO_DATA,
11619 		{ },
11620 		{ { 0, 1 } },
11621 		.fill_helper = bpf_fill_jmp32_jlt_imm,
11622 		.nr_testruns = NR_PATTERN_RUNS,
11623 	},
11624 	{
11625 		"JMP32_JLE_K: all immediate value magnitudes",
11626 		{ },
11627 		INTERNAL | FLAG_NO_DATA,
11628 		{ },
11629 		{ { 0, 1 } },
11630 		.fill_helper = bpf_fill_jmp32_jle_imm,
11631 		.nr_testruns = NR_PATTERN_RUNS,
11632 	},
11633 	{
11634 		"JMP32_JSGT_K: all immediate value magnitudes",
11635 		{ },
11636 		INTERNAL | FLAG_NO_DATA,
11637 		{ },
11638 		{ { 0, 1 } },
11639 		.fill_helper = bpf_fill_jmp32_jsgt_imm,
11640 		.nr_testruns = NR_PATTERN_RUNS,
11641 	},
11642 	{
11643 		"JMP32_JSGE_K: all immediate value magnitudes",
11644 		{ },
11645 		INTERNAL | FLAG_NO_DATA,
11646 		{ },
11647 		{ { 0, 1 } },
11648 		.fill_helper = bpf_fill_jmp32_jsge_imm,
11649 		.nr_testruns = NR_PATTERN_RUNS,
11650 	},
11651 	{
11652 		"JMP32_JSLT_K: all immediate value magnitudes",
11653 		{ },
11654 		INTERNAL | FLAG_NO_DATA,
11655 		{ },
11656 		{ { 0, 1 } },
11657 		.fill_helper = bpf_fill_jmp32_jslt_imm,
11658 		.nr_testruns = NR_PATTERN_RUNS,
11659 	},
11660 	{
11661 		"JMP32_JSLE_K: all immediate value magnitudes",
11662 		{ },
11663 		INTERNAL | FLAG_NO_DATA,
11664 		{ },
11665 		{ { 0, 1 } },
11666 		.fill_helper = bpf_fill_jmp32_jsle_imm,
11667 		.nr_testruns = NR_PATTERN_RUNS,
11668 	},
11669 	/* JMP32 register magnitudes */
11670 	{
11671 		"JMP32_JSET_X: all register value magnitudes",
11672 		{ },
11673 		INTERNAL | FLAG_NO_DATA,
11674 		{ },
11675 		{ { 0, 1 } },
11676 		.fill_helper = bpf_fill_jmp32_jset_reg,
11677 		.nr_testruns = NR_PATTERN_RUNS,
11678 	},
11679 	{
11680 		"JMP32_JEQ_X: all register value magnitudes",
11681 		{ },
11682 		INTERNAL | FLAG_NO_DATA,
11683 		{ },
11684 		{ { 0, 1 } },
11685 		.fill_helper = bpf_fill_jmp32_jeq_reg,
11686 		.nr_testruns = NR_PATTERN_RUNS,
11687 	},
11688 	{
11689 		"JMP32_JNE_X: all register value magnitudes",
11690 		{ },
11691 		INTERNAL | FLAG_NO_DATA,
11692 		{ },
11693 		{ { 0, 1 } },
11694 		.fill_helper = bpf_fill_jmp32_jne_reg,
11695 		.nr_testruns = NR_PATTERN_RUNS,
11696 	},
11697 	{
11698 		"JMP32_JGT_X: all register value magnitudes",
11699 		{ },
11700 		INTERNAL | FLAG_NO_DATA,
11701 		{ },
11702 		{ { 0, 1 } },
11703 		.fill_helper = bpf_fill_jmp32_jgt_reg,
11704 		.nr_testruns = NR_PATTERN_RUNS,
11705 	},
11706 	{
11707 		"JMP32_JGE_X: all register value magnitudes",
11708 		{ },
11709 		INTERNAL | FLAG_NO_DATA,
11710 		{ },
11711 		{ { 0, 1 } },
11712 		.fill_helper = bpf_fill_jmp32_jge_reg,
11713 		.nr_testruns = NR_PATTERN_RUNS,
11714 	},
11715 	{
11716 		"JMP32_JLT_X: all register value magnitudes",
11717 		{ },
11718 		INTERNAL | FLAG_NO_DATA,
11719 		{ },
11720 		{ { 0, 1 } },
11721 		.fill_helper = bpf_fill_jmp32_jlt_reg,
11722 		.nr_testruns = NR_PATTERN_RUNS,
11723 	},
11724 	{
11725 		"JMP32_JLE_X: all register value magnitudes",
11726 		{ },
11727 		INTERNAL | FLAG_NO_DATA,
11728 		{ },
11729 		{ { 0, 1 } },
11730 		.fill_helper = bpf_fill_jmp32_jle_reg,
11731 		.nr_testruns = NR_PATTERN_RUNS,
11732 	},
11733 	{
11734 		"JMP32_JSGT_X: all register value magnitudes",
11735 		{ },
11736 		INTERNAL | FLAG_NO_DATA,
11737 		{ },
11738 		{ { 0, 1 } },
11739 		.fill_helper = bpf_fill_jmp32_jsgt_reg,
11740 		.nr_testruns = NR_PATTERN_RUNS,
11741 	},
11742 	{
11743 		"JMP32_JSGE_X: all register value magnitudes",
11744 		{ },
11745 		INTERNAL | FLAG_NO_DATA,
11746 		{ },
11747 		{ { 0, 1 } },
11748 		.fill_helper = bpf_fill_jmp32_jsge_reg,
11749 		.nr_testruns = NR_PATTERN_RUNS,
11750 	},
11751 	{
11752 		"JMP32_JSLT_X: all register value magnitudes",
11753 		{ },
11754 		INTERNAL | FLAG_NO_DATA,
11755 		{ },
11756 		{ { 0, 1 } },
11757 		.fill_helper = bpf_fill_jmp32_jslt_reg,
11758 		.nr_testruns = NR_PATTERN_RUNS,
11759 	},
11760 	{
11761 		"JMP32_JSLE_X: all register value magnitudes",
11762 		{ },
11763 		INTERNAL | FLAG_NO_DATA,
11764 		{ },
11765 		{ { 0, 1 } },
11766 		.fill_helper = bpf_fill_jmp32_jsle_reg,
11767 		.nr_testruns = NR_PATTERN_RUNS,
11768 	},
11769 	/* Conditional jumps with constant decision */
11770 	{
11771 		"JMP_JSET_K: imm = 0 -> never taken",
11772 		.u.insns_int = {
11773 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
11774 			BPF_JMP_IMM(BPF_JSET, R1, 0, 1),
11775 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
11776 			BPF_EXIT_INSN(),
11777 		},
11778 		INTERNAL | FLAG_NO_DATA,
11779 		{ },
11780 		{ { 0, 0 } },
11781 	},
11782 	{
11783 		"JMP_JLT_K: imm = 0 -> never taken",
11784 		.u.insns_int = {
11785 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
11786 			BPF_JMP_IMM(BPF_JLT, R1, 0, 1),
11787 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
11788 			BPF_EXIT_INSN(),
11789 		},
11790 		INTERNAL | FLAG_NO_DATA,
11791 		{ },
11792 		{ { 0, 0 } },
11793 	},
11794 	{
11795 		"JMP_JGE_K: imm = 0 -> always taken",
11796 		.u.insns_int = {
11797 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
11798 			BPF_JMP_IMM(BPF_JGE, R1, 0, 1),
11799 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
11800 			BPF_EXIT_INSN(),
11801 		},
11802 		INTERNAL | FLAG_NO_DATA,
11803 		{ },
11804 		{ { 0, 1 } },
11805 	},
11806 	{
11807 		"JMP_JGT_K: imm = 0xffffffff -> never taken",
11808 		.u.insns_int = {
11809 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
11810 			BPF_JMP_IMM(BPF_JGT, R1, U32_MAX, 1),
11811 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
11812 			BPF_EXIT_INSN(),
11813 		},
11814 		INTERNAL | FLAG_NO_DATA,
11815 		{ },
11816 		{ { 0, 0 } },
11817 	},
11818 	{
11819 		"JMP_JLE_K: imm = 0xffffffff -> always taken",
11820 		.u.insns_int = {
11821 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
11822 			BPF_JMP_IMM(BPF_JLE, R1, U32_MAX, 1),
11823 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
11824 			BPF_EXIT_INSN(),
11825 		},
11826 		INTERNAL | FLAG_NO_DATA,
11827 		{ },
11828 		{ { 0, 1 } },
11829 	},
11830 	{
11831 		"JMP32_JSGT_K: imm = 0x7fffffff -> never taken",
11832 		.u.insns_int = {
11833 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
11834 			BPF_JMP32_IMM(BPF_JSGT, R1, S32_MAX, 1),
11835 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
11836 			BPF_EXIT_INSN(),
11837 		},
11838 		INTERNAL | FLAG_NO_DATA,
11839 		{ },
11840 		{ { 0, 0 } },
11841 	},
11842 	{
11843 		"JMP32_JSGE_K: imm = -0x80000000 -> always taken",
11844 		.u.insns_int = {
11845 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
11846 			BPF_JMP32_IMM(BPF_JSGE, R1, S32_MIN, 1),
11847 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
11848 			BPF_EXIT_INSN(),
11849 		},
11850 		INTERNAL | FLAG_NO_DATA,
11851 		{ },
11852 		{ { 0, 1 } },
11853 	},
11854 	{
11855 		"JMP32_JSLT_K: imm = -0x80000000 -> never taken",
11856 		.u.insns_int = {
11857 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
11858 			BPF_JMP32_IMM(BPF_JSLT, R1, S32_MIN, 1),
11859 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
11860 			BPF_EXIT_INSN(),
11861 		},
11862 		INTERNAL | FLAG_NO_DATA,
11863 		{ },
11864 		{ { 0, 0 } },
11865 	},
11866 	{
11867 		"JMP32_JSLE_K: imm = 0x7fffffff -> always taken",
11868 		.u.insns_int = {
11869 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
11870 			BPF_JMP32_IMM(BPF_JSLE, R1, S32_MAX, 1),
11871 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
11872 			BPF_EXIT_INSN(),
11873 		},
11874 		INTERNAL | FLAG_NO_DATA,
11875 		{ },
11876 		{ { 0, 1 } },
11877 	},
11878 	{
11879 		"JMP_JEQ_X: dst = src -> always taken",
11880 		.u.insns_int = {
11881 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
11882 			BPF_JMP_REG(BPF_JEQ, R1, R1, 1),
11883 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
11884 			BPF_EXIT_INSN(),
11885 		},
11886 		INTERNAL | FLAG_NO_DATA,
11887 		{ },
11888 		{ { 0, 1 } },
11889 	},
11890 	{
11891 		"JMP_JGE_X: dst = src -> always taken",
11892 		.u.insns_int = {
11893 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
11894 			BPF_JMP_REG(BPF_JGE, R1, R1, 1),
11895 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
11896 			BPF_EXIT_INSN(),
11897 		},
11898 		INTERNAL | FLAG_NO_DATA,
11899 		{ },
11900 		{ { 0, 1 } },
11901 	},
11902 	{
11903 		"JMP_JLE_X: dst = src -> always taken",
11904 		.u.insns_int = {
11905 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
11906 			BPF_JMP_REG(BPF_JLE, R1, R1, 1),
11907 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
11908 			BPF_EXIT_INSN(),
11909 		},
11910 		INTERNAL | FLAG_NO_DATA,
11911 		{ },
11912 		{ { 0, 1 } },
11913 	},
11914 	{
11915 		"JMP_JSGE_X: dst = src -> always taken",
11916 		.u.insns_int = {
11917 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
11918 			BPF_JMP_REG(BPF_JSGE, R1, R1, 1),
11919 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
11920 			BPF_EXIT_INSN(),
11921 		},
11922 		INTERNAL | FLAG_NO_DATA,
11923 		{ },
11924 		{ { 0, 1 } },
11925 	},
11926 	{
11927 		"JMP_JSLE_X: dst = src -> always taken",
11928 		.u.insns_int = {
11929 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
11930 			BPF_JMP_REG(BPF_JSLE, R1, R1, 1),
11931 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
11932 			BPF_EXIT_INSN(),
11933 		},
11934 		INTERNAL | FLAG_NO_DATA,
11935 		{ },
11936 		{ { 0, 1 } },
11937 	},
11938 	{
11939 		"JMP_JNE_X: dst = src -> never taken",
11940 		.u.insns_int = {
11941 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
11942 			BPF_JMP_REG(BPF_JNE, R1, R1, 1),
11943 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
11944 			BPF_EXIT_INSN(),
11945 		},
11946 		INTERNAL | FLAG_NO_DATA,
11947 		{ },
11948 		{ { 0, 0 } },
11949 	},
11950 	{
11951 		"JMP_JGT_X: dst = src -> never taken",
11952 		.u.insns_int = {
11953 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
11954 			BPF_JMP_REG(BPF_JGT, R1, R1, 1),
11955 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
11956 			BPF_EXIT_INSN(),
11957 		},
11958 		INTERNAL | FLAG_NO_DATA,
11959 		{ },
11960 		{ { 0, 0 } },
11961 	},
11962 	{
11963 		"JMP_JLT_X: dst = src -> never taken",
11964 		.u.insns_int = {
11965 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
11966 			BPF_JMP_REG(BPF_JLT, R1, R1, 1),
11967 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
11968 			BPF_EXIT_INSN(),
11969 		},
11970 		INTERNAL | FLAG_NO_DATA,
11971 		{ },
11972 		{ { 0, 0 } },
11973 	},
11974 	{
11975 		"JMP_JSGT_X: dst = src -> never taken",
11976 		.u.insns_int = {
11977 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
11978 			BPF_JMP_REG(BPF_JSGT, R1, R1, 1),
11979 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
11980 			BPF_EXIT_INSN(),
11981 		},
11982 		INTERNAL | FLAG_NO_DATA,
11983 		{ },
11984 		{ { 0, 0 } },
11985 	},
11986 	{
11987 		"JMP_JSLT_X: dst = src -> never taken",
11988 		.u.insns_int = {
11989 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
11990 			BPF_JMP_REG(BPF_JSLT, R1, R1, 1),
11991 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
11992 			BPF_EXIT_INSN(),
11993 		},
11994 		INTERNAL | FLAG_NO_DATA,
11995 		{ },
11996 		{ { 0, 0 } },
11997 	},
11998 	/* Short relative jumps */
11999 	{
12000 		"Short relative jump: offset=0",
12001 		.u.insns_int = {
12002 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
12003 			BPF_JMP_IMM(BPF_JEQ, R0, 0, 0),
12004 			BPF_EXIT_INSN(),
12005 			BPF_ALU32_IMM(BPF_MOV, R0, -1),
12006 		},
12007 		INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
12008 		{ },
12009 		{ { 0, 0 } },
12010 	},
12011 	{
12012 		"Short relative jump: offset=1",
12013 		.u.insns_int = {
12014 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
12015 			BPF_JMP_IMM(BPF_JEQ, R0, 0, 1),
12016 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
12017 			BPF_EXIT_INSN(),
12018 			BPF_ALU32_IMM(BPF_MOV, R0, -1),
12019 		},
12020 		INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
12021 		{ },
12022 		{ { 0, 0 } },
12023 	},
12024 	{
12025 		"Short relative jump: offset=2",
12026 		.u.insns_int = {
12027 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
12028 			BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
12029 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
12030 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
12031 			BPF_EXIT_INSN(),
12032 			BPF_ALU32_IMM(BPF_MOV, R0, -1),
12033 		},
12034 		INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
12035 		{ },
12036 		{ { 0, 0 } },
12037 	},
12038 	{
12039 		"Short relative jump: offset=3",
12040 		.u.insns_int = {
12041 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
12042 			BPF_JMP_IMM(BPF_JEQ, R0, 0, 3),
12043 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
12044 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
12045 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
12046 			BPF_EXIT_INSN(),
12047 			BPF_ALU32_IMM(BPF_MOV, R0, -1),
12048 		},
12049 		INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
12050 		{ },
12051 		{ { 0, 0 } },
12052 	},
12053 	{
12054 		"Short relative jump: offset=4",
12055 		.u.insns_int = {
12056 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
12057 			BPF_JMP_IMM(BPF_JEQ, R0, 0, 4),
12058 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
12059 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
12060 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
12061 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
12062 			BPF_EXIT_INSN(),
12063 			BPF_ALU32_IMM(BPF_MOV, R0, -1),
12064 		},
12065 		INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
12066 		{ },
12067 		{ { 0, 0 } },
12068 	},
12069 	/* Conditional branch conversions */
12070 	{
12071 		"Long conditional jump: taken at runtime",
12072 		{ },
12073 		INTERNAL | FLAG_NO_DATA,
12074 		{ },
12075 		{ { 0, 1 } },
12076 		.fill_helper = bpf_fill_max_jmp_taken,
12077 	},
12078 	{
12079 		"Long conditional jump: not taken at runtime",
12080 		{ },
12081 		INTERNAL | FLAG_NO_DATA,
12082 		{ },
12083 		{ { 0, 2 } },
12084 		.fill_helper = bpf_fill_max_jmp_not_taken,
12085 	},
12086 	{
12087 		"Long conditional jump: always taken, known at JIT time",
12088 		{ },
12089 		INTERNAL | FLAG_NO_DATA,
12090 		{ },
12091 		{ { 0, 1 } },
12092 		.fill_helper = bpf_fill_max_jmp_always_taken,
12093 	},
12094 	{
12095 		"Long conditional jump: never taken, known at JIT time",
12096 		{ },
12097 		INTERNAL | FLAG_NO_DATA,
12098 		{ },
12099 		{ { 0, 2 } },
12100 		.fill_helper = bpf_fill_max_jmp_never_taken,
12101 	},
12102 	/* Staggered jump sequences, immediate */
12103 	{
12104 		"Staggered jumps: JMP_JA",
12105 		{ },
12106 		INTERNAL | FLAG_NO_DATA,
12107 		{ },
12108 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12109 		.fill_helper = bpf_fill_staggered_ja,
12110 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12111 	},
12112 	{
12113 		"Staggered jumps: JMP_JEQ_K",
12114 		{ },
12115 		INTERNAL | FLAG_NO_DATA,
12116 		{ },
12117 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12118 		.fill_helper = bpf_fill_staggered_jeq_imm,
12119 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12120 	},
12121 	{
12122 		"Staggered jumps: JMP_JNE_K",
12123 		{ },
12124 		INTERNAL | FLAG_NO_DATA,
12125 		{ },
12126 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12127 		.fill_helper = bpf_fill_staggered_jne_imm,
12128 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12129 	},
12130 	{
12131 		"Staggered jumps: JMP_JSET_K",
12132 		{ },
12133 		INTERNAL | FLAG_NO_DATA,
12134 		{ },
12135 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12136 		.fill_helper = bpf_fill_staggered_jset_imm,
12137 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12138 	},
12139 	{
12140 		"Staggered jumps: JMP_JGT_K",
12141 		{ },
12142 		INTERNAL | FLAG_NO_DATA,
12143 		{ },
12144 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12145 		.fill_helper = bpf_fill_staggered_jgt_imm,
12146 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12147 	},
12148 	{
12149 		"Staggered jumps: JMP_JGE_K",
12150 		{ },
12151 		INTERNAL | FLAG_NO_DATA,
12152 		{ },
12153 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12154 		.fill_helper = bpf_fill_staggered_jge_imm,
12155 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12156 	},
12157 	{
12158 		"Staggered jumps: JMP_JLT_K",
12159 		{ },
12160 		INTERNAL | FLAG_NO_DATA,
12161 		{ },
12162 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12163 		.fill_helper = bpf_fill_staggered_jlt_imm,
12164 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12165 	},
12166 	{
12167 		"Staggered jumps: JMP_JLE_K",
12168 		{ },
12169 		INTERNAL | FLAG_NO_DATA,
12170 		{ },
12171 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12172 		.fill_helper = bpf_fill_staggered_jle_imm,
12173 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12174 	},
12175 	{
12176 		"Staggered jumps: JMP_JSGT_K",
12177 		{ },
12178 		INTERNAL | FLAG_NO_DATA,
12179 		{ },
12180 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12181 		.fill_helper = bpf_fill_staggered_jsgt_imm,
12182 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12183 	},
12184 	{
12185 		"Staggered jumps: JMP_JSGE_K",
12186 		{ },
12187 		INTERNAL | FLAG_NO_DATA,
12188 		{ },
12189 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12190 		.fill_helper = bpf_fill_staggered_jsge_imm,
12191 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12192 	},
12193 	{
12194 		"Staggered jumps: JMP_JSLT_K",
12195 		{ },
12196 		INTERNAL | FLAG_NO_DATA,
12197 		{ },
12198 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12199 		.fill_helper = bpf_fill_staggered_jslt_imm,
12200 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12201 	},
12202 	{
12203 		"Staggered jumps: JMP_JSLE_K",
12204 		{ },
12205 		INTERNAL | FLAG_NO_DATA,
12206 		{ },
12207 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12208 		.fill_helper = bpf_fill_staggered_jsle_imm,
12209 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12210 	},
12211 	/* Staggered jump sequences, register */
12212 	{
12213 		"Staggered jumps: JMP_JEQ_X",
12214 		{ },
12215 		INTERNAL | FLAG_NO_DATA,
12216 		{ },
12217 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12218 		.fill_helper = bpf_fill_staggered_jeq_reg,
12219 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12220 	},
12221 	{
12222 		"Staggered jumps: JMP_JNE_X",
12223 		{ },
12224 		INTERNAL | FLAG_NO_DATA,
12225 		{ },
12226 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12227 		.fill_helper = bpf_fill_staggered_jne_reg,
12228 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12229 	},
12230 	{
12231 		"Staggered jumps: JMP_JSET_X",
12232 		{ },
12233 		INTERNAL | FLAG_NO_DATA,
12234 		{ },
12235 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12236 		.fill_helper = bpf_fill_staggered_jset_reg,
12237 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12238 	},
12239 	{
12240 		"Staggered jumps: JMP_JGT_X",
12241 		{ },
12242 		INTERNAL | FLAG_NO_DATA,
12243 		{ },
12244 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12245 		.fill_helper = bpf_fill_staggered_jgt_reg,
12246 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12247 	},
12248 	{
12249 		"Staggered jumps: JMP_JGE_X",
12250 		{ },
12251 		INTERNAL | FLAG_NO_DATA,
12252 		{ },
12253 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12254 		.fill_helper = bpf_fill_staggered_jge_reg,
12255 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12256 	},
12257 	{
12258 		"Staggered jumps: JMP_JLT_X",
12259 		{ },
12260 		INTERNAL | FLAG_NO_DATA,
12261 		{ },
12262 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12263 		.fill_helper = bpf_fill_staggered_jlt_reg,
12264 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12265 	},
12266 	{
12267 		"Staggered jumps: JMP_JLE_X",
12268 		{ },
12269 		INTERNAL | FLAG_NO_DATA,
12270 		{ },
12271 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12272 		.fill_helper = bpf_fill_staggered_jle_reg,
12273 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12274 	},
12275 	{
12276 		"Staggered jumps: JMP_JSGT_X",
12277 		{ },
12278 		INTERNAL | FLAG_NO_DATA,
12279 		{ },
12280 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12281 		.fill_helper = bpf_fill_staggered_jsgt_reg,
12282 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12283 	},
12284 	{
12285 		"Staggered jumps: JMP_JSGE_X",
12286 		{ },
12287 		INTERNAL | FLAG_NO_DATA,
12288 		{ },
12289 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12290 		.fill_helper = bpf_fill_staggered_jsge_reg,
12291 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12292 	},
12293 	{
12294 		"Staggered jumps: JMP_JSLT_X",
12295 		{ },
12296 		INTERNAL | FLAG_NO_DATA,
12297 		{ },
12298 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12299 		.fill_helper = bpf_fill_staggered_jslt_reg,
12300 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12301 	},
12302 	{
12303 		"Staggered jumps: JMP_JSLE_X",
12304 		{ },
12305 		INTERNAL | FLAG_NO_DATA,
12306 		{ },
12307 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12308 		.fill_helper = bpf_fill_staggered_jsle_reg,
12309 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12310 	},
12311 	/* Staggered jump sequences, JMP32 immediate */
12312 	{
12313 		"Staggered jumps: JMP32_JEQ_K",
12314 		{ },
12315 		INTERNAL | FLAG_NO_DATA,
12316 		{ },
12317 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12318 		.fill_helper = bpf_fill_staggered_jeq32_imm,
12319 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12320 	},
12321 	{
12322 		"Staggered jumps: JMP32_JNE_K",
12323 		{ },
12324 		INTERNAL | FLAG_NO_DATA,
12325 		{ },
12326 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12327 		.fill_helper = bpf_fill_staggered_jne32_imm,
12328 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12329 	},
12330 	{
12331 		"Staggered jumps: JMP32_JSET_K",
12332 		{ },
12333 		INTERNAL | FLAG_NO_DATA,
12334 		{ },
12335 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12336 		.fill_helper = bpf_fill_staggered_jset32_imm,
12337 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12338 	},
12339 	{
12340 		"Staggered jumps: JMP32_JGT_K",
12341 		{ },
12342 		INTERNAL | FLAG_NO_DATA,
12343 		{ },
12344 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12345 		.fill_helper = bpf_fill_staggered_jgt32_imm,
12346 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12347 	},
12348 	{
12349 		"Staggered jumps: JMP32_JGE_K",
12350 		{ },
12351 		INTERNAL | FLAG_NO_DATA,
12352 		{ },
12353 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12354 		.fill_helper = bpf_fill_staggered_jge32_imm,
12355 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12356 	},
12357 	{
12358 		"Staggered jumps: JMP32_JLT_K",
12359 		{ },
12360 		INTERNAL | FLAG_NO_DATA,
12361 		{ },
12362 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12363 		.fill_helper = bpf_fill_staggered_jlt32_imm,
12364 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12365 	},
12366 	{
12367 		"Staggered jumps: JMP32_JLE_K",
12368 		{ },
12369 		INTERNAL | FLAG_NO_DATA,
12370 		{ },
12371 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12372 		.fill_helper = bpf_fill_staggered_jle32_imm,
12373 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12374 	},
12375 	{
12376 		"Staggered jumps: JMP32_JSGT_K",
12377 		{ },
12378 		INTERNAL | FLAG_NO_DATA,
12379 		{ },
12380 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12381 		.fill_helper = bpf_fill_staggered_jsgt32_imm,
12382 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12383 	},
12384 	{
12385 		"Staggered jumps: JMP32_JSGE_K",
12386 		{ },
12387 		INTERNAL | FLAG_NO_DATA,
12388 		{ },
12389 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12390 		.fill_helper = bpf_fill_staggered_jsge32_imm,
12391 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12392 	},
12393 	{
12394 		"Staggered jumps: JMP32_JSLT_K",
12395 		{ },
12396 		INTERNAL | FLAG_NO_DATA,
12397 		{ },
12398 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12399 		.fill_helper = bpf_fill_staggered_jslt32_imm,
12400 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12401 	},
12402 	{
12403 		"Staggered jumps: JMP32_JSLE_K",
12404 		{ },
12405 		INTERNAL | FLAG_NO_DATA,
12406 		{ },
12407 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12408 		.fill_helper = bpf_fill_staggered_jsle32_imm,
12409 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12410 	},
12411 	/* Staggered jump sequences, JMP32 register */
12412 	{
12413 		"Staggered jumps: JMP32_JEQ_X",
12414 		{ },
12415 		INTERNAL | FLAG_NO_DATA,
12416 		{ },
12417 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12418 		.fill_helper = bpf_fill_staggered_jeq32_reg,
12419 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12420 	},
12421 	{
12422 		"Staggered jumps: JMP32_JNE_X",
12423 		{ },
12424 		INTERNAL | FLAG_NO_DATA,
12425 		{ },
12426 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12427 		.fill_helper = bpf_fill_staggered_jne32_reg,
12428 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12429 	},
12430 	{
12431 		"Staggered jumps: JMP32_JSET_X",
12432 		{ },
12433 		INTERNAL | FLAG_NO_DATA,
12434 		{ },
12435 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12436 		.fill_helper = bpf_fill_staggered_jset32_reg,
12437 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12438 	},
12439 	{
12440 		"Staggered jumps: JMP32_JGT_X",
12441 		{ },
12442 		INTERNAL | FLAG_NO_DATA,
12443 		{ },
12444 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12445 		.fill_helper = bpf_fill_staggered_jgt32_reg,
12446 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12447 	},
12448 	{
12449 		"Staggered jumps: JMP32_JGE_X",
12450 		{ },
12451 		INTERNAL | FLAG_NO_DATA,
12452 		{ },
12453 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12454 		.fill_helper = bpf_fill_staggered_jge32_reg,
12455 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12456 	},
12457 	{
12458 		"Staggered jumps: JMP32_JLT_X",
12459 		{ },
12460 		INTERNAL | FLAG_NO_DATA,
12461 		{ },
12462 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12463 		.fill_helper = bpf_fill_staggered_jlt32_reg,
12464 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12465 	},
12466 	{
12467 		"Staggered jumps: JMP32_JLE_X",
12468 		{ },
12469 		INTERNAL | FLAG_NO_DATA,
12470 		{ },
12471 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12472 		.fill_helper = bpf_fill_staggered_jle32_reg,
12473 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12474 	},
12475 	{
12476 		"Staggered jumps: JMP32_JSGT_X",
12477 		{ },
12478 		INTERNAL | FLAG_NO_DATA,
12479 		{ },
12480 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12481 		.fill_helper = bpf_fill_staggered_jsgt32_reg,
12482 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12483 	},
12484 	{
12485 		"Staggered jumps: JMP32_JSGE_X",
12486 		{ },
12487 		INTERNAL | FLAG_NO_DATA,
12488 		{ },
12489 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12490 		.fill_helper = bpf_fill_staggered_jsge32_reg,
12491 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12492 	},
12493 	{
12494 		"Staggered jumps: JMP32_JSLT_X",
12495 		{ },
12496 		INTERNAL | FLAG_NO_DATA,
12497 		{ },
12498 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12499 		.fill_helper = bpf_fill_staggered_jslt32_reg,
12500 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12501 	},
12502 	{
12503 		"Staggered jumps: JMP32_JSLE_X",
12504 		{ },
12505 		INTERNAL | FLAG_NO_DATA,
12506 		{ },
12507 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12508 		.fill_helper = bpf_fill_staggered_jsle32_reg,
12509 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
12510 	},
12511 };
12512 
12513 static struct net_device dev;
12514 
12515 static struct sk_buff *populate_skb(char *buf, int size)
12516 {
12517 	struct sk_buff *skb;
12518 
12519 	if (size >= MAX_DATA)
12520 		return NULL;
12521 
12522 	skb = alloc_skb(MAX_DATA, GFP_KERNEL);
12523 	if (!skb)
12524 		return NULL;
12525 
12526 	__skb_put_data(skb, buf, size);
12527 
12528 	/* Initialize a fake skb with test pattern. */
12529 	skb_reset_mac_header(skb);
12530 	skb->protocol = htons(ETH_P_IP);
12531 	skb->pkt_type = SKB_TYPE;
12532 	skb->mark = SKB_MARK;
12533 	skb->hash = SKB_HASH;
12534 	skb->queue_mapping = SKB_QUEUE_MAP;
12535 	skb->vlan_tci = SKB_VLAN_TCI;
12536 	skb->vlan_present = SKB_VLAN_PRESENT;
12537 	skb->vlan_proto = htons(ETH_P_IP);
12538 	dev_net_set(&dev, &init_net);
12539 	skb->dev = &dev;
12540 	skb->dev->ifindex = SKB_DEV_IFINDEX;
12541 	skb->dev->type = SKB_DEV_TYPE;
12542 	skb_set_network_header(skb, min(size, ETH_HLEN));
12543 
12544 	return skb;
12545 }
12546 
12547 static void *generate_test_data(struct bpf_test *test, int sub)
12548 {
12549 	struct sk_buff *skb;
12550 	struct page *page;
12551 
12552 	if (test->aux & FLAG_NO_DATA)
12553 		return NULL;
12554 
12555 	/* Test case expects an skb, so populate one. Various
12556 	 * subtests generate skbs of different sizes based on
12557 	 * the same data.
12558 	 */
12559 	skb = populate_skb(test->data, test->test[sub].data_size);
12560 	if (!skb)
12561 		return NULL;
12562 
12563 	if (test->aux & FLAG_SKB_FRAG) {
12564 		/*
12565 		 * when the test requires a fragmented skb, add a
12566 		 * single fragment to the skb, filled with
12567 		 * test->frag_data.
12568 		 */
12569 		void *ptr;
12570 
12571 		page = alloc_page(GFP_KERNEL);
12572 
12573 		if (!page)
12574 			goto err_kfree_skb;
12575 
12576 		ptr = kmap(page);
12577 		if (!ptr)
12578 			goto err_free_page;
12579 		memcpy(ptr, test->frag_data, MAX_DATA);
12580 		kunmap(page);
12581 		skb_add_rx_frag(skb, 0, page, 0, MAX_DATA, MAX_DATA);
12582 	}
12583 
12584 	return skb;
12585 
12586 err_free_page:
12587 	__free_page(page);
12588 err_kfree_skb:
12589 	kfree_skb(skb);
12590 	return NULL;
12591 }
12592 
12593 static void release_test_data(const struct bpf_test *test, void *data)
12594 {
12595 	if (test->aux & FLAG_NO_DATA)
12596 		return;
12597 
12598 	kfree_skb(data);
12599 }
12600 
12601 static int filter_length(int which)
12602 {
12603 	struct sock_filter *fp;
12604 	int len;
12605 
12606 	if (tests[which].fill_helper)
12607 		return tests[which].u.ptr.len;
12608 
12609 	fp = tests[which].u.insns;
12610 	for (len = MAX_INSNS - 1; len > 0; --len)
12611 		if (fp[len].code != 0 || fp[len].k != 0)
12612 			break;
12613 
12614 	return len + 1;
12615 }
12616 
12617 static void *filter_pointer(int which)
12618 {
12619 	if (tests[which].fill_helper)
12620 		return tests[which].u.ptr.insns;
12621 	else
12622 		return tests[which].u.insns;
12623 }
12624 
12625 static struct bpf_prog *generate_filter(int which, int *err)
12626 {
12627 	__u8 test_type = tests[which].aux & TEST_TYPE_MASK;
12628 	unsigned int flen = filter_length(which);
12629 	void *fptr = filter_pointer(which);
12630 	struct sock_fprog_kern fprog;
12631 	struct bpf_prog *fp;
12632 
12633 	switch (test_type) {
12634 	case CLASSIC:
12635 		fprog.filter = fptr;
12636 		fprog.len = flen;
12637 
12638 		*err = bpf_prog_create(&fp, &fprog);
12639 		if (tests[which].aux & FLAG_EXPECTED_FAIL) {
12640 			if (*err == tests[which].expected_errcode) {
12641 				pr_cont("PASS\n");
12642 				/* Verifier rejected filter as expected. */
12643 				*err = 0;
12644 				return NULL;
12645 			} else {
12646 				pr_cont("UNEXPECTED_PASS\n");
12647 				/* Verifier didn't reject the test that's
12648 				 * bad enough, just return!
12649 				 */
12650 				*err = -EINVAL;
12651 				return NULL;
12652 			}
12653 		}
12654 		if (*err) {
12655 			pr_cont("FAIL to prog_create err=%d len=%d\n",
12656 				*err, fprog.len);
12657 			return NULL;
12658 		}
12659 		break;
12660 
12661 	case INTERNAL:
12662 		fp = bpf_prog_alloc(bpf_prog_size(flen), 0);
12663 		if (fp == NULL) {
12664 			pr_cont("UNEXPECTED_FAIL no memory left\n");
12665 			*err = -ENOMEM;
12666 			return NULL;
12667 		}
12668 
12669 		fp->len = flen;
12670 		/* Type doesn't really matter here as long as it's not unspec. */
12671 		fp->type = BPF_PROG_TYPE_SOCKET_FILTER;
12672 		memcpy(fp->insnsi, fptr, fp->len * sizeof(struct bpf_insn));
12673 		fp->aux->stack_depth = tests[which].stack_depth;
12674 		fp->aux->verifier_zext = !!(tests[which].aux &
12675 					    FLAG_VERIFIER_ZEXT);
12676 
12677 		/* We cannot error here as we don't need type compatibility
12678 		 * checks.
12679 		 */
12680 		fp = bpf_prog_select_runtime(fp, err);
12681 		if (*err) {
12682 			pr_cont("FAIL to select_runtime err=%d\n", *err);
12683 			return NULL;
12684 		}
12685 		break;
12686 	}
12687 
12688 	*err = 0;
12689 	return fp;
12690 }
12691 
12692 static void release_filter(struct bpf_prog *fp, int which)
12693 {
12694 	__u8 test_type = tests[which].aux & TEST_TYPE_MASK;
12695 
12696 	switch (test_type) {
12697 	case CLASSIC:
12698 		bpf_prog_destroy(fp);
12699 		break;
12700 	case INTERNAL:
12701 		bpf_prog_free(fp);
12702 		break;
12703 	}
12704 }
12705 
12706 static int __run_one(const struct bpf_prog *fp, const void *data,
12707 		     int runs, u64 *duration)
12708 {
12709 	u64 start, finish;
12710 	int ret = 0, i;
12711 
12712 	migrate_disable();
12713 	start = ktime_get_ns();
12714 
12715 	for (i = 0; i < runs; i++)
12716 		ret = bpf_prog_run(fp, data);
12717 
12718 	finish = ktime_get_ns();
12719 	migrate_enable();
12720 
12721 	*duration = finish - start;
12722 	do_div(*duration, runs);
12723 
12724 	return ret;
12725 }
12726 
12727 static int run_one(const struct bpf_prog *fp, struct bpf_test *test)
12728 {
12729 	int err_cnt = 0, i, runs = MAX_TESTRUNS;
12730 
12731 	if (test->nr_testruns)
12732 		runs = min(test->nr_testruns, MAX_TESTRUNS);
12733 
12734 	for (i = 0; i < MAX_SUBTESTS; i++) {
12735 		void *data;
12736 		u64 duration;
12737 		u32 ret;
12738 
12739 		/*
12740 		 * NOTE: Several sub-tests may be present, in which case
12741 		 * a zero {data_size, result} tuple indicates the end of
12742 		 * the sub-test array. The first test is always run,
12743 		 * even if both data_size and result happen to be zero.
12744 		 */
12745 		if (i > 0 &&
12746 		    test->test[i].data_size == 0 &&
12747 		    test->test[i].result == 0)
12748 			break;
12749 
12750 		data = generate_test_data(test, i);
12751 		if (!data && !(test->aux & FLAG_NO_DATA)) {
12752 			pr_cont("data generation failed ");
12753 			err_cnt++;
12754 			break;
12755 		}
12756 		ret = __run_one(fp, data, runs, &duration);
12757 		release_test_data(test, data);
12758 
12759 		if (ret == test->test[i].result) {
12760 			pr_cont("%lld ", duration);
12761 		} else {
12762 			pr_cont("ret %d != %d ", ret,
12763 				test->test[i].result);
12764 			err_cnt++;
12765 		}
12766 	}
12767 
12768 	return err_cnt;
12769 }
12770 
12771 static char test_name[64];
12772 module_param_string(test_name, test_name, sizeof(test_name), 0);
12773 
12774 static int test_id = -1;
12775 module_param(test_id, int, 0);
12776 
12777 static int test_range[2] = { 0, ARRAY_SIZE(tests) - 1 };
12778 module_param_array(test_range, int, NULL, 0);
12779 
12780 static __init int find_test_index(const char *test_name)
12781 {
12782 	int i;
12783 
12784 	for (i = 0; i < ARRAY_SIZE(tests); i++) {
12785 		if (!strcmp(tests[i].descr, test_name))
12786 			return i;
12787 	}
12788 	return -1;
12789 }
12790 
12791 static __init int prepare_bpf_tests(void)
12792 {
12793 	if (test_id >= 0) {
12794 		/*
12795 		 * if a test_id was specified, use test_range to
12796 		 * cover only that test.
12797 		 */
12798 		if (test_id >= ARRAY_SIZE(tests)) {
12799 			pr_err("test_bpf: invalid test_id specified.\n");
12800 			return -EINVAL;
12801 		}
12802 
12803 		test_range[0] = test_id;
12804 		test_range[1] = test_id;
12805 	} else if (*test_name) {
12806 		/*
12807 		 * if a test_name was specified, find it and setup
12808 		 * test_range to cover only that test.
12809 		 */
12810 		int idx = find_test_index(test_name);
12811 
12812 		if (idx < 0) {
12813 			pr_err("test_bpf: no test named '%s' found.\n",
12814 			       test_name);
12815 			return -EINVAL;
12816 		}
12817 		test_range[0] = idx;
12818 		test_range[1] = idx;
12819 	} else {
12820 		/*
12821 		 * check that the supplied test_range is valid.
12822 		 */
12823 		if (test_range[0] >= ARRAY_SIZE(tests) ||
12824 		    test_range[1] >= ARRAY_SIZE(tests) ||
12825 		    test_range[0] < 0 || test_range[1] < 0) {
12826 			pr_err("test_bpf: test_range is out of bound.\n");
12827 			return -EINVAL;
12828 		}
12829 
12830 		if (test_range[1] < test_range[0]) {
12831 			pr_err("test_bpf: test_range is ending before it starts.\n");
12832 			return -EINVAL;
12833 		}
12834 	}
12835 
12836 	return 0;
12837 }
12838 
12839 static __init void destroy_bpf_tests(void)
12840 {
12841 }
12842 
12843 static bool exclude_test(int test_id)
12844 {
12845 	return test_id < test_range[0] || test_id > test_range[1];
12846 }
12847 
12848 static __init struct sk_buff *build_test_skb(void)
12849 {
12850 	u32 headroom = NET_SKB_PAD + NET_IP_ALIGN + ETH_HLEN;
12851 	struct sk_buff *skb[2];
12852 	struct page *page[2];
12853 	int i, data_size = 8;
12854 
12855 	for (i = 0; i < 2; i++) {
12856 		page[i] = alloc_page(GFP_KERNEL);
12857 		if (!page[i]) {
12858 			if (i == 0)
12859 				goto err_page0;
12860 			else
12861 				goto err_page1;
12862 		}
12863 
12864 		/* this will set skb[i]->head_frag */
12865 		skb[i] = dev_alloc_skb(headroom + data_size);
12866 		if (!skb[i]) {
12867 			if (i == 0)
12868 				goto err_skb0;
12869 			else
12870 				goto err_skb1;
12871 		}
12872 
12873 		skb_reserve(skb[i], headroom);
12874 		skb_put(skb[i], data_size);
12875 		skb[i]->protocol = htons(ETH_P_IP);
12876 		skb_reset_network_header(skb[i]);
12877 		skb_set_mac_header(skb[i], -ETH_HLEN);
12878 
12879 		skb_add_rx_frag(skb[i], 0, page[i], 0, 64, 64);
12880 		// skb_headlen(skb[i]): 8, skb[i]->head_frag = 1
12881 	}
12882 
12883 	/* setup shinfo */
12884 	skb_shinfo(skb[0])->gso_size = 1448;
12885 	skb_shinfo(skb[0])->gso_type = SKB_GSO_TCPV4;
12886 	skb_shinfo(skb[0])->gso_type |= SKB_GSO_DODGY;
12887 	skb_shinfo(skb[0])->gso_segs = 0;
12888 	skb_shinfo(skb[0])->frag_list = skb[1];
12889 	skb_shinfo(skb[0])->hwtstamps.hwtstamp = 1000;
12890 
12891 	/* adjust skb[0]'s len */
12892 	skb[0]->len += skb[1]->len;
12893 	skb[0]->data_len += skb[1]->data_len;
12894 	skb[0]->truesize += skb[1]->truesize;
12895 
12896 	return skb[0];
12897 
12898 err_skb1:
12899 	__free_page(page[1]);
12900 err_page1:
12901 	kfree_skb(skb[0]);
12902 err_skb0:
12903 	__free_page(page[0]);
12904 err_page0:
12905 	return NULL;
12906 }
12907 
12908 static __init struct sk_buff *build_test_skb_linear_no_head_frag(void)
12909 {
12910 	unsigned int alloc_size = 2000;
12911 	unsigned int headroom = 102, doffset = 72, data_size = 1308;
12912 	struct sk_buff *skb[2];
12913 	int i;
12914 
12915 	/* skbs linked in a frag_list, both with linear data, with head_frag=0
12916 	 * (data allocated by kmalloc), both have tcp data of 1308 bytes
12917 	 * (total payload is 2616 bytes).
12918 	 * Data offset is 72 bytes (40 ipv6 hdr, 32 tcp hdr). Some headroom.
12919 	 */
12920 	for (i = 0; i < 2; i++) {
12921 		skb[i] = alloc_skb(alloc_size, GFP_KERNEL);
12922 		if (!skb[i]) {
12923 			if (i == 0)
12924 				goto err_skb0;
12925 			else
12926 				goto err_skb1;
12927 		}
12928 
12929 		skb[i]->protocol = htons(ETH_P_IPV6);
12930 		skb_reserve(skb[i], headroom);
12931 		skb_put(skb[i], doffset + data_size);
12932 		skb_reset_network_header(skb[i]);
12933 		if (i == 0)
12934 			skb_reset_mac_header(skb[i]);
12935 		else
12936 			skb_set_mac_header(skb[i], -ETH_HLEN);
12937 		__skb_pull(skb[i], doffset);
12938 	}
12939 
12940 	/* setup shinfo.
12941 	 * mimic bpf_skb_proto_4_to_6, which resets gso_segs and assigns a
12942 	 * reduced gso_size.
12943 	 */
12944 	skb_shinfo(skb[0])->gso_size = 1288;
12945 	skb_shinfo(skb[0])->gso_type = SKB_GSO_TCPV6 | SKB_GSO_DODGY;
12946 	skb_shinfo(skb[0])->gso_segs = 0;
12947 	skb_shinfo(skb[0])->frag_list = skb[1];
12948 
12949 	/* adjust skb[0]'s len */
12950 	skb[0]->len += skb[1]->len;
12951 	skb[0]->data_len += skb[1]->len;
12952 	skb[0]->truesize += skb[1]->truesize;
12953 
12954 	return skb[0];
12955 
12956 err_skb1:
12957 	kfree_skb(skb[0]);
12958 err_skb0:
12959 	return NULL;
12960 }
12961 
12962 struct skb_segment_test {
12963 	const char *descr;
12964 	struct sk_buff *(*build_skb)(void);
12965 	netdev_features_t features;
12966 };
12967 
12968 static struct skb_segment_test skb_segment_tests[] __initconst = {
12969 	{
12970 		.descr = "gso_with_rx_frags",
12971 		.build_skb = build_test_skb,
12972 		.features = NETIF_F_SG | NETIF_F_GSO_PARTIAL | NETIF_F_IP_CSUM |
12973 			    NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM
12974 	},
12975 	{
12976 		.descr = "gso_linear_no_head_frag",
12977 		.build_skb = build_test_skb_linear_no_head_frag,
12978 		.features = NETIF_F_SG | NETIF_F_FRAGLIST |
12979 			    NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_GSO |
12980 			    NETIF_F_LLTX_BIT | NETIF_F_GRO |
12981 			    NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM |
12982 			    NETIF_F_HW_VLAN_STAG_TX_BIT
12983 	}
12984 };
12985 
12986 static __init int test_skb_segment_single(const struct skb_segment_test *test)
12987 {
12988 	struct sk_buff *skb, *segs;
12989 	int ret = -1;
12990 
12991 	skb = test->build_skb();
12992 	if (!skb) {
12993 		pr_info("%s: failed to build_test_skb", __func__);
12994 		goto done;
12995 	}
12996 
12997 	segs = skb_segment(skb, test->features);
12998 	if (!IS_ERR(segs)) {
12999 		kfree_skb_list(segs);
13000 		ret = 0;
13001 	}
13002 	kfree_skb(skb);
13003 done:
13004 	return ret;
13005 }
13006 
13007 static __init int test_skb_segment(void)
13008 {
13009 	int i, err_cnt = 0, pass_cnt = 0;
13010 
13011 	for (i = 0; i < ARRAY_SIZE(skb_segment_tests); i++) {
13012 		const struct skb_segment_test *test = &skb_segment_tests[i];
13013 
13014 		pr_info("#%d %s ", i, test->descr);
13015 
13016 		if (test_skb_segment_single(test)) {
13017 			pr_cont("FAIL\n");
13018 			err_cnt++;
13019 		} else {
13020 			pr_cont("PASS\n");
13021 			pass_cnt++;
13022 		}
13023 	}
13024 
13025 	pr_info("%s: Summary: %d PASSED, %d FAILED\n", __func__,
13026 		pass_cnt, err_cnt);
13027 	return err_cnt ? -EINVAL : 0;
13028 }
13029 
13030 static __init int test_bpf(void)
13031 {
13032 	int i, err_cnt = 0, pass_cnt = 0;
13033 	int jit_cnt = 0, run_cnt = 0;
13034 
13035 	for (i = 0; i < ARRAY_SIZE(tests); i++) {
13036 		struct bpf_prog *fp;
13037 		int err;
13038 
13039 		cond_resched();
13040 		if (exclude_test(i))
13041 			continue;
13042 
13043 		pr_info("#%d %s ", i, tests[i].descr);
13044 
13045 		if (tests[i].fill_helper &&
13046 		    tests[i].fill_helper(&tests[i]) < 0) {
13047 			pr_cont("FAIL to prog_fill\n");
13048 			continue;
13049 		}
13050 
13051 		fp = generate_filter(i, &err);
13052 
13053 		if (tests[i].fill_helper) {
13054 			kfree(tests[i].u.ptr.insns);
13055 			tests[i].u.ptr.insns = NULL;
13056 		}
13057 
13058 		if (fp == NULL) {
13059 			if (err == 0) {
13060 				pass_cnt++;
13061 				continue;
13062 			}
13063 			err_cnt++;
13064 			continue;
13065 		}
13066 
13067 		pr_cont("jited:%u ", fp->jited);
13068 
13069 		run_cnt++;
13070 		if (fp->jited)
13071 			jit_cnt++;
13072 
13073 		err = run_one(fp, &tests[i]);
13074 		release_filter(fp, i);
13075 
13076 		if (err) {
13077 			pr_cont("FAIL (%d times)\n", err);
13078 			err_cnt++;
13079 		} else {
13080 			pr_cont("PASS\n");
13081 			pass_cnt++;
13082 		}
13083 	}
13084 
13085 	pr_info("Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n",
13086 		pass_cnt, err_cnt, jit_cnt, run_cnt);
13087 
13088 	return err_cnt ? -EINVAL : 0;
13089 }
13090 
13091 struct tail_call_test {
13092 	const char *descr;
13093 	struct bpf_insn insns[MAX_INSNS];
13094 	int flags;
13095 	int result;
13096 	int stack_depth;
13097 };
13098 
13099 /* Flags that can be passed to tail call test cases */
13100 #define FLAG_NEED_STATE		BIT(0)
13101 #define FLAG_RESULT_IN_STATE	BIT(1)
13102 
13103 /*
13104  * Magic marker used in test snippets for tail calls below.
13105  * BPF_LD/MOV to R2 and R2 with this immediate value is replaced
13106  * with the proper values by the test runner.
13107  */
13108 #define TAIL_CALL_MARKER 0x7a11ca11
13109 
13110 /* Special offset to indicate a NULL call target */
13111 #define TAIL_CALL_NULL 0x7fff
13112 
13113 /* Special offset to indicate an out-of-range index */
13114 #define TAIL_CALL_INVALID 0x7ffe
13115 
13116 #define TAIL_CALL(offset)			       \
13117 	BPF_LD_IMM64(R2, TAIL_CALL_MARKER),	       \
13118 	BPF_RAW_INSN(BPF_ALU | BPF_MOV | BPF_K, R3, 0, \
13119 		     offset, TAIL_CALL_MARKER),	       \
13120 	BPF_JMP_IMM(BPF_TAIL_CALL, 0, 0, 0)
13121 
13122 /*
13123  * A test function to be called from a BPF program, clobbering a lot of
13124  * CPU registers in the process. A JITed BPF program calling this function
13125  * must save and restore any caller-saved registers it uses for internal
13126  * state, for example the current tail call count.
13127  */
13128 BPF_CALL_1(bpf_test_func, u64, arg)
13129 {
13130 	char buf[64];
13131 	long a = 0;
13132 	long b = 1;
13133 	long c = 2;
13134 	long d = 3;
13135 	long e = 4;
13136 	long f = 5;
13137 	long g = 6;
13138 	long h = 7;
13139 
13140 	return snprintf(buf, sizeof(buf),
13141 			"%ld %lu %lx %ld %lu %lx %ld %lu %x",
13142 			a, b, c, d, e, f, g, h, (int)arg);
13143 }
13144 #define BPF_FUNC_test_func __BPF_FUNC_MAX_ID
13145 
13146 /*
13147  * Tail call tests. Each test case may call any other test in the table,
13148  * including itself, specified as a relative index offset from the calling
13149  * test. The index TAIL_CALL_NULL can be used to specify a NULL target
13150  * function to test the JIT error path. Similarly, the index TAIL_CALL_INVALID
13151  * results in a target index that is out of range.
13152  */
13153 static struct tail_call_test tail_call_tests[] = {
13154 	{
13155 		"Tail call leaf",
13156 		.insns = {
13157 			BPF_ALU64_REG(BPF_MOV, R0, R1),
13158 			BPF_ALU64_IMM(BPF_ADD, R0, 1),
13159 			BPF_EXIT_INSN(),
13160 		},
13161 		.result = 1,
13162 	},
13163 	{
13164 		"Tail call 2",
13165 		.insns = {
13166 			BPF_ALU64_IMM(BPF_ADD, R1, 2),
13167 			TAIL_CALL(-1),
13168 			BPF_ALU64_IMM(BPF_MOV, R0, -1),
13169 			BPF_EXIT_INSN(),
13170 		},
13171 		.result = 3,
13172 	},
13173 	{
13174 		"Tail call 3",
13175 		.insns = {
13176 			BPF_ALU64_IMM(BPF_ADD, R1, 3),
13177 			TAIL_CALL(-1),
13178 			BPF_ALU64_IMM(BPF_MOV, R0, -1),
13179 			BPF_EXIT_INSN(),
13180 		},
13181 		.result = 6,
13182 	},
13183 	{
13184 		"Tail call 4",
13185 		.insns = {
13186 			BPF_ALU64_IMM(BPF_ADD, R1, 4),
13187 			TAIL_CALL(-1),
13188 			BPF_ALU64_IMM(BPF_MOV, R0, -1),
13189 			BPF_EXIT_INSN(),
13190 		},
13191 		.result = 10,
13192 	},
13193 	{
13194 		"Tail call error path, max count reached",
13195 		.insns = {
13196 			BPF_LDX_MEM(BPF_W, R2, R1, 0),
13197 			BPF_ALU64_IMM(BPF_ADD, R2, 1),
13198 			BPF_STX_MEM(BPF_W, R1, R2, 0),
13199 			TAIL_CALL(0),
13200 			BPF_EXIT_INSN(),
13201 		},
13202 		.flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE,
13203 		.result = (MAX_TAIL_CALL_CNT + 1 + 1) * MAX_TESTRUNS,
13204 	},
13205 	{
13206 		"Tail call count preserved across function calls",
13207 		.insns = {
13208 			BPF_LDX_MEM(BPF_W, R2, R1, 0),
13209 			BPF_ALU64_IMM(BPF_ADD, R2, 1),
13210 			BPF_STX_MEM(BPF_W, R1, R2, 0),
13211 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
13212 			BPF_CALL_REL(BPF_FUNC_get_numa_node_id),
13213 			BPF_CALL_REL(BPF_FUNC_ktime_get_ns),
13214 			BPF_CALL_REL(BPF_FUNC_ktime_get_boot_ns),
13215 			BPF_CALL_REL(BPF_FUNC_ktime_get_coarse_ns),
13216 			BPF_CALL_REL(BPF_FUNC_jiffies64),
13217 			BPF_CALL_REL(BPF_FUNC_test_func),
13218 			BPF_LDX_MEM(BPF_DW, R1, R10, -8),
13219 			BPF_ALU32_REG(BPF_MOV, R0, R1),
13220 			TAIL_CALL(0),
13221 			BPF_EXIT_INSN(),
13222 		},
13223 		.stack_depth = 8,
13224 		.flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE,
13225 		.result = (MAX_TAIL_CALL_CNT + 1 + 1) * MAX_TESTRUNS,
13226 	},
13227 	{
13228 		"Tail call error path, NULL target",
13229 		.insns = {
13230 			BPF_LDX_MEM(BPF_W, R2, R1, 0),
13231 			BPF_ALU64_IMM(BPF_ADD, R2, 1),
13232 			BPF_STX_MEM(BPF_W, R1, R2, 0),
13233 			TAIL_CALL(TAIL_CALL_NULL),
13234 			BPF_EXIT_INSN(),
13235 		},
13236 		.flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE,
13237 		.result = MAX_TESTRUNS,
13238 	},
13239 	{
13240 		"Tail call error path, index out of range",
13241 		.insns = {
13242 			BPF_LDX_MEM(BPF_W, R2, R1, 0),
13243 			BPF_ALU64_IMM(BPF_ADD, R2, 1),
13244 			BPF_STX_MEM(BPF_W, R1, R2, 0),
13245 			TAIL_CALL(TAIL_CALL_INVALID),
13246 			BPF_EXIT_INSN(),
13247 		},
13248 		.flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE,
13249 		.result = MAX_TESTRUNS,
13250 	},
13251 };
13252 
13253 static void __init destroy_tail_call_tests(struct bpf_array *progs)
13254 {
13255 	int i;
13256 
13257 	for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++)
13258 		if (progs->ptrs[i])
13259 			bpf_prog_free(progs->ptrs[i]);
13260 	kfree(progs);
13261 }
13262 
13263 static __init int prepare_tail_call_tests(struct bpf_array **pprogs)
13264 {
13265 	int ntests = ARRAY_SIZE(tail_call_tests);
13266 	struct bpf_array *progs;
13267 	int which, err;
13268 
13269 	/* Allocate the table of programs to be used for tall calls */
13270 	progs = kzalloc(sizeof(*progs) + (ntests + 1) * sizeof(progs->ptrs[0]),
13271 			GFP_KERNEL);
13272 	if (!progs)
13273 		goto out_nomem;
13274 
13275 	/* Create all eBPF programs and populate the table */
13276 	for (which = 0; which < ntests; which++) {
13277 		struct tail_call_test *test = &tail_call_tests[which];
13278 		struct bpf_prog *fp;
13279 		int len, i;
13280 
13281 		/* Compute the number of program instructions */
13282 		for (len = 0; len < MAX_INSNS; len++) {
13283 			struct bpf_insn *insn = &test->insns[len];
13284 
13285 			if (len < MAX_INSNS - 1 &&
13286 			    insn->code == (BPF_LD | BPF_DW | BPF_IMM))
13287 				len++;
13288 			if (insn->code == 0)
13289 				break;
13290 		}
13291 
13292 		/* Allocate and initialize the program */
13293 		fp = bpf_prog_alloc(bpf_prog_size(len), 0);
13294 		if (!fp)
13295 			goto out_nomem;
13296 
13297 		fp->len = len;
13298 		fp->type = BPF_PROG_TYPE_SOCKET_FILTER;
13299 		fp->aux->stack_depth = test->stack_depth;
13300 		memcpy(fp->insnsi, test->insns, len * sizeof(struct bpf_insn));
13301 
13302 		/* Relocate runtime tail call offsets and addresses */
13303 		for (i = 0; i < len; i++) {
13304 			struct bpf_insn *insn = &fp->insnsi[i];
13305 			long addr = 0;
13306 
13307 			switch (insn->code) {
13308 			case BPF_LD | BPF_DW | BPF_IMM:
13309 				if (insn->imm != TAIL_CALL_MARKER)
13310 					break;
13311 				insn[0].imm = (u32)(long)progs;
13312 				insn[1].imm = ((u64)(long)progs) >> 32;
13313 				break;
13314 
13315 			case BPF_ALU | BPF_MOV | BPF_K:
13316 				if (insn->imm != TAIL_CALL_MARKER)
13317 					break;
13318 				if (insn->off == TAIL_CALL_NULL)
13319 					insn->imm = ntests;
13320 				else if (insn->off == TAIL_CALL_INVALID)
13321 					insn->imm = ntests + 1;
13322 				else
13323 					insn->imm = which + insn->off;
13324 				insn->off = 0;
13325 				break;
13326 
13327 			case BPF_JMP | BPF_CALL:
13328 				if (insn->src_reg != BPF_PSEUDO_CALL)
13329 					break;
13330 				switch (insn->imm) {
13331 				case BPF_FUNC_get_numa_node_id:
13332 					addr = (long)&numa_node_id;
13333 					break;
13334 				case BPF_FUNC_ktime_get_ns:
13335 					addr = (long)&ktime_get_ns;
13336 					break;
13337 				case BPF_FUNC_ktime_get_boot_ns:
13338 					addr = (long)&ktime_get_boot_fast_ns;
13339 					break;
13340 				case BPF_FUNC_ktime_get_coarse_ns:
13341 					addr = (long)&ktime_get_coarse_ns;
13342 					break;
13343 				case BPF_FUNC_jiffies64:
13344 					addr = (long)&get_jiffies_64;
13345 					break;
13346 				case BPF_FUNC_test_func:
13347 					addr = (long)&bpf_test_func;
13348 					break;
13349 				default:
13350 					err = -EFAULT;
13351 					goto out_err;
13352 				}
13353 				*insn = BPF_EMIT_CALL(addr);
13354 				if ((long)__bpf_call_base + insn->imm != addr)
13355 					*insn = BPF_JMP_A(0); /* Skip: NOP */
13356 				break;
13357 			}
13358 		}
13359 
13360 		fp = bpf_prog_select_runtime(fp, &err);
13361 		if (err)
13362 			goto out_err;
13363 
13364 		progs->ptrs[which] = fp;
13365 	}
13366 
13367 	/* The last entry contains a NULL program pointer */
13368 	progs->map.max_entries = ntests + 1;
13369 	*pprogs = progs;
13370 	return 0;
13371 
13372 out_nomem:
13373 	err = -ENOMEM;
13374 
13375 out_err:
13376 	if (progs)
13377 		destroy_tail_call_tests(progs);
13378 	return err;
13379 }
13380 
13381 static __init int test_tail_calls(struct bpf_array *progs)
13382 {
13383 	int i, err_cnt = 0, pass_cnt = 0;
13384 	int jit_cnt = 0, run_cnt = 0;
13385 
13386 	for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++) {
13387 		struct tail_call_test *test = &tail_call_tests[i];
13388 		struct bpf_prog *fp = progs->ptrs[i];
13389 		int *data = NULL;
13390 		int state = 0;
13391 		u64 duration;
13392 		int ret;
13393 
13394 		cond_resched();
13395 
13396 		pr_info("#%d %s ", i, test->descr);
13397 		if (!fp) {
13398 			err_cnt++;
13399 			continue;
13400 		}
13401 		pr_cont("jited:%u ", fp->jited);
13402 
13403 		run_cnt++;
13404 		if (fp->jited)
13405 			jit_cnt++;
13406 
13407 		if (test->flags & FLAG_NEED_STATE)
13408 			data = &state;
13409 		ret = __run_one(fp, data, MAX_TESTRUNS, &duration);
13410 		if (test->flags & FLAG_RESULT_IN_STATE)
13411 			ret = state;
13412 		if (ret == test->result) {
13413 			pr_cont("%lld PASS", duration);
13414 			pass_cnt++;
13415 		} else {
13416 			pr_cont("ret %d != %d FAIL", ret, test->result);
13417 			err_cnt++;
13418 		}
13419 	}
13420 
13421 	pr_info("%s: Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n",
13422 		__func__, pass_cnt, err_cnt, jit_cnt, run_cnt);
13423 
13424 	return err_cnt ? -EINVAL : 0;
13425 }
13426 
13427 static int __init test_bpf_init(void)
13428 {
13429 	struct bpf_array *progs = NULL;
13430 	int ret;
13431 
13432 	ret = prepare_bpf_tests();
13433 	if (ret < 0)
13434 		return ret;
13435 
13436 	ret = test_bpf();
13437 	destroy_bpf_tests();
13438 	if (ret)
13439 		return ret;
13440 
13441 	ret = prepare_tail_call_tests(&progs);
13442 	if (ret)
13443 		return ret;
13444 	ret = test_tail_calls(progs);
13445 	destroy_tail_call_tests(progs);
13446 	if (ret)
13447 		return ret;
13448 
13449 	return test_skb_segment();
13450 }
13451 
13452 static void __exit test_bpf_exit(void)
13453 {
13454 }
13455 
13456 module_init(test_bpf_init);
13457 module_exit(test_bpf_exit);
13458 
13459 MODULE_LICENSE("GPL");
13460