xref: /openbmc/linux/lib/test_bpf.c (revision e65e175b) 
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 #define FLAG_LARGE_MEM		BIT(4)
57 
58 enum {
59 	CLASSIC  = BIT(6),	/* Old BPF instructions only. */
60 	INTERNAL = BIT(7),	/* Extended instruction set.  */
61 };
62 
63 #define TEST_TYPE_MASK		(CLASSIC | INTERNAL)
64 
65 struct bpf_test {
66 	const char *descr;
67 	union {
68 		struct sock_filter insns[MAX_INSNS];
69 		struct bpf_insn insns_int[MAX_INSNS];
70 		struct {
71 			void *insns;
72 			unsigned int len;
73 		} ptr;
74 	} u;
75 	__u8 aux;
76 	__u8 data[MAX_DATA];
77 	struct {
78 		int data_size;
79 		__u32 result;
80 	} test[MAX_SUBTESTS];
81 	int (*fill_helper)(struct bpf_test *self);
82 	int expected_errcode; /* used when FLAG_EXPECTED_FAIL is set in the aux */
83 	__u8 frag_data[MAX_DATA];
84 	int stack_depth; /* for eBPF only, since tests don't call verifier */
85 	int nr_testruns; /* Custom run count, defaults to MAX_TESTRUNS if 0 */
86 };
87 
88 /* Large test cases need separate allocation and fill handler. */
89 
90 static int bpf_fill_maxinsns1(struct bpf_test *self)
91 {
92 	unsigned int len = BPF_MAXINSNS;
93 	struct sock_filter *insn;
94 	__u32 k = ~0;
95 	int i;
96 
97 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
98 	if (!insn)
99 		return -ENOMEM;
100 
101 	for (i = 0; i < len; i++, k--)
102 		insn[i] = __BPF_STMT(BPF_RET | BPF_K, k);
103 
104 	self->u.ptr.insns = insn;
105 	self->u.ptr.len = len;
106 
107 	return 0;
108 }
109 
110 static int bpf_fill_maxinsns2(struct bpf_test *self)
111 {
112 	unsigned int len = BPF_MAXINSNS;
113 	struct sock_filter *insn;
114 	int i;
115 
116 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
117 	if (!insn)
118 		return -ENOMEM;
119 
120 	for (i = 0; i < len; i++)
121 		insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
122 
123 	self->u.ptr.insns = insn;
124 	self->u.ptr.len = len;
125 
126 	return 0;
127 }
128 
129 static int bpf_fill_maxinsns3(struct bpf_test *self)
130 {
131 	unsigned int len = BPF_MAXINSNS;
132 	struct sock_filter *insn;
133 	struct rnd_state rnd;
134 	int i;
135 
136 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
137 	if (!insn)
138 		return -ENOMEM;
139 
140 	prandom_seed_state(&rnd, 3141592653589793238ULL);
141 
142 	for (i = 0; i < len - 1; i++) {
143 		__u32 k = prandom_u32_state(&rnd);
144 
145 		insn[i] = __BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, k);
146 	}
147 
148 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
149 
150 	self->u.ptr.insns = insn;
151 	self->u.ptr.len = len;
152 
153 	return 0;
154 }
155 
156 static int bpf_fill_maxinsns4(struct bpf_test *self)
157 {
158 	unsigned int len = BPF_MAXINSNS + 1;
159 	struct sock_filter *insn;
160 	int i;
161 
162 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
163 	if (!insn)
164 		return -ENOMEM;
165 
166 	for (i = 0; i < len; i++)
167 		insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
168 
169 	self->u.ptr.insns = insn;
170 	self->u.ptr.len = len;
171 
172 	return 0;
173 }
174 
175 static int bpf_fill_maxinsns5(struct bpf_test *self)
176 {
177 	unsigned int len = BPF_MAXINSNS;
178 	struct sock_filter *insn;
179 	int i;
180 
181 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
182 	if (!insn)
183 		return -ENOMEM;
184 
185 	insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0);
186 
187 	for (i = 1; i < len - 1; i++)
188 		insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
189 
190 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab);
191 
192 	self->u.ptr.insns = insn;
193 	self->u.ptr.len = len;
194 
195 	return 0;
196 }
197 
198 static int bpf_fill_maxinsns6(struct bpf_test *self)
199 {
200 	unsigned int len = BPF_MAXINSNS;
201 	struct sock_filter *insn;
202 	int i;
203 
204 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
205 	if (!insn)
206 		return -ENOMEM;
207 
208 	for (i = 0; i < len - 1; i++)
209 		insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
210 				     SKF_AD_VLAN_TAG_PRESENT);
211 
212 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
213 
214 	self->u.ptr.insns = insn;
215 	self->u.ptr.len = len;
216 
217 	return 0;
218 }
219 
220 static int bpf_fill_maxinsns7(struct bpf_test *self)
221 {
222 	unsigned int len = BPF_MAXINSNS;
223 	struct sock_filter *insn;
224 	int i;
225 
226 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
227 	if (!insn)
228 		return -ENOMEM;
229 
230 	for (i = 0; i < len - 4; i++)
231 		insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
232 				     SKF_AD_CPU);
233 
234 	insn[len - 4] = __BPF_STMT(BPF_MISC | BPF_TAX, 0);
235 	insn[len - 3] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
236 				   SKF_AD_CPU);
237 	insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0);
238 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
239 
240 	self->u.ptr.insns = insn;
241 	self->u.ptr.len = len;
242 
243 	return 0;
244 }
245 
246 static int bpf_fill_maxinsns8(struct bpf_test *self)
247 {
248 	unsigned int len = BPF_MAXINSNS;
249 	struct sock_filter *insn;
250 	int i, jmp_off = len - 3;
251 
252 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
253 	if (!insn)
254 		return -ENOMEM;
255 
256 	insn[0] = __BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff);
257 
258 	for (i = 1; i < len - 1; i++)
259 		insn[i] = __BPF_JUMP(BPF_JMP | BPF_JGT, 0xffffffff, jmp_off--, 0);
260 
261 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
262 
263 	self->u.ptr.insns = insn;
264 	self->u.ptr.len = len;
265 
266 	return 0;
267 }
268 
269 static int bpf_fill_maxinsns9(struct bpf_test *self)
270 {
271 	unsigned int len = BPF_MAXINSNS;
272 	struct bpf_insn *insn;
273 	int i;
274 
275 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
276 	if (!insn)
277 		return -ENOMEM;
278 
279 	insn[0] = BPF_JMP_IMM(BPF_JA, 0, 0, len - 2);
280 	insn[1] = BPF_ALU32_IMM(BPF_MOV, R0, 0xcbababab);
281 	insn[2] = BPF_EXIT_INSN();
282 
283 	for (i = 3; i < len - 2; i++)
284 		insn[i] = BPF_ALU32_IMM(BPF_MOV, R0, 0xfefefefe);
285 
286 	insn[len - 2] = BPF_EXIT_INSN();
287 	insn[len - 1] = BPF_JMP_IMM(BPF_JA, 0, 0, -(len - 1));
288 
289 	self->u.ptr.insns = insn;
290 	self->u.ptr.len = len;
291 
292 	return 0;
293 }
294 
295 static int bpf_fill_maxinsns10(struct bpf_test *self)
296 {
297 	unsigned int len = BPF_MAXINSNS, hlen = len - 2;
298 	struct bpf_insn *insn;
299 	int i;
300 
301 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
302 	if (!insn)
303 		return -ENOMEM;
304 
305 	for (i = 0; i < hlen / 2; i++)
306 		insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 2 - 2 * i);
307 	for (i = hlen - 1; i > hlen / 2; i--)
308 		insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 1 - 2 * i);
309 
310 	insn[hlen / 2] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen / 2 - 1);
311 	insn[hlen]     = BPF_ALU32_IMM(BPF_MOV, R0, 0xabababac);
312 	insn[hlen + 1] = BPF_EXIT_INSN();
313 
314 	self->u.ptr.insns = insn;
315 	self->u.ptr.len = len;
316 
317 	return 0;
318 }
319 
320 static int __bpf_fill_ja(struct bpf_test *self, unsigned int len,
321 			 unsigned int plen)
322 {
323 	struct sock_filter *insn;
324 	unsigned int rlen;
325 	int i, j;
326 
327 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
328 	if (!insn)
329 		return -ENOMEM;
330 
331 	rlen = (len % plen) - 1;
332 
333 	for (i = 0; i + plen < len; i += plen)
334 		for (j = 0; j < plen; j++)
335 			insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA,
336 						 plen - 1 - j, 0, 0);
337 	for (j = 0; j < rlen; j++)
338 		insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA, rlen - 1 - j,
339 					 0, 0);
340 
341 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xababcbac);
342 
343 	self->u.ptr.insns = insn;
344 	self->u.ptr.len = len;
345 
346 	return 0;
347 }
348 
349 static int bpf_fill_maxinsns11(struct bpf_test *self)
350 {
351 	/* Hits 70 passes on x86_64 and triggers NOPs padding. */
352 	return __bpf_fill_ja(self, BPF_MAXINSNS, 68);
353 }
354 
355 static int bpf_fill_maxinsns12(struct bpf_test *self)
356 {
357 	unsigned int len = BPF_MAXINSNS;
358 	struct sock_filter *insn;
359 	int i = 0;
360 
361 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
362 	if (!insn)
363 		return -ENOMEM;
364 
365 	insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0);
366 
367 	for (i = 1; i < len - 1; i++)
368 		insn[i] = __BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0);
369 
370 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab);
371 
372 	self->u.ptr.insns = insn;
373 	self->u.ptr.len = len;
374 
375 	return 0;
376 }
377 
378 static int bpf_fill_maxinsns13(struct bpf_test *self)
379 {
380 	unsigned int len = BPF_MAXINSNS;
381 	struct sock_filter *insn;
382 	int i = 0;
383 
384 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
385 	if (!insn)
386 		return -ENOMEM;
387 
388 	for (i = 0; i < len - 3; i++)
389 		insn[i] = __BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0);
390 
391 	insn[len - 3] = __BPF_STMT(BPF_LD | BPF_IMM, 0xabababab);
392 	insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0);
393 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
394 
395 	self->u.ptr.insns = insn;
396 	self->u.ptr.len = len;
397 
398 	return 0;
399 }
400 
401 static int bpf_fill_ja(struct bpf_test *self)
402 {
403 	/* Hits exactly 11 passes on x86_64 JIT. */
404 	return __bpf_fill_ja(self, 12, 9);
405 }
406 
407 static int bpf_fill_ld_abs_get_processor_id(struct bpf_test *self)
408 {
409 	unsigned int len = BPF_MAXINSNS;
410 	struct sock_filter *insn;
411 	int i;
412 
413 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
414 	if (!insn)
415 		return -ENOMEM;
416 
417 	for (i = 0; i < len - 1; i += 2) {
418 		insn[i] = __BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 0);
419 		insn[i + 1] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
420 					 SKF_AD_OFF + SKF_AD_CPU);
421 	}
422 
423 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xbee);
424 
425 	self->u.ptr.insns = insn;
426 	self->u.ptr.len = len;
427 
428 	return 0;
429 }
430 
431 static int __bpf_fill_stxdw(struct bpf_test *self, int size)
432 {
433 	unsigned int len = BPF_MAXINSNS;
434 	struct bpf_insn *insn;
435 	int i;
436 
437 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
438 	if (!insn)
439 		return -ENOMEM;
440 
441 	insn[0] = BPF_ALU32_IMM(BPF_MOV, R0, 1);
442 	insn[1] = BPF_ST_MEM(size, R10, -40, 42);
443 
444 	for (i = 2; i < len - 2; i++)
445 		insn[i] = BPF_STX_XADD(size, R10, R0, -40);
446 
447 	insn[len - 2] = BPF_LDX_MEM(size, R0, R10, -40);
448 	insn[len - 1] = BPF_EXIT_INSN();
449 
450 	self->u.ptr.insns = insn;
451 	self->u.ptr.len = len;
452 	self->stack_depth = 40;
453 
454 	return 0;
455 }
456 
457 static int bpf_fill_stxw(struct bpf_test *self)
458 {
459 	return __bpf_fill_stxdw(self, BPF_W);
460 }
461 
462 static int bpf_fill_stxdw(struct bpf_test *self)
463 {
464 	return __bpf_fill_stxdw(self, BPF_DW);
465 }
466 
467 static int __bpf_ld_imm64(struct bpf_insn insns[2], u8 reg, s64 imm64)
468 {
469 	struct bpf_insn tmp[] = {BPF_LD_IMM64(reg, imm64)};
470 
471 	memcpy(insns, tmp, sizeof(tmp));
472 	return 2;
473 }
474 
475 /*
476  * Branch conversion tests. Complex operations can expand to a lot
477  * of instructions when JITed. This in turn may cause jump offsets
478  * to overflow the field size of the native instruction, triggering
479  * a branch conversion mechanism in some JITs.
480  */
481 static int __bpf_fill_max_jmp(struct bpf_test *self, int jmp, int imm)
482 {
483 	struct bpf_insn *insns;
484 	int len = S16_MAX + 5;
485 	int i;
486 
487 	insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL);
488 	if (!insns)
489 		return -ENOMEM;
490 
491 	i = __bpf_ld_imm64(insns, R1, 0x0123456789abcdefULL);
492 	insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
493 	insns[i++] = BPF_JMP_IMM(jmp, R0, imm, S16_MAX);
494 	insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 2);
495 	insns[i++] = BPF_EXIT_INSN();
496 
497 	while (i < len - 1) {
498 		static const int ops[] = {
499 			BPF_LSH, BPF_RSH, BPF_ARSH, BPF_ADD,
500 			BPF_SUB, BPF_MUL, BPF_DIV, BPF_MOD,
501 		};
502 		int op = ops[(i >> 1) % ARRAY_SIZE(ops)];
503 
504 		if (i & 1)
505 			insns[i++] = BPF_ALU32_REG(op, R0, R1);
506 		else
507 			insns[i++] = BPF_ALU64_REG(op, R0, R1);
508 	}
509 
510 	insns[i++] = BPF_EXIT_INSN();
511 	self->u.ptr.insns = insns;
512 	self->u.ptr.len = len;
513 	BUG_ON(i != len);
514 
515 	return 0;
516 }
517 
518 /* Branch taken by runtime decision */
519 static int bpf_fill_max_jmp_taken(struct bpf_test *self)
520 {
521 	return __bpf_fill_max_jmp(self, BPF_JEQ, 1);
522 }
523 
524 /* Branch not taken by runtime decision */
525 static int bpf_fill_max_jmp_not_taken(struct bpf_test *self)
526 {
527 	return __bpf_fill_max_jmp(self, BPF_JEQ, 0);
528 }
529 
530 /* Branch always taken, known at JIT time */
531 static int bpf_fill_max_jmp_always_taken(struct bpf_test *self)
532 {
533 	return __bpf_fill_max_jmp(self, BPF_JGE, 0);
534 }
535 
536 /* Branch never taken, known at JIT time */
537 static int bpf_fill_max_jmp_never_taken(struct bpf_test *self)
538 {
539 	return __bpf_fill_max_jmp(self, BPF_JLT, 0);
540 }
541 
542 /* ALU result computation used in tests */
543 static bool __bpf_alu_result(u64 *res, u64 v1, u64 v2, u8 op)
544 {
545 	*res = 0;
546 	switch (op) {
547 	case BPF_MOV:
548 		*res = v2;
549 		break;
550 	case BPF_AND:
551 		*res = v1 & v2;
552 		break;
553 	case BPF_OR:
554 		*res = v1 | v2;
555 		break;
556 	case BPF_XOR:
557 		*res = v1 ^ v2;
558 		break;
559 	case BPF_LSH:
560 		*res = v1 << v2;
561 		break;
562 	case BPF_RSH:
563 		*res = v1 >> v2;
564 		break;
565 	case BPF_ARSH:
566 		*res = v1 >> v2;
567 		if (v2 > 0 && v1 > S64_MAX)
568 			*res |= ~0ULL << (64 - v2);
569 		break;
570 	case BPF_ADD:
571 		*res = v1 + v2;
572 		break;
573 	case BPF_SUB:
574 		*res = v1 - v2;
575 		break;
576 	case BPF_MUL:
577 		*res = v1 * v2;
578 		break;
579 	case BPF_DIV:
580 		if (v2 == 0)
581 			return false;
582 		*res = div64_u64(v1, v2);
583 		break;
584 	case BPF_MOD:
585 		if (v2 == 0)
586 			return false;
587 		div64_u64_rem(v1, v2, res);
588 		break;
589 	}
590 	return true;
591 }
592 
593 /* Test an ALU shift operation for all valid shift values */
594 static int __bpf_fill_alu_shift(struct bpf_test *self, u8 op,
595 				u8 mode, bool alu32)
596 {
597 	static const s64 regs[] = {
598 		0x0123456789abcdefLL, /* dword > 0, word < 0 */
599 		0xfedcba9876543210LL, /* dowrd < 0, word > 0 */
600 		0xfedcba0198765432LL, /* dowrd < 0, word < 0 */
601 		0x0123458967abcdefLL, /* dword > 0, word > 0 */
602 	};
603 	int bits = alu32 ? 32 : 64;
604 	int len = (2 + 7 * bits) * ARRAY_SIZE(regs) + 3;
605 	struct bpf_insn *insn;
606 	int imm, k;
607 	int i = 0;
608 
609 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
610 	if (!insn)
611 		return -ENOMEM;
612 
613 	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
614 
615 	for (k = 0; k < ARRAY_SIZE(regs); k++) {
616 		s64 reg = regs[k];
617 
618 		i += __bpf_ld_imm64(&insn[i], R3, reg);
619 
620 		for (imm = 0; imm < bits; imm++) {
621 			u64 val;
622 
623 			/* Perform operation */
624 			insn[i++] = BPF_ALU64_REG(BPF_MOV, R1, R3);
625 			insn[i++] = BPF_ALU64_IMM(BPF_MOV, R2, imm);
626 			if (alu32) {
627 				if (mode == BPF_K)
628 					insn[i++] = BPF_ALU32_IMM(op, R1, imm);
629 				else
630 					insn[i++] = BPF_ALU32_REG(op, R1, R2);
631 
632 				if (op == BPF_ARSH)
633 					reg = (s32)reg;
634 				else
635 					reg = (u32)reg;
636 				__bpf_alu_result(&val, reg, imm, op);
637 				val = (u32)val;
638 			} else {
639 				if (mode == BPF_K)
640 					insn[i++] = BPF_ALU64_IMM(op, R1, imm);
641 				else
642 					insn[i++] = BPF_ALU64_REG(op, R1, R2);
643 				__bpf_alu_result(&val, reg, imm, op);
644 			}
645 
646 			/*
647 			 * When debugging a JIT that fails this test, one
648 			 * can write the immediate value to R0 here to find
649 			 * out which operand values that fail.
650 			 */
651 
652 			/* Load reference and check the result */
653 			i += __bpf_ld_imm64(&insn[i], R4, val);
654 			insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R4, 1);
655 			insn[i++] = BPF_EXIT_INSN();
656 		}
657 	}
658 
659 	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
660 	insn[i++] = BPF_EXIT_INSN();
661 
662 	self->u.ptr.insns = insn;
663 	self->u.ptr.len = len;
664 	BUG_ON(i != len);
665 
666 	return 0;
667 }
668 
669 static int bpf_fill_alu64_lsh_imm(struct bpf_test *self)
670 {
671 	return __bpf_fill_alu_shift(self, BPF_LSH, BPF_K, false);
672 }
673 
674 static int bpf_fill_alu64_rsh_imm(struct bpf_test *self)
675 {
676 	return __bpf_fill_alu_shift(self, BPF_RSH, BPF_K, false);
677 }
678 
679 static int bpf_fill_alu64_arsh_imm(struct bpf_test *self)
680 {
681 	return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_K, false);
682 }
683 
684 static int bpf_fill_alu64_lsh_reg(struct bpf_test *self)
685 {
686 	return __bpf_fill_alu_shift(self, BPF_LSH, BPF_X, false);
687 }
688 
689 static int bpf_fill_alu64_rsh_reg(struct bpf_test *self)
690 {
691 	return __bpf_fill_alu_shift(self, BPF_RSH, BPF_X, false);
692 }
693 
694 static int bpf_fill_alu64_arsh_reg(struct bpf_test *self)
695 {
696 	return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_X, false);
697 }
698 
699 static int bpf_fill_alu32_lsh_imm(struct bpf_test *self)
700 {
701 	return __bpf_fill_alu_shift(self, BPF_LSH, BPF_K, true);
702 }
703 
704 static int bpf_fill_alu32_rsh_imm(struct bpf_test *self)
705 {
706 	return __bpf_fill_alu_shift(self, BPF_RSH, BPF_K, true);
707 }
708 
709 static int bpf_fill_alu32_arsh_imm(struct bpf_test *self)
710 {
711 	return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_K, true);
712 }
713 
714 static int bpf_fill_alu32_lsh_reg(struct bpf_test *self)
715 {
716 	return __bpf_fill_alu_shift(self, BPF_LSH, BPF_X, true);
717 }
718 
719 static int bpf_fill_alu32_rsh_reg(struct bpf_test *self)
720 {
721 	return __bpf_fill_alu_shift(self, BPF_RSH, BPF_X, true);
722 }
723 
724 static int bpf_fill_alu32_arsh_reg(struct bpf_test *self)
725 {
726 	return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_X, true);
727 }
728 
729 /*
730  * Test an ALU register shift operation for all valid shift values
731  * for the case when the source and destination are the same.
732  */
733 static int __bpf_fill_alu_shift_same_reg(struct bpf_test *self, u8 op,
734 					 bool alu32)
735 {
736 	int bits = alu32 ? 32 : 64;
737 	int len = 3 + 6 * bits;
738 	struct bpf_insn *insn;
739 	int i = 0;
740 	u64 val;
741 
742 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
743 	if (!insn)
744 		return -ENOMEM;
745 
746 	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
747 
748 	for (val = 0; val < bits; val++) {
749 		u64 res;
750 
751 		/* Perform operation */
752 		insn[i++] = BPF_ALU64_IMM(BPF_MOV, R1, val);
753 		if (alu32)
754 			insn[i++] = BPF_ALU32_REG(op, R1, R1);
755 		else
756 			insn[i++] = BPF_ALU64_REG(op, R1, R1);
757 
758 		/* Compute the reference result */
759 		__bpf_alu_result(&res, val, val, op);
760 		if (alu32)
761 			res = (u32)res;
762 		i += __bpf_ld_imm64(&insn[i], R2, res);
763 
764 		/* Check the actual result */
765 		insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R2, 1);
766 		insn[i++] = BPF_EXIT_INSN();
767 	}
768 
769 	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
770 	insn[i++] = BPF_EXIT_INSN();
771 
772 	self->u.ptr.insns = insn;
773 	self->u.ptr.len = len;
774 	BUG_ON(i != len);
775 
776 	return 0;
777 }
778 
779 static int bpf_fill_alu64_lsh_same_reg(struct bpf_test *self)
780 {
781 	return __bpf_fill_alu_shift_same_reg(self, BPF_LSH, false);
782 }
783 
784 static int bpf_fill_alu64_rsh_same_reg(struct bpf_test *self)
785 {
786 	return __bpf_fill_alu_shift_same_reg(self, BPF_RSH, false);
787 }
788 
789 static int bpf_fill_alu64_arsh_same_reg(struct bpf_test *self)
790 {
791 	return __bpf_fill_alu_shift_same_reg(self, BPF_ARSH, false);
792 }
793 
794 static int bpf_fill_alu32_lsh_same_reg(struct bpf_test *self)
795 {
796 	return __bpf_fill_alu_shift_same_reg(self, BPF_LSH, true);
797 }
798 
799 static int bpf_fill_alu32_rsh_same_reg(struct bpf_test *self)
800 {
801 	return __bpf_fill_alu_shift_same_reg(self, BPF_RSH, true);
802 }
803 
804 static int bpf_fill_alu32_arsh_same_reg(struct bpf_test *self)
805 {
806 	return __bpf_fill_alu_shift_same_reg(self, BPF_ARSH, true);
807 }
808 
809 /*
810  * Common operand pattern generator for exhaustive power-of-two magnitudes
811  * tests. The block size parameters can be adjusted to increase/reduce the
812  * number of combinatons tested and thereby execution speed and memory
813  * footprint.
814  */
815 
816 static inline s64 value(int msb, int delta, int sign)
817 {
818 	return sign * (1LL << msb) + delta;
819 }
820 
821 static int __bpf_fill_pattern(struct bpf_test *self, void *arg,
822 			      int dbits, int sbits, int block1, int block2,
823 			      int (*emit)(struct bpf_test*, void*,
824 					  struct bpf_insn*, s64, s64))
825 {
826 	static const int sgn[][2] = {{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
827 	struct bpf_insn *insns;
828 	int di, si, bt, db, sb;
829 	int count, len, k;
830 	int extra = 1 + 2;
831 	int i = 0;
832 
833 	/* Total number of iterations for the two pattern */
834 	count = (dbits - 1) * (sbits - 1) * block1 * block1 * ARRAY_SIZE(sgn);
835 	count += (max(dbits, sbits) - 1) * block2 * block2 * ARRAY_SIZE(sgn);
836 
837 	/* Compute the maximum number of insns and allocate the buffer */
838 	len = extra + count * (*emit)(self, arg, NULL, 0, 0);
839 	insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL);
840 	if (!insns)
841 		return -ENOMEM;
842 
843 	/* Add head instruction(s) */
844 	insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
845 
846 	/*
847 	 * Pattern 1: all combinations of power-of-two magnitudes and sign,
848 	 * and with a block of contiguous values around each magnitude.
849 	 */
850 	for (di = 0; di < dbits - 1; di++)                 /* Dst magnitudes */
851 		for (si = 0; si < sbits - 1; si++)         /* Src magnitudes */
852 			for (k = 0; k < ARRAY_SIZE(sgn); k++) /* Sign combos */
853 				for (db = -(block1 / 2);
854 				     db < (block1 + 1) / 2; db++)
855 					for (sb = -(block1 / 2);
856 					     sb < (block1 + 1) / 2; sb++) {
857 						s64 dst, src;
858 
859 						dst = value(di, db, sgn[k][0]);
860 						src = value(si, sb, sgn[k][1]);
861 						i += (*emit)(self, arg,
862 							     &insns[i],
863 							     dst, src);
864 					}
865 	/*
866 	 * Pattern 2: all combinations for a larger block of values
867 	 * for each power-of-two magnitude and sign, where the magnitude is
868 	 * the same for both operands.
869 	 */
870 	for (bt = 0; bt < max(dbits, sbits) - 1; bt++)        /* Magnitude   */
871 		for (k = 0; k < ARRAY_SIZE(sgn); k++)         /* Sign combos */
872 			for (db = -(block2 / 2); db < (block2 + 1) / 2; db++)
873 				for (sb = -(block2 / 2);
874 				     sb < (block2 + 1) / 2; sb++) {
875 					s64 dst, src;
876 
877 					dst = value(bt % dbits, db, sgn[k][0]);
878 					src = value(bt % sbits, sb, sgn[k][1]);
879 					i += (*emit)(self, arg, &insns[i],
880 						     dst, src);
881 				}
882 
883 	/* Append tail instructions */
884 	insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
885 	insns[i++] = BPF_EXIT_INSN();
886 	BUG_ON(i > len);
887 
888 	self->u.ptr.insns = insns;
889 	self->u.ptr.len = i;
890 
891 	return 0;
892 }
893 
894 /*
895  * Block size parameters used in pattern tests below. une as needed to
896  * increase/reduce the number combinations tested, see following examples.
897  *        block   values per operand MSB
898  * ----------------------------------------
899  *           0     none
900  *           1     (1 << MSB)
901  *           2     (1 << MSB) + [-1, 0]
902  *           3     (1 << MSB) + [-1, 0, 1]
903  */
904 #define PATTERN_BLOCK1 1
905 #define PATTERN_BLOCK2 5
906 
907 /* Number of test runs for a pattern test */
908 #define NR_PATTERN_RUNS 1
909 
910 /*
911  * Exhaustive tests of ALU operations for all combinations of power-of-two
912  * magnitudes of the operands, both for positive and negative values. The
913  * test is designed to verify e.g. the ALU and ALU64 operations for JITs that
914  * emit different code depending on the magnitude of the immediate value.
915  */
916 static int __bpf_emit_alu64_imm(struct bpf_test *self, void *arg,
917 				struct bpf_insn *insns, s64 dst, s64 imm)
918 {
919 	int op = *(int *)arg;
920 	int i = 0;
921 	u64 res;
922 
923 	if (!insns)
924 		return 7;
925 
926 	if (__bpf_alu_result(&res, dst, (s32)imm, op)) {
927 		i += __bpf_ld_imm64(&insns[i], R1, dst);
928 		i += __bpf_ld_imm64(&insns[i], R3, res);
929 		insns[i++] = BPF_ALU64_IMM(op, R1, imm);
930 		insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
931 		insns[i++] = BPF_EXIT_INSN();
932 	}
933 
934 	return i;
935 }
936 
937 static int __bpf_emit_alu32_imm(struct bpf_test *self, void *arg,
938 				struct bpf_insn *insns, s64 dst, s64 imm)
939 {
940 	int op = *(int *)arg;
941 	int i = 0;
942 	u64 res;
943 
944 	if (!insns)
945 		return 7;
946 
947 	if (__bpf_alu_result(&res, (u32)dst, (u32)imm, op)) {
948 		i += __bpf_ld_imm64(&insns[i], R1, dst);
949 		i += __bpf_ld_imm64(&insns[i], R3, (u32)res);
950 		insns[i++] = BPF_ALU32_IMM(op, R1, imm);
951 		insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
952 		insns[i++] = BPF_EXIT_INSN();
953 	}
954 
955 	return i;
956 }
957 
958 static int __bpf_emit_alu64_reg(struct bpf_test *self, void *arg,
959 				struct bpf_insn *insns, s64 dst, s64 src)
960 {
961 	int op = *(int *)arg;
962 	int i = 0;
963 	u64 res;
964 
965 	if (!insns)
966 		return 9;
967 
968 	if (__bpf_alu_result(&res, dst, src, op)) {
969 		i += __bpf_ld_imm64(&insns[i], R1, dst);
970 		i += __bpf_ld_imm64(&insns[i], R2, src);
971 		i += __bpf_ld_imm64(&insns[i], R3, res);
972 		insns[i++] = BPF_ALU64_REG(op, R1, R2);
973 		insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
974 		insns[i++] = BPF_EXIT_INSN();
975 	}
976 
977 	return i;
978 }
979 
980 static int __bpf_emit_alu32_reg(struct bpf_test *self, void *arg,
981 				struct bpf_insn *insns, s64 dst, s64 src)
982 {
983 	int op = *(int *)arg;
984 	int i = 0;
985 	u64 res;
986 
987 	if (!insns)
988 		return 9;
989 
990 	if (__bpf_alu_result(&res, (u32)dst, (u32)src, op)) {
991 		i += __bpf_ld_imm64(&insns[i], R1, dst);
992 		i += __bpf_ld_imm64(&insns[i], R2, src);
993 		i += __bpf_ld_imm64(&insns[i], R3, (u32)res);
994 		insns[i++] = BPF_ALU32_REG(op, R1, R2);
995 		insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
996 		insns[i++] = BPF_EXIT_INSN();
997 	}
998 
999 	return i;
1000 }
1001 
1002 static int __bpf_fill_alu64_imm(struct bpf_test *self, int op)
1003 {
1004 	return __bpf_fill_pattern(self, &op, 64, 32,
1005 				  PATTERN_BLOCK1, PATTERN_BLOCK2,
1006 				  &__bpf_emit_alu64_imm);
1007 }
1008 
1009 static int __bpf_fill_alu32_imm(struct bpf_test *self, int op)
1010 {
1011 	return __bpf_fill_pattern(self, &op, 64, 32,
1012 				  PATTERN_BLOCK1, PATTERN_BLOCK2,
1013 				  &__bpf_emit_alu32_imm);
1014 }
1015 
1016 static int __bpf_fill_alu64_reg(struct bpf_test *self, int op)
1017 {
1018 	return __bpf_fill_pattern(self, &op, 64, 64,
1019 				  PATTERN_BLOCK1, PATTERN_BLOCK2,
1020 				  &__bpf_emit_alu64_reg);
1021 }
1022 
1023 static int __bpf_fill_alu32_reg(struct bpf_test *self, int op)
1024 {
1025 	return __bpf_fill_pattern(self, &op, 64, 64,
1026 				  PATTERN_BLOCK1, PATTERN_BLOCK2,
1027 				  &__bpf_emit_alu32_reg);
1028 }
1029 
1030 /* ALU64 immediate operations */
1031 static int bpf_fill_alu64_mov_imm(struct bpf_test *self)
1032 {
1033 	return __bpf_fill_alu64_imm(self, BPF_MOV);
1034 }
1035 
1036 static int bpf_fill_alu64_and_imm(struct bpf_test *self)
1037 {
1038 	return __bpf_fill_alu64_imm(self, BPF_AND);
1039 }
1040 
1041 static int bpf_fill_alu64_or_imm(struct bpf_test *self)
1042 {
1043 	return __bpf_fill_alu64_imm(self, BPF_OR);
1044 }
1045 
1046 static int bpf_fill_alu64_xor_imm(struct bpf_test *self)
1047 {
1048 	return __bpf_fill_alu64_imm(self, BPF_XOR);
1049 }
1050 
1051 static int bpf_fill_alu64_add_imm(struct bpf_test *self)
1052 {
1053 	return __bpf_fill_alu64_imm(self, BPF_ADD);
1054 }
1055 
1056 static int bpf_fill_alu64_sub_imm(struct bpf_test *self)
1057 {
1058 	return __bpf_fill_alu64_imm(self, BPF_SUB);
1059 }
1060 
1061 static int bpf_fill_alu64_mul_imm(struct bpf_test *self)
1062 {
1063 	return __bpf_fill_alu64_imm(self, BPF_MUL);
1064 }
1065 
1066 static int bpf_fill_alu64_div_imm(struct bpf_test *self)
1067 {
1068 	return __bpf_fill_alu64_imm(self, BPF_DIV);
1069 }
1070 
1071 static int bpf_fill_alu64_mod_imm(struct bpf_test *self)
1072 {
1073 	return __bpf_fill_alu64_imm(self, BPF_MOD);
1074 }
1075 
1076 /* ALU32 immediate operations */
1077 static int bpf_fill_alu32_mov_imm(struct bpf_test *self)
1078 {
1079 	return __bpf_fill_alu32_imm(self, BPF_MOV);
1080 }
1081 
1082 static int bpf_fill_alu32_and_imm(struct bpf_test *self)
1083 {
1084 	return __bpf_fill_alu32_imm(self, BPF_AND);
1085 }
1086 
1087 static int bpf_fill_alu32_or_imm(struct bpf_test *self)
1088 {
1089 	return __bpf_fill_alu32_imm(self, BPF_OR);
1090 }
1091 
1092 static int bpf_fill_alu32_xor_imm(struct bpf_test *self)
1093 {
1094 	return __bpf_fill_alu32_imm(self, BPF_XOR);
1095 }
1096 
1097 static int bpf_fill_alu32_add_imm(struct bpf_test *self)
1098 {
1099 	return __bpf_fill_alu32_imm(self, BPF_ADD);
1100 }
1101 
1102 static int bpf_fill_alu32_sub_imm(struct bpf_test *self)
1103 {
1104 	return __bpf_fill_alu32_imm(self, BPF_SUB);
1105 }
1106 
1107 static int bpf_fill_alu32_mul_imm(struct bpf_test *self)
1108 {
1109 	return __bpf_fill_alu32_imm(self, BPF_MUL);
1110 }
1111 
1112 static int bpf_fill_alu32_div_imm(struct bpf_test *self)
1113 {
1114 	return __bpf_fill_alu32_imm(self, BPF_DIV);
1115 }
1116 
1117 static int bpf_fill_alu32_mod_imm(struct bpf_test *self)
1118 {
1119 	return __bpf_fill_alu32_imm(self, BPF_MOD);
1120 }
1121 
1122 /* ALU64 register operations */
1123 static int bpf_fill_alu64_mov_reg(struct bpf_test *self)
1124 {
1125 	return __bpf_fill_alu64_reg(self, BPF_MOV);
1126 }
1127 
1128 static int bpf_fill_alu64_and_reg(struct bpf_test *self)
1129 {
1130 	return __bpf_fill_alu64_reg(self, BPF_AND);
1131 }
1132 
1133 static int bpf_fill_alu64_or_reg(struct bpf_test *self)
1134 {
1135 	return __bpf_fill_alu64_reg(self, BPF_OR);
1136 }
1137 
1138 static int bpf_fill_alu64_xor_reg(struct bpf_test *self)
1139 {
1140 	return __bpf_fill_alu64_reg(self, BPF_XOR);
1141 }
1142 
1143 static int bpf_fill_alu64_add_reg(struct bpf_test *self)
1144 {
1145 	return __bpf_fill_alu64_reg(self, BPF_ADD);
1146 }
1147 
1148 static int bpf_fill_alu64_sub_reg(struct bpf_test *self)
1149 {
1150 	return __bpf_fill_alu64_reg(self, BPF_SUB);
1151 }
1152 
1153 static int bpf_fill_alu64_mul_reg(struct bpf_test *self)
1154 {
1155 	return __bpf_fill_alu64_reg(self, BPF_MUL);
1156 }
1157 
1158 static int bpf_fill_alu64_div_reg(struct bpf_test *self)
1159 {
1160 	return __bpf_fill_alu64_reg(self, BPF_DIV);
1161 }
1162 
1163 static int bpf_fill_alu64_mod_reg(struct bpf_test *self)
1164 {
1165 	return __bpf_fill_alu64_reg(self, BPF_MOD);
1166 }
1167 
1168 /* ALU32 register operations */
1169 static int bpf_fill_alu32_mov_reg(struct bpf_test *self)
1170 {
1171 	return __bpf_fill_alu32_reg(self, BPF_MOV);
1172 }
1173 
1174 static int bpf_fill_alu32_and_reg(struct bpf_test *self)
1175 {
1176 	return __bpf_fill_alu32_reg(self, BPF_AND);
1177 }
1178 
1179 static int bpf_fill_alu32_or_reg(struct bpf_test *self)
1180 {
1181 	return __bpf_fill_alu32_reg(self, BPF_OR);
1182 }
1183 
1184 static int bpf_fill_alu32_xor_reg(struct bpf_test *self)
1185 {
1186 	return __bpf_fill_alu32_reg(self, BPF_XOR);
1187 }
1188 
1189 static int bpf_fill_alu32_add_reg(struct bpf_test *self)
1190 {
1191 	return __bpf_fill_alu32_reg(self, BPF_ADD);
1192 }
1193 
1194 static int bpf_fill_alu32_sub_reg(struct bpf_test *self)
1195 {
1196 	return __bpf_fill_alu32_reg(self, BPF_SUB);
1197 }
1198 
1199 static int bpf_fill_alu32_mul_reg(struct bpf_test *self)
1200 {
1201 	return __bpf_fill_alu32_reg(self, BPF_MUL);
1202 }
1203 
1204 static int bpf_fill_alu32_div_reg(struct bpf_test *self)
1205 {
1206 	return __bpf_fill_alu32_reg(self, BPF_DIV);
1207 }
1208 
1209 static int bpf_fill_alu32_mod_reg(struct bpf_test *self)
1210 {
1211 	return __bpf_fill_alu32_reg(self, BPF_MOD);
1212 }
1213 
1214 /*
1215  * Test JITs that implement complex ALU operations as function
1216  * calls, and must re-arrange operands for argument passing.
1217  */
1218 static int __bpf_fill_alu_imm_regs(struct bpf_test *self, u8 op, bool alu32)
1219 {
1220 	int len = 2 + 10 * 10;
1221 	struct bpf_insn *insns;
1222 	u64 dst, res;
1223 	int i = 0;
1224 	u32 imm;
1225 	int rd;
1226 
1227 	insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL);
1228 	if (!insns)
1229 		return -ENOMEM;
1230 
1231 	/* Operand and result values according to operation */
1232 	if (alu32)
1233 		dst = 0x76543210U;
1234 	else
1235 		dst = 0x7edcba9876543210ULL;
1236 	imm = 0x01234567U;
1237 
1238 	if (op == BPF_LSH || op == BPF_RSH || op == BPF_ARSH)
1239 		imm &= 31;
1240 
1241 	__bpf_alu_result(&res, dst, imm, op);
1242 
1243 	if (alu32)
1244 		res = (u32)res;
1245 
1246 	/* Check all operand registers */
1247 	for (rd = R0; rd <= R9; rd++) {
1248 		i += __bpf_ld_imm64(&insns[i], rd, dst);
1249 
1250 		if (alu32)
1251 			insns[i++] = BPF_ALU32_IMM(op, rd, imm);
1252 		else
1253 			insns[i++] = BPF_ALU64_IMM(op, rd, imm);
1254 
1255 		insns[i++] = BPF_JMP32_IMM(BPF_JEQ, rd, res, 2);
1256 		insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1257 		insns[i++] = BPF_EXIT_INSN();
1258 
1259 		insns[i++] = BPF_ALU64_IMM(BPF_RSH, rd, 32);
1260 		insns[i++] = BPF_JMP32_IMM(BPF_JEQ, rd, res >> 32, 2);
1261 		insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1262 		insns[i++] = BPF_EXIT_INSN();
1263 	}
1264 
1265 	insns[i++] = BPF_MOV64_IMM(R0, 1);
1266 	insns[i++] = BPF_EXIT_INSN();
1267 
1268 	self->u.ptr.insns = insns;
1269 	self->u.ptr.len = len;
1270 	BUG_ON(i != len);
1271 
1272 	return 0;
1273 }
1274 
1275 /* ALU64 K registers */
1276 static int bpf_fill_alu64_mov_imm_regs(struct bpf_test *self)
1277 {
1278 	return __bpf_fill_alu_imm_regs(self, BPF_MOV, false);
1279 }
1280 
1281 static int bpf_fill_alu64_and_imm_regs(struct bpf_test *self)
1282 {
1283 	return __bpf_fill_alu_imm_regs(self, BPF_AND, false);
1284 }
1285 
1286 static int bpf_fill_alu64_or_imm_regs(struct bpf_test *self)
1287 {
1288 	return __bpf_fill_alu_imm_regs(self, BPF_OR, false);
1289 }
1290 
1291 static int bpf_fill_alu64_xor_imm_regs(struct bpf_test *self)
1292 {
1293 	return __bpf_fill_alu_imm_regs(self, BPF_XOR, false);
1294 }
1295 
1296 static int bpf_fill_alu64_lsh_imm_regs(struct bpf_test *self)
1297 {
1298 	return __bpf_fill_alu_imm_regs(self, BPF_LSH, false);
1299 }
1300 
1301 static int bpf_fill_alu64_rsh_imm_regs(struct bpf_test *self)
1302 {
1303 	return __bpf_fill_alu_imm_regs(self, BPF_RSH, false);
1304 }
1305 
1306 static int bpf_fill_alu64_arsh_imm_regs(struct bpf_test *self)
1307 {
1308 	return __bpf_fill_alu_imm_regs(self, BPF_ARSH, false);
1309 }
1310 
1311 static int bpf_fill_alu64_add_imm_regs(struct bpf_test *self)
1312 {
1313 	return __bpf_fill_alu_imm_regs(self, BPF_ADD, false);
1314 }
1315 
1316 static int bpf_fill_alu64_sub_imm_regs(struct bpf_test *self)
1317 {
1318 	return __bpf_fill_alu_imm_regs(self, BPF_SUB, false);
1319 }
1320 
1321 static int bpf_fill_alu64_mul_imm_regs(struct bpf_test *self)
1322 {
1323 	return __bpf_fill_alu_imm_regs(self, BPF_MUL, false);
1324 }
1325 
1326 static int bpf_fill_alu64_div_imm_regs(struct bpf_test *self)
1327 {
1328 	return __bpf_fill_alu_imm_regs(self, BPF_DIV, false);
1329 }
1330 
1331 static int bpf_fill_alu64_mod_imm_regs(struct bpf_test *self)
1332 {
1333 	return __bpf_fill_alu_imm_regs(self, BPF_MOD, false);
1334 }
1335 
1336 /* ALU32 K registers */
1337 static int bpf_fill_alu32_mov_imm_regs(struct bpf_test *self)
1338 {
1339 	return __bpf_fill_alu_imm_regs(self, BPF_MOV, true);
1340 }
1341 
1342 static int bpf_fill_alu32_and_imm_regs(struct bpf_test *self)
1343 {
1344 	return __bpf_fill_alu_imm_regs(self, BPF_AND, true);
1345 }
1346 
1347 static int bpf_fill_alu32_or_imm_regs(struct bpf_test *self)
1348 {
1349 	return __bpf_fill_alu_imm_regs(self, BPF_OR, true);
1350 }
1351 
1352 static int bpf_fill_alu32_xor_imm_regs(struct bpf_test *self)
1353 {
1354 	return __bpf_fill_alu_imm_regs(self, BPF_XOR, true);
1355 }
1356 
1357 static int bpf_fill_alu32_lsh_imm_regs(struct bpf_test *self)
1358 {
1359 	return __bpf_fill_alu_imm_regs(self, BPF_LSH, true);
1360 }
1361 
1362 static int bpf_fill_alu32_rsh_imm_regs(struct bpf_test *self)
1363 {
1364 	return __bpf_fill_alu_imm_regs(self, BPF_RSH, true);
1365 }
1366 
1367 static int bpf_fill_alu32_arsh_imm_regs(struct bpf_test *self)
1368 {
1369 	return __bpf_fill_alu_imm_regs(self, BPF_ARSH, true);
1370 }
1371 
1372 static int bpf_fill_alu32_add_imm_regs(struct bpf_test *self)
1373 {
1374 	return __bpf_fill_alu_imm_regs(self, BPF_ADD, true);
1375 }
1376 
1377 static int bpf_fill_alu32_sub_imm_regs(struct bpf_test *self)
1378 {
1379 	return __bpf_fill_alu_imm_regs(self, BPF_SUB, true);
1380 }
1381 
1382 static int bpf_fill_alu32_mul_imm_regs(struct bpf_test *self)
1383 {
1384 	return __bpf_fill_alu_imm_regs(self, BPF_MUL, true);
1385 }
1386 
1387 static int bpf_fill_alu32_div_imm_regs(struct bpf_test *self)
1388 {
1389 	return __bpf_fill_alu_imm_regs(self, BPF_DIV, true);
1390 }
1391 
1392 static int bpf_fill_alu32_mod_imm_regs(struct bpf_test *self)
1393 {
1394 	return __bpf_fill_alu_imm_regs(self, BPF_MOD, true);
1395 }
1396 
1397 /*
1398  * Test JITs that implement complex ALU operations as function
1399  * calls, and must re-arrange operands for argument passing.
1400  */
1401 static int __bpf_fill_alu_reg_pairs(struct bpf_test *self, u8 op, bool alu32)
1402 {
1403 	int len = 2 + 10 * 10 * 12;
1404 	u64 dst, src, res, same;
1405 	struct bpf_insn *insns;
1406 	int rd, rs;
1407 	int i = 0;
1408 
1409 	insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL);
1410 	if (!insns)
1411 		return -ENOMEM;
1412 
1413 	/* Operand and result values according to operation */
1414 	if (alu32) {
1415 		dst = 0x76543210U;
1416 		src = 0x01234567U;
1417 	} else {
1418 		dst = 0x7edcba9876543210ULL;
1419 		src = 0x0123456789abcdefULL;
1420 	}
1421 
1422 	if (op == BPF_LSH || op == BPF_RSH || op == BPF_ARSH)
1423 		src &= 31;
1424 
1425 	__bpf_alu_result(&res, dst, src, op);
1426 	__bpf_alu_result(&same, src, src, op);
1427 
1428 	if (alu32) {
1429 		res = (u32)res;
1430 		same = (u32)same;
1431 	}
1432 
1433 	/* Check all combinations of operand registers */
1434 	for (rd = R0; rd <= R9; rd++) {
1435 		for (rs = R0; rs <= R9; rs++) {
1436 			u64 val = rd == rs ? same : res;
1437 
1438 			i += __bpf_ld_imm64(&insns[i], rd, dst);
1439 			i += __bpf_ld_imm64(&insns[i], rs, src);
1440 
1441 			if (alu32)
1442 				insns[i++] = BPF_ALU32_REG(op, rd, rs);
1443 			else
1444 				insns[i++] = BPF_ALU64_REG(op, rd, rs);
1445 
1446 			insns[i++] = BPF_JMP32_IMM(BPF_JEQ, rd, val, 2);
1447 			insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1448 			insns[i++] = BPF_EXIT_INSN();
1449 
1450 			insns[i++] = BPF_ALU64_IMM(BPF_RSH, rd, 32);
1451 			insns[i++] = BPF_JMP32_IMM(BPF_JEQ, rd, val >> 32, 2);
1452 			insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1453 			insns[i++] = BPF_EXIT_INSN();
1454 		}
1455 	}
1456 
1457 	insns[i++] = BPF_MOV64_IMM(R0, 1);
1458 	insns[i++] = BPF_EXIT_INSN();
1459 
1460 	self->u.ptr.insns = insns;
1461 	self->u.ptr.len = len;
1462 	BUG_ON(i != len);
1463 
1464 	return 0;
1465 }
1466 
1467 /* ALU64 X register combinations */
1468 static int bpf_fill_alu64_mov_reg_pairs(struct bpf_test *self)
1469 {
1470 	return __bpf_fill_alu_reg_pairs(self, BPF_MOV, false);
1471 }
1472 
1473 static int bpf_fill_alu64_and_reg_pairs(struct bpf_test *self)
1474 {
1475 	return __bpf_fill_alu_reg_pairs(self, BPF_AND, false);
1476 }
1477 
1478 static int bpf_fill_alu64_or_reg_pairs(struct bpf_test *self)
1479 {
1480 	return __bpf_fill_alu_reg_pairs(self, BPF_OR, false);
1481 }
1482 
1483 static int bpf_fill_alu64_xor_reg_pairs(struct bpf_test *self)
1484 {
1485 	return __bpf_fill_alu_reg_pairs(self, BPF_XOR, false);
1486 }
1487 
1488 static int bpf_fill_alu64_lsh_reg_pairs(struct bpf_test *self)
1489 {
1490 	return __bpf_fill_alu_reg_pairs(self, BPF_LSH, false);
1491 }
1492 
1493 static int bpf_fill_alu64_rsh_reg_pairs(struct bpf_test *self)
1494 {
1495 	return __bpf_fill_alu_reg_pairs(self, BPF_RSH, false);
1496 }
1497 
1498 static int bpf_fill_alu64_arsh_reg_pairs(struct bpf_test *self)
1499 {
1500 	return __bpf_fill_alu_reg_pairs(self, BPF_ARSH, false);
1501 }
1502 
1503 static int bpf_fill_alu64_add_reg_pairs(struct bpf_test *self)
1504 {
1505 	return __bpf_fill_alu_reg_pairs(self, BPF_ADD, false);
1506 }
1507 
1508 static int bpf_fill_alu64_sub_reg_pairs(struct bpf_test *self)
1509 {
1510 	return __bpf_fill_alu_reg_pairs(self, BPF_SUB, false);
1511 }
1512 
1513 static int bpf_fill_alu64_mul_reg_pairs(struct bpf_test *self)
1514 {
1515 	return __bpf_fill_alu_reg_pairs(self, BPF_MUL, false);
1516 }
1517 
1518 static int bpf_fill_alu64_div_reg_pairs(struct bpf_test *self)
1519 {
1520 	return __bpf_fill_alu_reg_pairs(self, BPF_DIV, false);
1521 }
1522 
1523 static int bpf_fill_alu64_mod_reg_pairs(struct bpf_test *self)
1524 {
1525 	return __bpf_fill_alu_reg_pairs(self, BPF_MOD, false);
1526 }
1527 
1528 /* ALU32 X register combinations */
1529 static int bpf_fill_alu32_mov_reg_pairs(struct bpf_test *self)
1530 {
1531 	return __bpf_fill_alu_reg_pairs(self, BPF_MOV, true);
1532 }
1533 
1534 static int bpf_fill_alu32_and_reg_pairs(struct bpf_test *self)
1535 {
1536 	return __bpf_fill_alu_reg_pairs(self, BPF_AND, true);
1537 }
1538 
1539 static int bpf_fill_alu32_or_reg_pairs(struct bpf_test *self)
1540 {
1541 	return __bpf_fill_alu_reg_pairs(self, BPF_OR, true);
1542 }
1543 
1544 static int bpf_fill_alu32_xor_reg_pairs(struct bpf_test *self)
1545 {
1546 	return __bpf_fill_alu_reg_pairs(self, BPF_XOR, true);
1547 }
1548 
1549 static int bpf_fill_alu32_lsh_reg_pairs(struct bpf_test *self)
1550 {
1551 	return __bpf_fill_alu_reg_pairs(self, BPF_LSH, true);
1552 }
1553 
1554 static int bpf_fill_alu32_rsh_reg_pairs(struct bpf_test *self)
1555 {
1556 	return __bpf_fill_alu_reg_pairs(self, BPF_RSH, true);
1557 }
1558 
1559 static int bpf_fill_alu32_arsh_reg_pairs(struct bpf_test *self)
1560 {
1561 	return __bpf_fill_alu_reg_pairs(self, BPF_ARSH, true);
1562 }
1563 
1564 static int bpf_fill_alu32_add_reg_pairs(struct bpf_test *self)
1565 {
1566 	return __bpf_fill_alu_reg_pairs(self, BPF_ADD, true);
1567 }
1568 
1569 static int bpf_fill_alu32_sub_reg_pairs(struct bpf_test *self)
1570 {
1571 	return __bpf_fill_alu_reg_pairs(self, BPF_SUB, true);
1572 }
1573 
1574 static int bpf_fill_alu32_mul_reg_pairs(struct bpf_test *self)
1575 {
1576 	return __bpf_fill_alu_reg_pairs(self, BPF_MUL, true);
1577 }
1578 
1579 static int bpf_fill_alu32_div_reg_pairs(struct bpf_test *self)
1580 {
1581 	return __bpf_fill_alu_reg_pairs(self, BPF_DIV, true);
1582 }
1583 
1584 static int bpf_fill_alu32_mod_reg_pairs(struct bpf_test *self)
1585 {
1586 	return __bpf_fill_alu_reg_pairs(self, BPF_MOD, true);
1587 }
1588 
1589 /*
1590  * Exhaustive tests of atomic operations for all power-of-two operand
1591  * magnitudes, both for positive and negative values.
1592  */
1593 
1594 static int __bpf_emit_atomic64(struct bpf_test *self, void *arg,
1595 			       struct bpf_insn *insns, s64 dst, s64 src)
1596 {
1597 	int op = *(int *)arg;
1598 	u64 keep, fetch, res;
1599 	int i = 0;
1600 
1601 	if (!insns)
1602 		return 21;
1603 
1604 	switch (op) {
1605 	case BPF_XCHG:
1606 		res = src;
1607 		break;
1608 	default:
1609 		__bpf_alu_result(&res, dst, src, BPF_OP(op));
1610 	}
1611 
1612 	keep = 0x0123456789abcdefULL;
1613 	if (op & BPF_FETCH)
1614 		fetch = dst;
1615 	else
1616 		fetch = src;
1617 
1618 	i += __bpf_ld_imm64(&insns[i], R0, keep);
1619 	i += __bpf_ld_imm64(&insns[i], R1, dst);
1620 	i += __bpf_ld_imm64(&insns[i], R2, src);
1621 	i += __bpf_ld_imm64(&insns[i], R3, res);
1622 	i += __bpf_ld_imm64(&insns[i], R4, fetch);
1623 	i += __bpf_ld_imm64(&insns[i], R5, keep);
1624 
1625 	insns[i++] = BPF_STX_MEM(BPF_DW, R10, R1, -8);
1626 	insns[i++] = BPF_ATOMIC_OP(BPF_DW, op, R10, R2, -8);
1627 	insns[i++] = BPF_LDX_MEM(BPF_DW, R1, R10, -8);
1628 
1629 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
1630 	insns[i++] = BPF_EXIT_INSN();
1631 
1632 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R2, R4, 1);
1633 	insns[i++] = BPF_EXIT_INSN();
1634 
1635 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R5, 1);
1636 	insns[i++] = BPF_EXIT_INSN();
1637 
1638 	return i;
1639 }
1640 
1641 static int __bpf_emit_atomic32(struct bpf_test *self, void *arg,
1642 			       struct bpf_insn *insns, s64 dst, s64 src)
1643 {
1644 	int op = *(int *)arg;
1645 	u64 keep, fetch, res;
1646 	int i = 0;
1647 
1648 	if (!insns)
1649 		return 21;
1650 
1651 	switch (op) {
1652 	case BPF_XCHG:
1653 		res = src;
1654 		break;
1655 	default:
1656 		__bpf_alu_result(&res, (u32)dst, (u32)src, BPF_OP(op));
1657 	}
1658 
1659 	keep = 0x0123456789abcdefULL;
1660 	if (op & BPF_FETCH)
1661 		fetch = (u32)dst;
1662 	else
1663 		fetch = src;
1664 
1665 	i += __bpf_ld_imm64(&insns[i], R0, keep);
1666 	i += __bpf_ld_imm64(&insns[i], R1, (u32)dst);
1667 	i += __bpf_ld_imm64(&insns[i], R2, src);
1668 	i += __bpf_ld_imm64(&insns[i], R3, (u32)res);
1669 	i += __bpf_ld_imm64(&insns[i], R4, fetch);
1670 	i += __bpf_ld_imm64(&insns[i], R5, keep);
1671 
1672 	insns[i++] = BPF_STX_MEM(BPF_W, R10, R1, -4);
1673 	insns[i++] = BPF_ATOMIC_OP(BPF_W, op, R10, R2, -4);
1674 	insns[i++] = BPF_LDX_MEM(BPF_W, R1, R10, -4);
1675 
1676 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
1677 	insns[i++] = BPF_EXIT_INSN();
1678 
1679 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R2, R4, 1);
1680 	insns[i++] = BPF_EXIT_INSN();
1681 
1682 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R5, 1);
1683 	insns[i++] = BPF_EXIT_INSN();
1684 
1685 	return i;
1686 }
1687 
1688 static int __bpf_emit_cmpxchg64(struct bpf_test *self, void *arg,
1689 				struct bpf_insn *insns, s64 dst, s64 src)
1690 {
1691 	int i = 0;
1692 
1693 	if (!insns)
1694 		return 23;
1695 
1696 	i += __bpf_ld_imm64(&insns[i], R0, ~dst);
1697 	i += __bpf_ld_imm64(&insns[i], R1, dst);
1698 	i += __bpf_ld_imm64(&insns[i], R2, src);
1699 
1700 	/* Result unsuccessful */
1701 	insns[i++] = BPF_STX_MEM(BPF_DW, R10, R1, -8);
1702 	insns[i++] = BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -8);
1703 	insns[i++] = BPF_LDX_MEM(BPF_DW, R3, R10, -8);
1704 
1705 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 2);
1706 	insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1707 	insns[i++] = BPF_EXIT_INSN();
1708 
1709 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R3, 2);
1710 	insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1711 	insns[i++] = BPF_EXIT_INSN();
1712 
1713 	/* Result successful */
1714 	insns[i++] = BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -8);
1715 	insns[i++] = BPF_LDX_MEM(BPF_DW, R3, R10, -8);
1716 
1717 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R2, R3, 2);
1718 	insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1719 	insns[i++] = BPF_EXIT_INSN();
1720 
1721 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R1, 2);
1722 	insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1723 	insns[i++] = BPF_EXIT_INSN();
1724 
1725 	return i;
1726 }
1727 
1728 static int __bpf_emit_cmpxchg32(struct bpf_test *self, void *arg,
1729 				struct bpf_insn *insns, s64 dst, s64 src)
1730 {
1731 	int i = 0;
1732 
1733 	if (!insns)
1734 		return 27;
1735 
1736 	i += __bpf_ld_imm64(&insns[i], R0, ~dst);
1737 	i += __bpf_ld_imm64(&insns[i], R1, (u32)dst);
1738 	i += __bpf_ld_imm64(&insns[i], R2, src);
1739 
1740 	/* Result unsuccessful */
1741 	insns[i++] = BPF_STX_MEM(BPF_W, R10, R1, -4);
1742 	insns[i++] = BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R2, -4);
1743 	insns[i++] = BPF_ZEXT_REG(R0), /* Zext always inserted by verifier */
1744 	insns[i++] = BPF_LDX_MEM(BPF_W, R3, R10, -4);
1745 
1746 	insns[i++] = BPF_JMP32_REG(BPF_JEQ, R1, R3, 2);
1747 	insns[i++] = BPF_MOV32_IMM(R0, __LINE__);
1748 	insns[i++] = BPF_EXIT_INSN();
1749 
1750 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R3, 2);
1751 	insns[i++] = BPF_MOV32_IMM(R0, __LINE__);
1752 	insns[i++] = BPF_EXIT_INSN();
1753 
1754 	/* Result successful */
1755 	i += __bpf_ld_imm64(&insns[i], R0, dst);
1756 	insns[i++] = BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R2, -4);
1757 	insns[i++] = BPF_ZEXT_REG(R0), /* Zext always inserted by verifier */
1758 	insns[i++] = BPF_LDX_MEM(BPF_W, R3, R10, -4);
1759 
1760 	insns[i++] = BPF_JMP32_REG(BPF_JEQ, R2, R3, 2);
1761 	insns[i++] = BPF_MOV32_IMM(R0, __LINE__);
1762 	insns[i++] = BPF_EXIT_INSN();
1763 
1764 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R1, 2);
1765 	insns[i++] = BPF_MOV32_IMM(R0, __LINE__);
1766 	insns[i++] = BPF_EXIT_INSN();
1767 
1768 	return i;
1769 }
1770 
1771 static int __bpf_fill_atomic64(struct bpf_test *self, int op)
1772 {
1773 	return __bpf_fill_pattern(self, &op, 64, 64,
1774 				  0, PATTERN_BLOCK2,
1775 				  &__bpf_emit_atomic64);
1776 }
1777 
1778 static int __bpf_fill_atomic32(struct bpf_test *self, int op)
1779 {
1780 	return __bpf_fill_pattern(self, &op, 64, 64,
1781 				  0, PATTERN_BLOCK2,
1782 				  &__bpf_emit_atomic32);
1783 }
1784 
1785 /* 64-bit atomic operations */
1786 static int bpf_fill_atomic64_add(struct bpf_test *self)
1787 {
1788 	return __bpf_fill_atomic64(self, BPF_ADD);
1789 }
1790 
1791 static int bpf_fill_atomic64_and(struct bpf_test *self)
1792 {
1793 	return __bpf_fill_atomic64(self, BPF_AND);
1794 }
1795 
1796 static int bpf_fill_atomic64_or(struct bpf_test *self)
1797 {
1798 	return __bpf_fill_atomic64(self, BPF_OR);
1799 }
1800 
1801 static int bpf_fill_atomic64_xor(struct bpf_test *self)
1802 {
1803 	return __bpf_fill_atomic64(self, BPF_XOR);
1804 }
1805 
1806 static int bpf_fill_atomic64_add_fetch(struct bpf_test *self)
1807 {
1808 	return __bpf_fill_atomic64(self, BPF_ADD | BPF_FETCH);
1809 }
1810 
1811 static int bpf_fill_atomic64_and_fetch(struct bpf_test *self)
1812 {
1813 	return __bpf_fill_atomic64(self, BPF_AND | BPF_FETCH);
1814 }
1815 
1816 static int bpf_fill_atomic64_or_fetch(struct bpf_test *self)
1817 {
1818 	return __bpf_fill_atomic64(self, BPF_OR | BPF_FETCH);
1819 }
1820 
1821 static int bpf_fill_atomic64_xor_fetch(struct bpf_test *self)
1822 {
1823 	return __bpf_fill_atomic64(self, BPF_XOR | BPF_FETCH);
1824 }
1825 
1826 static int bpf_fill_atomic64_xchg(struct bpf_test *self)
1827 {
1828 	return __bpf_fill_atomic64(self, BPF_XCHG);
1829 }
1830 
1831 static int bpf_fill_cmpxchg64(struct bpf_test *self)
1832 {
1833 	return __bpf_fill_pattern(self, NULL, 64, 64, 0, PATTERN_BLOCK2,
1834 				  &__bpf_emit_cmpxchg64);
1835 }
1836 
1837 /* 32-bit atomic operations */
1838 static int bpf_fill_atomic32_add(struct bpf_test *self)
1839 {
1840 	return __bpf_fill_atomic32(self, BPF_ADD);
1841 }
1842 
1843 static int bpf_fill_atomic32_and(struct bpf_test *self)
1844 {
1845 	return __bpf_fill_atomic32(self, BPF_AND);
1846 }
1847 
1848 static int bpf_fill_atomic32_or(struct bpf_test *self)
1849 {
1850 	return __bpf_fill_atomic32(self, BPF_OR);
1851 }
1852 
1853 static int bpf_fill_atomic32_xor(struct bpf_test *self)
1854 {
1855 	return __bpf_fill_atomic32(self, BPF_XOR);
1856 }
1857 
1858 static int bpf_fill_atomic32_add_fetch(struct bpf_test *self)
1859 {
1860 	return __bpf_fill_atomic32(self, BPF_ADD | BPF_FETCH);
1861 }
1862 
1863 static int bpf_fill_atomic32_and_fetch(struct bpf_test *self)
1864 {
1865 	return __bpf_fill_atomic32(self, BPF_AND | BPF_FETCH);
1866 }
1867 
1868 static int bpf_fill_atomic32_or_fetch(struct bpf_test *self)
1869 {
1870 	return __bpf_fill_atomic32(self, BPF_OR | BPF_FETCH);
1871 }
1872 
1873 static int bpf_fill_atomic32_xor_fetch(struct bpf_test *self)
1874 {
1875 	return __bpf_fill_atomic32(self, BPF_XOR | BPF_FETCH);
1876 }
1877 
1878 static int bpf_fill_atomic32_xchg(struct bpf_test *self)
1879 {
1880 	return __bpf_fill_atomic32(self, BPF_XCHG);
1881 }
1882 
1883 static int bpf_fill_cmpxchg32(struct bpf_test *self)
1884 {
1885 	return __bpf_fill_pattern(self, NULL, 64, 64, 0, PATTERN_BLOCK2,
1886 				  &__bpf_emit_cmpxchg32);
1887 }
1888 
1889 /*
1890  * Test JITs that implement ATOMIC operations as function calls or
1891  * other primitives, and must re-arrange operands for argument passing.
1892  */
1893 static int __bpf_fill_atomic_reg_pairs(struct bpf_test *self, u8 width, u8 op)
1894 {
1895 	struct bpf_insn *insn;
1896 	int len = 2 + 34 * 10 * 10;
1897 	u64 mem, upd, res;
1898 	int rd, rs, i = 0;
1899 
1900 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
1901 	if (!insn)
1902 		return -ENOMEM;
1903 
1904 	/* Operand and memory values */
1905 	if (width == BPF_DW) {
1906 		mem = 0x0123456789abcdefULL;
1907 		upd = 0xfedcba9876543210ULL;
1908 	} else { /* BPF_W */
1909 		mem = 0x01234567U;
1910 		upd = 0x76543210U;
1911 	}
1912 
1913 	/* Memory updated according to operation */
1914 	switch (op) {
1915 	case BPF_XCHG:
1916 		res = upd;
1917 		break;
1918 	case BPF_CMPXCHG:
1919 		res = mem;
1920 		break;
1921 	default:
1922 		__bpf_alu_result(&res, mem, upd, BPF_OP(op));
1923 	}
1924 
1925 	/* Test all operand registers */
1926 	for (rd = R0; rd <= R9; rd++) {
1927 		for (rs = R0; rs <= R9; rs++) {
1928 			u64 cmp, src;
1929 
1930 			/* Initialize value in memory */
1931 			i += __bpf_ld_imm64(&insn[i], R0, mem);
1932 			insn[i++] = BPF_STX_MEM(width, R10, R0, -8);
1933 
1934 			/* Initialize registers in order */
1935 			i += __bpf_ld_imm64(&insn[i], R0, ~mem);
1936 			i += __bpf_ld_imm64(&insn[i], rs, upd);
1937 			insn[i++] = BPF_MOV64_REG(rd, R10);
1938 
1939 			/* Perform atomic operation */
1940 			insn[i++] = BPF_ATOMIC_OP(width, op, rd, rs, -8);
1941 			if (op == BPF_CMPXCHG && width == BPF_W)
1942 				insn[i++] = BPF_ZEXT_REG(R0);
1943 
1944 			/* Check R0 register value */
1945 			if (op == BPF_CMPXCHG)
1946 				cmp = mem;  /* Expect value from memory */
1947 			else if (R0 == rd || R0 == rs)
1948 				cmp = 0;    /* Aliased, checked below */
1949 			else
1950 				cmp = ~mem; /* Expect value to be preserved */
1951 			if (cmp) {
1952 				insn[i++] = BPF_JMP32_IMM(BPF_JEQ, R0,
1953 							   (u32)cmp, 2);
1954 				insn[i++] = BPF_MOV32_IMM(R0, __LINE__);
1955 				insn[i++] = BPF_EXIT_INSN();
1956 				insn[i++] = BPF_ALU64_IMM(BPF_RSH, R0, 32);
1957 				insn[i++] = BPF_JMP32_IMM(BPF_JEQ, R0,
1958 							   cmp >> 32, 2);
1959 				insn[i++] = BPF_MOV32_IMM(R0, __LINE__);
1960 				insn[i++] = BPF_EXIT_INSN();
1961 			}
1962 
1963 			/* Check source register value */
1964 			if (rs == R0 && op == BPF_CMPXCHG)
1965 				src = 0;   /* Aliased with R0, checked above */
1966 			else if (rs == rd && (op == BPF_CMPXCHG ||
1967 					      !(op & BPF_FETCH)))
1968 				src = 0;   /* Aliased with rd, checked below */
1969 			else if (op == BPF_CMPXCHG)
1970 				src = upd; /* Expect value to be preserved */
1971 			else if (op & BPF_FETCH)
1972 				src = mem; /* Expect fetched value from mem */
1973 			else /* no fetch */
1974 				src = upd; /* Expect value to be preserved */
1975 			if (src) {
1976 				insn[i++] = BPF_JMP32_IMM(BPF_JEQ, rs,
1977 							   (u32)src, 2);
1978 				insn[i++] = BPF_MOV32_IMM(R0, __LINE__);
1979 				insn[i++] = BPF_EXIT_INSN();
1980 				insn[i++] = BPF_ALU64_IMM(BPF_RSH, rs, 32);
1981 				insn[i++] = BPF_JMP32_IMM(BPF_JEQ, rs,
1982 							   src >> 32, 2);
1983 				insn[i++] = BPF_MOV32_IMM(R0, __LINE__);
1984 				insn[i++] = BPF_EXIT_INSN();
1985 			}
1986 
1987 			/* Check destination register value */
1988 			if (!(rd == R0 && op == BPF_CMPXCHG) &&
1989 			    !(rd == rs && (op & BPF_FETCH))) {
1990 				insn[i++] = BPF_JMP_REG(BPF_JEQ, rd, R10, 2);
1991 				insn[i++] = BPF_MOV32_IMM(R0, __LINE__);
1992 				insn[i++] = BPF_EXIT_INSN();
1993 			}
1994 
1995 			/* Check value in memory */
1996 			if (rs != rd) {                  /* No aliasing */
1997 				i += __bpf_ld_imm64(&insn[i], R1, res);
1998 			} else if (op == BPF_XCHG) {     /* Aliased, XCHG */
1999 				insn[i++] = BPF_MOV64_REG(R1, R10);
2000 			} else if (op == BPF_CMPXCHG) {  /* Aliased, CMPXCHG */
2001 				i += __bpf_ld_imm64(&insn[i], R1, mem);
2002 			} else {                        /* Aliased, ALU oper */
2003 				i += __bpf_ld_imm64(&insn[i], R1, mem);
2004 				insn[i++] = BPF_ALU64_REG(BPF_OP(op), R1, R10);
2005 			}
2006 
2007 			insn[i++] = BPF_LDX_MEM(width, R0, R10, -8);
2008 			if (width == BPF_DW)
2009 				insn[i++] = BPF_JMP_REG(BPF_JEQ, R0, R1, 2);
2010 			else /* width == BPF_W */
2011 				insn[i++] = BPF_JMP32_REG(BPF_JEQ, R0, R1, 2);
2012 			insn[i++] = BPF_MOV32_IMM(R0, __LINE__);
2013 			insn[i++] = BPF_EXIT_INSN();
2014 		}
2015 	}
2016 
2017 	insn[i++] = BPF_MOV64_IMM(R0, 1);
2018 	insn[i++] = BPF_EXIT_INSN();
2019 
2020 	self->u.ptr.insns = insn;
2021 	self->u.ptr.len = i;
2022 	BUG_ON(i > len);
2023 
2024 	return 0;
2025 }
2026 
2027 /* 64-bit atomic register tests */
2028 static int bpf_fill_atomic64_add_reg_pairs(struct bpf_test *self)
2029 {
2030 	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_ADD);
2031 }
2032 
2033 static int bpf_fill_atomic64_and_reg_pairs(struct bpf_test *self)
2034 {
2035 	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_AND);
2036 }
2037 
2038 static int bpf_fill_atomic64_or_reg_pairs(struct bpf_test *self)
2039 {
2040 	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_OR);
2041 }
2042 
2043 static int bpf_fill_atomic64_xor_reg_pairs(struct bpf_test *self)
2044 {
2045 	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_XOR);
2046 }
2047 
2048 static int bpf_fill_atomic64_add_fetch_reg_pairs(struct bpf_test *self)
2049 {
2050 	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_ADD | BPF_FETCH);
2051 }
2052 
2053 static int bpf_fill_atomic64_and_fetch_reg_pairs(struct bpf_test *self)
2054 {
2055 	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_AND | BPF_FETCH);
2056 }
2057 
2058 static int bpf_fill_atomic64_or_fetch_reg_pairs(struct bpf_test *self)
2059 {
2060 	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_OR | BPF_FETCH);
2061 }
2062 
2063 static int bpf_fill_atomic64_xor_fetch_reg_pairs(struct bpf_test *self)
2064 {
2065 	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_XOR | BPF_FETCH);
2066 }
2067 
2068 static int bpf_fill_atomic64_xchg_reg_pairs(struct bpf_test *self)
2069 {
2070 	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_XCHG);
2071 }
2072 
2073 static int bpf_fill_atomic64_cmpxchg_reg_pairs(struct bpf_test *self)
2074 {
2075 	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_CMPXCHG);
2076 }
2077 
2078 /* 32-bit atomic register tests */
2079 static int bpf_fill_atomic32_add_reg_pairs(struct bpf_test *self)
2080 {
2081 	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_ADD);
2082 }
2083 
2084 static int bpf_fill_atomic32_and_reg_pairs(struct bpf_test *self)
2085 {
2086 	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_AND);
2087 }
2088 
2089 static int bpf_fill_atomic32_or_reg_pairs(struct bpf_test *self)
2090 {
2091 	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_OR);
2092 }
2093 
2094 static int bpf_fill_atomic32_xor_reg_pairs(struct bpf_test *self)
2095 {
2096 	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_XOR);
2097 }
2098 
2099 static int bpf_fill_atomic32_add_fetch_reg_pairs(struct bpf_test *self)
2100 {
2101 	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_ADD | BPF_FETCH);
2102 }
2103 
2104 static int bpf_fill_atomic32_and_fetch_reg_pairs(struct bpf_test *self)
2105 {
2106 	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_AND | BPF_FETCH);
2107 }
2108 
2109 static int bpf_fill_atomic32_or_fetch_reg_pairs(struct bpf_test *self)
2110 {
2111 	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_OR | BPF_FETCH);
2112 }
2113 
2114 static int bpf_fill_atomic32_xor_fetch_reg_pairs(struct bpf_test *self)
2115 {
2116 	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_XOR | BPF_FETCH);
2117 }
2118 
2119 static int bpf_fill_atomic32_xchg_reg_pairs(struct bpf_test *self)
2120 {
2121 	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_XCHG);
2122 }
2123 
2124 static int bpf_fill_atomic32_cmpxchg_reg_pairs(struct bpf_test *self)
2125 {
2126 	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_CMPXCHG);
2127 }
2128 
2129 /*
2130  * Test the two-instruction 64-bit immediate load operation for all
2131  * power-of-two magnitudes of the immediate operand. For each MSB, a block
2132  * of immediate values centered around the power-of-two MSB are tested,
2133  * both for positive and negative values. The test is designed to verify
2134  * the operation for JITs that emit different code depending on the magnitude
2135  * of the immediate value. This is often the case if the native instruction
2136  * immediate field width is narrower than 32 bits.
2137  */
2138 static int bpf_fill_ld_imm64_magn(struct bpf_test *self)
2139 {
2140 	int block = 64; /* Increase for more tests per MSB position */
2141 	int len = 3 + 8 * 63 * block * 2;
2142 	struct bpf_insn *insn;
2143 	int bit, adj, sign;
2144 	int i = 0;
2145 
2146 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
2147 	if (!insn)
2148 		return -ENOMEM;
2149 
2150 	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
2151 
2152 	for (bit = 0; bit <= 62; bit++) {
2153 		for (adj = -block / 2; adj < block / 2; adj++) {
2154 			for (sign = -1; sign <= 1; sign += 2) {
2155 				s64 imm = sign * ((1LL << bit) + adj);
2156 
2157 				/* Perform operation */
2158 				i += __bpf_ld_imm64(&insn[i], R1, imm);
2159 
2160 				/* Load reference */
2161 				insn[i++] = BPF_ALU32_IMM(BPF_MOV, R2, imm);
2162 				insn[i++] = BPF_ALU32_IMM(BPF_MOV, R3,
2163 							  (u32)(imm >> 32));
2164 				insn[i++] = BPF_ALU64_IMM(BPF_LSH, R3, 32);
2165 				insn[i++] = BPF_ALU64_REG(BPF_OR, R2, R3);
2166 
2167 				/* Check result */
2168 				insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R2, 1);
2169 				insn[i++] = BPF_EXIT_INSN();
2170 			}
2171 		}
2172 	}
2173 
2174 	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
2175 	insn[i++] = BPF_EXIT_INSN();
2176 
2177 	self->u.ptr.insns = insn;
2178 	self->u.ptr.len = len;
2179 	BUG_ON(i != len);
2180 
2181 	return 0;
2182 }
2183 
2184 /*
2185  * Test the two-instruction 64-bit immediate load operation for different
2186  * combinations of bytes. Each byte in the 64-bit word is constructed as
2187  * (base & mask) | (rand() & ~mask), where rand() is a deterministic LCG.
2188  * All patterns (base1, mask1) and (base2, mask2) bytes are tested.
2189  */
2190 static int __bpf_fill_ld_imm64_bytes(struct bpf_test *self,
2191 				     u8 base1, u8 mask1,
2192 				     u8 base2, u8 mask2)
2193 {
2194 	struct bpf_insn *insn;
2195 	int len = 3 + 8 * BIT(8);
2196 	int pattern, index;
2197 	u32 rand = 1;
2198 	int i = 0;
2199 
2200 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
2201 	if (!insn)
2202 		return -ENOMEM;
2203 
2204 	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
2205 
2206 	for (pattern = 0; pattern < BIT(8); pattern++) {
2207 		u64 imm = 0;
2208 
2209 		for (index = 0; index < 8; index++) {
2210 			int byte;
2211 
2212 			if (pattern & BIT(index))
2213 				byte = (base1 & mask1) | (rand & ~mask1);
2214 			else
2215 				byte = (base2 & mask2) | (rand & ~mask2);
2216 			imm = (imm << 8) | byte;
2217 		}
2218 
2219 		/* Update our LCG */
2220 		rand = rand * 1664525 + 1013904223;
2221 
2222 		/* Perform operation */
2223 		i += __bpf_ld_imm64(&insn[i], R1, imm);
2224 
2225 		/* Load reference */
2226 		insn[i++] = BPF_ALU32_IMM(BPF_MOV, R2, imm);
2227 		insn[i++] = BPF_ALU32_IMM(BPF_MOV, R3, (u32)(imm >> 32));
2228 		insn[i++] = BPF_ALU64_IMM(BPF_LSH, R3, 32);
2229 		insn[i++] = BPF_ALU64_REG(BPF_OR, R2, R3);
2230 
2231 		/* Check result */
2232 		insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R2, 1);
2233 		insn[i++] = BPF_EXIT_INSN();
2234 	}
2235 
2236 	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
2237 	insn[i++] = BPF_EXIT_INSN();
2238 
2239 	self->u.ptr.insns = insn;
2240 	self->u.ptr.len = len;
2241 	BUG_ON(i != len);
2242 
2243 	return 0;
2244 }
2245 
2246 static int bpf_fill_ld_imm64_checker(struct bpf_test *self)
2247 {
2248 	return __bpf_fill_ld_imm64_bytes(self, 0, 0xff, 0xff, 0xff);
2249 }
2250 
2251 static int bpf_fill_ld_imm64_pos_neg(struct bpf_test *self)
2252 {
2253 	return __bpf_fill_ld_imm64_bytes(self, 1, 0x81, 0x80, 0x80);
2254 }
2255 
2256 static int bpf_fill_ld_imm64_pos_zero(struct bpf_test *self)
2257 {
2258 	return __bpf_fill_ld_imm64_bytes(self, 1, 0x81, 0, 0xff);
2259 }
2260 
2261 static int bpf_fill_ld_imm64_neg_zero(struct bpf_test *self)
2262 {
2263 	return __bpf_fill_ld_imm64_bytes(self, 0x80, 0x80, 0, 0xff);
2264 }
2265 
2266 /*
2267  * Exhaustive tests of JMP operations for all combinations of power-of-two
2268  * magnitudes of the operands, both for positive and negative values. The
2269  * test is designed to verify e.g. the JMP and JMP32 operations for JITs that
2270  * emit different code depending on the magnitude of the immediate value.
2271  */
2272 
2273 static bool __bpf_match_jmp_cond(s64 v1, s64 v2, u8 op)
2274 {
2275 	switch (op) {
2276 	case BPF_JSET:
2277 		return !!(v1 & v2);
2278 	case BPF_JEQ:
2279 		return v1 == v2;
2280 	case BPF_JNE:
2281 		return v1 != v2;
2282 	case BPF_JGT:
2283 		return (u64)v1 > (u64)v2;
2284 	case BPF_JGE:
2285 		return (u64)v1 >= (u64)v2;
2286 	case BPF_JLT:
2287 		return (u64)v1 < (u64)v2;
2288 	case BPF_JLE:
2289 		return (u64)v1 <= (u64)v2;
2290 	case BPF_JSGT:
2291 		return v1 > v2;
2292 	case BPF_JSGE:
2293 		return v1 >= v2;
2294 	case BPF_JSLT:
2295 		return v1 < v2;
2296 	case BPF_JSLE:
2297 		return v1 <= v2;
2298 	}
2299 	return false;
2300 }
2301 
2302 static int __bpf_emit_jmp_imm(struct bpf_test *self, void *arg,
2303 			      struct bpf_insn *insns, s64 dst, s64 imm)
2304 {
2305 	int op = *(int *)arg;
2306 
2307 	if (insns) {
2308 		bool match = __bpf_match_jmp_cond(dst, (s32)imm, op);
2309 		int i = 0;
2310 
2311 		insns[i++] = BPF_ALU32_IMM(BPF_MOV, R0, match);
2312 
2313 		i += __bpf_ld_imm64(&insns[i], R1, dst);
2314 		insns[i++] = BPF_JMP_IMM(op, R1, imm, 1);
2315 		if (!match)
2316 			insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
2317 		insns[i++] = BPF_EXIT_INSN();
2318 
2319 		return i;
2320 	}
2321 
2322 	return 5 + 1;
2323 }
2324 
2325 static int __bpf_emit_jmp32_imm(struct bpf_test *self, void *arg,
2326 				struct bpf_insn *insns, s64 dst, s64 imm)
2327 {
2328 	int op = *(int *)arg;
2329 
2330 	if (insns) {
2331 		bool match = __bpf_match_jmp_cond((s32)dst, (s32)imm, op);
2332 		int i = 0;
2333 
2334 		i += __bpf_ld_imm64(&insns[i], R1, dst);
2335 		insns[i++] = BPF_JMP32_IMM(op, R1, imm, 1);
2336 		if (!match)
2337 			insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
2338 		insns[i++] = BPF_EXIT_INSN();
2339 
2340 		return i;
2341 	}
2342 
2343 	return 5;
2344 }
2345 
2346 static int __bpf_emit_jmp_reg(struct bpf_test *self, void *arg,
2347 			      struct bpf_insn *insns, s64 dst, s64 src)
2348 {
2349 	int op = *(int *)arg;
2350 
2351 	if (insns) {
2352 		bool match = __bpf_match_jmp_cond(dst, src, op);
2353 		int i = 0;
2354 
2355 		i += __bpf_ld_imm64(&insns[i], R1, dst);
2356 		i += __bpf_ld_imm64(&insns[i], R2, src);
2357 		insns[i++] = BPF_JMP_REG(op, R1, R2, 1);
2358 		if (!match)
2359 			insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
2360 		insns[i++] = BPF_EXIT_INSN();
2361 
2362 		return i;
2363 	}
2364 
2365 	return 7;
2366 }
2367 
2368 static int __bpf_emit_jmp32_reg(struct bpf_test *self, void *arg,
2369 				struct bpf_insn *insns, s64 dst, s64 src)
2370 {
2371 	int op = *(int *)arg;
2372 
2373 	if (insns) {
2374 		bool match = __bpf_match_jmp_cond((s32)dst, (s32)src, op);
2375 		int i = 0;
2376 
2377 		i += __bpf_ld_imm64(&insns[i], R1, dst);
2378 		i += __bpf_ld_imm64(&insns[i], R2, src);
2379 		insns[i++] = BPF_JMP32_REG(op, R1, R2, 1);
2380 		if (!match)
2381 			insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
2382 		insns[i++] = BPF_EXIT_INSN();
2383 
2384 		return i;
2385 	}
2386 
2387 	return 7;
2388 }
2389 
2390 static int __bpf_fill_jmp_imm(struct bpf_test *self, int op)
2391 {
2392 	return __bpf_fill_pattern(self, &op, 64, 32,
2393 				  PATTERN_BLOCK1, PATTERN_BLOCK2,
2394 				  &__bpf_emit_jmp_imm);
2395 }
2396 
2397 static int __bpf_fill_jmp32_imm(struct bpf_test *self, int op)
2398 {
2399 	return __bpf_fill_pattern(self, &op, 64, 32,
2400 				  PATTERN_BLOCK1, PATTERN_BLOCK2,
2401 				  &__bpf_emit_jmp32_imm);
2402 }
2403 
2404 static int __bpf_fill_jmp_reg(struct bpf_test *self, int op)
2405 {
2406 	return __bpf_fill_pattern(self, &op, 64, 64,
2407 				  PATTERN_BLOCK1, PATTERN_BLOCK2,
2408 				  &__bpf_emit_jmp_reg);
2409 }
2410 
2411 static int __bpf_fill_jmp32_reg(struct bpf_test *self, int op)
2412 {
2413 	return __bpf_fill_pattern(self, &op, 64, 64,
2414 				  PATTERN_BLOCK1, PATTERN_BLOCK2,
2415 				  &__bpf_emit_jmp32_reg);
2416 }
2417 
2418 /* JMP immediate tests */
2419 static int bpf_fill_jmp_jset_imm(struct bpf_test *self)
2420 {
2421 	return __bpf_fill_jmp_imm(self, BPF_JSET);
2422 }
2423 
2424 static int bpf_fill_jmp_jeq_imm(struct bpf_test *self)
2425 {
2426 	return __bpf_fill_jmp_imm(self, BPF_JEQ);
2427 }
2428 
2429 static int bpf_fill_jmp_jne_imm(struct bpf_test *self)
2430 {
2431 	return __bpf_fill_jmp_imm(self, BPF_JNE);
2432 }
2433 
2434 static int bpf_fill_jmp_jgt_imm(struct bpf_test *self)
2435 {
2436 	return __bpf_fill_jmp_imm(self, BPF_JGT);
2437 }
2438 
2439 static int bpf_fill_jmp_jge_imm(struct bpf_test *self)
2440 {
2441 	return __bpf_fill_jmp_imm(self, BPF_JGE);
2442 }
2443 
2444 static int bpf_fill_jmp_jlt_imm(struct bpf_test *self)
2445 {
2446 	return __bpf_fill_jmp_imm(self, BPF_JLT);
2447 }
2448 
2449 static int bpf_fill_jmp_jle_imm(struct bpf_test *self)
2450 {
2451 	return __bpf_fill_jmp_imm(self, BPF_JLE);
2452 }
2453 
2454 static int bpf_fill_jmp_jsgt_imm(struct bpf_test *self)
2455 {
2456 	return __bpf_fill_jmp_imm(self, BPF_JSGT);
2457 }
2458 
2459 static int bpf_fill_jmp_jsge_imm(struct bpf_test *self)
2460 {
2461 	return __bpf_fill_jmp_imm(self, BPF_JSGE);
2462 }
2463 
2464 static int bpf_fill_jmp_jslt_imm(struct bpf_test *self)
2465 {
2466 	return __bpf_fill_jmp_imm(self, BPF_JSLT);
2467 }
2468 
2469 static int bpf_fill_jmp_jsle_imm(struct bpf_test *self)
2470 {
2471 	return __bpf_fill_jmp_imm(self, BPF_JSLE);
2472 }
2473 
2474 /* JMP32 immediate tests */
2475 static int bpf_fill_jmp32_jset_imm(struct bpf_test *self)
2476 {
2477 	return __bpf_fill_jmp32_imm(self, BPF_JSET);
2478 }
2479 
2480 static int bpf_fill_jmp32_jeq_imm(struct bpf_test *self)
2481 {
2482 	return __bpf_fill_jmp32_imm(self, BPF_JEQ);
2483 }
2484 
2485 static int bpf_fill_jmp32_jne_imm(struct bpf_test *self)
2486 {
2487 	return __bpf_fill_jmp32_imm(self, BPF_JNE);
2488 }
2489 
2490 static int bpf_fill_jmp32_jgt_imm(struct bpf_test *self)
2491 {
2492 	return __bpf_fill_jmp32_imm(self, BPF_JGT);
2493 }
2494 
2495 static int bpf_fill_jmp32_jge_imm(struct bpf_test *self)
2496 {
2497 	return __bpf_fill_jmp32_imm(self, BPF_JGE);
2498 }
2499 
2500 static int bpf_fill_jmp32_jlt_imm(struct bpf_test *self)
2501 {
2502 	return __bpf_fill_jmp32_imm(self, BPF_JLT);
2503 }
2504 
2505 static int bpf_fill_jmp32_jle_imm(struct bpf_test *self)
2506 {
2507 	return __bpf_fill_jmp32_imm(self, BPF_JLE);
2508 }
2509 
2510 static int bpf_fill_jmp32_jsgt_imm(struct bpf_test *self)
2511 {
2512 	return __bpf_fill_jmp32_imm(self, BPF_JSGT);
2513 }
2514 
2515 static int bpf_fill_jmp32_jsge_imm(struct bpf_test *self)
2516 {
2517 	return __bpf_fill_jmp32_imm(self, BPF_JSGE);
2518 }
2519 
2520 static int bpf_fill_jmp32_jslt_imm(struct bpf_test *self)
2521 {
2522 	return __bpf_fill_jmp32_imm(self, BPF_JSLT);
2523 }
2524 
2525 static int bpf_fill_jmp32_jsle_imm(struct bpf_test *self)
2526 {
2527 	return __bpf_fill_jmp32_imm(self, BPF_JSLE);
2528 }
2529 
2530 /* JMP register tests */
2531 static int bpf_fill_jmp_jset_reg(struct bpf_test *self)
2532 {
2533 	return __bpf_fill_jmp_reg(self, BPF_JSET);
2534 }
2535 
2536 static int bpf_fill_jmp_jeq_reg(struct bpf_test *self)
2537 {
2538 	return __bpf_fill_jmp_reg(self, BPF_JEQ);
2539 }
2540 
2541 static int bpf_fill_jmp_jne_reg(struct bpf_test *self)
2542 {
2543 	return __bpf_fill_jmp_reg(self, BPF_JNE);
2544 }
2545 
2546 static int bpf_fill_jmp_jgt_reg(struct bpf_test *self)
2547 {
2548 	return __bpf_fill_jmp_reg(self, BPF_JGT);
2549 }
2550 
2551 static int bpf_fill_jmp_jge_reg(struct bpf_test *self)
2552 {
2553 	return __bpf_fill_jmp_reg(self, BPF_JGE);
2554 }
2555 
2556 static int bpf_fill_jmp_jlt_reg(struct bpf_test *self)
2557 {
2558 	return __bpf_fill_jmp_reg(self, BPF_JLT);
2559 }
2560 
2561 static int bpf_fill_jmp_jle_reg(struct bpf_test *self)
2562 {
2563 	return __bpf_fill_jmp_reg(self, BPF_JLE);
2564 }
2565 
2566 static int bpf_fill_jmp_jsgt_reg(struct bpf_test *self)
2567 {
2568 	return __bpf_fill_jmp_reg(self, BPF_JSGT);
2569 }
2570 
2571 static int bpf_fill_jmp_jsge_reg(struct bpf_test *self)
2572 {
2573 	return __bpf_fill_jmp_reg(self, BPF_JSGE);
2574 }
2575 
2576 static int bpf_fill_jmp_jslt_reg(struct bpf_test *self)
2577 {
2578 	return __bpf_fill_jmp_reg(self, BPF_JSLT);
2579 }
2580 
2581 static int bpf_fill_jmp_jsle_reg(struct bpf_test *self)
2582 {
2583 	return __bpf_fill_jmp_reg(self, BPF_JSLE);
2584 }
2585 
2586 /* JMP32 register tests */
2587 static int bpf_fill_jmp32_jset_reg(struct bpf_test *self)
2588 {
2589 	return __bpf_fill_jmp32_reg(self, BPF_JSET);
2590 }
2591 
2592 static int bpf_fill_jmp32_jeq_reg(struct bpf_test *self)
2593 {
2594 	return __bpf_fill_jmp32_reg(self, BPF_JEQ);
2595 }
2596 
2597 static int bpf_fill_jmp32_jne_reg(struct bpf_test *self)
2598 {
2599 	return __bpf_fill_jmp32_reg(self, BPF_JNE);
2600 }
2601 
2602 static int bpf_fill_jmp32_jgt_reg(struct bpf_test *self)
2603 {
2604 	return __bpf_fill_jmp32_reg(self, BPF_JGT);
2605 }
2606 
2607 static int bpf_fill_jmp32_jge_reg(struct bpf_test *self)
2608 {
2609 	return __bpf_fill_jmp32_reg(self, BPF_JGE);
2610 }
2611 
2612 static int bpf_fill_jmp32_jlt_reg(struct bpf_test *self)
2613 {
2614 	return __bpf_fill_jmp32_reg(self, BPF_JLT);
2615 }
2616 
2617 static int bpf_fill_jmp32_jle_reg(struct bpf_test *self)
2618 {
2619 	return __bpf_fill_jmp32_reg(self, BPF_JLE);
2620 }
2621 
2622 static int bpf_fill_jmp32_jsgt_reg(struct bpf_test *self)
2623 {
2624 	return __bpf_fill_jmp32_reg(self, BPF_JSGT);
2625 }
2626 
2627 static int bpf_fill_jmp32_jsge_reg(struct bpf_test *self)
2628 {
2629 	return __bpf_fill_jmp32_reg(self, BPF_JSGE);
2630 }
2631 
2632 static int bpf_fill_jmp32_jslt_reg(struct bpf_test *self)
2633 {
2634 	return __bpf_fill_jmp32_reg(self, BPF_JSLT);
2635 }
2636 
2637 static int bpf_fill_jmp32_jsle_reg(struct bpf_test *self)
2638 {
2639 	return __bpf_fill_jmp32_reg(self, BPF_JSLE);
2640 }
2641 
2642 /*
2643  * Set up a sequence of staggered jumps, forwards and backwards with
2644  * increasing offset. This tests the conversion of relative jumps to
2645  * JITed native jumps. On some architectures, for example MIPS, a large
2646  * PC-relative jump offset may overflow the immediate field of the native
2647  * conditional branch instruction, triggering a conversion to use an
2648  * absolute jump instead. Since this changes the jump offsets, another
2649  * offset computation pass is necessary, and that may in turn trigger
2650  * another branch conversion. This jump sequence is particularly nasty
2651  * in that regard.
2652  *
2653  * The sequence generation is parameterized by size and jump type.
2654  * The size must be even, and the expected result is always size + 1.
2655  * Below is an example with size=8 and result=9.
2656  *
2657  *                     ________________________Start
2658  *                     R0 = 0
2659  *                     R1 = r1
2660  *                     R2 = r2
2661  *            ,------- JMP +4 * 3______________Preamble: 4 insns
2662  * ,----------|-ind 0- if R0 != 7 JMP 8 * 3 + 1 <--------------------.
2663  * |          |        R0 = 8                                        |
2664  * |          |        JMP +7 * 3               ------------------------.
2665  * | ,--------|-----1- if R0 != 5 JMP 7 * 3 + 1 <--------------.     |  |
2666  * | |        |        R0 = 6                                  |     |  |
2667  * | |        |        JMP +5 * 3               ------------------.  |  |
2668  * | | ,------|-----2- if R0 != 3 JMP 6 * 3 + 1 <--------.     |  |  |  |
2669  * | | |      |        R0 = 4                            |     |  |  |  |
2670  * | | |      |        JMP +3 * 3               ------------.  |  |  |  |
2671  * | | | ,----|-----3- if R0 != 1 JMP 5 * 3 + 1 <--.     |  |  |  |  |  |
2672  * | | | |    |        R0 = 2                      |     |  |  |  |  |  |
2673  * | | | |    |        JMP +1 * 3               ------.  |  |  |  |  |  |
2674  * | | | | ,--t=====4> if R0 != 0 JMP 4 * 3 + 1    1  2  3  4  5  6  7  8 loc
2675  * | | | | |           R0 = 1                     -1 +2 -3 +4 -5 +6 -7 +8 off
2676  * | | | | |           JMP -2 * 3               ---'  |  |  |  |  |  |  |
2677  * | | | | | ,------5- if R0 != 2 JMP 3 * 3 + 1 <-----'  |  |  |  |  |  |
2678  * | | | | | |         R0 = 3                            |  |  |  |  |  |
2679  * | | | | | |         JMP -4 * 3               ---------'  |  |  |  |  |
2680  * | | | | | | ,----6- if R0 != 4 JMP 2 * 3 + 1 <-----------'  |  |  |  |
2681  * | | | | | | |       R0 = 5                                  |  |  |  |
2682  * | | | | | | |       JMP -6 * 3               ---------------'  |  |  |
2683  * | | | | | | | ,--7- if R0 != 6 JMP 1 * 3 + 1 <-----------------'  |  |
2684  * | | | | | | | |     R0 = 7                                        |  |
2685  * | | Error | | |     JMP -8 * 3               ---------------------'  |
2686  * | | paths | | | ,8- if R0 != 8 JMP 0 * 3 + 1 <-----------------------'
2687  * | | | | | | | | |   R0 = 9__________________Sequence: 3 * size - 1 insns
2688  * `-+-+-+-+-+-+-+-+-> EXIT____________________Return: 1 insn
2689  *
2690  */
2691 
2692 /* The maximum size parameter */
2693 #define MAX_STAGGERED_JMP_SIZE ((0x7fff / 3) & ~1)
2694 
2695 /* We use a reduced number of iterations to get a reasonable execution time */
2696 #define NR_STAGGERED_JMP_RUNS 10
2697 
2698 static int __bpf_fill_staggered_jumps(struct bpf_test *self,
2699 				      const struct bpf_insn *jmp,
2700 				      u64 r1, u64 r2)
2701 {
2702 	int size = self->test[0].result - 1;
2703 	int len = 4 + 3 * (size + 1);
2704 	struct bpf_insn *insns;
2705 	int off, ind;
2706 
2707 	insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL);
2708 	if (!insns)
2709 		return -ENOMEM;
2710 
2711 	/* Preamble */
2712 	insns[0] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
2713 	insns[1] = BPF_ALU64_IMM(BPF_MOV, R1, r1);
2714 	insns[2] = BPF_ALU64_IMM(BPF_MOV, R2, r2);
2715 	insns[3] = BPF_JMP_IMM(BPF_JA, 0, 0, 3 * size / 2);
2716 
2717 	/* Sequence */
2718 	for (ind = 0, off = size; ind <= size; ind++, off -= 2) {
2719 		struct bpf_insn *ins = &insns[4 + 3 * ind];
2720 		int loc;
2721 
2722 		if (off == 0)
2723 			off--;
2724 
2725 		loc = abs(off);
2726 		ins[0] = BPF_JMP_IMM(BPF_JNE, R0, loc - 1,
2727 				     3 * (size - ind) + 1);
2728 		ins[1] = BPF_ALU64_IMM(BPF_MOV, R0, loc);
2729 		ins[2] = *jmp;
2730 		ins[2].off = 3 * (off - 1);
2731 	}
2732 
2733 	/* Return */
2734 	insns[len - 1] = BPF_EXIT_INSN();
2735 
2736 	self->u.ptr.insns = insns;
2737 	self->u.ptr.len = len;
2738 
2739 	return 0;
2740 }
2741 
2742 /* 64-bit unconditional jump */
2743 static int bpf_fill_staggered_ja(struct bpf_test *self)
2744 {
2745 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JA, 0, 0, 0);
2746 
2747 	return __bpf_fill_staggered_jumps(self, &jmp, 0, 0);
2748 }
2749 
2750 /* 64-bit immediate jumps */
2751 static int bpf_fill_staggered_jeq_imm(struct bpf_test *self)
2752 {
2753 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JEQ, R1, 1234, 0);
2754 
2755 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2756 }
2757 
2758 static int bpf_fill_staggered_jne_imm(struct bpf_test *self)
2759 {
2760 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JNE, R1, 1234, 0);
2761 
2762 	return __bpf_fill_staggered_jumps(self, &jmp, 4321, 0);
2763 }
2764 
2765 static int bpf_fill_staggered_jset_imm(struct bpf_test *self)
2766 {
2767 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSET, R1, 0x82, 0);
2768 
2769 	return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0);
2770 }
2771 
2772 static int bpf_fill_staggered_jgt_imm(struct bpf_test *self)
2773 {
2774 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JGT, R1, 1234, 0);
2775 
2776 	return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 0);
2777 }
2778 
2779 static int bpf_fill_staggered_jge_imm(struct bpf_test *self)
2780 {
2781 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JGE, R1, 1234, 0);
2782 
2783 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2784 }
2785 
2786 static int bpf_fill_staggered_jlt_imm(struct bpf_test *self)
2787 {
2788 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JLT, R1, 0x80000000, 0);
2789 
2790 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2791 }
2792 
2793 static int bpf_fill_staggered_jle_imm(struct bpf_test *self)
2794 {
2795 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JLE, R1, 1234, 0);
2796 
2797 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2798 }
2799 
2800 static int bpf_fill_staggered_jsgt_imm(struct bpf_test *self)
2801 {
2802 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSGT, R1, -2, 0);
2803 
2804 	return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
2805 }
2806 
2807 static int bpf_fill_staggered_jsge_imm(struct bpf_test *self)
2808 {
2809 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSGE, R1, -2, 0);
2810 
2811 	return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
2812 }
2813 
2814 static int bpf_fill_staggered_jslt_imm(struct bpf_test *self)
2815 {
2816 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSLT, R1, -1, 0);
2817 
2818 	return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
2819 }
2820 
2821 static int bpf_fill_staggered_jsle_imm(struct bpf_test *self)
2822 {
2823 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSLE, R1, -1, 0);
2824 
2825 	return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
2826 }
2827 
2828 /* 64-bit register jumps */
2829 static int bpf_fill_staggered_jeq_reg(struct bpf_test *self)
2830 {
2831 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JEQ, R1, R2, 0);
2832 
2833 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
2834 }
2835 
2836 static int bpf_fill_staggered_jne_reg(struct bpf_test *self)
2837 {
2838 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JNE, R1, R2, 0);
2839 
2840 	return __bpf_fill_staggered_jumps(self, &jmp, 4321, 1234);
2841 }
2842 
2843 static int bpf_fill_staggered_jset_reg(struct bpf_test *self)
2844 {
2845 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JSET, R1, R2, 0);
2846 
2847 	return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0x82);
2848 }
2849 
2850 static int bpf_fill_staggered_jgt_reg(struct bpf_test *self)
2851 {
2852 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JGT, R1, R2, 0);
2853 
2854 	return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 1234);
2855 }
2856 
2857 static int bpf_fill_staggered_jge_reg(struct bpf_test *self)
2858 {
2859 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JGE, R1, R2, 0);
2860 
2861 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
2862 }
2863 
2864 static int bpf_fill_staggered_jlt_reg(struct bpf_test *self)
2865 {
2866 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JLT, R1, R2, 0);
2867 
2868 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0x80000000);
2869 }
2870 
2871 static int bpf_fill_staggered_jle_reg(struct bpf_test *self)
2872 {
2873 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JLE, R1, R2, 0);
2874 
2875 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
2876 }
2877 
2878 static int bpf_fill_staggered_jsgt_reg(struct bpf_test *self)
2879 {
2880 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JSGT, R1, R2, 0);
2881 
2882 	return __bpf_fill_staggered_jumps(self, &jmp, -1, -2);
2883 }
2884 
2885 static int bpf_fill_staggered_jsge_reg(struct bpf_test *self)
2886 {
2887 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JSGE, R1, R2, 0);
2888 
2889 	return __bpf_fill_staggered_jumps(self, &jmp, -2, -2);
2890 }
2891 
2892 static int bpf_fill_staggered_jslt_reg(struct bpf_test *self)
2893 {
2894 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JSLT, R1, R2, 0);
2895 
2896 	return __bpf_fill_staggered_jumps(self, &jmp, -2, -1);
2897 }
2898 
2899 static int bpf_fill_staggered_jsle_reg(struct bpf_test *self)
2900 {
2901 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JSLE, R1, R2, 0);
2902 
2903 	return __bpf_fill_staggered_jumps(self, &jmp, -1, -1);
2904 }
2905 
2906 /* 32-bit immediate jumps */
2907 static int bpf_fill_staggered_jeq32_imm(struct bpf_test *self)
2908 {
2909 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JEQ, R1, 1234, 0);
2910 
2911 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2912 }
2913 
2914 static int bpf_fill_staggered_jne32_imm(struct bpf_test *self)
2915 {
2916 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JNE, R1, 1234, 0);
2917 
2918 	return __bpf_fill_staggered_jumps(self, &jmp, 4321, 0);
2919 }
2920 
2921 static int bpf_fill_staggered_jset32_imm(struct bpf_test *self)
2922 {
2923 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSET, R1, 0x82, 0);
2924 
2925 	return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0);
2926 }
2927 
2928 static int bpf_fill_staggered_jgt32_imm(struct bpf_test *self)
2929 {
2930 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JGT, R1, 1234, 0);
2931 
2932 	return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 0);
2933 }
2934 
2935 static int bpf_fill_staggered_jge32_imm(struct bpf_test *self)
2936 {
2937 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JGE, R1, 1234, 0);
2938 
2939 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2940 }
2941 
2942 static int bpf_fill_staggered_jlt32_imm(struct bpf_test *self)
2943 {
2944 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JLT, R1, 0x80000000, 0);
2945 
2946 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2947 }
2948 
2949 static int bpf_fill_staggered_jle32_imm(struct bpf_test *self)
2950 {
2951 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JLE, R1, 1234, 0);
2952 
2953 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2954 }
2955 
2956 static int bpf_fill_staggered_jsgt32_imm(struct bpf_test *self)
2957 {
2958 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSGT, R1, -2, 0);
2959 
2960 	return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
2961 }
2962 
2963 static int bpf_fill_staggered_jsge32_imm(struct bpf_test *self)
2964 {
2965 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSGE, R1, -2, 0);
2966 
2967 	return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
2968 }
2969 
2970 static int bpf_fill_staggered_jslt32_imm(struct bpf_test *self)
2971 {
2972 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSLT, R1, -1, 0);
2973 
2974 	return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
2975 }
2976 
2977 static int bpf_fill_staggered_jsle32_imm(struct bpf_test *self)
2978 {
2979 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSLE, R1, -1, 0);
2980 
2981 	return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
2982 }
2983 
2984 /* 32-bit register jumps */
2985 static int bpf_fill_staggered_jeq32_reg(struct bpf_test *self)
2986 {
2987 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JEQ, R1, R2, 0);
2988 
2989 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
2990 }
2991 
2992 static int bpf_fill_staggered_jne32_reg(struct bpf_test *self)
2993 {
2994 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JNE, R1, R2, 0);
2995 
2996 	return __bpf_fill_staggered_jumps(self, &jmp, 4321, 1234);
2997 }
2998 
2999 static int bpf_fill_staggered_jset32_reg(struct bpf_test *self)
3000 {
3001 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSET, R1, R2, 0);
3002 
3003 	return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0x82);
3004 }
3005 
3006 static int bpf_fill_staggered_jgt32_reg(struct bpf_test *self)
3007 {
3008 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JGT, R1, R2, 0);
3009 
3010 	return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 1234);
3011 }
3012 
3013 static int bpf_fill_staggered_jge32_reg(struct bpf_test *self)
3014 {
3015 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JGE, R1, R2, 0);
3016 
3017 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
3018 }
3019 
3020 static int bpf_fill_staggered_jlt32_reg(struct bpf_test *self)
3021 {
3022 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JLT, R1, R2, 0);
3023 
3024 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0x80000000);
3025 }
3026 
3027 static int bpf_fill_staggered_jle32_reg(struct bpf_test *self)
3028 {
3029 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JLE, R1, R2, 0);
3030 
3031 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
3032 }
3033 
3034 static int bpf_fill_staggered_jsgt32_reg(struct bpf_test *self)
3035 {
3036 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSGT, R1, R2, 0);
3037 
3038 	return __bpf_fill_staggered_jumps(self, &jmp, -1, -2);
3039 }
3040 
3041 static int bpf_fill_staggered_jsge32_reg(struct bpf_test *self)
3042 {
3043 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSGE, R1, R2, 0);
3044 
3045 	return __bpf_fill_staggered_jumps(self, &jmp, -2, -2);
3046 }
3047 
3048 static int bpf_fill_staggered_jslt32_reg(struct bpf_test *self)
3049 {
3050 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSLT, R1, R2, 0);
3051 
3052 	return __bpf_fill_staggered_jumps(self, &jmp, -2, -1);
3053 }
3054 
3055 static int bpf_fill_staggered_jsle32_reg(struct bpf_test *self)
3056 {
3057 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSLE, R1, R2, 0);
3058 
3059 	return __bpf_fill_staggered_jumps(self, &jmp, -1, -1);
3060 }
3061 
3062 
3063 static struct bpf_test tests[] = {
3064 	{
3065 		"TAX",
3066 		.u.insns = {
3067 			BPF_STMT(BPF_LD | BPF_IMM, 1),
3068 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3069 			BPF_STMT(BPF_LD | BPF_IMM, 2),
3070 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3071 			BPF_STMT(BPF_ALU | BPF_NEG, 0), /* A == -3 */
3072 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3073 			BPF_STMT(BPF_LD | BPF_LEN, 0),
3074 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3075 			BPF_STMT(BPF_MISC | BPF_TAX, 0), /* X == len - 3 */
3076 			BPF_STMT(BPF_LD | BPF_B | BPF_IND, 1),
3077 			BPF_STMT(BPF_RET | BPF_A, 0)
3078 		},
3079 		CLASSIC,
3080 		{ 10, 20, 30, 40, 50 },
3081 		{ { 2, 10 }, { 3, 20 }, { 4, 30 } },
3082 	},
3083 	{
3084 		"TXA",
3085 		.u.insns = {
3086 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3087 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
3088 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3089 			BPF_STMT(BPF_RET | BPF_A, 0) /* A == len * 2 */
3090 		},
3091 		CLASSIC,
3092 		{ 10, 20, 30, 40, 50 },
3093 		{ { 1, 2 }, { 3, 6 }, { 4, 8 } },
3094 	},
3095 	{
3096 		"ADD_SUB_MUL_K",
3097 		.u.insns = {
3098 			BPF_STMT(BPF_LD | BPF_IMM, 1),
3099 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 2),
3100 			BPF_STMT(BPF_LDX | BPF_IMM, 3),
3101 			BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
3102 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0xffffffff),
3103 			BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 3),
3104 			BPF_STMT(BPF_RET | BPF_A, 0)
3105 		},
3106 		CLASSIC | FLAG_NO_DATA,
3107 		{ },
3108 		{ { 0, 0xfffffffd } }
3109 	},
3110 	{
3111 		"DIV_MOD_KX",
3112 		.u.insns = {
3113 			BPF_STMT(BPF_LD | BPF_IMM, 8),
3114 			BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 2),
3115 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3116 			BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
3117 			BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
3118 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3119 			BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
3120 			BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x70000000),
3121 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3122 			BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
3123 			BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
3124 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3125 			BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
3126 			BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x70000000),
3127 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3128 			BPF_STMT(BPF_RET | BPF_A, 0)
3129 		},
3130 		CLASSIC | FLAG_NO_DATA,
3131 		{ },
3132 		{ { 0, 0x20000000 } }
3133 	},
3134 	{
3135 		"AND_OR_LSH_K",
3136 		.u.insns = {
3137 			BPF_STMT(BPF_LD | BPF_IMM, 0xff),
3138 			BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
3139 			BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 27),
3140 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3141 			BPF_STMT(BPF_LD | BPF_IMM, 0xf),
3142 			BPF_STMT(BPF_ALU | BPF_OR | BPF_K, 0xf0),
3143 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3144 			BPF_STMT(BPF_RET | BPF_A, 0)
3145 		},
3146 		CLASSIC | FLAG_NO_DATA,
3147 		{ },
3148 		{ { 0, 0x800000ff }, { 1, 0x800000ff } },
3149 	},
3150 	{
3151 		"LD_IMM_0",
3152 		.u.insns = {
3153 			BPF_STMT(BPF_LD | BPF_IMM, 0), /* ld #0 */
3154 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0, 1, 0),
3155 			BPF_STMT(BPF_RET | BPF_K, 0),
3156 			BPF_STMT(BPF_RET | BPF_K, 1),
3157 		},
3158 		CLASSIC,
3159 		{ },
3160 		{ { 1, 1 } },
3161 	},
3162 	{
3163 		"LD_IND",
3164 		.u.insns = {
3165 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3166 			BPF_STMT(BPF_LD | BPF_H | BPF_IND, MAX_K),
3167 			BPF_STMT(BPF_RET | BPF_K, 1)
3168 		},
3169 		CLASSIC,
3170 		{ },
3171 		{ { 1, 0 }, { 10, 0 }, { 60, 0 } },
3172 	},
3173 	{
3174 		"LD_ABS",
3175 		.u.insns = {
3176 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1000),
3177 			BPF_STMT(BPF_RET | BPF_K, 1)
3178 		},
3179 		CLASSIC,
3180 		{ },
3181 		{ { 1, 0 }, { 10, 0 }, { 60, 0 } },
3182 	},
3183 	{
3184 		"LD_ABS_LL",
3185 		.u.insns = {
3186 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF),
3187 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3188 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF + 1),
3189 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3190 			BPF_STMT(BPF_RET | BPF_A, 0)
3191 		},
3192 		CLASSIC,
3193 		{ 1, 2, 3 },
3194 		{ { 1, 0 }, { 2, 3 } },
3195 	},
3196 	{
3197 		"LD_IND_LL",
3198 		.u.insns = {
3199 			BPF_STMT(BPF_LD | BPF_IMM, SKF_LL_OFF - 1),
3200 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3201 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3202 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3203 			BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
3204 			BPF_STMT(BPF_RET | BPF_A, 0)
3205 		},
3206 		CLASSIC,
3207 		{ 1, 2, 3, 0xff },
3208 		{ { 1, 1 }, { 3, 3 }, { 4, 0xff } },
3209 	},
3210 	{
3211 		"LD_ABS_NET",
3212 		.u.insns = {
3213 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF),
3214 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3215 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF + 1),
3216 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3217 			BPF_STMT(BPF_RET | BPF_A, 0)
3218 		},
3219 		CLASSIC,
3220 		{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
3221 		{ { 15, 0 }, { 16, 3 } },
3222 	},
3223 	{
3224 		"LD_IND_NET",
3225 		.u.insns = {
3226 			BPF_STMT(BPF_LD | BPF_IMM, SKF_NET_OFF - 15),
3227 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3228 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3229 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3230 			BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
3231 			BPF_STMT(BPF_RET | BPF_A, 0)
3232 		},
3233 		CLASSIC,
3234 		{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
3235 		{ { 14, 0 }, { 15, 1 }, { 17, 3 } },
3236 	},
3237 	{
3238 		"LD_PKTTYPE",
3239 		.u.insns = {
3240 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3241 				 SKF_AD_OFF + SKF_AD_PKTTYPE),
3242 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
3243 			BPF_STMT(BPF_RET | BPF_K, 1),
3244 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3245 				 SKF_AD_OFF + SKF_AD_PKTTYPE),
3246 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
3247 			BPF_STMT(BPF_RET | BPF_K, 1),
3248 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3249 				 SKF_AD_OFF + SKF_AD_PKTTYPE),
3250 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
3251 			BPF_STMT(BPF_RET | BPF_K, 1),
3252 			BPF_STMT(BPF_RET | BPF_A, 0)
3253 		},
3254 		CLASSIC,
3255 		{ },
3256 		{ { 1, 3 }, { 10, 3 } },
3257 	},
3258 	{
3259 		"LD_MARK",
3260 		.u.insns = {
3261 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3262 				 SKF_AD_OFF + SKF_AD_MARK),
3263 			BPF_STMT(BPF_RET | BPF_A, 0)
3264 		},
3265 		CLASSIC,
3266 		{ },
3267 		{ { 1, SKB_MARK}, { 10, SKB_MARK} },
3268 	},
3269 	{
3270 		"LD_RXHASH",
3271 		.u.insns = {
3272 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3273 				 SKF_AD_OFF + SKF_AD_RXHASH),
3274 			BPF_STMT(BPF_RET | BPF_A, 0)
3275 		},
3276 		CLASSIC,
3277 		{ },
3278 		{ { 1, SKB_HASH}, { 10, SKB_HASH} },
3279 	},
3280 	{
3281 		"LD_QUEUE",
3282 		.u.insns = {
3283 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3284 				 SKF_AD_OFF + SKF_AD_QUEUE),
3285 			BPF_STMT(BPF_RET | BPF_A, 0)
3286 		},
3287 		CLASSIC,
3288 		{ },
3289 		{ { 1, SKB_QUEUE_MAP }, { 10, SKB_QUEUE_MAP } },
3290 	},
3291 	{
3292 		"LD_PROTOCOL",
3293 		.u.insns = {
3294 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 1),
3295 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 20, 1, 0),
3296 			BPF_STMT(BPF_RET | BPF_K, 0),
3297 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3298 				 SKF_AD_OFF + SKF_AD_PROTOCOL),
3299 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3300 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
3301 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 30, 1, 0),
3302 			BPF_STMT(BPF_RET | BPF_K, 0),
3303 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
3304 			BPF_STMT(BPF_RET | BPF_A, 0)
3305 		},
3306 		CLASSIC,
3307 		{ 10, 20, 30 },
3308 		{ { 10, ETH_P_IP }, { 100, ETH_P_IP } },
3309 	},
3310 	{
3311 		"LD_VLAN_TAG",
3312 		.u.insns = {
3313 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3314 				 SKF_AD_OFF + SKF_AD_VLAN_TAG),
3315 			BPF_STMT(BPF_RET | BPF_A, 0)
3316 		},
3317 		CLASSIC,
3318 		{ },
3319 		{
3320 			{ 1, SKB_VLAN_TCI },
3321 			{ 10, SKB_VLAN_TCI }
3322 		},
3323 	},
3324 	{
3325 		"LD_VLAN_TAG_PRESENT",
3326 		.u.insns = {
3327 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3328 				 SKF_AD_OFF + SKF_AD_VLAN_TAG_PRESENT),
3329 			BPF_STMT(BPF_RET | BPF_A, 0)
3330 		},
3331 		CLASSIC,
3332 		{ },
3333 		{
3334 			{ 1, SKB_VLAN_PRESENT },
3335 			{ 10, SKB_VLAN_PRESENT }
3336 		},
3337 	},
3338 	{
3339 		"LD_IFINDEX",
3340 		.u.insns = {
3341 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3342 				 SKF_AD_OFF + SKF_AD_IFINDEX),
3343 			BPF_STMT(BPF_RET | BPF_A, 0)
3344 		},
3345 		CLASSIC,
3346 		{ },
3347 		{ { 1, SKB_DEV_IFINDEX }, { 10, SKB_DEV_IFINDEX } },
3348 	},
3349 	{
3350 		"LD_HATYPE",
3351 		.u.insns = {
3352 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3353 				 SKF_AD_OFF + SKF_AD_HATYPE),
3354 			BPF_STMT(BPF_RET | BPF_A, 0)
3355 		},
3356 		CLASSIC,
3357 		{ },
3358 		{ { 1, SKB_DEV_TYPE }, { 10, SKB_DEV_TYPE } },
3359 	},
3360 	{
3361 		"LD_CPU",
3362 		.u.insns = {
3363 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3364 				 SKF_AD_OFF + SKF_AD_CPU),
3365 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3366 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3367 				 SKF_AD_OFF + SKF_AD_CPU),
3368 			BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
3369 			BPF_STMT(BPF_RET | BPF_A, 0)
3370 		},
3371 		CLASSIC,
3372 		{ },
3373 		{ { 1, 0 }, { 10, 0 } },
3374 	},
3375 	{
3376 		"LD_NLATTR",
3377 		.u.insns = {
3378 			BPF_STMT(BPF_LDX | BPF_IMM, 2),
3379 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
3380 			BPF_STMT(BPF_LDX | BPF_IMM, 3),
3381 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3382 				 SKF_AD_OFF + SKF_AD_NLATTR),
3383 			BPF_STMT(BPF_RET | BPF_A, 0)
3384 		},
3385 		CLASSIC,
3386 #ifdef __BIG_ENDIAN
3387 		{ 0xff, 0xff, 0, 4, 0, 2, 0, 4, 0, 3 },
3388 #else
3389 		{ 0xff, 0xff, 4, 0, 2, 0, 4, 0, 3, 0 },
3390 #endif
3391 		{ { 4, 0 }, { 20, 6 } },
3392 	},
3393 	{
3394 		"LD_NLATTR_NEST",
3395 		.u.insns = {
3396 			BPF_STMT(BPF_LD | BPF_IMM, 2),
3397 			BPF_STMT(BPF_LDX | BPF_IMM, 3),
3398 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3399 				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3400 			BPF_STMT(BPF_LD | BPF_IMM, 2),
3401 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3402 				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3403 			BPF_STMT(BPF_LD | BPF_IMM, 2),
3404 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3405 				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3406 			BPF_STMT(BPF_LD | BPF_IMM, 2),
3407 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3408 				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3409 			BPF_STMT(BPF_LD | BPF_IMM, 2),
3410 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3411 				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3412 			BPF_STMT(BPF_LD | BPF_IMM, 2),
3413 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3414 				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3415 			BPF_STMT(BPF_LD | BPF_IMM, 2),
3416 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3417 				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3418 			BPF_STMT(BPF_LD | BPF_IMM, 2),
3419 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3420 				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3421 			BPF_STMT(BPF_RET | BPF_A, 0)
3422 		},
3423 		CLASSIC,
3424 #ifdef __BIG_ENDIAN
3425 		{ 0xff, 0xff, 0, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3 },
3426 #else
3427 		{ 0xff, 0xff, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3, 0 },
3428 #endif
3429 		{ { 4, 0 }, { 20, 10 } },
3430 	},
3431 	{
3432 		"LD_PAYLOAD_OFF",
3433 		.u.insns = {
3434 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3435 				 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
3436 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3437 				 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
3438 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3439 				 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
3440 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3441 				 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
3442 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3443 				 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
3444 			BPF_STMT(BPF_RET | BPF_A, 0)
3445 		},
3446 		CLASSIC,
3447 		/* 00:00:00:00:00:00 > 00:00:00:00:00:00, ethtype IPv4 (0x0800),
3448 		 * length 98: 127.0.0.1 > 127.0.0.1: ICMP echo request,
3449 		 * id 9737, seq 1, length 64
3450 		 */
3451 		{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3452 		  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3453 		  0x08, 0x00,
3454 		  0x45, 0x00, 0x00, 0x54, 0xac, 0x8b, 0x40, 0x00, 0x40,
3455 		  0x01, 0x90, 0x1b, 0x7f, 0x00, 0x00, 0x01 },
3456 		{ { 30, 0 }, { 100, 42 } },
3457 	},
3458 	{
3459 		"LD_ANC_XOR",
3460 		.u.insns = {
3461 			BPF_STMT(BPF_LD | BPF_IMM, 10),
3462 			BPF_STMT(BPF_LDX | BPF_IMM, 300),
3463 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3464 				 SKF_AD_OFF + SKF_AD_ALU_XOR_X),
3465 			BPF_STMT(BPF_RET | BPF_A, 0)
3466 		},
3467 		CLASSIC,
3468 		{ },
3469 		{ { 4, 0xA ^ 300 }, { 20, 0xA ^ 300 } },
3470 	},
3471 	{
3472 		"SPILL_FILL",
3473 		.u.insns = {
3474 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3475 			BPF_STMT(BPF_LD | BPF_IMM, 2),
3476 			BPF_STMT(BPF_ALU | BPF_RSH, 1),
3477 			BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
3478 			BPF_STMT(BPF_ST, 1), /* M1 = 1 ^ len */
3479 			BPF_STMT(BPF_ALU | BPF_XOR | BPF_K, 0x80000000),
3480 			BPF_STMT(BPF_ST, 2), /* M2 = 1 ^ len ^ 0x80000000 */
3481 			BPF_STMT(BPF_STX, 15), /* M3 = len */
3482 			BPF_STMT(BPF_LDX | BPF_MEM, 1),
3483 			BPF_STMT(BPF_LD | BPF_MEM, 2),
3484 			BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
3485 			BPF_STMT(BPF_LDX | BPF_MEM, 15),
3486 			BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
3487 			BPF_STMT(BPF_RET | BPF_A, 0)
3488 		},
3489 		CLASSIC,
3490 		{ },
3491 		{ { 1, 0x80000001 }, { 2, 0x80000002 }, { 60, 0x80000000 ^ 60 } }
3492 	},
3493 	{
3494 		"JEQ",
3495 		.u.insns = {
3496 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3497 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
3498 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 0, 1),
3499 			BPF_STMT(BPF_RET | BPF_K, 1),
3500 			BPF_STMT(BPF_RET | BPF_K, MAX_K)
3501 		},
3502 		CLASSIC,
3503 		{ 3, 3, 3, 3, 3 },
3504 		{ { 1, 0 }, { 3, 1 }, { 4, MAX_K } },
3505 	},
3506 	{
3507 		"JGT",
3508 		.u.insns = {
3509 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3510 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
3511 			BPF_JUMP(BPF_JMP | BPF_JGT | BPF_X, 0, 0, 1),
3512 			BPF_STMT(BPF_RET | BPF_K, 1),
3513 			BPF_STMT(BPF_RET | BPF_K, MAX_K)
3514 		},
3515 		CLASSIC,
3516 		{ 4, 4, 4, 3, 3 },
3517 		{ { 2, 0 }, { 3, 1 }, { 4, MAX_K } },
3518 	},
3519 	{
3520 		"JGE (jt 0), test 1",
3521 		.u.insns = {
3522 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3523 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
3524 			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 1),
3525 			BPF_STMT(BPF_RET | BPF_K, 1),
3526 			BPF_STMT(BPF_RET | BPF_K, MAX_K)
3527 		},
3528 		CLASSIC,
3529 		{ 4, 4, 4, 3, 3 },
3530 		{ { 2, 0 }, { 3, 1 }, { 4, 1 } },
3531 	},
3532 	{
3533 		"JGE (jt 0), test 2",
3534 		.u.insns = {
3535 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3536 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
3537 			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 1),
3538 			BPF_STMT(BPF_RET | BPF_K, 1),
3539 			BPF_STMT(BPF_RET | BPF_K, MAX_K)
3540 		},
3541 		CLASSIC,
3542 		{ 4, 4, 5, 3, 3 },
3543 		{ { 4, 1 }, { 5, 1 }, { 6, MAX_K } },
3544 	},
3545 	{
3546 		"JGE",
3547 		.u.insns = {
3548 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3549 			BPF_STMT(BPF_LD | BPF_B | BPF_IND, MAX_K),
3550 			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 1, 1, 0),
3551 			BPF_STMT(BPF_RET | BPF_K, 10),
3552 			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 2, 1, 0),
3553 			BPF_STMT(BPF_RET | BPF_K, 20),
3554 			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 3, 1, 0),
3555 			BPF_STMT(BPF_RET | BPF_K, 30),
3556 			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 4, 1, 0),
3557 			BPF_STMT(BPF_RET | BPF_K, 40),
3558 			BPF_STMT(BPF_RET | BPF_K, MAX_K)
3559 		},
3560 		CLASSIC,
3561 		{ 1, 2, 3, 4, 5 },
3562 		{ { 1, 20 }, { 3, 40 }, { 5, MAX_K } },
3563 	},
3564 	{
3565 		"JSET",
3566 		.u.insns = {
3567 			BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
3568 			BPF_JUMP(BPF_JMP | BPF_JA, 1, 1, 1),
3569 			BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
3570 			BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
3571 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3572 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
3573 			BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, 4),
3574 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3575 			BPF_STMT(BPF_LD | BPF_W | BPF_IND, 0),
3576 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 1, 0, 1),
3577 			BPF_STMT(BPF_RET | BPF_K, 10),
3578 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x80000000, 0, 1),
3579 			BPF_STMT(BPF_RET | BPF_K, 20),
3580 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
3581 			BPF_STMT(BPF_RET | BPF_K, 30),
3582 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
3583 			BPF_STMT(BPF_RET | BPF_K, 30),
3584 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
3585 			BPF_STMT(BPF_RET | BPF_K, 30),
3586 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
3587 			BPF_STMT(BPF_RET | BPF_K, 30),
3588 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
3589 			BPF_STMT(BPF_RET | BPF_K, 30),
3590 			BPF_STMT(BPF_RET | BPF_K, MAX_K)
3591 		},
3592 		CLASSIC,
3593 		{ 0, 0xAA, 0x55, 1 },
3594 		{ { 4, 10 }, { 5, 20 }, { 6, MAX_K } },
3595 	},
3596 	{
3597 		"tcpdump port 22",
3598 		.u.insns = {
3599 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
3600 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 0, 8), /* IPv6 */
3601 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 20),
3602 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
3603 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
3604 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 17),
3605 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 54),
3606 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 14, 0),
3607 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 56),
3608 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 12, 13),
3609 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0800, 0, 12), /* IPv4 */
3610 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
3611 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
3612 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
3613 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 8),
3614 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
3615 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 6, 0),
3616 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
3617 			BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
3618 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
3619 			BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
3620 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 1),
3621 			BPF_STMT(BPF_RET | BPF_K, 0xffff),
3622 			BPF_STMT(BPF_RET | BPF_K, 0),
3623 		},
3624 		CLASSIC,
3625 		/* 3c:07:54:43:e5:76 > 10:bf:48:d6:43:d6, ethertype IPv4(0x0800)
3626 		 * length 114: 10.1.1.149.49700 > 10.1.2.10.22: Flags [P.],
3627 		 * seq 1305692979:1305693027, ack 3650467037, win 65535,
3628 		 * options [nop,nop,TS val 2502645400 ecr 3971138], length 48
3629 		 */
3630 		{ 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
3631 		  0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
3632 		  0x08, 0x00,
3633 		  0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
3634 		  0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
3635 		  0x0a, 0x01, 0x01, 0x95, /* ip src */
3636 		  0x0a, 0x01, 0x02, 0x0a, /* ip dst */
3637 		  0xc2, 0x24,
3638 		  0x00, 0x16 /* dst port */ },
3639 		{ { 10, 0 }, { 30, 0 }, { 100, 65535 } },
3640 	},
3641 	{
3642 		"tcpdump complex",
3643 		.u.insns = {
3644 			/* tcpdump -nei eth0 'tcp port 22 and (((ip[2:2] -
3645 			 * ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0) and
3646 			 * (len > 115 or len < 30000000000)' -d
3647 			 */
3648 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
3649 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 30, 0),
3650 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x800, 0, 29),
3651 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
3652 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 0, 27),
3653 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
3654 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 25, 0),
3655 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
3656 			BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
3657 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
3658 			BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
3659 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 20),
3660 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 16),
3661 			BPF_STMT(BPF_ST, 1),
3662 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 14),
3663 			BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf),
3664 			BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 2),
3665 			BPF_STMT(BPF_MISC | BPF_TAX, 0x5), /* libpcap emits K on TAX */
3666 			BPF_STMT(BPF_LD | BPF_MEM, 1),
3667 			BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
3668 			BPF_STMT(BPF_ST, 5),
3669 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
3670 			BPF_STMT(BPF_LD | BPF_B | BPF_IND, 26),
3671 			BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
3672 			BPF_STMT(BPF_ALU | BPF_RSH | BPF_K, 2),
3673 			BPF_STMT(BPF_MISC | BPF_TAX, 0x9), /* libpcap emits K on TAX */
3674 			BPF_STMT(BPF_LD | BPF_MEM, 5),
3675 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 4, 0),
3676 			BPF_STMT(BPF_LD | BPF_LEN, 0),
3677 			BPF_JUMP(BPF_JMP | BPF_JGT | BPF_K, 0x73, 1, 0),
3678 			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 0xfc23ac00, 1, 0),
3679 			BPF_STMT(BPF_RET | BPF_K, 0xffff),
3680 			BPF_STMT(BPF_RET | BPF_K, 0),
3681 		},
3682 		CLASSIC,
3683 		{ 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
3684 		  0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
3685 		  0x08, 0x00,
3686 		  0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
3687 		  0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
3688 		  0x0a, 0x01, 0x01, 0x95, /* ip src */
3689 		  0x0a, 0x01, 0x02, 0x0a, /* ip dst */
3690 		  0xc2, 0x24,
3691 		  0x00, 0x16 /* dst port */ },
3692 		{ { 10, 0 }, { 30, 0 }, { 100, 65535 } },
3693 	},
3694 	{
3695 		"RET_A",
3696 		.u.insns = {
3697 			/* check that uninitialized X and A contain zeros */
3698 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
3699 			BPF_STMT(BPF_RET | BPF_A, 0)
3700 		},
3701 		CLASSIC,
3702 		{ },
3703 		{ {1, 0}, {2, 0} },
3704 	},
3705 	{
3706 		"INT: ADD trivial",
3707 		.u.insns_int = {
3708 			BPF_ALU64_IMM(BPF_MOV, R1, 1),
3709 			BPF_ALU64_IMM(BPF_ADD, R1, 2),
3710 			BPF_ALU64_IMM(BPF_MOV, R2, 3),
3711 			BPF_ALU64_REG(BPF_SUB, R1, R2),
3712 			BPF_ALU64_IMM(BPF_ADD, R1, -1),
3713 			BPF_ALU64_IMM(BPF_MUL, R1, 3),
3714 			BPF_ALU64_REG(BPF_MOV, R0, R1),
3715 			BPF_EXIT_INSN(),
3716 		},
3717 		INTERNAL,
3718 		{ },
3719 		{ { 0, 0xfffffffd } }
3720 	},
3721 	{
3722 		"INT: MUL_X",
3723 		.u.insns_int = {
3724 			BPF_ALU64_IMM(BPF_MOV, R0, -1),
3725 			BPF_ALU64_IMM(BPF_MOV, R1, -1),
3726 			BPF_ALU64_IMM(BPF_MOV, R2, 3),
3727 			BPF_ALU64_REG(BPF_MUL, R1, R2),
3728 			BPF_JMP_IMM(BPF_JEQ, R1, 0xfffffffd, 1),
3729 			BPF_EXIT_INSN(),
3730 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
3731 			BPF_EXIT_INSN(),
3732 		},
3733 		INTERNAL,
3734 		{ },
3735 		{ { 0, 1 } }
3736 	},
3737 	{
3738 		"INT: MUL_X2",
3739 		.u.insns_int = {
3740 			BPF_ALU32_IMM(BPF_MOV, R0, -1),
3741 			BPF_ALU32_IMM(BPF_MOV, R1, -1),
3742 			BPF_ALU32_IMM(BPF_MOV, R2, 3),
3743 			BPF_ALU64_REG(BPF_MUL, R1, R2),
3744 			BPF_ALU64_IMM(BPF_RSH, R1, 8),
3745 			BPF_JMP_IMM(BPF_JEQ, R1, 0x2ffffff, 1),
3746 			BPF_EXIT_INSN(),
3747 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
3748 			BPF_EXIT_INSN(),
3749 		},
3750 		INTERNAL,
3751 		{ },
3752 		{ { 0, 1 } }
3753 	},
3754 	{
3755 		"INT: MUL32_X",
3756 		.u.insns_int = {
3757 			BPF_ALU32_IMM(BPF_MOV, R0, -1),
3758 			BPF_ALU64_IMM(BPF_MOV, R1, -1),
3759 			BPF_ALU32_IMM(BPF_MOV, R2, 3),
3760 			BPF_ALU32_REG(BPF_MUL, R1, R2),
3761 			BPF_ALU64_IMM(BPF_RSH, R1, 8),
3762 			BPF_JMP_IMM(BPF_JEQ, R1, 0xffffff, 1),
3763 			BPF_EXIT_INSN(),
3764 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
3765 			BPF_EXIT_INSN(),
3766 		},
3767 		INTERNAL,
3768 		{ },
3769 		{ { 0, 1 } }
3770 	},
3771 	{
3772 		/* Have to test all register combinations, since
3773 		 * JITing of different registers will produce
3774 		 * different asm code.
3775 		 */
3776 		"INT: ADD 64-bit",
3777 		.u.insns_int = {
3778 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
3779 			BPF_ALU64_IMM(BPF_MOV, R1, 1),
3780 			BPF_ALU64_IMM(BPF_MOV, R2, 2),
3781 			BPF_ALU64_IMM(BPF_MOV, R3, 3),
3782 			BPF_ALU64_IMM(BPF_MOV, R4, 4),
3783 			BPF_ALU64_IMM(BPF_MOV, R5, 5),
3784 			BPF_ALU64_IMM(BPF_MOV, R6, 6),
3785 			BPF_ALU64_IMM(BPF_MOV, R7, 7),
3786 			BPF_ALU64_IMM(BPF_MOV, R8, 8),
3787 			BPF_ALU64_IMM(BPF_MOV, R9, 9),
3788 			BPF_ALU64_IMM(BPF_ADD, R0, 20),
3789 			BPF_ALU64_IMM(BPF_ADD, R1, 20),
3790 			BPF_ALU64_IMM(BPF_ADD, R2, 20),
3791 			BPF_ALU64_IMM(BPF_ADD, R3, 20),
3792 			BPF_ALU64_IMM(BPF_ADD, R4, 20),
3793 			BPF_ALU64_IMM(BPF_ADD, R5, 20),
3794 			BPF_ALU64_IMM(BPF_ADD, R6, 20),
3795 			BPF_ALU64_IMM(BPF_ADD, R7, 20),
3796 			BPF_ALU64_IMM(BPF_ADD, R8, 20),
3797 			BPF_ALU64_IMM(BPF_ADD, R9, 20),
3798 			BPF_ALU64_IMM(BPF_SUB, R0, 10),
3799 			BPF_ALU64_IMM(BPF_SUB, R1, 10),
3800 			BPF_ALU64_IMM(BPF_SUB, R2, 10),
3801 			BPF_ALU64_IMM(BPF_SUB, R3, 10),
3802 			BPF_ALU64_IMM(BPF_SUB, R4, 10),
3803 			BPF_ALU64_IMM(BPF_SUB, R5, 10),
3804 			BPF_ALU64_IMM(BPF_SUB, R6, 10),
3805 			BPF_ALU64_IMM(BPF_SUB, R7, 10),
3806 			BPF_ALU64_IMM(BPF_SUB, R8, 10),
3807 			BPF_ALU64_IMM(BPF_SUB, R9, 10),
3808 			BPF_ALU64_REG(BPF_ADD, R0, R0),
3809 			BPF_ALU64_REG(BPF_ADD, R0, R1),
3810 			BPF_ALU64_REG(BPF_ADD, R0, R2),
3811 			BPF_ALU64_REG(BPF_ADD, R0, R3),
3812 			BPF_ALU64_REG(BPF_ADD, R0, R4),
3813 			BPF_ALU64_REG(BPF_ADD, R0, R5),
3814 			BPF_ALU64_REG(BPF_ADD, R0, R6),
3815 			BPF_ALU64_REG(BPF_ADD, R0, R7),
3816 			BPF_ALU64_REG(BPF_ADD, R0, R8),
3817 			BPF_ALU64_REG(BPF_ADD, R0, R9), /* R0 == 155 */
3818 			BPF_JMP_IMM(BPF_JEQ, R0, 155, 1),
3819 			BPF_EXIT_INSN(),
3820 			BPF_ALU64_REG(BPF_ADD, R1, R0),
3821 			BPF_ALU64_REG(BPF_ADD, R1, R1),
3822 			BPF_ALU64_REG(BPF_ADD, R1, R2),
3823 			BPF_ALU64_REG(BPF_ADD, R1, R3),
3824 			BPF_ALU64_REG(BPF_ADD, R1, R4),
3825 			BPF_ALU64_REG(BPF_ADD, R1, R5),
3826 			BPF_ALU64_REG(BPF_ADD, R1, R6),
3827 			BPF_ALU64_REG(BPF_ADD, R1, R7),
3828 			BPF_ALU64_REG(BPF_ADD, R1, R8),
3829 			BPF_ALU64_REG(BPF_ADD, R1, R9), /* R1 == 456 */
3830 			BPF_JMP_IMM(BPF_JEQ, R1, 456, 1),
3831 			BPF_EXIT_INSN(),
3832 			BPF_ALU64_REG(BPF_ADD, R2, R0),
3833 			BPF_ALU64_REG(BPF_ADD, R2, R1),
3834 			BPF_ALU64_REG(BPF_ADD, R2, R2),
3835 			BPF_ALU64_REG(BPF_ADD, R2, R3),
3836 			BPF_ALU64_REG(BPF_ADD, R2, R4),
3837 			BPF_ALU64_REG(BPF_ADD, R2, R5),
3838 			BPF_ALU64_REG(BPF_ADD, R2, R6),
3839 			BPF_ALU64_REG(BPF_ADD, R2, R7),
3840 			BPF_ALU64_REG(BPF_ADD, R2, R8),
3841 			BPF_ALU64_REG(BPF_ADD, R2, R9), /* R2 == 1358 */
3842 			BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1),
3843 			BPF_EXIT_INSN(),
3844 			BPF_ALU64_REG(BPF_ADD, R3, R0),
3845 			BPF_ALU64_REG(BPF_ADD, R3, R1),
3846 			BPF_ALU64_REG(BPF_ADD, R3, R2),
3847 			BPF_ALU64_REG(BPF_ADD, R3, R3),
3848 			BPF_ALU64_REG(BPF_ADD, R3, R4),
3849 			BPF_ALU64_REG(BPF_ADD, R3, R5),
3850 			BPF_ALU64_REG(BPF_ADD, R3, R6),
3851 			BPF_ALU64_REG(BPF_ADD, R3, R7),
3852 			BPF_ALU64_REG(BPF_ADD, R3, R8),
3853 			BPF_ALU64_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
3854 			BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
3855 			BPF_EXIT_INSN(),
3856 			BPF_ALU64_REG(BPF_ADD, R4, R0),
3857 			BPF_ALU64_REG(BPF_ADD, R4, R1),
3858 			BPF_ALU64_REG(BPF_ADD, R4, R2),
3859 			BPF_ALU64_REG(BPF_ADD, R4, R3),
3860 			BPF_ALU64_REG(BPF_ADD, R4, R4),
3861 			BPF_ALU64_REG(BPF_ADD, R4, R5),
3862 			BPF_ALU64_REG(BPF_ADD, R4, R6),
3863 			BPF_ALU64_REG(BPF_ADD, R4, R7),
3864 			BPF_ALU64_REG(BPF_ADD, R4, R8),
3865 			BPF_ALU64_REG(BPF_ADD, R4, R9), /* R4 == 12177 */
3866 			BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1),
3867 			BPF_EXIT_INSN(),
3868 			BPF_ALU64_REG(BPF_ADD, R5, R0),
3869 			BPF_ALU64_REG(BPF_ADD, R5, R1),
3870 			BPF_ALU64_REG(BPF_ADD, R5, R2),
3871 			BPF_ALU64_REG(BPF_ADD, R5, R3),
3872 			BPF_ALU64_REG(BPF_ADD, R5, R4),
3873 			BPF_ALU64_REG(BPF_ADD, R5, R5),
3874 			BPF_ALU64_REG(BPF_ADD, R5, R6),
3875 			BPF_ALU64_REG(BPF_ADD, R5, R7),
3876 			BPF_ALU64_REG(BPF_ADD, R5, R8),
3877 			BPF_ALU64_REG(BPF_ADD, R5, R9), /* R5 == 36518 */
3878 			BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1),
3879 			BPF_EXIT_INSN(),
3880 			BPF_ALU64_REG(BPF_ADD, R6, R0),
3881 			BPF_ALU64_REG(BPF_ADD, R6, R1),
3882 			BPF_ALU64_REG(BPF_ADD, R6, R2),
3883 			BPF_ALU64_REG(BPF_ADD, R6, R3),
3884 			BPF_ALU64_REG(BPF_ADD, R6, R4),
3885 			BPF_ALU64_REG(BPF_ADD, R6, R5),
3886 			BPF_ALU64_REG(BPF_ADD, R6, R6),
3887 			BPF_ALU64_REG(BPF_ADD, R6, R7),
3888 			BPF_ALU64_REG(BPF_ADD, R6, R8),
3889 			BPF_ALU64_REG(BPF_ADD, R6, R9), /* R6 == 109540 */
3890 			BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1),
3891 			BPF_EXIT_INSN(),
3892 			BPF_ALU64_REG(BPF_ADD, R7, R0),
3893 			BPF_ALU64_REG(BPF_ADD, R7, R1),
3894 			BPF_ALU64_REG(BPF_ADD, R7, R2),
3895 			BPF_ALU64_REG(BPF_ADD, R7, R3),
3896 			BPF_ALU64_REG(BPF_ADD, R7, R4),
3897 			BPF_ALU64_REG(BPF_ADD, R7, R5),
3898 			BPF_ALU64_REG(BPF_ADD, R7, R6),
3899 			BPF_ALU64_REG(BPF_ADD, R7, R7),
3900 			BPF_ALU64_REG(BPF_ADD, R7, R8),
3901 			BPF_ALU64_REG(BPF_ADD, R7, R9), /* R7 == 328605 */
3902 			BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1),
3903 			BPF_EXIT_INSN(),
3904 			BPF_ALU64_REG(BPF_ADD, R8, R0),
3905 			BPF_ALU64_REG(BPF_ADD, R8, R1),
3906 			BPF_ALU64_REG(BPF_ADD, R8, R2),
3907 			BPF_ALU64_REG(BPF_ADD, R8, R3),
3908 			BPF_ALU64_REG(BPF_ADD, R8, R4),
3909 			BPF_ALU64_REG(BPF_ADD, R8, R5),
3910 			BPF_ALU64_REG(BPF_ADD, R8, R6),
3911 			BPF_ALU64_REG(BPF_ADD, R8, R7),
3912 			BPF_ALU64_REG(BPF_ADD, R8, R8),
3913 			BPF_ALU64_REG(BPF_ADD, R8, R9), /* R8 == 985799 */
3914 			BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1),
3915 			BPF_EXIT_INSN(),
3916 			BPF_ALU64_REG(BPF_ADD, R9, R0),
3917 			BPF_ALU64_REG(BPF_ADD, R9, R1),
3918 			BPF_ALU64_REG(BPF_ADD, R9, R2),
3919 			BPF_ALU64_REG(BPF_ADD, R9, R3),
3920 			BPF_ALU64_REG(BPF_ADD, R9, R4),
3921 			BPF_ALU64_REG(BPF_ADD, R9, R5),
3922 			BPF_ALU64_REG(BPF_ADD, R9, R6),
3923 			BPF_ALU64_REG(BPF_ADD, R9, R7),
3924 			BPF_ALU64_REG(BPF_ADD, R9, R8),
3925 			BPF_ALU64_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */
3926 			BPF_ALU64_REG(BPF_MOV, R0, R9),
3927 			BPF_EXIT_INSN(),
3928 		},
3929 		INTERNAL,
3930 		{ },
3931 		{ { 0, 2957380 } }
3932 	},
3933 	{
3934 		"INT: ADD 32-bit",
3935 		.u.insns_int = {
3936 			BPF_ALU32_IMM(BPF_MOV, R0, 20),
3937 			BPF_ALU32_IMM(BPF_MOV, R1, 1),
3938 			BPF_ALU32_IMM(BPF_MOV, R2, 2),
3939 			BPF_ALU32_IMM(BPF_MOV, R3, 3),
3940 			BPF_ALU32_IMM(BPF_MOV, R4, 4),
3941 			BPF_ALU32_IMM(BPF_MOV, R5, 5),
3942 			BPF_ALU32_IMM(BPF_MOV, R6, 6),
3943 			BPF_ALU32_IMM(BPF_MOV, R7, 7),
3944 			BPF_ALU32_IMM(BPF_MOV, R8, 8),
3945 			BPF_ALU32_IMM(BPF_MOV, R9, 9),
3946 			BPF_ALU64_IMM(BPF_ADD, R1, 10),
3947 			BPF_ALU64_IMM(BPF_ADD, R2, 10),
3948 			BPF_ALU64_IMM(BPF_ADD, R3, 10),
3949 			BPF_ALU64_IMM(BPF_ADD, R4, 10),
3950 			BPF_ALU64_IMM(BPF_ADD, R5, 10),
3951 			BPF_ALU64_IMM(BPF_ADD, R6, 10),
3952 			BPF_ALU64_IMM(BPF_ADD, R7, 10),
3953 			BPF_ALU64_IMM(BPF_ADD, R8, 10),
3954 			BPF_ALU64_IMM(BPF_ADD, R9, 10),
3955 			BPF_ALU32_REG(BPF_ADD, R0, R1),
3956 			BPF_ALU32_REG(BPF_ADD, R0, R2),
3957 			BPF_ALU32_REG(BPF_ADD, R0, R3),
3958 			BPF_ALU32_REG(BPF_ADD, R0, R4),
3959 			BPF_ALU32_REG(BPF_ADD, R0, R5),
3960 			BPF_ALU32_REG(BPF_ADD, R0, R6),
3961 			BPF_ALU32_REG(BPF_ADD, R0, R7),
3962 			BPF_ALU32_REG(BPF_ADD, R0, R8),
3963 			BPF_ALU32_REG(BPF_ADD, R0, R9), /* R0 == 155 */
3964 			BPF_JMP_IMM(BPF_JEQ, R0, 155, 1),
3965 			BPF_EXIT_INSN(),
3966 			BPF_ALU32_REG(BPF_ADD, R1, R0),
3967 			BPF_ALU32_REG(BPF_ADD, R1, R1),
3968 			BPF_ALU32_REG(BPF_ADD, R1, R2),
3969 			BPF_ALU32_REG(BPF_ADD, R1, R3),
3970 			BPF_ALU32_REG(BPF_ADD, R1, R4),
3971 			BPF_ALU32_REG(BPF_ADD, R1, R5),
3972 			BPF_ALU32_REG(BPF_ADD, R1, R6),
3973 			BPF_ALU32_REG(BPF_ADD, R1, R7),
3974 			BPF_ALU32_REG(BPF_ADD, R1, R8),
3975 			BPF_ALU32_REG(BPF_ADD, R1, R9), /* R1 == 456 */
3976 			BPF_JMP_IMM(BPF_JEQ, R1, 456, 1),
3977 			BPF_EXIT_INSN(),
3978 			BPF_ALU32_REG(BPF_ADD, R2, R0),
3979 			BPF_ALU32_REG(BPF_ADD, R2, R1),
3980 			BPF_ALU32_REG(BPF_ADD, R2, R2),
3981 			BPF_ALU32_REG(BPF_ADD, R2, R3),
3982 			BPF_ALU32_REG(BPF_ADD, R2, R4),
3983 			BPF_ALU32_REG(BPF_ADD, R2, R5),
3984 			BPF_ALU32_REG(BPF_ADD, R2, R6),
3985 			BPF_ALU32_REG(BPF_ADD, R2, R7),
3986 			BPF_ALU32_REG(BPF_ADD, R2, R8),
3987 			BPF_ALU32_REG(BPF_ADD, R2, R9), /* R2 == 1358 */
3988 			BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1),
3989 			BPF_EXIT_INSN(),
3990 			BPF_ALU32_REG(BPF_ADD, R3, R0),
3991 			BPF_ALU32_REG(BPF_ADD, R3, R1),
3992 			BPF_ALU32_REG(BPF_ADD, R3, R2),
3993 			BPF_ALU32_REG(BPF_ADD, R3, R3),
3994 			BPF_ALU32_REG(BPF_ADD, R3, R4),
3995 			BPF_ALU32_REG(BPF_ADD, R3, R5),
3996 			BPF_ALU32_REG(BPF_ADD, R3, R6),
3997 			BPF_ALU32_REG(BPF_ADD, R3, R7),
3998 			BPF_ALU32_REG(BPF_ADD, R3, R8),
3999 			BPF_ALU32_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
4000 			BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
4001 			BPF_EXIT_INSN(),
4002 			BPF_ALU32_REG(BPF_ADD, R4, R0),
4003 			BPF_ALU32_REG(BPF_ADD, R4, R1),
4004 			BPF_ALU32_REG(BPF_ADD, R4, R2),
4005 			BPF_ALU32_REG(BPF_ADD, R4, R3),
4006 			BPF_ALU32_REG(BPF_ADD, R4, R4),
4007 			BPF_ALU32_REG(BPF_ADD, R4, R5),
4008 			BPF_ALU32_REG(BPF_ADD, R4, R6),
4009 			BPF_ALU32_REG(BPF_ADD, R4, R7),
4010 			BPF_ALU32_REG(BPF_ADD, R4, R8),
4011 			BPF_ALU32_REG(BPF_ADD, R4, R9), /* R4 == 12177 */
4012 			BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1),
4013 			BPF_EXIT_INSN(),
4014 			BPF_ALU32_REG(BPF_ADD, R5, R0),
4015 			BPF_ALU32_REG(BPF_ADD, R5, R1),
4016 			BPF_ALU32_REG(BPF_ADD, R5, R2),
4017 			BPF_ALU32_REG(BPF_ADD, R5, R3),
4018 			BPF_ALU32_REG(BPF_ADD, R5, R4),
4019 			BPF_ALU32_REG(BPF_ADD, R5, R5),
4020 			BPF_ALU32_REG(BPF_ADD, R5, R6),
4021 			BPF_ALU32_REG(BPF_ADD, R5, R7),
4022 			BPF_ALU32_REG(BPF_ADD, R5, R8),
4023 			BPF_ALU32_REG(BPF_ADD, R5, R9), /* R5 == 36518 */
4024 			BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1),
4025 			BPF_EXIT_INSN(),
4026 			BPF_ALU32_REG(BPF_ADD, R6, R0),
4027 			BPF_ALU32_REG(BPF_ADD, R6, R1),
4028 			BPF_ALU32_REG(BPF_ADD, R6, R2),
4029 			BPF_ALU32_REG(BPF_ADD, R6, R3),
4030 			BPF_ALU32_REG(BPF_ADD, R6, R4),
4031 			BPF_ALU32_REG(BPF_ADD, R6, R5),
4032 			BPF_ALU32_REG(BPF_ADD, R6, R6),
4033 			BPF_ALU32_REG(BPF_ADD, R6, R7),
4034 			BPF_ALU32_REG(BPF_ADD, R6, R8),
4035 			BPF_ALU32_REG(BPF_ADD, R6, R9), /* R6 == 109540 */
4036 			BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1),
4037 			BPF_EXIT_INSN(),
4038 			BPF_ALU32_REG(BPF_ADD, R7, R0),
4039 			BPF_ALU32_REG(BPF_ADD, R7, R1),
4040 			BPF_ALU32_REG(BPF_ADD, R7, R2),
4041 			BPF_ALU32_REG(BPF_ADD, R7, R3),
4042 			BPF_ALU32_REG(BPF_ADD, R7, R4),
4043 			BPF_ALU32_REG(BPF_ADD, R7, R5),
4044 			BPF_ALU32_REG(BPF_ADD, R7, R6),
4045 			BPF_ALU32_REG(BPF_ADD, R7, R7),
4046 			BPF_ALU32_REG(BPF_ADD, R7, R8),
4047 			BPF_ALU32_REG(BPF_ADD, R7, R9), /* R7 == 328605 */
4048 			BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1),
4049 			BPF_EXIT_INSN(),
4050 			BPF_ALU32_REG(BPF_ADD, R8, R0),
4051 			BPF_ALU32_REG(BPF_ADD, R8, R1),
4052 			BPF_ALU32_REG(BPF_ADD, R8, R2),
4053 			BPF_ALU32_REG(BPF_ADD, R8, R3),
4054 			BPF_ALU32_REG(BPF_ADD, R8, R4),
4055 			BPF_ALU32_REG(BPF_ADD, R8, R5),
4056 			BPF_ALU32_REG(BPF_ADD, R8, R6),
4057 			BPF_ALU32_REG(BPF_ADD, R8, R7),
4058 			BPF_ALU32_REG(BPF_ADD, R8, R8),
4059 			BPF_ALU32_REG(BPF_ADD, R8, R9), /* R8 == 985799 */
4060 			BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1),
4061 			BPF_EXIT_INSN(),
4062 			BPF_ALU32_REG(BPF_ADD, R9, R0),
4063 			BPF_ALU32_REG(BPF_ADD, R9, R1),
4064 			BPF_ALU32_REG(BPF_ADD, R9, R2),
4065 			BPF_ALU32_REG(BPF_ADD, R9, R3),
4066 			BPF_ALU32_REG(BPF_ADD, R9, R4),
4067 			BPF_ALU32_REG(BPF_ADD, R9, R5),
4068 			BPF_ALU32_REG(BPF_ADD, R9, R6),
4069 			BPF_ALU32_REG(BPF_ADD, R9, R7),
4070 			BPF_ALU32_REG(BPF_ADD, R9, R8),
4071 			BPF_ALU32_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */
4072 			BPF_ALU32_REG(BPF_MOV, R0, R9),
4073 			BPF_EXIT_INSN(),
4074 		},
4075 		INTERNAL,
4076 		{ },
4077 		{ { 0, 2957380 } }
4078 	},
4079 	{	/* Mainly checking JIT here. */
4080 		"INT: SUB",
4081 		.u.insns_int = {
4082 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
4083 			BPF_ALU64_IMM(BPF_MOV, R1, 1),
4084 			BPF_ALU64_IMM(BPF_MOV, R2, 2),
4085 			BPF_ALU64_IMM(BPF_MOV, R3, 3),
4086 			BPF_ALU64_IMM(BPF_MOV, R4, 4),
4087 			BPF_ALU64_IMM(BPF_MOV, R5, 5),
4088 			BPF_ALU64_IMM(BPF_MOV, R6, 6),
4089 			BPF_ALU64_IMM(BPF_MOV, R7, 7),
4090 			BPF_ALU64_IMM(BPF_MOV, R8, 8),
4091 			BPF_ALU64_IMM(BPF_MOV, R9, 9),
4092 			BPF_ALU64_REG(BPF_SUB, R0, R0),
4093 			BPF_ALU64_REG(BPF_SUB, R0, R1),
4094 			BPF_ALU64_REG(BPF_SUB, R0, R2),
4095 			BPF_ALU64_REG(BPF_SUB, R0, R3),
4096 			BPF_ALU64_REG(BPF_SUB, R0, R4),
4097 			BPF_ALU64_REG(BPF_SUB, R0, R5),
4098 			BPF_ALU64_REG(BPF_SUB, R0, R6),
4099 			BPF_ALU64_REG(BPF_SUB, R0, R7),
4100 			BPF_ALU64_REG(BPF_SUB, R0, R8),
4101 			BPF_ALU64_REG(BPF_SUB, R0, R9),
4102 			BPF_ALU64_IMM(BPF_SUB, R0, 10),
4103 			BPF_JMP_IMM(BPF_JEQ, R0, -55, 1),
4104 			BPF_EXIT_INSN(),
4105 			BPF_ALU64_REG(BPF_SUB, R1, R0),
4106 			BPF_ALU64_REG(BPF_SUB, R1, R2),
4107 			BPF_ALU64_REG(BPF_SUB, R1, R3),
4108 			BPF_ALU64_REG(BPF_SUB, R1, R4),
4109 			BPF_ALU64_REG(BPF_SUB, R1, R5),
4110 			BPF_ALU64_REG(BPF_SUB, R1, R6),
4111 			BPF_ALU64_REG(BPF_SUB, R1, R7),
4112 			BPF_ALU64_REG(BPF_SUB, R1, R8),
4113 			BPF_ALU64_REG(BPF_SUB, R1, R9),
4114 			BPF_ALU64_IMM(BPF_SUB, R1, 10),
4115 			BPF_ALU64_REG(BPF_SUB, R2, R0),
4116 			BPF_ALU64_REG(BPF_SUB, R2, R1),
4117 			BPF_ALU64_REG(BPF_SUB, R2, R3),
4118 			BPF_ALU64_REG(BPF_SUB, R2, R4),
4119 			BPF_ALU64_REG(BPF_SUB, R2, R5),
4120 			BPF_ALU64_REG(BPF_SUB, R2, R6),
4121 			BPF_ALU64_REG(BPF_SUB, R2, R7),
4122 			BPF_ALU64_REG(BPF_SUB, R2, R8),
4123 			BPF_ALU64_REG(BPF_SUB, R2, R9),
4124 			BPF_ALU64_IMM(BPF_SUB, R2, 10),
4125 			BPF_ALU64_REG(BPF_SUB, R3, R0),
4126 			BPF_ALU64_REG(BPF_SUB, R3, R1),
4127 			BPF_ALU64_REG(BPF_SUB, R3, R2),
4128 			BPF_ALU64_REG(BPF_SUB, R3, R4),
4129 			BPF_ALU64_REG(BPF_SUB, R3, R5),
4130 			BPF_ALU64_REG(BPF_SUB, R3, R6),
4131 			BPF_ALU64_REG(BPF_SUB, R3, R7),
4132 			BPF_ALU64_REG(BPF_SUB, R3, R8),
4133 			BPF_ALU64_REG(BPF_SUB, R3, R9),
4134 			BPF_ALU64_IMM(BPF_SUB, R3, 10),
4135 			BPF_ALU64_REG(BPF_SUB, R4, R0),
4136 			BPF_ALU64_REG(BPF_SUB, R4, R1),
4137 			BPF_ALU64_REG(BPF_SUB, R4, R2),
4138 			BPF_ALU64_REG(BPF_SUB, R4, R3),
4139 			BPF_ALU64_REG(BPF_SUB, R4, R5),
4140 			BPF_ALU64_REG(BPF_SUB, R4, R6),
4141 			BPF_ALU64_REG(BPF_SUB, R4, R7),
4142 			BPF_ALU64_REG(BPF_SUB, R4, R8),
4143 			BPF_ALU64_REG(BPF_SUB, R4, R9),
4144 			BPF_ALU64_IMM(BPF_SUB, R4, 10),
4145 			BPF_ALU64_REG(BPF_SUB, R5, R0),
4146 			BPF_ALU64_REG(BPF_SUB, R5, R1),
4147 			BPF_ALU64_REG(BPF_SUB, R5, R2),
4148 			BPF_ALU64_REG(BPF_SUB, R5, R3),
4149 			BPF_ALU64_REG(BPF_SUB, R5, R4),
4150 			BPF_ALU64_REG(BPF_SUB, R5, R6),
4151 			BPF_ALU64_REG(BPF_SUB, R5, R7),
4152 			BPF_ALU64_REG(BPF_SUB, R5, R8),
4153 			BPF_ALU64_REG(BPF_SUB, R5, R9),
4154 			BPF_ALU64_IMM(BPF_SUB, R5, 10),
4155 			BPF_ALU64_REG(BPF_SUB, R6, R0),
4156 			BPF_ALU64_REG(BPF_SUB, R6, R1),
4157 			BPF_ALU64_REG(BPF_SUB, R6, R2),
4158 			BPF_ALU64_REG(BPF_SUB, R6, R3),
4159 			BPF_ALU64_REG(BPF_SUB, R6, R4),
4160 			BPF_ALU64_REG(BPF_SUB, R6, R5),
4161 			BPF_ALU64_REG(BPF_SUB, R6, R7),
4162 			BPF_ALU64_REG(BPF_SUB, R6, R8),
4163 			BPF_ALU64_REG(BPF_SUB, R6, R9),
4164 			BPF_ALU64_IMM(BPF_SUB, R6, 10),
4165 			BPF_ALU64_REG(BPF_SUB, R7, R0),
4166 			BPF_ALU64_REG(BPF_SUB, R7, R1),
4167 			BPF_ALU64_REG(BPF_SUB, R7, R2),
4168 			BPF_ALU64_REG(BPF_SUB, R7, R3),
4169 			BPF_ALU64_REG(BPF_SUB, R7, R4),
4170 			BPF_ALU64_REG(BPF_SUB, R7, R5),
4171 			BPF_ALU64_REG(BPF_SUB, R7, R6),
4172 			BPF_ALU64_REG(BPF_SUB, R7, R8),
4173 			BPF_ALU64_REG(BPF_SUB, R7, R9),
4174 			BPF_ALU64_IMM(BPF_SUB, R7, 10),
4175 			BPF_ALU64_REG(BPF_SUB, R8, R0),
4176 			BPF_ALU64_REG(BPF_SUB, R8, R1),
4177 			BPF_ALU64_REG(BPF_SUB, R8, R2),
4178 			BPF_ALU64_REG(BPF_SUB, R8, R3),
4179 			BPF_ALU64_REG(BPF_SUB, R8, R4),
4180 			BPF_ALU64_REG(BPF_SUB, R8, R5),
4181 			BPF_ALU64_REG(BPF_SUB, R8, R6),
4182 			BPF_ALU64_REG(BPF_SUB, R8, R7),
4183 			BPF_ALU64_REG(BPF_SUB, R8, R9),
4184 			BPF_ALU64_IMM(BPF_SUB, R8, 10),
4185 			BPF_ALU64_REG(BPF_SUB, R9, R0),
4186 			BPF_ALU64_REG(BPF_SUB, R9, R1),
4187 			BPF_ALU64_REG(BPF_SUB, R9, R2),
4188 			BPF_ALU64_REG(BPF_SUB, R9, R3),
4189 			BPF_ALU64_REG(BPF_SUB, R9, R4),
4190 			BPF_ALU64_REG(BPF_SUB, R9, R5),
4191 			BPF_ALU64_REG(BPF_SUB, R9, R6),
4192 			BPF_ALU64_REG(BPF_SUB, R9, R7),
4193 			BPF_ALU64_REG(BPF_SUB, R9, R8),
4194 			BPF_ALU64_IMM(BPF_SUB, R9, 10),
4195 			BPF_ALU64_IMM(BPF_SUB, R0, 10),
4196 			BPF_ALU64_IMM(BPF_NEG, R0, 0),
4197 			BPF_ALU64_REG(BPF_SUB, R0, R1),
4198 			BPF_ALU64_REG(BPF_SUB, R0, R2),
4199 			BPF_ALU64_REG(BPF_SUB, R0, R3),
4200 			BPF_ALU64_REG(BPF_SUB, R0, R4),
4201 			BPF_ALU64_REG(BPF_SUB, R0, R5),
4202 			BPF_ALU64_REG(BPF_SUB, R0, R6),
4203 			BPF_ALU64_REG(BPF_SUB, R0, R7),
4204 			BPF_ALU64_REG(BPF_SUB, R0, R8),
4205 			BPF_ALU64_REG(BPF_SUB, R0, R9),
4206 			BPF_EXIT_INSN(),
4207 		},
4208 		INTERNAL,
4209 		{ },
4210 		{ { 0, 11 } }
4211 	},
4212 	{	/* Mainly checking JIT here. */
4213 		"INT: XOR",
4214 		.u.insns_int = {
4215 			BPF_ALU64_REG(BPF_SUB, R0, R0),
4216 			BPF_ALU64_REG(BPF_XOR, R1, R1),
4217 			BPF_JMP_REG(BPF_JEQ, R0, R1, 1),
4218 			BPF_EXIT_INSN(),
4219 			BPF_ALU64_IMM(BPF_MOV, R0, 10),
4220 			BPF_ALU64_IMM(BPF_MOV, R1, -1),
4221 			BPF_ALU64_REG(BPF_SUB, R1, R1),
4222 			BPF_ALU64_REG(BPF_XOR, R2, R2),
4223 			BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
4224 			BPF_EXIT_INSN(),
4225 			BPF_ALU64_REG(BPF_SUB, R2, R2),
4226 			BPF_ALU64_REG(BPF_XOR, R3, R3),
4227 			BPF_ALU64_IMM(BPF_MOV, R0, 10),
4228 			BPF_ALU64_IMM(BPF_MOV, R1, -1),
4229 			BPF_JMP_REG(BPF_JEQ, R2, R3, 1),
4230 			BPF_EXIT_INSN(),
4231 			BPF_ALU64_REG(BPF_SUB, R3, R3),
4232 			BPF_ALU64_REG(BPF_XOR, R4, R4),
4233 			BPF_ALU64_IMM(BPF_MOV, R2, 1),
4234 			BPF_ALU64_IMM(BPF_MOV, R5, -1),
4235 			BPF_JMP_REG(BPF_JEQ, R3, R4, 1),
4236 			BPF_EXIT_INSN(),
4237 			BPF_ALU64_REG(BPF_SUB, R4, R4),
4238 			BPF_ALU64_REG(BPF_XOR, R5, R5),
4239 			BPF_ALU64_IMM(BPF_MOV, R3, 1),
4240 			BPF_ALU64_IMM(BPF_MOV, R7, -1),
4241 			BPF_JMP_REG(BPF_JEQ, R5, R4, 1),
4242 			BPF_EXIT_INSN(),
4243 			BPF_ALU64_IMM(BPF_MOV, R5, 1),
4244 			BPF_ALU64_REG(BPF_SUB, R5, R5),
4245 			BPF_ALU64_REG(BPF_XOR, R6, R6),
4246 			BPF_ALU64_IMM(BPF_MOV, R1, 1),
4247 			BPF_ALU64_IMM(BPF_MOV, R8, -1),
4248 			BPF_JMP_REG(BPF_JEQ, R5, R6, 1),
4249 			BPF_EXIT_INSN(),
4250 			BPF_ALU64_REG(BPF_SUB, R6, R6),
4251 			BPF_ALU64_REG(BPF_XOR, R7, R7),
4252 			BPF_JMP_REG(BPF_JEQ, R7, R6, 1),
4253 			BPF_EXIT_INSN(),
4254 			BPF_ALU64_REG(BPF_SUB, R7, R7),
4255 			BPF_ALU64_REG(BPF_XOR, R8, R8),
4256 			BPF_JMP_REG(BPF_JEQ, R7, R8, 1),
4257 			BPF_EXIT_INSN(),
4258 			BPF_ALU64_REG(BPF_SUB, R8, R8),
4259 			BPF_ALU64_REG(BPF_XOR, R9, R9),
4260 			BPF_JMP_REG(BPF_JEQ, R9, R8, 1),
4261 			BPF_EXIT_INSN(),
4262 			BPF_ALU64_REG(BPF_SUB, R9, R9),
4263 			BPF_ALU64_REG(BPF_XOR, R0, R0),
4264 			BPF_JMP_REG(BPF_JEQ, R9, R0, 1),
4265 			BPF_EXIT_INSN(),
4266 			BPF_ALU64_REG(BPF_SUB, R1, R1),
4267 			BPF_ALU64_REG(BPF_XOR, R0, R0),
4268 			BPF_JMP_REG(BPF_JEQ, R9, R0, 2),
4269 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
4270 			BPF_EXIT_INSN(),
4271 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
4272 			BPF_EXIT_INSN(),
4273 		},
4274 		INTERNAL,
4275 		{ },
4276 		{ { 0, 1 } }
4277 	},
4278 	{	/* Mainly checking JIT here. */
4279 		"INT: MUL",
4280 		.u.insns_int = {
4281 			BPF_ALU64_IMM(BPF_MOV, R0, 11),
4282 			BPF_ALU64_IMM(BPF_MOV, R1, 1),
4283 			BPF_ALU64_IMM(BPF_MOV, R2, 2),
4284 			BPF_ALU64_IMM(BPF_MOV, R3, 3),
4285 			BPF_ALU64_IMM(BPF_MOV, R4, 4),
4286 			BPF_ALU64_IMM(BPF_MOV, R5, 5),
4287 			BPF_ALU64_IMM(BPF_MOV, R6, 6),
4288 			BPF_ALU64_IMM(BPF_MOV, R7, 7),
4289 			BPF_ALU64_IMM(BPF_MOV, R8, 8),
4290 			BPF_ALU64_IMM(BPF_MOV, R9, 9),
4291 			BPF_ALU64_REG(BPF_MUL, R0, R0),
4292 			BPF_ALU64_REG(BPF_MUL, R0, R1),
4293 			BPF_ALU64_REG(BPF_MUL, R0, R2),
4294 			BPF_ALU64_REG(BPF_MUL, R0, R3),
4295 			BPF_ALU64_REG(BPF_MUL, R0, R4),
4296 			BPF_ALU64_REG(BPF_MUL, R0, R5),
4297 			BPF_ALU64_REG(BPF_MUL, R0, R6),
4298 			BPF_ALU64_REG(BPF_MUL, R0, R7),
4299 			BPF_ALU64_REG(BPF_MUL, R0, R8),
4300 			BPF_ALU64_REG(BPF_MUL, R0, R9),
4301 			BPF_ALU64_IMM(BPF_MUL, R0, 10),
4302 			BPF_JMP_IMM(BPF_JEQ, R0, 439084800, 1),
4303 			BPF_EXIT_INSN(),
4304 			BPF_ALU64_REG(BPF_MUL, R1, R0),
4305 			BPF_ALU64_REG(BPF_MUL, R1, R2),
4306 			BPF_ALU64_REG(BPF_MUL, R1, R3),
4307 			BPF_ALU64_REG(BPF_MUL, R1, R4),
4308 			BPF_ALU64_REG(BPF_MUL, R1, R5),
4309 			BPF_ALU64_REG(BPF_MUL, R1, R6),
4310 			BPF_ALU64_REG(BPF_MUL, R1, R7),
4311 			BPF_ALU64_REG(BPF_MUL, R1, R8),
4312 			BPF_ALU64_REG(BPF_MUL, R1, R9),
4313 			BPF_ALU64_IMM(BPF_MUL, R1, 10),
4314 			BPF_ALU64_REG(BPF_MOV, R2, R1),
4315 			BPF_ALU64_IMM(BPF_RSH, R2, 32),
4316 			BPF_JMP_IMM(BPF_JEQ, R2, 0x5a924, 1),
4317 			BPF_EXIT_INSN(),
4318 			BPF_ALU64_IMM(BPF_LSH, R1, 32),
4319 			BPF_ALU64_IMM(BPF_ARSH, R1, 32),
4320 			BPF_JMP_IMM(BPF_JEQ, R1, 0xebb90000, 1),
4321 			BPF_EXIT_INSN(),
4322 			BPF_ALU64_REG(BPF_MUL, R2, R0),
4323 			BPF_ALU64_REG(BPF_MUL, R2, R1),
4324 			BPF_ALU64_REG(BPF_MUL, R2, R3),
4325 			BPF_ALU64_REG(BPF_MUL, R2, R4),
4326 			BPF_ALU64_REG(BPF_MUL, R2, R5),
4327 			BPF_ALU64_REG(BPF_MUL, R2, R6),
4328 			BPF_ALU64_REG(BPF_MUL, R2, R7),
4329 			BPF_ALU64_REG(BPF_MUL, R2, R8),
4330 			BPF_ALU64_REG(BPF_MUL, R2, R9),
4331 			BPF_ALU64_IMM(BPF_MUL, R2, 10),
4332 			BPF_ALU64_IMM(BPF_RSH, R2, 32),
4333 			BPF_ALU64_REG(BPF_MOV, R0, R2),
4334 			BPF_EXIT_INSN(),
4335 		},
4336 		INTERNAL,
4337 		{ },
4338 		{ { 0, 0x35d97ef2 } }
4339 	},
4340 	{	/* Mainly checking JIT here. */
4341 		"MOV REG64",
4342 		.u.insns_int = {
4343 			BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
4344 			BPF_MOV64_REG(R1, R0),
4345 			BPF_MOV64_REG(R2, R1),
4346 			BPF_MOV64_REG(R3, R2),
4347 			BPF_MOV64_REG(R4, R3),
4348 			BPF_MOV64_REG(R5, R4),
4349 			BPF_MOV64_REG(R6, R5),
4350 			BPF_MOV64_REG(R7, R6),
4351 			BPF_MOV64_REG(R8, R7),
4352 			BPF_MOV64_REG(R9, R8),
4353 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
4354 			BPF_ALU64_IMM(BPF_MOV, R1, 0),
4355 			BPF_ALU64_IMM(BPF_MOV, R2, 0),
4356 			BPF_ALU64_IMM(BPF_MOV, R3, 0),
4357 			BPF_ALU64_IMM(BPF_MOV, R4, 0),
4358 			BPF_ALU64_IMM(BPF_MOV, R5, 0),
4359 			BPF_ALU64_IMM(BPF_MOV, R6, 0),
4360 			BPF_ALU64_IMM(BPF_MOV, R7, 0),
4361 			BPF_ALU64_IMM(BPF_MOV, R8, 0),
4362 			BPF_ALU64_IMM(BPF_MOV, R9, 0),
4363 			BPF_ALU64_REG(BPF_ADD, R0, R0),
4364 			BPF_ALU64_REG(BPF_ADD, R0, R1),
4365 			BPF_ALU64_REG(BPF_ADD, R0, R2),
4366 			BPF_ALU64_REG(BPF_ADD, R0, R3),
4367 			BPF_ALU64_REG(BPF_ADD, R0, R4),
4368 			BPF_ALU64_REG(BPF_ADD, R0, R5),
4369 			BPF_ALU64_REG(BPF_ADD, R0, R6),
4370 			BPF_ALU64_REG(BPF_ADD, R0, R7),
4371 			BPF_ALU64_REG(BPF_ADD, R0, R8),
4372 			BPF_ALU64_REG(BPF_ADD, R0, R9),
4373 			BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
4374 			BPF_EXIT_INSN(),
4375 		},
4376 		INTERNAL,
4377 		{ },
4378 		{ { 0, 0xfefe } }
4379 	},
4380 	{	/* Mainly checking JIT here. */
4381 		"MOV REG32",
4382 		.u.insns_int = {
4383 			BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
4384 			BPF_MOV64_REG(R1, R0),
4385 			BPF_MOV64_REG(R2, R1),
4386 			BPF_MOV64_REG(R3, R2),
4387 			BPF_MOV64_REG(R4, R3),
4388 			BPF_MOV64_REG(R5, R4),
4389 			BPF_MOV64_REG(R6, R5),
4390 			BPF_MOV64_REG(R7, R6),
4391 			BPF_MOV64_REG(R8, R7),
4392 			BPF_MOV64_REG(R9, R8),
4393 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
4394 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
4395 			BPF_ALU32_IMM(BPF_MOV, R2, 0),
4396 			BPF_ALU32_IMM(BPF_MOV, R3, 0),
4397 			BPF_ALU32_IMM(BPF_MOV, R4, 0),
4398 			BPF_ALU32_IMM(BPF_MOV, R5, 0),
4399 			BPF_ALU32_IMM(BPF_MOV, R6, 0),
4400 			BPF_ALU32_IMM(BPF_MOV, R7, 0),
4401 			BPF_ALU32_IMM(BPF_MOV, R8, 0),
4402 			BPF_ALU32_IMM(BPF_MOV, R9, 0),
4403 			BPF_ALU64_REG(BPF_ADD, R0, R0),
4404 			BPF_ALU64_REG(BPF_ADD, R0, R1),
4405 			BPF_ALU64_REG(BPF_ADD, R0, R2),
4406 			BPF_ALU64_REG(BPF_ADD, R0, R3),
4407 			BPF_ALU64_REG(BPF_ADD, R0, R4),
4408 			BPF_ALU64_REG(BPF_ADD, R0, R5),
4409 			BPF_ALU64_REG(BPF_ADD, R0, R6),
4410 			BPF_ALU64_REG(BPF_ADD, R0, R7),
4411 			BPF_ALU64_REG(BPF_ADD, R0, R8),
4412 			BPF_ALU64_REG(BPF_ADD, R0, R9),
4413 			BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
4414 			BPF_EXIT_INSN(),
4415 		},
4416 		INTERNAL,
4417 		{ },
4418 		{ { 0, 0xfefe } }
4419 	},
4420 	{	/* Mainly checking JIT here. */
4421 		"LD IMM64",
4422 		.u.insns_int = {
4423 			BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
4424 			BPF_MOV64_REG(R1, R0),
4425 			BPF_MOV64_REG(R2, R1),
4426 			BPF_MOV64_REG(R3, R2),
4427 			BPF_MOV64_REG(R4, R3),
4428 			BPF_MOV64_REG(R5, R4),
4429 			BPF_MOV64_REG(R6, R5),
4430 			BPF_MOV64_REG(R7, R6),
4431 			BPF_MOV64_REG(R8, R7),
4432 			BPF_MOV64_REG(R9, R8),
4433 			BPF_LD_IMM64(R0, 0x0LL),
4434 			BPF_LD_IMM64(R1, 0x0LL),
4435 			BPF_LD_IMM64(R2, 0x0LL),
4436 			BPF_LD_IMM64(R3, 0x0LL),
4437 			BPF_LD_IMM64(R4, 0x0LL),
4438 			BPF_LD_IMM64(R5, 0x0LL),
4439 			BPF_LD_IMM64(R6, 0x0LL),
4440 			BPF_LD_IMM64(R7, 0x0LL),
4441 			BPF_LD_IMM64(R8, 0x0LL),
4442 			BPF_LD_IMM64(R9, 0x0LL),
4443 			BPF_ALU64_REG(BPF_ADD, R0, R0),
4444 			BPF_ALU64_REG(BPF_ADD, R0, R1),
4445 			BPF_ALU64_REG(BPF_ADD, R0, R2),
4446 			BPF_ALU64_REG(BPF_ADD, R0, R3),
4447 			BPF_ALU64_REG(BPF_ADD, R0, R4),
4448 			BPF_ALU64_REG(BPF_ADD, R0, R5),
4449 			BPF_ALU64_REG(BPF_ADD, R0, R6),
4450 			BPF_ALU64_REG(BPF_ADD, R0, R7),
4451 			BPF_ALU64_REG(BPF_ADD, R0, R8),
4452 			BPF_ALU64_REG(BPF_ADD, R0, R9),
4453 			BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
4454 			BPF_EXIT_INSN(),
4455 		},
4456 		INTERNAL,
4457 		{ },
4458 		{ { 0, 0xfefe } }
4459 	},
4460 	{
4461 		"INT: ALU MIX",
4462 		.u.insns_int = {
4463 			BPF_ALU64_IMM(BPF_MOV, R0, 11),
4464 			BPF_ALU64_IMM(BPF_ADD, R0, -1),
4465 			BPF_ALU64_IMM(BPF_MOV, R2, 2),
4466 			BPF_ALU64_IMM(BPF_XOR, R2, 3),
4467 			BPF_ALU64_REG(BPF_DIV, R0, R2),
4468 			BPF_JMP_IMM(BPF_JEQ, R0, 10, 1),
4469 			BPF_EXIT_INSN(),
4470 			BPF_ALU64_IMM(BPF_MOD, R0, 3),
4471 			BPF_JMP_IMM(BPF_JEQ, R0, 1, 1),
4472 			BPF_EXIT_INSN(),
4473 			BPF_ALU64_IMM(BPF_MOV, R0, -1),
4474 			BPF_EXIT_INSN(),
4475 		},
4476 		INTERNAL,
4477 		{ },
4478 		{ { 0, -1 } }
4479 	},
4480 	{
4481 		"INT: shifts by register",
4482 		.u.insns_int = {
4483 			BPF_MOV64_IMM(R0, -1234),
4484 			BPF_MOV64_IMM(R1, 1),
4485 			BPF_ALU32_REG(BPF_RSH, R0, R1),
4486 			BPF_JMP_IMM(BPF_JEQ, R0, 0x7ffffd97, 1),
4487 			BPF_EXIT_INSN(),
4488 			BPF_MOV64_IMM(R2, 1),
4489 			BPF_ALU64_REG(BPF_LSH, R0, R2),
4490 			BPF_MOV32_IMM(R4, -1234),
4491 			BPF_JMP_REG(BPF_JEQ, R0, R4, 1),
4492 			BPF_EXIT_INSN(),
4493 			BPF_ALU64_IMM(BPF_AND, R4, 63),
4494 			BPF_ALU64_REG(BPF_LSH, R0, R4), /* R0 <= 46 */
4495 			BPF_MOV64_IMM(R3, 47),
4496 			BPF_ALU64_REG(BPF_ARSH, R0, R3),
4497 			BPF_JMP_IMM(BPF_JEQ, R0, -617, 1),
4498 			BPF_EXIT_INSN(),
4499 			BPF_MOV64_IMM(R2, 1),
4500 			BPF_ALU64_REG(BPF_LSH, R4, R2), /* R4 = 46 << 1 */
4501 			BPF_JMP_IMM(BPF_JEQ, R4, 92, 1),
4502 			BPF_EXIT_INSN(),
4503 			BPF_MOV64_IMM(R4, 4),
4504 			BPF_ALU64_REG(BPF_LSH, R4, R4), /* R4 = 4 << 4 */
4505 			BPF_JMP_IMM(BPF_JEQ, R4, 64, 1),
4506 			BPF_EXIT_INSN(),
4507 			BPF_MOV64_IMM(R4, 5),
4508 			BPF_ALU32_REG(BPF_LSH, R4, R4), /* R4 = 5 << 5 */
4509 			BPF_JMP_IMM(BPF_JEQ, R4, 160, 1),
4510 			BPF_EXIT_INSN(),
4511 			BPF_MOV64_IMM(R0, -1),
4512 			BPF_EXIT_INSN(),
4513 		},
4514 		INTERNAL,
4515 		{ },
4516 		{ { 0, -1 } }
4517 	},
4518 #ifdef CONFIG_32BIT
4519 	{
4520 		"INT: 32-bit context pointer word order and zero-extension",
4521 		.u.insns_int = {
4522 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
4523 			BPF_JMP32_IMM(BPF_JEQ, R1, 0, 3),
4524 			BPF_ALU64_IMM(BPF_RSH, R1, 32),
4525 			BPF_JMP32_IMM(BPF_JNE, R1, 0, 1),
4526 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
4527 			BPF_EXIT_INSN(),
4528 		},
4529 		INTERNAL,
4530 		{ },
4531 		{ { 0, 1 } }
4532 	},
4533 #endif
4534 	{
4535 		"check: missing ret",
4536 		.u.insns = {
4537 			BPF_STMT(BPF_LD | BPF_IMM, 1),
4538 		},
4539 		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4540 		{ },
4541 		{ },
4542 		.fill_helper = NULL,
4543 		.expected_errcode = -EINVAL,
4544 	},
4545 	{
4546 		"check: div_k_0",
4547 		.u.insns = {
4548 			BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0),
4549 			BPF_STMT(BPF_RET | BPF_K, 0)
4550 		},
4551 		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4552 		{ },
4553 		{ },
4554 		.fill_helper = NULL,
4555 		.expected_errcode = -EINVAL,
4556 	},
4557 	{
4558 		"check: unknown insn",
4559 		.u.insns = {
4560 			/* seccomp insn, rejected in socket filter */
4561 			BPF_STMT(BPF_LDX | BPF_W | BPF_ABS, 0),
4562 			BPF_STMT(BPF_RET | BPF_K, 0)
4563 		},
4564 		CLASSIC | FLAG_EXPECTED_FAIL,
4565 		{ },
4566 		{ },
4567 		.fill_helper = NULL,
4568 		.expected_errcode = -EINVAL,
4569 	},
4570 	{
4571 		"check: out of range spill/fill",
4572 		.u.insns = {
4573 			BPF_STMT(BPF_STX, 16),
4574 			BPF_STMT(BPF_RET | BPF_K, 0)
4575 		},
4576 		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4577 		{ },
4578 		{ },
4579 		.fill_helper = NULL,
4580 		.expected_errcode = -EINVAL,
4581 	},
4582 	{
4583 		"JUMPS + HOLES",
4584 		.u.insns = {
4585 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4586 			BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 15),
4587 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4588 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4589 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4590 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4591 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4592 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4593 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4594 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4595 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4596 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4597 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4598 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4599 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4600 			BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 3, 4),
4601 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4602 			BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 1, 2),
4603 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4604 			BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
4605 			BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
4606 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4607 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4608 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4609 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4610 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4611 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4612 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4613 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4614 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4615 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4616 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4617 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4618 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4619 			BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 2, 3),
4620 			BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 1, 2),
4621 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4622 			BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
4623 			BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
4624 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4625 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4626 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4627 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4628 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4629 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4630 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4631 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4632 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4633 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4634 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4635 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4636 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4637 			BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 2, 3),
4638 			BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 1, 2),
4639 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4640 			BPF_STMT(BPF_RET | BPF_A, 0),
4641 			BPF_STMT(BPF_RET | BPF_A, 0),
4642 		},
4643 		CLASSIC,
4644 		{ 0x00, 0x1b, 0x21, 0x3c, 0x9d, 0xf8,
4645 		  0x90, 0xe2, 0xba, 0x0a, 0x56, 0xb4,
4646 		  0x08, 0x00,
4647 		  0x45, 0x00, 0x00, 0x28, 0x00, 0x00,
4648 		  0x20, 0x00, 0x40, 0x11, 0x00, 0x00, /* IP header */
4649 		  0xc0, 0xa8, 0x33, 0x01,
4650 		  0xc0, 0xa8, 0x33, 0x02,
4651 		  0xbb, 0xb6,
4652 		  0xa9, 0xfa,
4653 		  0x00, 0x14, 0x00, 0x00,
4654 		  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4655 		  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4656 		  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4657 		  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4658 		  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4659 		  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4660 		  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4661 		  0xcc, 0xcc, 0xcc, 0xcc },
4662 		{ { 88, 0x001b } }
4663 	},
4664 	{
4665 		"check: RET X",
4666 		.u.insns = {
4667 			BPF_STMT(BPF_RET | BPF_X, 0),
4668 		},
4669 		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4670 		{ },
4671 		{ },
4672 		.fill_helper = NULL,
4673 		.expected_errcode = -EINVAL,
4674 	},
4675 	{
4676 		"check: LDX + RET X",
4677 		.u.insns = {
4678 			BPF_STMT(BPF_LDX | BPF_IMM, 42),
4679 			BPF_STMT(BPF_RET | BPF_X, 0),
4680 		},
4681 		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4682 		{ },
4683 		{ },
4684 		.fill_helper = NULL,
4685 		.expected_errcode = -EINVAL,
4686 	},
4687 	{	/* Mainly checking JIT here. */
4688 		"M[]: alt STX + LDX",
4689 		.u.insns = {
4690 			BPF_STMT(BPF_LDX | BPF_IMM, 100),
4691 			BPF_STMT(BPF_STX, 0),
4692 			BPF_STMT(BPF_LDX | BPF_MEM, 0),
4693 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4694 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4695 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4696 			BPF_STMT(BPF_STX, 1),
4697 			BPF_STMT(BPF_LDX | BPF_MEM, 1),
4698 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4699 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4700 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4701 			BPF_STMT(BPF_STX, 2),
4702 			BPF_STMT(BPF_LDX | BPF_MEM, 2),
4703 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4704 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4705 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4706 			BPF_STMT(BPF_STX, 3),
4707 			BPF_STMT(BPF_LDX | BPF_MEM, 3),
4708 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4709 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4710 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4711 			BPF_STMT(BPF_STX, 4),
4712 			BPF_STMT(BPF_LDX | BPF_MEM, 4),
4713 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4714 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4715 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4716 			BPF_STMT(BPF_STX, 5),
4717 			BPF_STMT(BPF_LDX | BPF_MEM, 5),
4718 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4719 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4720 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4721 			BPF_STMT(BPF_STX, 6),
4722 			BPF_STMT(BPF_LDX | BPF_MEM, 6),
4723 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4724 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4725 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4726 			BPF_STMT(BPF_STX, 7),
4727 			BPF_STMT(BPF_LDX | BPF_MEM, 7),
4728 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4729 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4730 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4731 			BPF_STMT(BPF_STX, 8),
4732 			BPF_STMT(BPF_LDX | BPF_MEM, 8),
4733 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4734 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4735 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4736 			BPF_STMT(BPF_STX, 9),
4737 			BPF_STMT(BPF_LDX | BPF_MEM, 9),
4738 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4739 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4740 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4741 			BPF_STMT(BPF_STX, 10),
4742 			BPF_STMT(BPF_LDX | BPF_MEM, 10),
4743 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4744 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4745 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4746 			BPF_STMT(BPF_STX, 11),
4747 			BPF_STMT(BPF_LDX | BPF_MEM, 11),
4748 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4749 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4750 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4751 			BPF_STMT(BPF_STX, 12),
4752 			BPF_STMT(BPF_LDX | BPF_MEM, 12),
4753 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4754 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4755 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4756 			BPF_STMT(BPF_STX, 13),
4757 			BPF_STMT(BPF_LDX | BPF_MEM, 13),
4758 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4759 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4760 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4761 			BPF_STMT(BPF_STX, 14),
4762 			BPF_STMT(BPF_LDX | BPF_MEM, 14),
4763 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4764 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4765 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4766 			BPF_STMT(BPF_STX, 15),
4767 			BPF_STMT(BPF_LDX | BPF_MEM, 15),
4768 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4769 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4770 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4771 			BPF_STMT(BPF_RET | BPF_A, 0),
4772 		},
4773 		CLASSIC | FLAG_NO_DATA,
4774 		{ },
4775 		{ { 0, 116 } },
4776 	},
4777 	{	/* Mainly checking JIT here. */
4778 		"M[]: full STX + full LDX",
4779 		.u.insns = {
4780 			BPF_STMT(BPF_LDX | BPF_IMM, 0xbadfeedb),
4781 			BPF_STMT(BPF_STX, 0),
4782 			BPF_STMT(BPF_LDX | BPF_IMM, 0xecabedae),
4783 			BPF_STMT(BPF_STX, 1),
4784 			BPF_STMT(BPF_LDX | BPF_IMM, 0xafccfeaf),
4785 			BPF_STMT(BPF_STX, 2),
4786 			BPF_STMT(BPF_LDX | BPF_IMM, 0xbffdcedc),
4787 			BPF_STMT(BPF_STX, 3),
4788 			BPF_STMT(BPF_LDX | BPF_IMM, 0xfbbbdccb),
4789 			BPF_STMT(BPF_STX, 4),
4790 			BPF_STMT(BPF_LDX | BPF_IMM, 0xfbabcbda),
4791 			BPF_STMT(BPF_STX, 5),
4792 			BPF_STMT(BPF_LDX | BPF_IMM, 0xaedecbdb),
4793 			BPF_STMT(BPF_STX, 6),
4794 			BPF_STMT(BPF_LDX | BPF_IMM, 0xadebbade),
4795 			BPF_STMT(BPF_STX, 7),
4796 			BPF_STMT(BPF_LDX | BPF_IMM, 0xfcfcfaec),
4797 			BPF_STMT(BPF_STX, 8),
4798 			BPF_STMT(BPF_LDX | BPF_IMM, 0xbcdddbdc),
4799 			BPF_STMT(BPF_STX, 9),
4800 			BPF_STMT(BPF_LDX | BPF_IMM, 0xfeefdfac),
4801 			BPF_STMT(BPF_STX, 10),
4802 			BPF_STMT(BPF_LDX | BPF_IMM, 0xcddcdeea),
4803 			BPF_STMT(BPF_STX, 11),
4804 			BPF_STMT(BPF_LDX | BPF_IMM, 0xaccfaebb),
4805 			BPF_STMT(BPF_STX, 12),
4806 			BPF_STMT(BPF_LDX | BPF_IMM, 0xbdcccdcf),
4807 			BPF_STMT(BPF_STX, 13),
4808 			BPF_STMT(BPF_LDX | BPF_IMM, 0xaaedecde),
4809 			BPF_STMT(BPF_STX, 14),
4810 			BPF_STMT(BPF_LDX | BPF_IMM, 0xfaeacdad),
4811 			BPF_STMT(BPF_STX, 15),
4812 			BPF_STMT(BPF_LDX | BPF_MEM, 0),
4813 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4814 			BPF_STMT(BPF_LDX | BPF_MEM, 1),
4815 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4816 			BPF_STMT(BPF_LDX | BPF_MEM, 2),
4817 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4818 			BPF_STMT(BPF_LDX | BPF_MEM, 3),
4819 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4820 			BPF_STMT(BPF_LDX | BPF_MEM, 4),
4821 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4822 			BPF_STMT(BPF_LDX | BPF_MEM, 5),
4823 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4824 			BPF_STMT(BPF_LDX | BPF_MEM, 6),
4825 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4826 			BPF_STMT(BPF_LDX | BPF_MEM, 7),
4827 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4828 			BPF_STMT(BPF_LDX | BPF_MEM, 8),
4829 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4830 			BPF_STMT(BPF_LDX | BPF_MEM, 9),
4831 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4832 			BPF_STMT(BPF_LDX | BPF_MEM, 10),
4833 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4834 			BPF_STMT(BPF_LDX | BPF_MEM, 11),
4835 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4836 			BPF_STMT(BPF_LDX | BPF_MEM, 12),
4837 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4838 			BPF_STMT(BPF_LDX | BPF_MEM, 13),
4839 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4840 			BPF_STMT(BPF_LDX | BPF_MEM, 14),
4841 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4842 			BPF_STMT(BPF_LDX | BPF_MEM, 15),
4843 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4844 			BPF_STMT(BPF_RET | BPF_A, 0),
4845 		},
4846 		CLASSIC | FLAG_NO_DATA,
4847 		{ },
4848 		{ { 0, 0x2a5a5e5 } },
4849 	},
4850 	{
4851 		"check: SKF_AD_MAX",
4852 		.u.insns = {
4853 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
4854 				 SKF_AD_OFF + SKF_AD_MAX),
4855 			BPF_STMT(BPF_RET | BPF_A, 0),
4856 		},
4857 		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4858 		{ },
4859 		{ },
4860 		.fill_helper = NULL,
4861 		.expected_errcode = -EINVAL,
4862 	},
4863 	{	/* Passes checker but fails during runtime. */
4864 		"LD [SKF_AD_OFF-1]",
4865 		.u.insns = {
4866 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
4867 				 SKF_AD_OFF - 1),
4868 			BPF_STMT(BPF_RET | BPF_K, 1),
4869 		},
4870 		CLASSIC,
4871 		{ },
4872 		{ { 1, 0 } },
4873 	},
4874 	{
4875 		"load 64-bit immediate",
4876 		.u.insns_int = {
4877 			BPF_LD_IMM64(R1, 0x567800001234LL),
4878 			BPF_MOV64_REG(R2, R1),
4879 			BPF_MOV64_REG(R3, R2),
4880 			BPF_ALU64_IMM(BPF_RSH, R2, 32),
4881 			BPF_ALU64_IMM(BPF_LSH, R3, 32),
4882 			BPF_ALU64_IMM(BPF_RSH, R3, 32),
4883 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
4884 			BPF_JMP_IMM(BPF_JEQ, R2, 0x5678, 1),
4885 			BPF_EXIT_INSN(),
4886 			BPF_JMP_IMM(BPF_JEQ, R3, 0x1234, 1),
4887 			BPF_EXIT_INSN(),
4888 			BPF_LD_IMM64(R0, 0x1ffffffffLL),
4889 			BPF_ALU64_IMM(BPF_RSH, R0, 32), /* R0 = 1 */
4890 			BPF_EXIT_INSN(),
4891 		},
4892 		INTERNAL,
4893 		{ },
4894 		{ { 0, 1 } }
4895 	},
4896 	/* BPF_ALU | BPF_MOV | BPF_X */
4897 	{
4898 		"ALU_MOV_X: dst = 2",
4899 		.u.insns_int = {
4900 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
4901 			BPF_ALU32_REG(BPF_MOV, R0, R1),
4902 			BPF_EXIT_INSN(),
4903 		},
4904 		INTERNAL,
4905 		{ },
4906 		{ { 0, 2 } },
4907 	},
4908 	{
4909 		"ALU_MOV_X: dst = 4294967295",
4910 		.u.insns_int = {
4911 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
4912 			BPF_ALU32_REG(BPF_MOV, R0, R1),
4913 			BPF_EXIT_INSN(),
4914 		},
4915 		INTERNAL,
4916 		{ },
4917 		{ { 0, 4294967295U } },
4918 	},
4919 	{
4920 		"ALU64_MOV_X: dst = 2",
4921 		.u.insns_int = {
4922 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
4923 			BPF_ALU64_REG(BPF_MOV, R0, R1),
4924 			BPF_EXIT_INSN(),
4925 		},
4926 		INTERNAL,
4927 		{ },
4928 		{ { 0, 2 } },
4929 	},
4930 	{
4931 		"ALU64_MOV_X: dst = 4294967295",
4932 		.u.insns_int = {
4933 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
4934 			BPF_ALU64_REG(BPF_MOV, R0, R1),
4935 			BPF_EXIT_INSN(),
4936 		},
4937 		INTERNAL,
4938 		{ },
4939 		{ { 0, 4294967295U } },
4940 	},
4941 	/* BPF_ALU | BPF_MOV | BPF_K */
4942 	{
4943 		"ALU_MOV_K: dst = 2",
4944 		.u.insns_int = {
4945 			BPF_ALU32_IMM(BPF_MOV, R0, 2),
4946 			BPF_EXIT_INSN(),
4947 		},
4948 		INTERNAL,
4949 		{ },
4950 		{ { 0, 2 } },
4951 	},
4952 	{
4953 		"ALU_MOV_K: dst = 4294967295",
4954 		.u.insns_int = {
4955 			BPF_ALU32_IMM(BPF_MOV, R0, 4294967295U),
4956 			BPF_EXIT_INSN(),
4957 		},
4958 		INTERNAL,
4959 		{ },
4960 		{ { 0, 4294967295U } },
4961 	},
4962 	{
4963 		"ALU_MOV_K: 0x0000ffffffff0000 = 0x00000000ffffffff",
4964 		.u.insns_int = {
4965 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
4966 			BPF_LD_IMM64(R3, 0x00000000ffffffffLL),
4967 			BPF_ALU32_IMM(BPF_MOV, R2, 0xffffffff),
4968 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4969 			BPF_MOV32_IMM(R0, 2),
4970 			BPF_EXIT_INSN(),
4971 			BPF_MOV32_IMM(R0, 1),
4972 			BPF_EXIT_INSN(),
4973 		},
4974 		INTERNAL,
4975 		{ },
4976 		{ { 0, 0x1 } },
4977 	},
4978 	{
4979 		"ALU_MOV_K: small negative",
4980 		.u.insns_int = {
4981 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
4982 			BPF_EXIT_INSN(),
4983 		},
4984 		INTERNAL,
4985 		{ },
4986 		{ { 0, -123 } }
4987 	},
4988 	{
4989 		"ALU_MOV_K: small negative zero extension",
4990 		.u.insns_int = {
4991 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
4992 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
4993 			BPF_EXIT_INSN(),
4994 		},
4995 		INTERNAL,
4996 		{ },
4997 		{ { 0, 0 } }
4998 	},
4999 	{
5000 		"ALU_MOV_K: large negative",
5001 		.u.insns_int = {
5002 			BPF_ALU32_IMM(BPF_MOV, R0, -123456789),
5003 			BPF_EXIT_INSN(),
5004 		},
5005 		INTERNAL,
5006 		{ },
5007 		{ { 0, -123456789 } }
5008 	},
5009 	{
5010 		"ALU_MOV_K: large negative zero extension",
5011 		.u.insns_int = {
5012 			BPF_ALU32_IMM(BPF_MOV, R0, -123456789),
5013 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
5014 			BPF_EXIT_INSN(),
5015 		},
5016 		INTERNAL,
5017 		{ },
5018 		{ { 0, 0 } }
5019 	},
5020 	{
5021 		"ALU64_MOV_K: dst = 2",
5022 		.u.insns_int = {
5023 			BPF_ALU64_IMM(BPF_MOV, R0, 2),
5024 			BPF_EXIT_INSN(),
5025 		},
5026 		INTERNAL,
5027 		{ },
5028 		{ { 0, 2 } },
5029 	},
5030 	{
5031 		"ALU64_MOV_K: dst = 2147483647",
5032 		.u.insns_int = {
5033 			BPF_ALU64_IMM(BPF_MOV, R0, 2147483647),
5034 			BPF_EXIT_INSN(),
5035 		},
5036 		INTERNAL,
5037 		{ },
5038 		{ { 0, 2147483647 } },
5039 	},
5040 	{
5041 		"ALU64_OR_K: dst = 0x0",
5042 		.u.insns_int = {
5043 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
5044 			BPF_LD_IMM64(R3, 0x0),
5045 			BPF_ALU64_IMM(BPF_MOV, R2, 0x0),
5046 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5047 			BPF_MOV32_IMM(R0, 2),
5048 			BPF_EXIT_INSN(),
5049 			BPF_MOV32_IMM(R0, 1),
5050 			BPF_EXIT_INSN(),
5051 		},
5052 		INTERNAL,
5053 		{ },
5054 		{ { 0, 0x1 } },
5055 	},
5056 	{
5057 		"ALU64_MOV_K: dst = -1",
5058 		.u.insns_int = {
5059 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
5060 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
5061 			BPF_ALU64_IMM(BPF_MOV, R2, 0xffffffff),
5062 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5063 			BPF_MOV32_IMM(R0, 2),
5064 			BPF_EXIT_INSN(),
5065 			BPF_MOV32_IMM(R0, 1),
5066 			BPF_EXIT_INSN(),
5067 		},
5068 		INTERNAL,
5069 		{ },
5070 		{ { 0, 0x1 } },
5071 	},
5072 	{
5073 		"ALU64_MOV_K: small negative",
5074 		.u.insns_int = {
5075 			BPF_ALU64_IMM(BPF_MOV, R0, -123),
5076 			BPF_EXIT_INSN(),
5077 		},
5078 		INTERNAL,
5079 		{ },
5080 		{ { 0, -123 } }
5081 	},
5082 	{
5083 		"ALU64_MOV_K: small negative sign extension",
5084 		.u.insns_int = {
5085 			BPF_ALU64_IMM(BPF_MOV, R0, -123),
5086 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
5087 			BPF_EXIT_INSN(),
5088 		},
5089 		INTERNAL,
5090 		{ },
5091 		{ { 0, 0xffffffff } }
5092 	},
5093 	{
5094 		"ALU64_MOV_K: large negative",
5095 		.u.insns_int = {
5096 			BPF_ALU64_IMM(BPF_MOV, R0, -123456789),
5097 			BPF_EXIT_INSN(),
5098 		},
5099 		INTERNAL,
5100 		{ },
5101 		{ { 0, -123456789 } }
5102 	},
5103 	{
5104 		"ALU64_MOV_K: large negative sign extension",
5105 		.u.insns_int = {
5106 			BPF_ALU64_IMM(BPF_MOV, R0, -123456789),
5107 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
5108 			BPF_EXIT_INSN(),
5109 		},
5110 		INTERNAL,
5111 		{ },
5112 		{ { 0, 0xffffffff } }
5113 	},
5114 	/* BPF_ALU | BPF_ADD | BPF_X */
5115 	{
5116 		"ALU_ADD_X: 1 + 2 = 3",
5117 		.u.insns_int = {
5118 			BPF_LD_IMM64(R0, 1),
5119 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
5120 			BPF_ALU32_REG(BPF_ADD, R0, R1),
5121 			BPF_EXIT_INSN(),
5122 		},
5123 		INTERNAL,
5124 		{ },
5125 		{ { 0, 3 } },
5126 	},
5127 	{
5128 		"ALU_ADD_X: 1 + 4294967294 = 4294967295",
5129 		.u.insns_int = {
5130 			BPF_LD_IMM64(R0, 1),
5131 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
5132 			BPF_ALU32_REG(BPF_ADD, R0, R1),
5133 			BPF_EXIT_INSN(),
5134 		},
5135 		INTERNAL,
5136 		{ },
5137 		{ { 0, 4294967295U } },
5138 	},
5139 	{
5140 		"ALU_ADD_X: 2 + 4294967294 = 0",
5141 		.u.insns_int = {
5142 			BPF_LD_IMM64(R0, 2),
5143 			BPF_LD_IMM64(R1, 4294967294U),
5144 			BPF_ALU32_REG(BPF_ADD, R0, R1),
5145 			BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
5146 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
5147 			BPF_EXIT_INSN(),
5148 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
5149 			BPF_EXIT_INSN(),
5150 		},
5151 		INTERNAL,
5152 		{ },
5153 		{ { 0, 1 } },
5154 	},
5155 	{
5156 		"ALU64_ADD_X: 1 + 2 = 3",
5157 		.u.insns_int = {
5158 			BPF_LD_IMM64(R0, 1),
5159 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
5160 			BPF_ALU64_REG(BPF_ADD, R0, R1),
5161 			BPF_EXIT_INSN(),
5162 		},
5163 		INTERNAL,
5164 		{ },
5165 		{ { 0, 3 } },
5166 	},
5167 	{
5168 		"ALU64_ADD_X: 1 + 4294967294 = 4294967295",
5169 		.u.insns_int = {
5170 			BPF_LD_IMM64(R0, 1),
5171 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
5172 			BPF_ALU64_REG(BPF_ADD, R0, R1),
5173 			BPF_EXIT_INSN(),
5174 		},
5175 		INTERNAL,
5176 		{ },
5177 		{ { 0, 4294967295U } },
5178 	},
5179 	{
5180 		"ALU64_ADD_X: 2 + 4294967294 = 4294967296",
5181 		.u.insns_int = {
5182 			BPF_LD_IMM64(R0, 2),
5183 			BPF_LD_IMM64(R1, 4294967294U),
5184 			BPF_LD_IMM64(R2, 4294967296ULL),
5185 			BPF_ALU64_REG(BPF_ADD, R0, R1),
5186 			BPF_JMP_REG(BPF_JEQ, R0, R2, 2),
5187 			BPF_MOV32_IMM(R0, 0),
5188 			BPF_EXIT_INSN(),
5189 			BPF_MOV32_IMM(R0, 1),
5190 			BPF_EXIT_INSN(),
5191 		},
5192 		INTERNAL,
5193 		{ },
5194 		{ { 0, 1 } },
5195 	},
5196 	/* BPF_ALU | BPF_ADD | BPF_K */
5197 	{
5198 		"ALU_ADD_K: 1 + 2 = 3",
5199 		.u.insns_int = {
5200 			BPF_LD_IMM64(R0, 1),
5201 			BPF_ALU32_IMM(BPF_ADD, R0, 2),
5202 			BPF_EXIT_INSN(),
5203 		},
5204 		INTERNAL,
5205 		{ },
5206 		{ { 0, 3 } },
5207 	},
5208 	{
5209 		"ALU_ADD_K: 3 + 0 = 3",
5210 		.u.insns_int = {
5211 			BPF_LD_IMM64(R0, 3),
5212 			BPF_ALU32_IMM(BPF_ADD, R0, 0),
5213 			BPF_EXIT_INSN(),
5214 		},
5215 		INTERNAL,
5216 		{ },
5217 		{ { 0, 3 } },
5218 	},
5219 	{
5220 		"ALU_ADD_K: 1 + 4294967294 = 4294967295",
5221 		.u.insns_int = {
5222 			BPF_LD_IMM64(R0, 1),
5223 			BPF_ALU32_IMM(BPF_ADD, R0, 4294967294U),
5224 			BPF_EXIT_INSN(),
5225 		},
5226 		INTERNAL,
5227 		{ },
5228 		{ { 0, 4294967295U } },
5229 	},
5230 	{
5231 		"ALU_ADD_K: 4294967294 + 2 = 0",
5232 		.u.insns_int = {
5233 			BPF_LD_IMM64(R0, 4294967294U),
5234 			BPF_ALU32_IMM(BPF_ADD, R0, 2),
5235 			BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
5236 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
5237 			BPF_EXIT_INSN(),
5238 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
5239 			BPF_EXIT_INSN(),
5240 		},
5241 		INTERNAL,
5242 		{ },
5243 		{ { 0, 1 } },
5244 	},
5245 	{
5246 		"ALU_ADD_K: 0 + (-1) = 0x00000000ffffffff",
5247 		.u.insns_int = {
5248 			BPF_LD_IMM64(R2, 0x0),
5249 			BPF_LD_IMM64(R3, 0x00000000ffffffff),
5250 			BPF_ALU32_IMM(BPF_ADD, R2, 0xffffffff),
5251 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5252 			BPF_MOV32_IMM(R0, 2),
5253 			BPF_EXIT_INSN(),
5254 			BPF_MOV32_IMM(R0, 1),
5255 			BPF_EXIT_INSN(),
5256 		},
5257 		INTERNAL,
5258 		{ },
5259 		{ { 0, 0x1 } },
5260 	},
5261 	{
5262 		"ALU_ADD_K: 0 + 0xffff = 0xffff",
5263 		.u.insns_int = {
5264 			BPF_LD_IMM64(R2, 0x0),
5265 			BPF_LD_IMM64(R3, 0xffff),
5266 			BPF_ALU32_IMM(BPF_ADD, R2, 0xffff),
5267 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5268 			BPF_MOV32_IMM(R0, 2),
5269 			BPF_EXIT_INSN(),
5270 			BPF_MOV32_IMM(R0, 1),
5271 			BPF_EXIT_INSN(),
5272 		},
5273 		INTERNAL,
5274 		{ },
5275 		{ { 0, 0x1 } },
5276 	},
5277 	{
5278 		"ALU_ADD_K: 0 + 0x7fffffff = 0x7fffffff",
5279 		.u.insns_int = {
5280 			BPF_LD_IMM64(R2, 0x0),
5281 			BPF_LD_IMM64(R3, 0x7fffffff),
5282 			BPF_ALU32_IMM(BPF_ADD, R2, 0x7fffffff),
5283 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5284 			BPF_MOV32_IMM(R0, 2),
5285 			BPF_EXIT_INSN(),
5286 			BPF_MOV32_IMM(R0, 1),
5287 			BPF_EXIT_INSN(),
5288 		},
5289 		INTERNAL,
5290 		{ },
5291 		{ { 0, 0x1 } },
5292 	},
5293 	{
5294 		"ALU_ADD_K: 0 + 0x80000000 = 0x80000000",
5295 		.u.insns_int = {
5296 			BPF_LD_IMM64(R2, 0x0),
5297 			BPF_LD_IMM64(R3, 0x80000000),
5298 			BPF_ALU32_IMM(BPF_ADD, R2, 0x80000000),
5299 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5300 			BPF_MOV32_IMM(R0, 2),
5301 			BPF_EXIT_INSN(),
5302 			BPF_MOV32_IMM(R0, 1),
5303 			BPF_EXIT_INSN(),
5304 		},
5305 		INTERNAL,
5306 		{ },
5307 		{ { 0, 0x1 } },
5308 	},
5309 	{
5310 		"ALU_ADD_K: 0 + 0x80008000 = 0x80008000",
5311 		.u.insns_int = {
5312 			BPF_LD_IMM64(R2, 0x0),
5313 			BPF_LD_IMM64(R3, 0x80008000),
5314 			BPF_ALU32_IMM(BPF_ADD, R2, 0x80008000),
5315 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5316 			BPF_MOV32_IMM(R0, 2),
5317 			BPF_EXIT_INSN(),
5318 			BPF_MOV32_IMM(R0, 1),
5319 			BPF_EXIT_INSN(),
5320 		},
5321 		INTERNAL,
5322 		{ },
5323 		{ { 0, 0x1 } },
5324 	},
5325 	{
5326 		"ALU64_ADD_K: 1 + 2 = 3",
5327 		.u.insns_int = {
5328 			BPF_LD_IMM64(R0, 1),
5329 			BPF_ALU64_IMM(BPF_ADD, R0, 2),
5330 			BPF_EXIT_INSN(),
5331 		},
5332 		INTERNAL,
5333 		{ },
5334 		{ { 0, 3 } },
5335 	},
5336 	{
5337 		"ALU64_ADD_K: 3 + 0 = 3",
5338 		.u.insns_int = {
5339 			BPF_LD_IMM64(R0, 3),
5340 			BPF_ALU64_IMM(BPF_ADD, R0, 0),
5341 			BPF_EXIT_INSN(),
5342 		},
5343 		INTERNAL,
5344 		{ },
5345 		{ { 0, 3 } },
5346 	},
5347 	{
5348 		"ALU64_ADD_K: 1 + 2147483646 = 2147483647",
5349 		.u.insns_int = {
5350 			BPF_LD_IMM64(R0, 1),
5351 			BPF_ALU64_IMM(BPF_ADD, R0, 2147483646),
5352 			BPF_EXIT_INSN(),
5353 		},
5354 		INTERNAL,
5355 		{ },
5356 		{ { 0, 2147483647 } },
5357 	},
5358 	{
5359 		"ALU64_ADD_K: 4294967294 + 2 = 4294967296",
5360 		.u.insns_int = {
5361 			BPF_LD_IMM64(R0, 4294967294U),
5362 			BPF_LD_IMM64(R1, 4294967296ULL),
5363 			BPF_ALU64_IMM(BPF_ADD, R0, 2),
5364 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
5365 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
5366 			BPF_EXIT_INSN(),
5367 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
5368 			BPF_EXIT_INSN(),
5369 		},
5370 		INTERNAL,
5371 		{ },
5372 		{ { 0, 1 } },
5373 	},
5374 	{
5375 		"ALU64_ADD_K: 2147483646 + -2147483647 = -1",
5376 		.u.insns_int = {
5377 			BPF_LD_IMM64(R0, 2147483646),
5378 			BPF_ALU64_IMM(BPF_ADD, R0, -2147483647),
5379 			BPF_EXIT_INSN(),
5380 		},
5381 		INTERNAL,
5382 		{ },
5383 		{ { 0, -1 } },
5384 	},
5385 	{
5386 		"ALU64_ADD_K: 1 + 0 = 1",
5387 		.u.insns_int = {
5388 			BPF_LD_IMM64(R2, 0x1),
5389 			BPF_LD_IMM64(R3, 0x1),
5390 			BPF_ALU64_IMM(BPF_ADD, R2, 0x0),
5391 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5392 			BPF_MOV32_IMM(R0, 2),
5393 			BPF_EXIT_INSN(),
5394 			BPF_MOV32_IMM(R0, 1),
5395 			BPF_EXIT_INSN(),
5396 		},
5397 		INTERNAL,
5398 		{ },
5399 		{ { 0, 0x1 } },
5400 	},
5401 	{
5402 		"ALU64_ADD_K: 0 + (-1) = 0xffffffffffffffff",
5403 		.u.insns_int = {
5404 			BPF_LD_IMM64(R2, 0x0),
5405 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
5406 			BPF_ALU64_IMM(BPF_ADD, R2, 0xffffffff),
5407 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5408 			BPF_MOV32_IMM(R0, 2),
5409 			BPF_EXIT_INSN(),
5410 			BPF_MOV32_IMM(R0, 1),
5411 			BPF_EXIT_INSN(),
5412 		},
5413 		INTERNAL,
5414 		{ },
5415 		{ { 0, 0x1 } },
5416 	},
5417 	{
5418 		"ALU64_ADD_K: 0 + 0xffff = 0xffff",
5419 		.u.insns_int = {
5420 			BPF_LD_IMM64(R2, 0x0),
5421 			BPF_LD_IMM64(R3, 0xffff),
5422 			BPF_ALU64_IMM(BPF_ADD, R2, 0xffff),
5423 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5424 			BPF_MOV32_IMM(R0, 2),
5425 			BPF_EXIT_INSN(),
5426 			BPF_MOV32_IMM(R0, 1),
5427 			BPF_EXIT_INSN(),
5428 		},
5429 		INTERNAL,
5430 		{ },
5431 		{ { 0, 0x1 } },
5432 	},
5433 	{
5434 		"ALU64_ADD_K: 0 + 0x7fffffff = 0x7fffffff",
5435 		.u.insns_int = {
5436 			BPF_LD_IMM64(R2, 0x0),
5437 			BPF_LD_IMM64(R3, 0x7fffffff),
5438 			BPF_ALU64_IMM(BPF_ADD, R2, 0x7fffffff),
5439 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5440 			BPF_MOV32_IMM(R0, 2),
5441 			BPF_EXIT_INSN(),
5442 			BPF_MOV32_IMM(R0, 1),
5443 			BPF_EXIT_INSN(),
5444 		},
5445 		INTERNAL,
5446 		{ },
5447 		{ { 0, 0x1 } },
5448 	},
5449 	{
5450 		"ALU64_ADD_K: 0 + 0x80000000 = 0xffffffff80000000",
5451 		.u.insns_int = {
5452 			BPF_LD_IMM64(R2, 0x0),
5453 			BPF_LD_IMM64(R3, 0xffffffff80000000LL),
5454 			BPF_ALU64_IMM(BPF_ADD, R2, 0x80000000),
5455 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5456 			BPF_MOV32_IMM(R0, 2),
5457 			BPF_EXIT_INSN(),
5458 			BPF_MOV32_IMM(R0, 1),
5459 			BPF_EXIT_INSN(),
5460 		},
5461 		INTERNAL,
5462 		{ },
5463 		{ { 0, 0x1 } },
5464 	},
5465 	{
5466 		"ALU_ADD_K: 0 + 0x80008000 = 0xffffffff80008000",
5467 		.u.insns_int = {
5468 			BPF_LD_IMM64(R2, 0x0),
5469 			BPF_LD_IMM64(R3, 0xffffffff80008000LL),
5470 			BPF_ALU64_IMM(BPF_ADD, R2, 0x80008000),
5471 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5472 			BPF_MOV32_IMM(R0, 2),
5473 			BPF_EXIT_INSN(),
5474 			BPF_MOV32_IMM(R0, 1),
5475 			BPF_EXIT_INSN(),
5476 		},
5477 		INTERNAL,
5478 		{ },
5479 		{ { 0, 0x1 } },
5480 	},
5481 	/* BPF_ALU | BPF_SUB | BPF_X */
5482 	{
5483 		"ALU_SUB_X: 3 - 1 = 2",
5484 		.u.insns_int = {
5485 			BPF_LD_IMM64(R0, 3),
5486 			BPF_ALU32_IMM(BPF_MOV, R1, 1),
5487 			BPF_ALU32_REG(BPF_SUB, R0, R1),
5488 			BPF_EXIT_INSN(),
5489 		},
5490 		INTERNAL,
5491 		{ },
5492 		{ { 0, 2 } },
5493 	},
5494 	{
5495 		"ALU_SUB_X: 4294967295 - 4294967294 = 1",
5496 		.u.insns_int = {
5497 			BPF_LD_IMM64(R0, 4294967295U),
5498 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
5499 			BPF_ALU32_REG(BPF_SUB, R0, R1),
5500 			BPF_EXIT_INSN(),
5501 		},
5502 		INTERNAL,
5503 		{ },
5504 		{ { 0, 1 } },
5505 	},
5506 	{
5507 		"ALU64_SUB_X: 3 - 1 = 2",
5508 		.u.insns_int = {
5509 			BPF_LD_IMM64(R0, 3),
5510 			BPF_ALU32_IMM(BPF_MOV, R1, 1),
5511 			BPF_ALU64_REG(BPF_SUB, R0, R1),
5512 			BPF_EXIT_INSN(),
5513 		},
5514 		INTERNAL,
5515 		{ },
5516 		{ { 0, 2 } },
5517 	},
5518 	{
5519 		"ALU64_SUB_X: 4294967295 - 4294967294 = 1",
5520 		.u.insns_int = {
5521 			BPF_LD_IMM64(R0, 4294967295U),
5522 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
5523 			BPF_ALU64_REG(BPF_SUB, R0, R1),
5524 			BPF_EXIT_INSN(),
5525 		},
5526 		INTERNAL,
5527 		{ },
5528 		{ { 0, 1 } },
5529 	},
5530 	/* BPF_ALU | BPF_SUB | BPF_K */
5531 	{
5532 		"ALU_SUB_K: 3 - 1 = 2",
5533 		.u.insns_int = {
5534 			BPF_LD_IMM64(R0, 3),
5535 			BPF_ALU32_IMM(BPF_SUB, R0, 1),
5536 			BPF_EXIT_INSN(),
5537 		},
5538 		INTERNAL,
5539 		{ },
5540 		{ { 0, 2 } },
5541 	},
5542 	{
5543 		"ALU_SUB_K: 3 - 0 = 3",
5544 		.u.insns_int = {
5545 			BPF_LD_IMM64(R0, 3),
5546 			BPF_ALU32_IMM(BPF_SUB, R0, 0),
5547 			BPF_EXIT_INSN(),
5548 		},
5549 		INTERNAL,
5550 		{ },
5551 		{ { 0, 3 } },
5552 	},
5553 	{
5554 		"ALU_SUB_K: 4294967295 - 4294967294 = 1",
5555 		.u.insns_int = {
5556 			BPF_LD_IMM64(R0, 4294967295U),
5557 			BPF_ALU32_IMM(BPF_SUB, R0, 4294967294U),
5558 			BPF_EXIT_INSN(),
5559 		},
5560 		INTERNAL,
5561 		{ },
5562 		{ { 0, 1 } },
5563 	},
5564 	{
5565 		"ALU64_SUB_K: 3 - 1 = 2",
5566 		.u.insns_int = {
5567 			BPF_LD_IMM64(R0, 3),
5568 			BPF_ALU64_IMM(BPF_SUB, R0, 1),
5569 			BPF_EXIT_INSN(),
5570 		},
5571 		INTERNAL,
5572 		{ },
5573 		{ { 0, 2 } },
5574 	},
5575 	{
5576 		"ALU64_SUB_K: 3 - 0 = 3",
5577 		.u.insns_int = {
5578 			BPF_LD_IMM64(R0, 3),
5579 			BPF_ALU64_IMM(BPF_SUB, R0, 0),
5580 			BPF_EXIT_INSN(),
5581 		},
5582 		INTERNAL,
5583 		{ },
5584 		{ { 0, 3 } },
5585 	},
5586 	{
5587 		"ALU64_SUB_K: 4294967294 - 4294967295 = -1",
5588 		.u.insns_int = {
5589 			BPF_LD_IMM64(R0, 4294967294U),
5590 			BPF_ALU64_IMM(BPF_SUB, R0, 4294967295U),
5591 			BPF_EXIT_INSN(),
5592 		},
5593 		INTERNAL,
5594 		{ },
5595 		{ { 0, -1 } },
5596 	},
5597 	{
5598 		"ALU64_ADD_K: 2147483646 - 2147483647 = -1",
5599 		.u.insns_int = {
5600 			BPF_LD_IMM64(R0, 2147483646),
5601 			BPF_ALU64_IMM(BPF_SUB, R0, 2147483647),
5602 			BPF_EXIT_INSN(),
5603 		},
5604 		INTERNAL,
5605 		{ },
5606 		{ { 0, -1 } },
5607 	},
5608 	/* BPF_ALU | BPF_MUL | BPF_X */
5609 	{
5610 		"ALU_MUL_X: 2 * 3 = 6",
5611 		.u.insns_int = {
5612 			BPF_LD_IMM64(R0, 2),
5613 			BPF_ALU32_IMM(BPF_MOV, R1, 3),
5614 			BPF_ALU32_REG(BPF_MUL, R0, R1),
5615 			BPF_EXIT_INSN(),
5616 		},
5617 		INTERNAL,
5618 		{ },
5619 		{ { 0, 6 } },
5620 	},
5621 	{
5622 		"ALU_MUL_X: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
5623 		.u.insns_int = {
5624 			BPF_LD_IMM64(R0, 2),
5625 			BPF_ALU32_IMM(BPF_MOV, R1, 0x7FFFFFF8),
5626 			BPF_ALU32_REG(BPF_MUL, R0, R1),
5627 			BPF_EXIT_INSN(),
5628 		},
5629 		INTERNAL,
5630 		{ },
5631 		{ { 0, 0xFFFFFFF0 } },
5632 	},
5633 	{
5634 		"ALU_MUL_X: -1 * -1 = 1",
5635 		.u.insns_int = {
5636 			BPF_LD_IMM64(R0, -1),
5637 			BPF_ALU32_IMM(BPF_MOV, R1, -1),
5638 			BPF_ALU32_REG(BPF_MUL, R0, R1),
5639 			BPF_EXIT_INSN(),
5640 		},
5641 		INTERNAL,
5642 		{ },
5643 		{ { 0, 1 } },
5644 	},
5645 	{
5646 		"ALU64_MUL_X: 2 * 3 = 6",
5647 		.u.insns_int = {
5648 			BPF_LD_IMM64(R0, 2),
5649 			BPF_ALU32_IMM(BPF_MOV, R1, 3),
5650 			BPF_ALU64_REG(BPF_MUL, R0, R1),
5651 			BPF_EXIT_INSN(),
5652 		},
5653 		INTERNAL,
5654 		{ },
5655 		{ { 0, 6 } },
5656 	},
5657 	{
5658 		"ALU64_MUL_X: 1 * 2147483647 = 2147483647",
5659 		.u.insns_int = {
5660 			BPF_LD_IMM64(R0, 1),
5661 			BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
5662 			BPF_ALU64_REG(BPF_MUL, R0, R1),
5663 			BPF_EXIT_INSN(),
5664 		},
5665 		INTERNAL,
5666 		{ },
5667 		{ { 0, 2147483647 } },
5668 	},
5669 	{
5670 		"ALU64_MUL_X: 64x64 multiply, low word",
5671 		.u.insns_int = {
5672 			BPF_LD_IMM64(R0, 0x0fedcba987654321LL),
5673 			BPF_LD_IMM64(R1, 0x123456789abcdef0LL),
5674 			BPF_ALU64_REG(BPF_MUL, R0, R1),
5675 			BPF_EXIT_INSN(),
5676 		},
5677 		INTERNAL,
5678 		{ },
5679 		{ { 0, 0xe5618cf0 } }
5680 	},
5681 	{
5682 		"ALU64_MUL_X: 64x64 multiply, high word",
5683 		.u.insns_int = {
5684 			BPF_LD_IMM64(R0, 0x0fedcba987654321LL),
5685 			BPF_LD_IMM64(R1, 0x123456789abcdef0LL),
5686 			BPF_ALU64_REG(BPF_MUL, R0, R1),
5687 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
5688 			BPF_EXIT_INSN(),
5689 		},
5690 		INTERNAL,
5691 		{ },
5692 		{ { 0, 0x2236d88f } }
5693 	},
5694 	/* BPF_ALU | BPF_MUL | BPF_K */
5695 	{
5696 		"ALU_MUL_K: 2 * 3 = 6",
5697 		.u.insns_int = {
5698 			BPF_LD_IMM64(R0, 2),
5699 			BPF_ALU32_IMM(BPF_MUL, R0, 3),
5700 			BPF_EXIT_INSN(),
5701 		},
5702 		INTERNAL,
5703 		{ },
5704 		{ { 0, 6 } },
5705 	},
5706 	{
5707 		"ALU_MUL_K: 3 * 1 = 3",
5708 		.u.insns_int = {
5709 			BPF_LD_IMM64(R0, 3),
5710 			BPF_ALU32_IMM(BPF_MUL, R0, 1),
5711 			BPF_EXIT_INSN(),
5712 		},
5713 		INTERNAL,
5714 		{ },
5715 		{ { 0, 3 } },
5716 	},
5717 	{
5718 		"ALU_MUL_K: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
5719 		.u.insns_int = {
5720 			BPF_LD_IMM64(R0, 2),
5721 			BPF_ALU32_IMM(BPF_MUL, R0, 0x7FFFFFF8),
5722 			BPF_EXIT_INSN(),
5723 		},
5724 		INTERNAL,
5725 		{ },
5726 		{ { 0, 0xFFFFFFF0 } },
5727 	},
5728 	{
5729 		"ALU_MUL_K: 1 * (-1) = 0x00000000ffffffff",
5730 		.u.insns_int = {
5731 			BPF_LD_IMM64(R2, 0x1),
5732 			BPF_LD_IMM64(R3, 0x00000000ffffffff),
5733 			BPF_ALU32_IMM(BPF_MUL, R2, 0xffffffff),
5734 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5735 			BPF_MOV32_IMM(R0, 2),
5736 			BPF_EXIT_INSN(),
5737 			BPF_MOV32_IMM(R0, 1),
5738 			BPF_EXIT_INSN(),
5739 		},
5740 		INTERNAL,
5741 		{ },
5742 		{ { 0, 0x1 } },
5743 	},
5744 	{
5745 		"ALU64_MUL_K: 2 * 3 = 6",
5746 		.u.insns_int = {
5747 			BPF_LD_IMM64(R0, 2),
5748 			BPF_ALU64_IMM(BPF_MUL, R0, 3),
5749 			BPF_EXIT_INSN(),
5750 		},
5751 		INTERNAL,
5752 		{ },
5753 		{ { 0, 6 } },
5754 	},
5755 	{
5756 		"ALU64_MUL_K: 3 * 1 = 3",
5757 		.u.insns_int = {
5758 			BPF_LD_IMM64(R0, 3),
5759 			BPF_ALU64_IMM(BPF_MUL, R0, 1),
5760 			BPF_EXIT_INSN(),
5761 		},
5762 		INTERNAL,
5763 		{ },
5764 		{ { 0, 3 } },
5765 	},
5766 	{
5767 		"ALU64_MUL_K: 1 * 2147483647 = 2147483647",
5768 		.u.insns_int = {
5769 			BPF_LD_IMM64(R0, 1),
5770 			BPF_ALU64_IMM(BPF_MUL, R0, 2147483647),
5771 			BPF_EXIT_INSN(),
5772 		},
5773 		INTERNAL,
5774 		{ },
5775 		{ { 0, 2147483647 } },
5776 	},
5777 	{
5778 		"ALU64_MUL_K: 1 * -2147483647 = -2147483647",
5779 		.u.insns_int = {
5780 			BPF_LD_IMM64(R0, 1),
5781 			BPF_ALU64_IMM(BPF_MUL, R0, -2147483647),
5782 			BPF_EXIT_INSN(),
5783 		},
5784 		INTERNAL,
5785 		{ },
5786 		{ { 0, -2147483647 } },
5787 	},
5788 	{
5789 		"ALU64_MUL_K: 1 * (-1) = 0xffffffffffffffff",
5790 		.u.insns_int = {
5791 			BPF_LD_IMM64(R2, 0x1),
5792 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
5793 			BPF_ALU64_IMM(BPF_MUL, R2, 0xffffffff),
5794 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5795 			BPF_MOV32_IMM(R0, 2),
5796 			BPF_EXIT_INSN(),
5797 			BPF_MOV32_IMM(R0, 1),
5798 			BPF_EXIT_INSN(),
5799 		},
5800 		INTERNAL,
5801 		{ },
5802 		{ { 0, 0x1 } },
5803 	},
5804 	{
5805 		"ALU64_MUL_K: 64x32 multiply, low word",
5806 		.u.insns_int = {
5807 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5808 			BPF_ALU64_IMM(BPF_MUL, R0, 0x12345678),
5809 			BPF_EXIT_INSN(),
5810 		},
5811 		INTERNAL,
5812 		{ },
5813 		{ { 0, 0xe242d208 } }
5814 	},
5815 	{
5816 		"ALU64_MUL_K: 64x32 multiply, high word",
5817 		.u.insns_int = {
5818 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5819 			BPF_ALU64_IMM(BPF_MUL, R0, 0x12345678),
5820 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
5821 			BPF_EXIT_INSN(),
5822 		},
5823 		INTERNAL,
5824 		{ },
5825 		{ { 0, 0xc28f5c28 } }
5826 	},
5827 	/* BPF_ALU | BPF_DIV | BPF_X */
5828 	{
5829 		"ALU_DIV_X: 6 / 2 = 3",
5830 		.u.insns_int = {
5831 			BPF_LD_IMM64(R0, 6),
5832 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
5833 			BPF_ALU32_REG(BPF_DIV, R0, R1),
5834 			BPF_EXIT_INSN(),
5835 		},
5836 		INTERNAL,
5837 		{ },
5838 		{ { 0, 3 } },
5839 	},
5840 	{
5841 		"ALU_DIV_X: 4294967295 / 4294967295 = 1",
5842 		.u.insns_int = {
5843 			BPF_LD_IMM64(R0, 4294967295U),
5844 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
5845 			BPF_ALU32_REG(BPF_DIV, R0, R1),
5846 			BPF_EXIT_INSN(),
5847 		},
5848 		INTERNAL,
5849 		{ },
5850 		{ { 0, 1 } },
5851 	},
5852 	{
5853 		"ALU64_DIV_X: 6 / 2 = 3",
5854 		.u.insns_int = {
5855 			BPF_LD_IMM64(R0, 6),
5856 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
5857 			BPF_ALU64_REG(BPF_DIV, R0, R1),
5858 			BPF_EXIT_INSN(),
5859 		},
5860 		INTERNAL,
5861 		{ },
5862 		{ { 0, 3 } },
5863 	},
5864 	{
5865 		"ALU64_DIV_X: 2147483647 / 2147483647 = 1",
5866 		.u.insns_int = {
5867 			BPF_LD_IMM64(R0, 2147483647),
5868 			BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
5869 			BPF_ALU64_REG(BPF_DIV, R0, R1),
5870 			BPF_EXIT_INSN(),
5871 		},
5872 		INTERNAL,
5873 		{ },
5874 		{ { 0, 1 } },
5875 	},
5876 	{
5877 		"ALU64_DIV_X: 0xffffffffffffffff / (-1) = 0x0000000000000001",
5878 		.u.insns_int = {
5879 			BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
5880 			BPF_LD_IMM64(R4, 0xffffffffffffffffLL),
5881 			BPF_LD_IMM64(R3, 0x0000000000000001LL),
5882 			BPF_ALU64_REG(BPF_DIV, R2, R4),
5883 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5884 			BPF_MOV32_IMM(R0, 2),
5885 			BPF_EXIT_INSN(),
5886 			BPF_MOV32_IMM(R0, 1),
5887 			BPF_EXIT_INSN(),
5888 		},
5889 		INTERNAL,
5890 		{ },
5891 		{ { 0, 0x1 } },
5892 	},
5893 	/* BPF_ALU | BPF_DIV | BPF_K */
5894 	{
5895 		"ALU_DIV_K: 6 / 2 = 3",
5896 		.u.insns_int = {
5897 			BPF_LD_IMM64(R0, 6),
5898 			BPF_ALU32_IMM(BPF_DIV, R0, 2),
5899 			BPF_EXIT_INSN(),
5900 		},
5901 		INTERNAL,
5902 		{ },
5903 		{ { 0, 3 } },
5904 	},
5905 	{
5906 		"ALU_DIV_K: 3 / 1 = 3",
5907 		.u.insns_int = {
5908 			BPF_LD_IMM64(R0, 3),
5909 			BPF_ALU32_IMM(BPF_DIV, R0, 1),
5910 			BPF_EXIT_INSN(),
5911 		},
5912 		INTERNAL,
5913 		{ },
5914 		{ { 0, 3 } },
5915 	},
5916 	{
5917 		"ALU_DIV_K: 4294967295 / 4294967295 = 1",
5918 		.u.insns_int = {
5919 			BPF_LD_IMM64(R0, 4294967295U),
5920 			BPF_ALU32_IMM(BPF_DIV, R0, 4294967295U),
5921 			BPF_EXIT_INSN(),
5922 		},
5923 		INTERNAL,
5924 		{ },
5925 		{ { 0, 1 } },
5926 	},
5927 	{
5928 		"ALU_DIV_K: 0xffffffffffffffff / (-1) = 0x1",
5929 		.u.insns_int = {
5930 			BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
5931 			BPF_LD_IMM64(R3, 0x1UL),
5932 			BPF_ALU32_IMM(BPF_DIV, R2, 0xffffffff),
5933 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5934 			BPF_MOV32_IMM(R0, 2),
5935 			BPF_EXIT_INSN(),
5936 			BPF_MOV32_IMM(R0, 1),
5937 			BPF_EXIT_INSN(),
5938 		},
5939 		INTERNAL,
5940 		{ },
5941 		{ { 0, 0x1 } },
5942 	},
5943 	{
5944 		"ALU64_DIV_K: 6 / 2 = 3",
5945 		.u.insns_int = {
5946 			BPF_LD_IMM64(R0, 6),
5947 			BPF_ALU64_IMM(BPF_DIV, R0, 2),
5948 			BPF_EXIT_INSN(),
5949 		},
5950 		INTERNAL,
5951 		{ },
5952 		{ { 0, 3 } },
5953 	},
5954 	{
5955 		"ALU64_DIV_K: 3 / 1 = 3",
5956 		.u.insns_int = {
5957 			BPF_LD_IMM64(R0, 3),
5958 			BPF_ALU64_IMM(BPF_DIV, R0, 1),
5959 			BPF_EXIT_INSN(),
5960 		},
5961 		INTERNAL,
5962 		{ },
5963 		{ { 0, 3 } },
5964 	},
5965 	{
5966 		"ALU64_DIV_K: 2147483647 / 2147483647 = 1",
5967 		.u.insns_int = {
5968 			BPF_LD_IMM64(R0, 2147483647),
5969 			BPF_ALU64_IMM(BPF_DIV, R0, 2147483647),
5970 			BPF_EXIT_INSN(),
5971 		},
5972 		INTERNAL,
5973 		{ },
5974 		{ { 0, 1 } },
5975 	},
5976 	{
5977 		"ALU64_DIV_K: 0xffffffffffffffff / (-1) = 0x0000000000000001",
5978 		.u.insns_int = {
5979 			BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
5980 			BPF_LD_IMM64(R3, 0x0000000000000001LL),
5981 			BPF_ALU64_IMM(BPF_DIV, R2, 0xffffffff),
5982 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5983 			BPF_MOV32_IMM(R0, 2),
5984 			BPF_EXIT_INSN(),
5985 			BPF_MOV32_IMM(R0, 1),
5986 			BPF_EXIT_INSN(),
5987 		},
5988 		INTERNAL,
5989 		{ },
5990 		{ { 0, 0x1 } },
5991 	},
5992 	/* BPF_ALU | BPF_MOD | BPF_X */
5993 	{
5994 		"ALU_MOD_X: 3 % 2 = 1",
5995 		.u.insns_int = {
5996 			BPF_LD_IMM64(R0, 3),
5997 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
5998 			BPF_ALU32_REG(BPF_MOD, R0, R1),
5999 			BPF_EXIT_INSN(),
6000 		},
6001 		INTERNAL,
6002 		{ },
6003 		{ { 0, 1 } },
6004 	},
6005 	{
6006 		"ALU_MOD_X: 4294967295 % 4294967293 = 2",
6007 		.u.insns_int = {
6008 			BPF_LD_IMM64(R0, 4294967295U),
6009 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967293U),
6010 			BPF_ALU32_REG(BPF_MOD, R0, R1),
6011 			BPF_EXIT_INSN(),
6012 		},
6013 		INTERNAL,
6014 		{ },
6015 		{ { 0, 2 } },
6016 	},
6017 	{
6018 		"ALU64_MOD_X: 3 % 2 = 1",
6019 		.u.insns_int = {
6020 			BPF_LD_IMM64(R0, 3),
6021 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
6022 			BPF_ALU64_REG(BPF_MOD, R0, R1),
6023 			BPF_EXIT_INSN(),
6024 		},
6025 		INTERNAL,
6026 		{ },
6027 		{ { 0, 1 } },
6028 	},
6029 	{
6030 		"ALU64_MOD_X: 2147483647 % 2147483645 = 2",
6031 		.u.insns_int = {
6032 			BPF_LD_IMM64(R0, 2147483647),
6033 			BPF_ALU32_IMM(BPF_MOV, R1, 2147483645),
6034 			BPF_ALU64_REG(BPF_MOD, R0, R1),
6035 			BPF_EXIT_INSN(),
6036 		},
6037 		INTERNAL,
6038 		{ },
6039 		{ { 0, 2 } },
6040 	},
6041 	/* BPF_ALU | BPF_MOD | BPF_K */
6042 	{
6043 		"ALU_MOD_K: 3 % 2 = 1",
6044 		.u.insns_int = {
6045 			BPF_LD_IMM64(R0, 3),
6046 			BPF_ALU32_IMM(BPF_MOD, R0, 2),
6047 			BPF_EXIT_INSN(),
6048 		},
6049 		INTERNAL,
6050 		{ },
6051 		{ { 0, 1 } },
6052 	},
6053 	{
6054 		"ALU_MOD_K: 3 % 1 = 0",
6055 		.u.insns_int = {
6056 			BPF_LD_IMM64(R0, 3),
6057 			BPF_ALU32_IMM(BPF_MOD, R0, 1),
6058 			BPF_EXIT_INSN(),
6059 		},
6060 		INTERNAL,
6061 		{ },
6062 		{ { 0, 0 } },
6063 	},
6064 	{
6065 		"ALU_MOD_K: 4294967295 % 4294967293 = 2",
6066 		.u.insns_int = {
6067 			BPF_LD_IMM64(R0, 4294967295U),
6068 			BPF_ALU32_IMM(BPF_MOD, R0, 4294967293U),
6069 			BPF_EXIT_INSN(),
6070 		},
6071 		INTERNAL,
6072 		{ },
6073 		{ { 0, 2 } },
6074 	},
6075 	{
6076 		"ALU64_MOD_K: 3 % 2 = 1",
6077 		.u.insns_int = {
6078 			BPF_LD_IMM64(R0, 3),
6079 			BPF_ALU64_IMM(BPF_MOD, R0, 2),
6080 			BPF_EXIT_INSN(),
6081 		},
6082 		INTERNAL,
6083 		{ },
6084 		{ { 0, 1 } },
6085 	},
6086 	{
6087 		"ALU64_MOD_K: 3 % 1 = 0",
6088 		.u.insns_int = {
6089 			BPF_LD_IMM64(R0, 3),
6090 			BPF_ALU64_IMM(BPF_MOD, R0, 1),
6091 			BPF_EXIT_INSN(),
6092 		},
6093 		INTERNAL,
6094 		{ },
6095 		{ { 0, 0 } },
6096 	},
6097 	{
6098 		"ALU64_MOD_K: 2147483647 % 2147483645 = 2",
6099 		.u.insns_int = {
6100 			BPF_LD_IMM64(R0, 2147483647),
6101 			BPF_ALU64_IMM(BPF_MOD, R0, 2147483645),
6102 			BPF_EXIT_INSN(),
6103 		},
6104 		INTERNAL,
6105 		{ },
6106 		{ { 0, 2 } },
6107 	},
6108 	/* BPF_ALU | BPF_AND | BPF_X */
6109 	{
6110 		"ALU_AND_X: 3 & 2 = 2",
6111 		.u.insns_int = {
6112 			BPF_LD_IMM64(R0, 3),
6113 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
6114 			BPF_ALU32_REG(BPF_AND, R0, R1),
6115 			BPF_EXIT_INSN(),
6116 		},
6117 		INTERNAL,
6118 		{ },
6119 		{ { 0, 2 } },
6120 	},
6121 	{
6122 		"ALU_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
6123 		.u.insns_int = {
6124 			BPF_LD_IMM64(R0, 0xffffffff),
6125 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6126 			BPF_ALU32_REG(BPF_AND, R0, R1),
6127 			BPF_EXIT_INSN(),
6128 		},
6129 		INTERNAL,
6130 		{ },
6131 		{ { 0, 0xffffffff } },
6132 	},
6133 	{
6134 		"ALU64_AND_X: 3 & 2 = 2",
6135 		.u.insns_int = {
6136 			BPF_LD_IMM64(R0, 3),
6137 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
6138 			BPF_ALU64_REG(BPF_AND, R0, R1),
6139 			BPF_EXIT_INSN(),
6140 		},
6141 		INTERNAL,
6142 		{ },
6143 		{ { 0, 2 } },
6144 	},
6145 	{
6146 		"ALU64_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
6147 		.u.insns_int = {
6148 			BPF_LD_IMM64(R0, 0xffffffff),
6149 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6150 			BPF_ALU64_REG(BPF_AND, R0, R1),
6151 			BPF_EXIT_INSN(),
6152 		},
6153 		INTERNAL,
6154 		{ },
6155 		{ { 0, 0xffffffff } },
6156 	},
6157 	/* BPF_ALU | BPF_AND | BPF_K */
6158 	{
6159 		"ALU_AND_K: 3 & 2 = 2",
6160 		.u.insns_int = {
6161 			BPF_LD_IMM64(R0, 3),
6162 			BPF_ALU32_IMM(BPF_AND, R0, 2),
6163 			BPF_EXIT_INSN(),
6164 		},
6165 		INTERNAL,
6166 		{ },
6167 		{ { 0, 2 } },
6168 	},
6169 	{
6170 		"ALU_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
6171 		.u.insns_int = {
6172 			BPF_LD_IMM64(R0, 0xffffffff),
6173 			BPF_ALU32_IMM(BPF_AND, R0, 0xffffffff),
6174 			BPF_EXIT_INSN(),
6175 		},
6176 		INTERNAL,
6177 		{ },
6178 		{ { 0, 0xffffffff } },
6179 	},
6180 	{
6181 		"ALU_AND_K: Small immediate",
6182 		.u.insns_int = {
6183 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
6184 			BPF_ALU32_IMM(BPF_AND, R0, 15),
6185 			BPF_EXIT_INSN(),
6186 		},
6187 		INTERNAL,
6188 		{ },
6189 		{ { 0, 4 } }
6190 	},
6191 	{
6192 		"ALU_AND_K: Large immediate",
6193 		.u.insns_int = {
6194 			BPF_ALU32_IMM(BPF_MOV, R0, 0xf1f2f3f4),
6195 			BPF_ALU32_IMM(BPF_AND, R0, 0xafbfcfdf),
6196 			BPF_EXIT_INSN(),
6197 		},
6198 		INTERNAL,
6199 		{ },
6200 		{ { 0, 0xa1b2c3d4 } }
6201 	},
6202 	{
6203 		"ALU_AND_K: Zero extension",
6204 		.u.insns_int = {
6205 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6206 			BPF_LD_IMM64(R1, 0x0000000080a0c0e0LL),
6207 			BPF_ALU32_IMM(BPF_AND, R0, 0xf0f0f0f0),
6208 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6209 			BPF_MOV32_IMM(R0, 2),
6210 			BPF_EXIT_INSN(),
6211 			BPF_MOV32_IMM(R0, 1),
6212 			BPF_EXIT_INSN(),
6213 		},
6214 		INTERNAL,
6215 		{ },
6216 		{ { 0, 1 } }
6217 	},
6218 	{
6219 		"ALU64_AND_K: 3 & 2 = 2",
6220 		.u.insns_int = {
6221 			BPF_LD_IMM64(R0, 3),
6222 			BPF_ALU64_IMM(BPF_AND, R0, 2),
6223 			BPF_EXIT_INSN(),
6224 		},
6225 		INTERNAL,
6226 		{ },
6227 		{ { 0, 2 } },
6228 	},
6229 	{
6230 		"ALU64_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
6231 		.u.insns_int = {
6232 			BPF_LD_IMM64(R0, 0xffffffff),
6233 			BPF_ALU64_IMM(BPF_AND, R0, 0xffffffff),
6234 			BPF_EXIT_INSN(),
6235 		},
6236 		INTERNAL,
6237 		{ },
6238 		{ { 0, 0xffffffff } },
6239 	},
6240 	{
6241 		"ALU64_AND_K: 0x0000ffffffff0000 & 0x0 = 0x0000000000000000",
6242 		.u.insns_int = {
6243 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6244 			BPF_LD_IMM64(R3, 0x0000000000000000LL),
6245 			BPF_ALU64_IMM(BPF_AND, R2, 0x0),
6246 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6247 			BPF_MOV32_IMM(R0, 2),
6248 			BPF_EXIT_INSN(),
6249 			BPF_MOV32_IMM(R0, 1),
6250 			BPF_EXIT_INSN(),
6251 		},
6252 		INTERNAL,
6253 		{ },
6254 		{ { 0, 0x1 } },
6255 	},
6256 	{
6257 		"ALU64_AND_K: 0x0000ffffffff0000 & -1 = 0x0000ffffffff0000",
6258 		.u.insns_int = {
6259 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6260 			BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
6261 			BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
6262 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6263 			BPF_MOV32_IMM(R0, 2),
6264 			BPF_EXIT_INSN(),
6265 			BPF_MOV32_IMM(R0, 1),
6266 			BPF_EXIT_INSN(),
6267 		},
6268 		INTERNAL,
6269 		{ },
6270 		{ { 0, 0x1 } },
6271 	},
6272 	{
6273 		"ALU64_AND_K: 0xffffffffffffffff & -1 = 0xffffffffffffffff",
6274 		.u.insns_int = {
6275 			BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
6276 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
6277 			BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
6278 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6279 			BPF_MOV32_IMM(R0, 2),
6280 			BPF_EXIT_INSN(),
6281 			BPF_MOV32_IMM(R0, 1),
6282 			BPF_EXIT_INSN(),
6283 		},
6284 		INTERNAL,
6285 		{ },
6286 		{ { 0, 0x1 } },
6287 	},
6288 	{
6289 		"ALU64_AND_K: Sign extension 1",
6290 		.u.insns_int = {
6291 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6292 			BPF_LD_IMM64(R1, 0x00000000090b0d0fLL),
6293 			BPF_ALU64_IMM(BPF_AND, R0, 0x0f0f0f0f),
6294 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6295 			BPF_MOV32_IMM(R0, 2),
6296 			BPF_EXIT_INSN(),
6297 			BPF_MOV32_IMM(R0, 1),
6298 			BPF_EXIT_INSN(),
6299 		},
6300 		INTERNAL,
6301 		{ },
6302 		{ { 0, 1 } }
6303 	},
6304 	{
6305 		"ALU64_AND_K: Sign extension 2",
6306 		.u.insns_int = {
6307 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6308 			BPF_LD_IMM64(R1, 0x0123456780a0c0e0LL),
6309 			BPF_ALU64_IMM(BPF_AND, R0, 0xf0f0f0f0),
6310 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6311 			BPF_MOV32_IMM(R0, 2),
6312 			BPF_EXIT_INSN(),
6313 			BPF_MOV32_IMM(R0, 1),
6314 			BPF_EXIT_INSN(),
6315 		},
6316 		INTERNAL,
6317 		{ },
6318 		{ { 0, 1 } }
6319 	},
6320 	/* BPF_ALU | BPF_OR | BPF_X */
6321 	{
6322 		"ALU_OR_X: 1 | 2 = 3",
6323 		.u.insns_int = {
6324 			BPF_LD_IMM64(R0, 1),
6325 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
6326 			BPF_ALU32_REG(BPF_OR, R0, R1),
6327 			BPF_EXIT_INSN(),
6328 		},
6329 		INTERNAL,
6330 		{ },
6331 		{ { 0, 3 } },
6332 	},
6333 	{
6334 		"ALU_OR_X: 0x0 | 0xffffffff = 0xffffffff",
6335 		.u.insns_int = {
6336 			BPF_LD_IMM64(R0, 0),
6337 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6338 			BPF_ALU32_REG(BPF_OR, R0, R1),
6339 			BPF_EXIT_INSN(),
6340 		},
6341 		INTERNAL,
6342 		{ },
6343 		{ { 0, 0xffffffff } },
6344 	},
6345 	{
6346 		"ALU64_OR_X: 1 | 2 = 3",
6347 		.u.insns_int = {
6348 			BPF_LD_IMM64(R0, 1),
6349 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
6350 			BPF_ALU64_REG(BPF_OR, R0, R1),
6351 			BPF_EXIT_INSN(),
6352 		},
6353 		INTERNAL,
6354 		{ },
6355 		{ { 0, 3 } },
6356 	},
6357 	{
6358 		"ALU64_OR_X: 0 | 0xffffffff = 0xffffffff",
6359 		.u.insns_int = {
6360 			BPF_LD_IMM64(R0, 0),
6361 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6362 			BPF_ALU64_REG(BPF_OR, R0, R1),
6363 			BPF_EXIT_INSN(),
6364 		},
6365 		INTERNAL,
6366 		{ },
6367 		{ { 0, 0xffffffff } },
6368 	},
6369 	/* BPF_ALU | BPF_OR | BPF_K */
6370 	{
6371 		"ALU_OR_K: 1 | 2 = 3",
6372 		.u.insns_int = {
6373 			BPF_LD_IMM64(R0, 1),
6374 			BPF_ALU32_IMM(BPF_OR, R0, 2),
6375 			BPF_EXIT_INSN(),
6376 		},
6377 		INTERNAL,
6378 		{ },
6379 		{ { 0, 3 } },
6380 	},
6381 	{
6382 		"ALU_OR_K: 0 & 0xffffffff = 0xffffffff",
6383 		.u.insns_int = {
6384 			BPF_LD_IMM64(R0, 0),
6385 			BPF_ALU32_IMM(BPF_OR, R0, 0xffffffff),
6386 			BPF_EXIT_INSN(),
6387 		},
6388 		INTERNAL,
6389 		{ },
6390 		{ { 0, 0xffffffff } },
6391 	},
6392 	{
6393 		"ALU_OR_K: Small immediate",
6394 		.u.insns_int = {
6395 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
6396 			BPF_ALU32_IMM(BPF_OR, R0, 1),
6397 			BPF_EXIT_INSN(),
6398 		},
6399 		INTERNAL,
6400 		{ },
6401 		{ { 0, 0x01020305 } }
6402 	},
6403 	{
6404 		"ALU_OR_K: Large immediate",
6405 		.u.insns_int = {
6406 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
6407 			BPF_ALU32_IMM(BPF_OR, R0, 0xa0b0c0d0),
6408 			BPF_EXIT_INSN(),
6409 		},
6410 		INTERNAL,
6411 		{ },
6412 		{ { 0, 0xa1b2c3d4 } }
6413 	},
6414 	{
6415 		"ALU_OR_K: Zero extension",
6416 		.u.insns_int = {
6417 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6418 			BPF_LD_IMM64(R1, 0x00000000f9fbfdffLL),
6419 			BPF_ALU32_IMM(BPF_OR, R0, 0xf0f0f0f0),
6420 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6421 			BPF_MOV32_IMM(R0, 2),
6422 			BPF_EXIT_INSN(),
6423 			BPF_MOV32_IMM(R0, 1),
6424 			BPF_EXIT_INSN(),
6425 		},
6426 		INTERNAL,
6427 		{ },
6428 		{ { 0, 1 } }
6429 	},
6430 	{
6431 		"ALU64_OR_K: 1 | 2 = 3",
6432 		.u.insns_int = {
6433 			BPF_LD_IMM64(R0, 1),
6434 			BPF_ALU64_IMM(BPF_OR, R0, 2),
6435 			BPF_EXIT_INSN(),
6436 		},
6437 		INTERNAL,
6438 		{ },
6439 		{ { 0, 3 } },
6440 	},
6441 	{
6442 		"ALU64_OR_K: 0 & 0xffffffff = 0xffffffff",
6443 		.u.insns_int = {
6444 			BPF_LD_IMM64(R0, 0),
6445 			BPF_ALU64_IMM(BPF_OR, R0, 0xffffffff),
6446 			BPF_EXIT_INSN(),
6447 		},
6448 		INTERNAL,
6449 		{ },
6450 		{ { 0, 0xffffffff } },
6451 	},
6452 	{
6453 		"ALU64_OR_K: 0x0000ffffffff0000 | 0x0 = 0x0000ffffffff0000",
6454 		.u.insns_int = {
6455 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6456 			BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
6457 			BPF_ALU64_IMM(BPF_OR, R2, 0x0),
6458 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6459 			BPF_MOV32_IMM(R0, 2),
6460 			BPF_EXIT_INSN(),
6461 			BPF_MOV32_IMM(R0, 1),
6462 			BPF_EXIT_INSN(),
6463 		},
6464 		INTERNAL,
6465 		{ },
6466 		{ { 0, 0x1 } },
6467 	},
6468 	{
6469 		"ALU64_OR_K: 0x0000ffffffff0000 | -1 = 0xffffffffffffffff",
6470 		.u.insns_int = {
6471 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6472 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
6473 			BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
6474 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6475 			BPF_MOV32_IMM(R0, 2),
6476 			BPF_EXIT_INSN(),
6477 			BPF_MOV32_IMM(R0, 1),
6478 			BPF_EXIT_INSN(),
6479 		},
6480 		INTERNAL,
6481 		{ },
6482 		{ { 0, 0x1 } },
6483 	},
6484 	{
6485 		"ALU64_OR_K: 0x000000000000000 | -1 = 0xffffffffffffffff",
6486 		.u.insns_int = {
6487 			BPF_LD_IMM64(R2, 0x0000000000000000LL),
6488 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
6489 			BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
6490 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6491 			BPF_MOV32_IMM(R0, 2),
6492 			BPF_EXIT_INSN(),
6493 			BPF_MOV32_IMM(R0, 1),
6494 			BPF_EXIT_INSN(),
6495 		},
6496 		INTERNAL,
6497 		{ },
6498 		{ { 0, 0x1 } },
6499 	},
6500 	{
6501 		"ALU64_OR_K: Sign extension 1",
6502 		.u.insns_int = {
6503 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6504 			BPF_LD_IMM64(R1, 0x012345678fafcfefLL),
6505 			BPF_ALU64_IMM(BPF_OR, R0, 0x0f0f0f0f),
6506 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6507 			BPF_MOV32_IMM(R0, 2),
6508 			BPF_EXIT_INSN(),
6509 			BPF_MOV32_IMM(R0, 1),
6510 			BPF_EXIT_INSN(),
6511 		},
6512 		INTERNAL,
6513 		{ },
6514 		{ { 0, 1 } }
6515 	},
6516 	{
6517 		"ALU64_OR_K: Sign extension 2",
6518 		.u.insns_int = {
6519 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6520 			BPF_LD_IMM64(R1, 0xfffffffff9fbfdffLL),
6521 			BPF_ALU64_IMM(BPF_OR, R0, 0xf0f0f0f0),
6522 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6523 			BPF_MOV32_IMM(R0, 2),
6524 			BPF_EXIT_INSN(),
6525 			BPF_MOV32_IMM(R0, 1),
6526 			BPF_EXIT_INSN(),
6527 		},
6528 		INTERNAL,
6529 		{ },
6530 		{ { 0, 1 } }
6531 	},
6532 	/* BPF_ALU | BPF_XOR | BPF_X */
6533 	{
6534 		"ALU_XOR_X: 5 ^ 6 = 3",
6535 		.u.insns_int = {
6536 			BPF_LD_IMM64(R0, 5),
6537 			BPF_ALU32_IMM(BPF_MOV, R1, 6),
6538 			BPF_ALU32_REG(BPF_XOR, R0, R1),
6539 			BPF_EXIT_INSN(),
6540 		},
6541 		INTERNAL,
6542 		{ },
6543 		{ { 0, 3 } },
6544 	},
6545 	{
6546 		"ALU_XOR_X: 0x1 ^ 0xffffffff = 0xfffffffe",
6547 		.u.insns_int = {
6548 			BPF_LD_IMM64(R0, 1),
6549 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6550 			BPF_ALU32_REG(BPF_XOR, R0, R1),
6551 			BPF_EXIT_INSN(),
6552 		},
6553 		INTERNAL,
6554 		{ },
6555 		{ { 0, 0xfffffffe } },
6556 	},
6557 	{
6558 		"ALU64_XOR_X: 5 ^ 6 = 3",
6559 		.u.insns_int = {
6560 			BPF_LD_IMM64(R0, 5),
6561 			BPF_ALU32_IMM(BPF_MOV, R1, 6),
6562 			BPF_ALU64_REG(BPF_XOR, R0, R1),
6563 			BPF_EXIT_INSN(),
6564 		},
6565 		INTERNAL,
6566 		{ },
6567 		{ { 0, 3 } },
6568 	},
6569 	{
6570 		"ALU64_XOR_X: 1 ^ 0xffffffff = 0xfffffffe",
6571 		.u.insns_int = {
6572 			BPF_LD_IMM64(R0, 1),
6573 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6574 			BPF_ALU64_REG(BPF_XOR, R0, R1),
6575 			BPF_EXIT_INSN(),
6576 		},
6577 		INTERNAL,
6578 		{ },
6579 		{ { 0, 0xfffffffe } },
6580 	},
6581 	/* BPF_ALU | BPF_XOR | BPF_K */
6582 	{
6583 		"ALU_XOR_K: 5 ^ 6 = 3",
6584 		.u.insns_int = {
6585 			BPF_LD_IMM64(R0, 5),
6586 			BPF_ALU32_IMM(BPF_XOR, R0, 6),
6587 			BPF_EXIT_INSN(),
6588 		},
6589 		INTERNAL,
6590 		{ },
6591 		{ { 0, 3 } },
6592 	},
6593 	{
6594 		"ALU_XOR_K: 1 ^ 0xffffffff = 0xfffffffe",
6595 		.u.insns_int = {
6596 			BPF_LD_IMM64(R0, 1),
6597 			BPF_ALU32_IMM(BPF_XOR, R0, 0xffffffff),
6598 			BPF_EXIT_INSN(),
6599 		},
6600 		INTERNAL,
6601 		{ },
6602 		{ { 0, 0xfffffffe } },
6603 	},
6604 	{
6605 		"ALU_XOR_K: Small immediate",
6606 		.u.insns_int = {
6607 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
6608 			BPF_ALU32_IMM(BPF_XOR, R0, 15),
6609 			BPF_EXIT_INSN(),
6610 		},
6611 		INTERNAL,
6612 		{ },
6613 		{ { 0, 0x0102030b } }
6614 	},
6615 	{
6616 		"ALU_XOR_K: Large immediate",
6617 		.u.insns_int = {
6618 			BPF_ALU32_IMM(BPF_MOV, R0, 0xf1f2f3f4),
6619 			BPF_ALU32_IMM(BPF_XOR, R0, 0xafbfcfdf),
6620 			BPF_EXIT_INSN(),
6621 		},
6622 		INTERNAL,
6623 		{ },
6624 		{ { 0, 0x5e4d3c2b } }
6625 	},
6626 	{
6627 		"ALU_XOR_K: Zero extension",
6628 		.u.insns_int = {
6629 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6630 			BPF_LD_IMM64(R1, 0x00000000795b3d1fLL),
6631 			BPF_ALU32_IMM(BPF_XOR, R0, 0xf0f0f0f0),
6632 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6633 			BPF_MOV32_IMM(R0, 2),
6634 			BPF_EXIT_INSN(),
6635 			BPF_MOV32_IMM(R0, 1),
6636 			BPF_EXIT_INSN(),
6637 		},
6638 		INTERNAL,
6639 		{ },
6640 		{ { 0, 1 } }
6641 	},
6642 	{
6643 		"ALU64_XOR_K: 5 ^ 6 = 3",
6644 		.u.insns_int = {
6645 			BPF_LD_IMM64(R0, 5),
6646 			BPF_ALU64_IMM(BPF_XOR, R0, 6),
6647 			BPF_EXIT_INSN(),
6648 		},
6649 		INTERNAL,
6650 		{ },
6651 		{ { 0, 3 } },
6652 	},
6653 	{
6654 		"ALU64_XOR_K: 1 ^ 0xffffffff = 0xfffffffe",
6655 		.u.insns_int = {
6656 			BPF_LD_IMM64(R0, 1),
6657 			BPF_ALU64_IMM(BPF_XOR, R0, 0xffffffff),
6658 			BPF_EXIT_INSN(),
6659 		},
6660 		INTERNAL,
6661 		{ },
6662 		{ { 0, 0xfffffffe } },
6663 	},
6664 	{
6665 		"ALU64_XOR_K: 0x0000ffffffff0000 ^ 0x0 = 0x0000ffffffff0000",
6666 		.u.insns_int = {
6667 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6668 			BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
6669 			BPF_ALU64_IMM(BPF_XOR, R2, 0x0),
6670 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6671 			BPF_MOV32_IMM(R0, 2),
6672 			BPF_EXIT_INSN(),
6673 			BPF_MOV32_IMM(R0, 1),
6674 			BPF_EXIT_INSN(),
6675 		},
6676 		INTERNAL,
6677 		{ },
6678 		{ { 0, 0x1 } },
6679 	},
6680 	{
6681 		"ALU64_XOR_K: 0x0000ffffffff0000 ^ -1 = 0xffff00000000ffff",
6682 		.u.insns_int = {
6683 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6684 			BPF_LD_IMM64(R3, 0xffff00000000ffffLL),
6685 			BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
6686 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6687 			BPF_MOV32_IMM(R0, 2),
6688 			BPF_EXIT_INSN(),
6689 			BPF_MOV32_IMM(R0, 1),
6690 			BPF_EXIT_INSN(),
6691 		},
6692 		INTERNAL,
6693 		{ },
6694 		{ { 0, 0x1 } },
6695 	},
6696 	{
6697 		"ALU64_XOR_K: 0x000000000000000 ^ -1 = 0xffffffffffffffff",
6698 		.u.insns_int = {
6699 			BPF_LD_IMM64(R2, 0x0000000000000000LL),
6700 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
6701 			BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
6702 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6703 			BPF_MOV32_IMM(R0, 2),
6704 			BPF_EXIT_INSN(),
6705 			BPF_MOV32_IMM(R0, 1),
6706 			BPF_EXIT_INSN(),
6707 		},
6708 		INTERNAL,
6709 		{ },
6710 		{ { 0, 0x1 } },
6711 	},
6712 	{
6713 		"ALU64_XOR_K: Sign extension 1",
6714 		.u.insns_int = {
6715 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6716 			BPF_LD_IMM64(R1, 0x0123456786a4c2e0LL),
6717 			BPF_ALU64_IMM(BPF_XOR, R0, 0x0f0f0f0f),
6718 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6719 			BPF_MOV32_IMM(R0, 2),
6720 			BPF_EXIT_INSN(),
6721 			BPF_MOV32_IMM(R0, 1),
6722 			BPF_EXIT_INSN(),
6723 		},
6724 		INTERNAL,
6725 		{ },
6726 		{ { 0, 1 } }
6727 	},
6728 	{
6729 		"ALU64_XOR_K: Sign extension 2",
6730 		.u.insns_int = {
6731 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6732 			BPF_LD_IMM64(R1, 0xfedcba98795b3d1fLL),
6733 			BPF_ALU64_IMM(BPF_XOR, R0, 0xf0f0f0f0),
6734 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6735 			BPF_MOV32_IMM(R0, 2),
6736 			BPF_EXIT_INSN(),
6737 			BPF_MOV32_IMM(R0, 1),
6738 			BPF_EXIT_INSN(),
6739 		},
6740 		INTERNAL,
6741 		{ },
6742 		{ { 0, 1 } }
6743 	},
6744 	/* BPF_ALU | BPF_LSH | BPF_X */
6745 	{
6746 		"ALU_LSH_X: 1 << 1 = 2",
6747 		.u.insns_int = {
6748 			BPF_LD_IMM64(R0, 1),
6749 			BPF_ALU32_IMM(BPF_MOV, R1, 1),
6750 			BPF_ALU32_REG(BPF_LSH, R0, R1),
6751 			BPF_EXIT_INSN(),
6752 		},
6753 		INTERNAL,
6754 		{ },
6755 		{ { 0, 2 } },
6756 	},
6757 	{
6758 		"ALU_LSH_X: 1 << 31 = 0x80000000",
6759 		.u.insns_int = {
6760 			BPF_LD_IMM64(R0, 1),
6761 			BPF_ALU32_IMM(BPF_MOV, R1, 31),
6762 			BPF_ALU32_REG(BPF_LSH, R0, R1),
6763 			BPF_EXIT_INSN(),
6764 		},
6765 		INTERNAL,
6766 		{ },
6767 		{ { 0, 0x80000000 } },
6768 	},
6769 	{
6770 		"ALU_LSH_X: 0x12345678 << 12 = 0x45678000",
6771 		.u.insns_int = {
6772 			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
6773 			BPF_ALU32_IMM(BPF_MOV, R1, 12),
6774 			BPF_ALU32_REG(BPF_LSH, R0, R1),
6775 			BPF_EXIT_INSN(),
6776 		},
6777 		INTERNAL,
6778 		{ },
6779 		{ { 0, 0x45678000 } }
6780 	},
6781 	{
6782 		"ALU64_LSH_X: 1 << 1 = 2",
6783 		.u.insns_int = {
6784 			BPF_LD_IMM64(R0, 1),
6785 			BPF_ALU32_IMM(BPF_MOV, R1, 1),
6786 			BPF_ALU64_REG(BPF_LSH, R0, R1),
6787 			BPF_EXIT_INSN(),
6788 		},
6789 		INTERNAL,
6790 		{ },
6791 		{ { 0, 2 } },
6792 	},
6793 	{
6794 		"ALU64_LSH_X: 1 << 31 = 0x80000000",
6795 		.u.insns_int = {
6796 			BPF_LD_IMM64(R0, 1),
6797 			BPF_ALU32_IMM(BPF_MOV, R1, 31),
6798 			BPF_ALU64_REG(BPF_LSH, R0, R1),
6799 			BPF_EXIT_INSN(),
6800 		},
6801 		INTERNAL,
6802 		{ },
6803 		{ { 0, 0x80000000 } },
6804 	},
6805 	{
6806 		"ALU64_LSH_X: Shift < 32, low word",
6807 		.u.insns_int = {
6808 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6809 			BPF_ALU32_IMM(BPF_MOV, R1, 12),
6810 			BPF_ALU64_REG(BPF_LSH, R0, R1),
6811 			BPF_EXIT_INSN(),
6812 		},
6813 		INTERNAL,
6814 		{ },
6815 		{ { 0, 0xbcdef000 } }
6816 	},
6817 	{
6818 		"ALU64_LSH_X: Shift < 32, high word",
6819 		.u.insns_int = {
6820 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6821 			BPF_ALU32_IMM(BPF_MOV, R1, 12),
6822 			BPF_ALU64_REG(BPF_LSH, R0, R1),
6823 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6824 			BPF_EXIT_INSN(),
6825 		},
6826 		INTERNAL,
6827 		{ },
6828 		{ { 0, 0x3456789a } }
6829 	},
6830 	{
6831 		"ALU64_LSH_X: Shift > 32, low word",
6832 		.u.insns_int = {
6833 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6834 			BPF_ALU32_IMM(BPF_MOV, R1, 36),
6835 			BPF_ALU64_REG(BPF_LSH, R0, R1),
6836 			BPF_EXIT_INSN(),
6837 		},
6838 		INTERNAL,
6839 		{ },
6840 		{ { 0, 0 } }
6841 	},
6842 	{
6843 		"ALU64_LSH_X: Shift > 32, high word",
6844 		.u.insns_int = {
6845 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6846 			BPF_ALU32_IMM(BPF_MOV, R1, 36),
6847 			BPF_ALU64_REG(BPF_LSH, R0, R1),
6848 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6849 			BPF_EXIT_INSN(),
6850 		},
6851 		INTERNAL,
6852 		{ },
6853 		{ { 0, 0x9abcdef0 } }
6854 	},
6855 	{
6856 		"ALU64_LSH_X: Shift == 32, low word",
6857 		.u.insns_int = {
6858 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6859 			BPF_ALU32_IMM(BPF_MOV, R1, 32),
6860 			BPF_ALU64_REG(BPF_LSH, R0, R1),
6861 			BPF_EXIT_INSN(),
6862 		},
6863 		INTERNAL,
6864 		{ },
6865 		{ { 0, 0 } }
6866 	},
6867 	{
6868 		"ALU64_LSH_X: Shift == 32, high word",
6869 		.u.insns_int = {
6870 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6871 			BPF_ALU32_IMM(BPF_MOV, R1, 32),
6872 			BPF_ALU64_REG(BPF_LSH, R0, R1),
6873 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6874 			BPF_EXIT_INSN(),
6875 		},
6876 		INTERNAL,
6877 		{ },
6878 		{ { 0, 0x89abcdef } }
6879 	},
6880 	{
6881 		"ALU64_LSH_X: Zero shift, low word",
6882 		.u.insns_int = {
6883 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6884 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
6885 			BPF_ALU64_REG(BPF_LSH, R0, R1),
6886 			BPF_EXIT_INSN(),
6887 		},
6888 		INTERNAL,
6889 		{ },
6890 		{ { 0, 0x89abcdef } }
6891 	},
6892 	{
6893 		"ALU64_LSH_X: Zero shift, high word",
6894 		.u.insns_int = {
6895 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6896 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
6897 			BPF_ALU64_REG(BPF_LSH, R0, R1),
6898 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6899 			BPF_EXIT_INSN(),
6900 		},
6901 		INTERNAL,
6902 		{ },
6903 		{ { 0, 0x01234567 } }
6904 	},
6905 	/* BPF_ALU | BPF_LSH | BPF_K */
6906 	{
6907 		"ALU_LSH_K: 1 << 1 = 2",
6908 		.u.insns_int = {
6909 			BPF_LD_IMM64(R0, 1),
6910 			BPF_ALU32_IMM(BPF_LSH, R0, 1),
6911 			BPF_EXIT_INSN(),
6912 		},
6913 		INTERNAL,
6914 		{ },
6915 		{ { 0, 2 } },
6916 	},
6917 	{
6918 		"ALU_LSH_K: 1 << 31 = 0x80000000",
6919 		.u.insns_int = {
6920 			BPF_LD_IMM64(R0, 1),
6921 			BPF_ALU32_IMM(BPF_LSH, R0, 31),
6922 			BPF_EXIT_INSN(),
6923 		},
6924 		INTERNAL,
6925 		{ },
6926 		{ { 0, 0x80000000 } },
6927 	},
6928 	{
6929 		"ALU_LSH_K: 0x12345678 << 12 = 0x45678000",
6930 		.u.insns_int = {
6931 			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
6932 			BPF_ALU32_IMM(BPF_LSH, R0, 12),
6933 			BPF_EXIT_INSN(),
6934 		},
6935 		INTERNAL,
6936 		{ },
6937 		{ { 0, 0x45678000 } }
6938 	},
6939 	{
6940 		"ALU_LSH_K: 0x12345678 << 0 = 0x12345678",
6941 		.u.insns_int = {
6942 			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
6943 			BPF_ALU32_IMM(BPF_LSH, R0, 0),
6944 			BPF_EXIT_INSN(),
6945 		},
6946 		INTERNAL,
6947 		{ },
6948 		{ { 0, 0x12345678 } }
6949 	},
6950 	{
6951 		"ALU64_LSH_K: 1 << 1 = 2",
6952 		.u.insns_int = {
6953 			BPF_LD_IMM64(R0, 1),
6954 			BPF_ALU64_IMM(BPF_LSH, R0, 1),
6955 			BPF_EXIT_INSN(),
6956 		},
6957 		INTERNAL,
6958 		{ },
6959 		{ { 0, 2 } },
6960 	},
6961 	{
6962 		"ALU64_LSH_K: 1 << 31 = 0x80000000",
6963 		.u.insns_int = {
6964 			BPF_LD_IMM64(R0, 1),
6965 			BPF_ALU64_IMM(BPF_LSH, R0, 31),
6966 			BPF_EXIT_INSN(),
6967 		},
6968 		INTERNAL,
6969 		{ },
6970 		{ { 0, 0x80000000 } },
6971 	},
6972 	{
6973 		"ALU64_LSH_K: Shift < 32, low word",
6974 		.u.insns_int = {
6975 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6976 			BPF_ALU64_IMM(BPF_LSH, R0, 12),
6977 			BPF_EXIT_INSN(),
6978 		},
6979 		INTERNAL,
6980 		{ },
6981 		{ { 0, 0xbcdef000 } }
6982 	},
6983 	{
6984 		"ALU64_LSH_K: Shift < 32, high word",
6985 		.u.insns_int = {
6986 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6987 			BPF_ALU64_IMM(BPF_LSH, R0, 12),
6988 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6989 			BPF_EXIT_INSN(),
6990 		},
6991 		INTERNAL,
6992 		{ },
6993 		{ { 0, 0x3456789a } }
6994 	},
6995 	{
6996 		"ALU64_LSH_K: Shift > 32, low word",
6997 		.u.insns_int = {
6998 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6999 			BPF_ALU64_IMM(BPF_LSH, R0, 36),
7000 			BPF_EXIT_INSN(),
7001 		},
7002 		INTERNAL,
7003 		{ },
7004 		{ { 0, 0 } }
7005 	},
7006 	{
7007 		"ALU64_LSH_K: Shift > 32, high word",
7008 		.u.insns_int = {
7009 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7010 			BPF_ALU64_IMM(BPF_LSH, R0, 36),
7011 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7012 			BPF_EXIT_INSN(),
7013 		},
7014 		INTERNAL,
7015 		{ },
7016 		{ { 0, 0x9abcdef0 } }
7017 	},
7018 	{
7019 		"ALU64_LSH_K: Shift == 32, low word",
7020 		.u.insns_int = {
7021 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7022 			BPF_ALU64_IMM(BPF_LSH, R0, 32),
7023 			BPF_EXIT_INSN(),
7024 		},
7025 		INTERNAL,
7026 		{ },
7027 		{ { 0, 0 } }
7028 	},
7029 	{
7030 		"ALU64_LSH_K: Shift == 32, high word",
7031 		.u.insns_int = {
7032 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7033 			BPF_ALU64_IMM(BPF_LSH, R0, 32),
7034 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7035 			BPF_EXIT_INSN(),
7036 		},
7037 		INTERNAL,
7038 		{ },
7039 		{ { 0, 0x89abcdef } }
7040 	},
7041 	{
7042 		"ALU64_LSH_K: Zero shift",
7043 		.u.insns_int = {
7044 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7045 			BPF_ALU64_IMM(BPF_LSH, R0, 0),
7046 			BPF_EXIT_INSN(),
7047 		},
7048 		INTERNAL,
7049 		{ },
7050 		{ { 0, 0x89abcdef } }
7051 	},
7052 	/* BPF_ALU | BPF_RSH | BPF_X */
7053 	{
7054 		"ALU_RSH_X: 2 >> 1 = 1",
7055 		.u.insns_int = {
7056 			BPF_LD_IMM64(R0, 2),
7057 			BPF_ALU32_IMM(BPF_MOV, R1, 1),
7058 			BPF_ALU32_REG(BPF_RSH, R0, R1),
7059 			BPF_EXIT_INSN(),
7060 		},
7061 		INTERNAL,
7062 		{ },
7063 		{ { 0, 1 } },
7064 	},
7065 	{
7066 		"ALU_RSH_X: 0x80000000 >> 31 = 1",
7067 		.u.insns_int = {
7068 			BPF_LD_IMM64(R0, 0x80000000),
7069 			BPF_ALU32_IMM(BPF_MOV, R1, 31),
7070 			BPF_ALU32_REG(BPF_RSH, R0, R1),
7071 			BPF_EXIT_INSN(),
7072 		},
7073 		INTERNAL,
7074 		{ },
7075 		{ { 0, 1 } },
7076 	},
7077 	{
7078 		"ALU_RSH_X: 0x12345678 >> 20 = 0x123",
7079 		.u.insns_int = {
7080 			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
7081 			BPF_ALU32_IMM(BPF_MOV, R1, 20),
7082 			BPF_ALU32_REG(BPF_RSH, R0, R1),
7083 			BPF_EXIT_INSN(),
7084 		},
7085 		INTERNAL,
7086 		{ },
7087 		{ { 0, 0x123 } }
7088 	},
7089 	{
7090 		"ALU64_RSH_X: 2 >> 1 = 1",
7091 		.u.insns_int = {
7092 			BPF_LD_IMM64(R0, 2),
7093 			BPF_ALU32_IMM(BPF_MOV, R1, 1),
7094 			BPF_ALU64_REG(BPF_RSH, R0, R1),
7095 			BPF_EXIT_INSN(),
7096 		},
7097 		INTERNAL,
7098 		{ },
7099 		{ { 0, 1 } },
7100 	},
7101 	{
7102 		"ALU64_RSH_X: 0x80000000 >> 31 = 1",
7103 		.u.insns_int = {
7104 			BPF_LD_IMM64(R0, 0x80000000),
7105 			BPF_ALU32_IMM(BPF_MOV, R1, 31),
7106 			BPF_ALU64_REG(BPF_RSH, R0, R1),
7107 			BPF_EXIT_INSN(),
7108 		},
7109 		INTERNAL,
7110 		{ },
7111 		{ { 0, 1 } },
7112 	},
7113 	{
7114 		"ALU64_RSH_X: Shift < 32, low word",
7115 		.u.insns_int = {
7116 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7117 			BPF_ALU32_IMM(BPF_MOV, R1, 12),
7118 			BPF_ALU64_REG(BPF_RSH, R0, R1),
7119 			BPF_EXIT_INSN(),
7120 		},
7121 		INTERNAL,
7122 		{ },
7123 		{ { 0, 0x56789abc } }
7124 	},
7125 	{
7126 		"ALU64_RSH_X: Shift < 32, high word",
7127 		.u.insns_int = {
7128 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7129 			BPF_ALU32_IMM(BPF_MOV, R1, 12),
7130 			BPF_ALU64_REG(BPF_RSH, R0, R1),
7131 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7132 			BPF_EXIT_INSN(),
7133 		},
7134 		INTERNAL,
7135 		{ },
7136 		{ { 0, 0x00081234 } }
7137 	},
7138 	{
7139 		"ALU64_RSH_X: Shift > 32, low word",
7140 		.u.insns_int = {
7141 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7142 			BPF_ALU32_IMM(BPF_MOV, R1, 36),
7143 			BPF_ALU64_REG(BPF_RSH, R0, R1),
7144 			BPF_EXIT_INSN(),
7145 		},
7146 		INTERNAL,
7147 		{ },
7148 		{ { 0, 0x08123456 } }
7149 	},
7150 	{
7151 		"ALU64_RSH_X: Shift > 32, high word",
7152 		.u.insns_int = {
7153 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7154 			BPF_ALU32_IMM(BPF_MOV, R1, 36),
7155 			BPF_ALU64_REG(BPF_RSH, R0, R1),
7156 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7157 			BPF_EXIT_INSN(),
7158 		},
7159 		INTERNAL,
7160 		{ },
7161 		{ { 0, 0 } }
7162 	},
7163 	{
7164 		"ALU64_RSH_X: Shift == 32, low word",
7165 		.u.insns_int = {
7166 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7167 			BPF_ALU32_IMM(BPF_MOV, R1, 32),
7168 			BPF_ALU64_REG(BPF_RSH, R0, R1),
7169 			BPF_EXIT_INSN(),
7170 		},
7171 		INTERNAL,
7172 		{ },
7173 		{ { 0, 0x81234567 } }
7174 	},
7175 	{
7176 		"ALU64_RSH_X: Shift == 32, high word",
7177 		.u.insns_int = {
7178 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7179 			BPF_ALU32_IMM(BPF_MOV, R1, 32),
7180 			BPF_ALU64_REG(BPF_RSH, R0, R1),
7181 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7182 			BPF_EXIT_INSN(),
7183 		},
7184 		INTERNAL,
7185 		{ },
7186 		{ { 0, 0 } }
7187 	},
7188 	{
7189 		"ALU64_RSH_X: Zero shift, low word",
7190 		.u.insns_int = {
7191 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7192 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
7193 			BPF_ALU64_REG(BPF_RSH, R0, R1),
7194 			BPF_EXIT_INSN(),
7195 		},
7196 		INTERNAL,
7197 		{ },
7198 		{ { 0, 0x89abcdef } }
7199 	},
7200 	{
7201 		"ALU64_RSH_X: Zero shift, high word",
7202 		.u.insns_int = {
7203 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7204 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
7205 			BPF_ALU64_REG(BPF_RSH, R0, R1),
7206 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7207 			BPF_EXIT_INSN(),
7208 		},
7209 		INTERNAL,
7210 		{ },
7211 		{ { 0, 0x81234567 } }
7212 	},
7213 	/* BPF_ALU | BPF_RSH | BPF_K */
7214 	{
7215 		"ALU_RSH_K: 2 >> 1 = 1",
7216 		.u.insns_int = {
7217 			BPF_LD_IMM64(R0, 2),
7218 			BPF_ALU32_IMM(BPF_RSH, R0, 1),
7219 			BPF_EXIT_INSN(),
7220 		},
7221 		INTERNAL,
7222 		{ },
7223 		{ { 0, 1 } },
7224 	},
7225 	{
7226 		"ALU_RSH_K: 0x80000000 >> 31 = 1",
7227 		.u.insns_int = {
7228 			BPF_LD_IMM64(R0, 0x80000000),
7229 			BPF_ALU32_IMM(BPF_RSH, R0, 31),
7230 			BPF_EXIT_INSN(),
7231 		},
7232 		INTERNAL,
7233 		{ },
7234 		{ { 0, 1 } },
7235 	},
7236 	{
7237 		"ALU_RSH_K: 0x12345678 >> 20 = 0x123",
7238 		.u.insns_int = {
7239 			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
7240 			BPF_ALU32_IMM(BPF_RSH, R0, 20),
7241 			BPF_EXIT_INSN(),
7242 		},
7243 		INTERNAL,
7244 		{ },
7245 		{ { 0, 0x123 } }
7246 	},
7247 	{
7248 		"ALU_RSH_K: 0x12345678 >> 0 = 0x12345678",
7249 		.u.insns_int = {
7250 			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
7251 			BPF_ALU32_IMM(BPF_RSH, R0, 0),
7252 			BPF_EXIT_INSN(),
7253 		},
7254 		INTERNAL,
7255 		{ },
7256 		{ { 0, 0x12345678 } }
7257 	},
7258 	{
7259 		"ALU64_RSH_K: 2 >> 1 = 1",
7260 		.u.insns_int = {
7261 			BPF_LD_IMM64(R0, 2),
7262 			BPF_ALU64_IMM(BPF_RSH, R0, 1),
7263 			BPF_EXIT_INSN(),
7264 		},
7265 		INTERNAL,
7266 		{ },
7267 		{ { 0, 1 } },
7268 	},
7269 	{
7270 		"ALU64_RSH_K: 0x80000000 >> 31 = 1",
7271 		.u.insns_int = {
7272 			BPF_LD_IMM64(R0, 0x80000000),
7273 			BPF_ALU64_IMM(BPF_RSH, R0, 31),
7274 			BPF_EXIT_INSN(),
7275 		},
7276 		INTERNAL,
7277 		{ },
7278 		{ { 0, 1 } },
7279 	},
7280 	{
7281 		"ALU64_RSH_K: Shift < 32, low word",
7282 		.u.insns_int = {
7283 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7284 			BPF_ALU64_IMM(BPF_RSH, R0, 12),
7285 			BPF_EXIT_INSN(),
7286 		},
7287 		INTERNAL,
7288 		{ },
7289 		{ { 0, 0x56789abc } }
7290 	},
7291 	{
7292 		"ALU64_RSH_K: Shift < 32, high word",
7293 		.u.insns_int = {
7294 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7295 			BPF_ALU64_IMM(BPF_RSH, R0, 12),
7296 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7297 			BPF_EXIT_INSN(),
7298 		},
7299 		INTERNAL,
7300 		{ },
7301 		{ { 0, 0x00081234 } }
7302 	},
7303 	{
7304 		"ALU64_RSH_K: Shift > 32, low word",
7305 		.u.insns_int = {
7306 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7307 			BPF_ALU64_IMM(BPF_RSH, R0, 36),
7308 			BPF_EXIT_INSN(),
7309 		},
7310 		INTERNAL,
7311 		{ },
7312 		{ { 0, 0x08123456 } }
7313 	},
7314 	{
7315 		"ALU64_RSH_K: Shift > 32, high word",
7316 		.u.insns_int = {
7317 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7318 			BPF_ALU64_IMM(BPF_RSH, R0, 36),
7319 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7320 			BPF_EXIT_INSN(),
7321 		},
7322 		INTERNAL,
7323 		{ },
7324 		{ { 0, 0 } }
7325 	},
7326 	{
7327 		"ALU64_RSH_K: Shift == 32, low word",
7328 		.u.insns_int = {
7329 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7330 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7331 			BPF_EXIT_INSN(),
7332 		},
7333 		INTERNAL,
7334 		{ },
7335 		{ { 0, 0x81234567 } }
7336 	},
7337 	{
7338 		"ALU64_RSH_K: Shift == 32, high word",
7339 		.u.insns_int = {
7340 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7341 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7342 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7343 			BPF_EXIT_INSN(),
7344 		},
7345 		INTERNAL,
7346 		{ },
7347 		{ { 0, 0 } }
7348 	},
7349 	{
7350 		"ALU64_RSH_K: Zero shift",
7351 		.u.insns_int = {
7352 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7353 			BPF_ALU64_IMM(BPF_RSH, R0, 0),
7354 			BPF_EXIT_INSN(),
7355 		},
7356 		INTERNAL,
7357 		{ },
7358 		{ { 0, 0x89abcdef } }
7359 	},
7360 	/* BPF_ALU | BPF_ARSH | BPF_X */
7361 	{
7362 		"ALU32_ARSH_X: -1234 >> 7 = -10",
7363 		.u.insns_int = {
7364 			BPF_ALU32_IMM(BPF_MOV, R0, -1234),
7365 			BPF_ALU32_IMM(BPF_MOV, R1, 7),
7366 			BPF_ALU32_REG(BPF_ARSH, R0, R1),
7367 			BPF_EXIT_INSN(),
7368 		},
7369 		INTERNAL,
7370 		{ },
7371 		{ { 0, -10 } }
7372 	},
7373 	{
7374 		"ALU64_ARSH_X: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
7375 		.u.insns_int = {
7376 			BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
7377 			BPF_ALU32_IMM(BPF_MOV, R1, 40),
7378 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
7379 			BPF_EXIT_INSN(),
7380 		},
7381 		INTERNAL,
7382 		{ },
7383 		{ { 0, 0xffff00ff } },
7384 	},
7385 	{
7386 		"ALU64_ARSH_X: Shift < 32, low word",
7387 		.u.insns_int = {
7388 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7389 			BPF_ALU32_IMM(BPF_MOV, R1, 12),
7390 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
7391 			BPF_EXIT_INSN(),
7392 		},
7393 		INTERNAL,
7394 		{ },
7395 		{ { 0, 0x56789abc } }
7396 	},
7397 	{
7398 		"ALU64_ARSH_X: Shift < 32, high word",
7399 		.u.insns_int = {
7400 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7401 			BPF_ALU32_IMM(BPF_MOV, R1, 12),
7402 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
7403 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7404 			BPF_EXIT_INSN(),
7405 		},
7406 		INTERNAL,
7407 		{ },
7408 		{ { 0, 0xfff81234 } }
7409 	},
7410 	{
7411 		"ALU64_ARSH_X: Shift > 32, low word",
7412 		.u.insns_int = {
7413 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7414 			BPF_ALU32_IMM(BPF_MOV, R1, 36),
7415 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
7416 			BPF_EXIT_INSN(),
7417 		},
7418 		INTERNAL,
7419 		{ },
7420 		{ { 0, 0xf8123456 } }
7421 	},
7422 	{
7423 		"ALU64_ARSH_X: Shift > 32, high word",
7424 		.u.insns_int = {
7425 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7426 			BPF_ALU32_IMM(BPF_MOV, R1, 36),
7427 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
7428 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7429 			BPF_EXIT_INSN(),
7430 		},
7431 		INTERNAL,
7432 		{ },
7433 		{ { 0, -1 } }
7434 	},
7435 	{
7436 		"ALU64_ARSH_X: Shift == 32, low word",
7437 		.u.insns_int = {
7438 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7439 			BPF_ALU32_IMM(BPF_MOV, R1, 32),
7440 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
7441 			BPF_EXIT_INSN(),
7442 		},
7443 		INTERNAL,
7444 		{ },
7445 		{ { 0, 0x81234567 } }
7446 	},
7447 	{
7448 		"ALU64_ARSH_X: Shift == 32, high word",
7449 		.u.insns_int = {
7450 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7451 			BPF_ALU32_IMM(BPF_MOV, R1, 32),
7452 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
7453 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7454 			BPF_EXIT_INSN(),
7455 		},
7456 		INTERNAL,
7457 		{ },
7458 		{ { 0, -1 } }
7459 	},
7460 	{
7461 		"ALU64_ARSH_X: Zero shift, low word",
7462 		.u.insns_int = {
7463 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7464 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
7465 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
7466 			BPF_EXIT_INSN(),
7467 		},
7468 		INTERNAL,
7469 		{ },
7470 		{ { 0, 0x89abcdef } }
7471 	},
7472 	{
7473 		"ALU64_ARSH_X: Zero shift, high word",
7474 		.u.insns_int = {
7475 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7476 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
7477 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
7478 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7479 			BPF_EXIT_INSN(),
7480 		},
7481 		INTERNAL,
7482 		{ },
7483 		{ { 0, 0x81234567 } }
7484 	},
7485 	/* BPF_ALU | BPF_ARSH | BPF_K */
7486 	{
7487 		"ALU32_ARSH_K: -1234 >> 7 = -10",
7488 		.u.insns_int = {
7489 			BPF_ALU32_IMM(BPF_MOV, R0, -1234),
7490 			BPF_ALU32_IMM(BPF_ARSH, R0, 7),
7491 			BPF_EXIT_INSN(),
7492 		},
7493 		INTERNAL,
7494 		{ },
7495 		{ { 0, -10 } }
7496 	},
7497 	{
7498 		"ALU32_ARSH_K: -1234 >> 0 = -1234",
7499 		.u.insns_int = {
7500 			BPF_ALU32_IMM(BPF_MOV, R0, -1234),
7501 			BPF_ALU32_IMM(BPF_ARSH, R0, 0),
7502 			BPF_EXIT_INSN(),
7503 		},
7504 		INTERNAL,
7505 		{ },
7506 		{ { 0, -1234 } }
7507 	},
7508 	{
7509 		"ALU64_ARSH_K: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
7510 		.u.insns_int = {
7511 			BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
7512 			BPF_ALU64_IMM(BPF_ARSH, R0, 40),
7513 			BPF_EXIT_INSN(),
7514 		},
7515 		INTERNAL,
7516 		{ },
7517 		{ { 0, 0xffff00ff } },
7518 	},
7519 	{
7520 		"ALU64_ARSH_K: Shift < 32, low word",
7521 		.u.insns_int = {
7522 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7523 			BPF_ALU64_IMM(BPF_RSH, R0, 12),
7524 			BPF_EXIT_INSN(),
7525 		},
7526 		INTERNAL,
7527 		{ },
7528 		{ { 0, 0x56789abc } }
7529 	},
7530 	{
7531 		"ALU64_ARSH_K: Shift < 32, high word",
7532 		.u.insns_int = {
7533 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7534 			BPF_ALU64_IMM(BPF_ARSH, R0, 12),
7535 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7536 			BPF_EXIT_INSN(),
7537 		},
7538 		INTERNAL,
7539 		{ },
7540 		{ { 0, 0xfff81234 } }
7541 	},
7542 	{
7543 		"ALU64_ARSH_K: Shift > 32, low word",
7544 		.u.insns_int = {
7545 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7546 			BPF_ALU64_IMM(BPF_ARSH, R0, 36),
7547 			BPF_EXIT_INSN(),
7548 		},
7549 		INTERNAL,
7550 		{ },
7551 		{ { 0, 0xf8123456 } }
7552 	},
7553 	{
7554 		"ALU64_ARSH_K: Shift > 32, high word",
7555 		.u.insns_int = {
7556 			BPF_LD_IMM64(R0, 0xf123456789abcdefLL),
7557 			BPF_ALU64_IMM(BPF_ARSH, R0, 36),
7558 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7559 			BPF_EXIT_INSN(),
7560 		},
7561 		INTERNAL,
7562 		{ },
7563 		{ { 0, -1 } }
7564 	},
7565 	{
7566 		"ALU64_ARSH_K: Shift == 32, low word",
7567 		.u.insns_int = {
7568 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7569 			BPF_ALU64_IMM(BPF_ARSH, R0, 32),
7570 			BPF_EXIT_INSN(),
7571 		},
7572 		INTERNAL,
7573 		{ },
7574 		{ { 0, 0x81234567 } }
7575 	},
7576 	{
7577 		"ALU64_ARSH_K: Shift == 32, high word",
7578 		.u.insns_int = {
7579 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7580 			BPF_ALU64_IMM(BPF_ARSH, R0, 32),
7581 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7582 			BPF_EXIT_INSN(),
7583 		},
7584 		INTERNAL,
7585 		{ },
7586 		{ { 0, -1 } }
7587 	},
7588 	{
7589 		"ALU64_ARSH_K: Zero shift",
7590 		.u.insns_int = {
7591 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7592 			BPF_ALU64_IMM(BPF_ARSH, R0, 0),
7593 			BPF_EXIT_INSN(),
7594 		},
7595 		INTERNAL,
7596 		{ },
7597 		{ { 0, 0x89abcdef } }
7598 	},
7599 	/* BPF_ALU | BPF_NEG */
7600 	{
7601 		"ALU_NEG: -(3) = -3",
7602 		.u.insns_int = {
7603 			BPF_ALU32_IMM(BPF_MOV, R0, 3),
7604 			BPF_ALU32_IMM(BPF_NEG, R0, 0),
7605 			BPF_EXIT_INSN(),
7606 		},
7607 		INTERNAL,
7608 		{ },
7609 		{ { 0, -3 } },
7610 	},
7611 	{
7612 		"ALU_NEG: -(-3) = 3",
7613 		.u.insns_int = {
7614 			BPF_ALU32_IMM(BPF_MOV, R0, -3),
7615 			BPF_ALU32_IMM(BPF_NEG, R0, 0),
7616 			BPF_EXIT_INSN(),
7617 		},
7618 		INTERNAL,
7619 		{ },
7620 		{ { 0, 3 } },
7621 	},
7622 	{
7623 		"ALU64_NEG: -(3) = -3",
7624 		.u.insns_int = {
7625 			BPF_LD_IMM64(R0, 3),
7626 			BPF_ALU64_IMM(BPF_NEG, R0, 0),
7627 			BPF_EXIT_INSN(),
7628 		},
7629 		INTERNAL,
7630 		{ },
7631 		{ { 0, -3 } },
7632 	},
7633 	{
7634 		"ALU64_NEG: -(-3) = 3",
7635 		.u.insns_int = {
7636 			BPF_LD_IMM64(R0, -3),
7637 			BPF_ALU64_IMM(BPF_NEG, R0, 0),
7638 			BPF_EXIT_INSN(),
7639 		},
7640 		INTERNAL,
7641 		{ },
7642 		{ { 0, 3 } },
7643 	},
7644 	/* BPF_ALU | BPF_END | BPF_FROM_BE */
7645 	{
7646 		"ALU_END_FROM_BE 16: 0x0123456789abcdef -> 0xcdef",
7647 		.u.insns_int = {
7648 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7649 			BPF_ENDIAN(BPF_FROM_BE, R0, 16),
7650 			BPF_EXIT_INSN(),
7651 		},
7652 		INTERNAL,
7653 		{ },
7654 		{ { 0,  cpu_to_be16(0xcdef) } },
7655 	},
7656 	{
7657 		"ALU_END_FROM_BE 32: 0x0123456789abcdef -> 0x89abcdef",
7658 		.u.insns_int = {
7659 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7660 			BPF_ENDIAN(BPF_FROM_BE, R0, 32),
7661 			BPF_ALU64_REG(BPF_MOV, R1, R0),
7662 			BPF_ALU64_IMM(BPF_RSH, R1, 32),
7663 			BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
7664 			BPF_EXIT_INSN(),
7665 		},
7666 		INTERNAL,
7667 		{ },
7668 		{ { 0, cpu_to_be32(0x89abcdef) } },
7669 	},
7670 	{
7671 		"ALU_END_FROM_BE 64: 0x0123456789abcdef -> 0x89abcdef",
7672 		.u.insns_int = {
7673 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7674 			BPF_ENDIAN(BPF_FROM_BE, R0, 64),
7675 			BPF_EXIT_INSN(),
7676 		},
7677 		INTERNAL,
7678 		{ },
7679 		{ { 0, (u32) cpu_to_be64(0x0123456789abcdefLL) } },
7680 	},
7681 	{
7682 		"ALU_END_FROM_BE 64: 0x0123456789abcdef >> 32 -> 0x01234567",
7683 		.u.insns_int = {
7684 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7685 			BPF_ENDIAN(BPF_FROM_BE, R0, 64),
7686 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7687 			BPF_EXIT_INSN(),
7688 		},
7689 		INTERNAL,
7690 		{ },
7691 		{ { 0, (u32) (cpu_to_be64(0x0123456789abcdefLL) >> 32) } },
7692 	},
7693 	/* BPF_ALU | BPF_END | BPF_FROM_BE, reversed */
7694 	{
7695 		"ALU_END_FROM_BE 16: 0xfedcba9876543210 -> 0x3210",
7696 		.u.insns_int = {
7697 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7698 			BPF_ENDIAN(BPF_FROM_BE, R0, 16),
7699 			BPF_EXIT_INSN(),
7700 		},
7701 		INTERNAL,
7702 		{ },
7703 		{ { 0,  cpu_to_be16(0x3210) } },
7704 	},
7705 	{
7706 		"ALU_END_FROM_BE 32: 0xfedcba9876543210 -> 0x76543210",
7707 		.u.insns_int = {
7708 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7709 			BPF_ENDIAN(BPF_FROM_BE, R0, 32),
7710 			BPF_ALU64_REG(BPF_MOV, R1, R0),
7711 			BPF_ALU64_IMM(BPF_RSH, R1, 32),
7712 			BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
7713 			BPF_EXIT_INSN(),
7714 		},
7715 		INTERNAL,
7716 		{ },
7717 		{ { 0, cpu_to_be32(0x76543210) } },
7718 	},
7719 	{
7720 		"ALU_END_FROM_BE 64: 0xfedcba9876543210 -> 0x76543210",
7721 		.u.insns_int = {
7722 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7723 			BPF_ENDIAN(BPF_FROM_BE, R0, 64),
7724 			BPF_EXIT_INSN(),
7725 		},
7726 		INTERNAL,
7727 		{ },
7728 		{ { 0, (u32) cpu_to_be64(0xfedcba9876543210ULL) } },
7729 	},
7730 	{
7731 		"ALU_END_FROM_BE 64: 0xfedcba9876543210 >> 32 -> 0xfedcba98",
7732 		.u.insns_int = {
7733 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7734 			BPF_ENDIAN(BPF_FROM_BE, R0, 64),
7735 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7736 			BPF_EXIT_INSN(),
7737 		},
7738 		INTERNAL,
7739 		{ },
7740 		{ { 0, (u32) (cpu_to_be64(0xfedcba9876543210ULL) >> 32) } },
7741 	},
7742 	/* BPF_ALU | BPF_END | BPF_FROM_LE */
7743 	{
7744 		"ALU_END_FROM_LE 16: 0x0123456789abcdef -> 0xefcd",
7745 		.u.insns_int = {
7746 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7747 			BPF_ENDIAN(BPF_FROM_LE, R0, 16),
7748 			BPF_EXIT_INSN(),
7749 		},
7750 		INTERNAL,
7751 		{ },
7752 		{ { 0, cpu_to_le16(0xcdef) } },
7753 	},
7754 	{
7755 		"ALU_END_FROM_LE 32: 0x0123456789abcdef -> 0xefcdab89",
7756 		.u.insns_int = {
7757 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7758 			BPF_ENDIAN(BPF_FROM_LE, R0, 32),
7759 			BPF_ALU64_REG(BPF_MOV, R1, R0),
7760 			BPF_ALU64_IMM(BPF_RSH, R1, 32),
7761 			BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
7762 			BPF_EXIT_INSN(),
7763 		},
7764 		INTERNAL,
7765 		{ },
7766 		{ { 0, cpu_to_le32(0x89abcdef) } },
7767 	},
7768 	{
7769 		"ALU_END_FROM_LE 64: 0x0123456789abcdef -> 0x67452301",
7770 		.u.insns_int = {
7771 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7772 			BPF_ENDIAN(BPF_FROM_LE, R0, 64),
7773 			BPF_EXIT_INSN(),
7774 		},
7775 		INTERNAL,
7776 		{ },
7777 		{ { 0, (u32) cpu_to_le64(0x0123456789abcdefLL) } },
7778 	},
7779 	{
7780 		"ALU_END_FROM_LE 64: 0x0123456789abcdef >> 32 -> 0xefcdab89",
7781 		.u.insns_int = {
7782 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7783 			BPF_ENDIAN(BPF_FROM_LE, R0, 64),
7784 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7785 			BPF_EXIT_INSN(),
7786 		},
7787 		INTERNAL,
7788 		{ },
7789 		{ { 0, (u32) (cpu_to_le64(0x0123456789abcdefLL) >> 32) } },
7790 	},
7791 	/* BPF_ALU | BPF_END | BPF_FROM_LE, reversed */
7792 	{
7793 		"ALU_END_FROM_LE 16: 0xfedcba9876543210 -> 0x1032",
7794 		.u.insns_int = {
7795 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7796 			BPF_ENDIAN(BPF_FROM_LE, R0, 16),
7797 			BPF_EXIT_INSN(),
7798 		},
7799 		INTERNAL,
7800 		{ },
7801 		{ { 0,  cpu_to_le16(0x3210) } },
7802 	},
7803 	{
7804 		"ALU_END_FROM_LE 32: 0xfedcba9876543210 -> 0x10325476",
7805 		.u.insns_int = {
7806 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7807 			BPF_ENDIAN(BPF_FROM_LE, R0, 32),
7808 			BPF_ALU64_REG(BPF_MOV, R1, R0),
7809 			BPF_ALU64_IMM(BPF_RSH, R1, 32),
7810 			BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
7811 			BPF_EXIT_INSN(),
7812 		},
7813 		INTERNAL,
7814 		{ },
7815 		{ { 0, cpu_to_le32(0x76543210) } },
7816 	},
7817 	{
7818 		"ALU_END_FROM_LE 64: 0xfedcba9876543210 -> 0x10325476",
7819 		.u.insns_int = {
7820 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7821 			BPF_ENDIAN(BPF_FROM_LE, R0, 64),
7822 			BPF_EXIT_INSN(),
7823 		},
7824 		INTERNAL,
7825 		{ },
7826 		{ { 0, (u32) cpu_to_le64(0xfedcba9876543210ULL) } },
7827 	},
7828 	{
7829 		"ALU_END_FROM_LE 64: 0xfedcba9876543210 >> 32 -> 0x98badcfe",
7830 		.u.insns_int = {
7831 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7832 			BPF_ENDIAN(BPF_FROM_LE, R0, 64),
7833 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7834 			BPF_EXIT_INSN(),
7835 		},
7836 		INTERNAL,
7837 		{ },
7838 		{ { 0, (u32) (cpu_to_le64(0xfedcba9876543210ULL) >> 32) } },
7839 	},
7840 	/* BPF_LDX_MEM B/H/W/DW */
7841 	{
7842 		"BPF_LDX_MEM | BPF_B, base",
7843 		.u.insns_int = {
7844 			BPF_LD_IMM64(R1, 0x0102030405060708ULL),
7845 			BPF_LD_IMM64(R2, 0x0000000000000008ULL),
7846 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
7847 #ifdef __BIG_ENDIAN
7848 			BPF_LDX_MEM(BPF_B, R0, R10, -1),
7849 #else
7850 			BPF_LDX_MEM(BPF_B, R0, R10, -8),
7851 #endif
7852 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
7853 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7854 			BPF_EXIT_INSN(),
7855 		},
7856 		INTERNAL,
7857 		{ },
7858 		{ { 0, 0 } },
7859 		.stack_depth = 8,
7860 	},
7861 	{
7862 		"BPF_LDX_MEM | BPF_B, MSB set",
7863 		.u.insns_int = {
7864 			BPF_LD_IMM64(R1, 0x8182838485868788ULL),
7865 			BPF_LD_IMM64(R2, 0x0000000000000088ULL),
7866 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
7867 #ifdef __BIG_ENDIAN
7868 			BPF_LDX_MEM(BPF_B, R0, R10, -1),
7869 #else
7870 			BPF_LDX_MEM(BPF_B, R0, R10, -8),
7871 #endif
7872 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
7873 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7874 			BPF_EXIT_INSN(),
7875 		},
7876 		INTERNAL,
7877 		{ },
7878 		{ { 0, 0 } },
7879 		.stack_depth = 8,
7880 	},
7881 	{
7882 		"BPF_LDX_MEM | BPF_B, negative offset",
7883 		.u.insns_int = {
7884 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
7885 			BPF_LD_IMM64(R3, 0x0000000000000088ULL),
7886 			BPF_ALU64_IMM(BPF_ADD, R1, 512),
7887 			BPF_STX_MEM(BPF_B, R1, R2, -256),
7888 			BPF_LDX_MEM(BPF_B, R0, R1, -256),
7889 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
7890 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7891 			BPF_EXIT_INSN(),
7892 		},
7893 		INTERNAL | FLAG_LARGE_MEM,
7894 		{ },
7895 		{ { 512, 0 } },
7896 		.stack_depth = 0,
7897 	},
7898 	{
7899 		"BPF_LDX_MEM | BPF_B, small positive offset",
7900 		.u.insns_int = {
7901 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
7902 			BPF_LD_IMM64(R3, 0x0000000000000088ULL),
7903 			BPF_STX_MEM(BPF_B, R1, R2, 256),
7904 			BPF_LDX_MEM(BPF_B, R0, R1, 256),
7905 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
7906 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7907 			BPF_EXIT_INSN(),
7908 		},
7909 		INTERNAL | FLAG_LARGE_MEM,
7910 		{ },
7911 		{ { 512, 0 } },
7912 		.stack_depth = 0,
7913 	},
7914 	{
7915 		"BPF_LDX_MEM | BPF_B, large positive offset",
7916 		.u.insns_int = {
7917 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
7918 			BPF_LD_IMM64(R3, 0x0000000000000088ULL),
7919 			BPF_STX_MEM(BPF_B, R1, R2, 4096),
7920 			BPF_LDX_MEM(BPF_B, R0, R1, 4096),
7921 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
7922 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7923 			BPF_EXIT_INSN(),
7924 		},
7925 		INTERNAL | FLAG_LARGE_MEM,
7926 		{ },
7927 		{ { 4096 + 16, 0 } },
7928 		.stack_depth = 0,
7929 	},
7930 	{
7931 		"BPF_LDX_MEM | BPF_H, base",
7932 		.u.insns_int = {
7933 			BPF_LD_IMM64(R1, 0x0102030405060708ULL),
7934 			BPF_LD_IMM64(R2, 0x0000000000000708ULL),
7935 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
7936 #ifdef __BIG_ENDIAN
7937 			BPF_LDX_MEM(BPF_H, R0, R10, -2),
7938 #else
7939 			BPF_LDX_MEM(BPF_H, R0, R10, -8),
7940 #endif
7941 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
7942 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7943 			BPF_EXIT_INSN(),
7944 		},
7945 		INTERNAL,
7946 		{ },
7947 		{ { 0, 0 } },
7948 		.stack_depth = 8,
7949 	},
7950 	{
7951 		"BPF_LDX_MEM | BPF_H, MSB set",
7952 		.u.insns_int = {
7953 			BPF_LD_IMM64(R1, 0x8182838485868788ULL),
7954 			BPF_LD_IMM64(R2, 0x0000000000008788ULL),
7955 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
7956 #ifdef __BIG_ENDIAN
7957 			BPF_LDX_MEM(BPF_H, R0, R10, -2),
7958 #else
7959 			BPF_LDX_MEM(BPF_H, R0, R10, -8),
7960 #endif
7961 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
7962 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7963 			BPF_EXIT_INSN(),
7964 		},
7965 		INTERNAL,
7966 		{ },
7967 		{ { 0, 0 } },
7968 		.stack_depth = 8,
7969 	},
7970 	{
7971 		"BPF_LDX_MEM | BPF_H, negative offset",
7972 		.u.insns_int = {
7973 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
7974 			BPF_LD_IMM64(R3, 0x0000000000008788ULL),
7975 			BPF_ALU64_IMM(BPF_ADD, R1, 512),
7976 			BPF_STX_MEM(BPF_H, R1, R2, -256),
7977 			BPF_LDX_MEM(BPF_H, R0, R1, -256),
7978 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
7979 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7980 			BPF_EXIT_INSN(),
7981 		},
7982 		INTERNAL | FLAG_LARGE_MEM,
7983 		{ },
7984 		{ { 512, 0 } },
7985 		.stack_depth = 0,
7986 	},
7987 	{
7988 		"BPF_LDX_MEM | BPF_H, small positive offset",
7989 		.u.insns_int = {
7990 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
7991 			BPF_LD_IMM64(R3, 0x0000000000008788ULL),
7992 			BPF_STX_MEM(BPF_H, R1, R2, 256),
7993 			BPF_LDX_MEM(BPF_H, R0, R1, 256),
7994 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
7995 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7996 			BPF_EXIT_INSN(),
7997 		},
7998 		INTERNAL | FLAG_LARGE_MEM,
7999 		{ },
8000 		{ { 512, 0 } },
8001 		.stack_depth = 0,
8002 	},
8003 	{
8004 		"BPF_LDX_MEM | BPF_H, large positive offset",
8005 		.u.insns_int = {
8006 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8007 			BPF_LD_IMM64(R3, 0x0000000000008788ULL),
8008 			BPF_STX_MEM(BPF_H, R1, R2, 8192),
8009 			BPF_LDX_MEM(BPF_H, R0, R1, 8192),
8010 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8011 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8012 			BPF_EXIT_INSN(),
8013 		},
8014 		INTERNAL | FLAG_LARGE_MEM,
8015 		{ },
8016 		{ { 8192 + 16, 0 } },
8017 		.stack_depth = 0,
8018 	},
8019 	{
8020 		"BPF_LDX_MEM | BPF_H, unaligned positive offset",
8021 		.u.insns_int = {
8022 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8023 			BPF_LD_IMM64(R3, 0x0000000000008788ULL),
8024 			BPF_STX_MEM(BPF_H, R1, R2, 13),
8025 			BPF_LDX_MEM(BPF_H, R0, R1, 13),
8026 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8027 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8028 			BPF_EXIT_INSN(),
8029 		},
8030 		INTERNAL | FLAG_LARGE_MEM,
8031 		{ },
8032 		{ { 32, 0 } },
8033 		.stack_depth = 0,
8034 	},
8035 	{
8036 		"BPF_LDX_MEM | BPF_W, base",
8037 		.u.insns_int = {
8038 			BPF_LD_IMM64(R1, 0x0102030405060708ULL),
8039 			BPF_LD_IMM64(R2, 0x0000000005060708ULL),
8040 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
8041 #ifdef __BIG_ENDIAN
8042 			BPF_LDX_MEM(BPF_W, R0, R10, -4),
8043 #else
8044 			BPF_LDX_MEM(BPF_W, R0, R10, -8),
8045 #endif
8046 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8047 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8048 			BPF_EXIT_INSN(),
8049 		},
8050 		INTERNAL,
8051 		{ },
8052 		{ { 0, 0 } },
8053 		.stack_depth = 8,
8054 	},
8055 	{
8056 		"BPF_LDX_MEM | BPF_W, MSB set",
8057 		.u.insns_int = {
8058 			BPF_LD_IMM64(R1, 0x8182838485868788ULL),
8059 			BPF_LD_IMM64(R2, 0x0000000085868788ULL),
8060 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
8061 #ifdef __BIG_ENDIAN
8062 			BPF_LDX_MEM(BPF_W, R0, R10, -4),
8063 #else
8064 			BPF_LDX_MEM(BPF_W, R0, R10, -8),
8065 #endif
8066 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8067 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8068 			BPF_EXIT_INSN(),
8069 		},
8070 		INTERNAL,
8071 		{ },
8072 		{ { 0, 0 } },
8073 		.stack_depth = 8,
8074 	},
8075 	{
8076 		"BPF_LDX_MEM | BPF_W, negative offset",
8077 		.u.insns_int = {
8078 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8079 			BPF_LD_IMM64(R3, 0x0000000085868788ULL),
8080 			BPF_ALU64_IMM(BPF_ADD, R1, 512),
8081 			BPF_STX_MEM(BPF_W, R1, R2, -256),
8082 			BPF_LDX_MEM(BPF_W, R0, R1, -256),
8083 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8084 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8085 			BPF_EXIT_INSN(),
8086 		},
8087 		INTERNAL | FLAG_LARGE_MEM,
8088 		{ },
8089 		{ { 512, 0 } },
8090 		.stack_depth = 0,
8091 	},
8092 	{
8093 		"BPF_LDX_MEM | BPF_W, small positive offset",
8094 		.u.insns_int = {
8095 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8096 			BPF_LD_IMM64(R3, 0x0000000085868788ULL),
8097 			BPF_STX_MEM(BPF_W, R1, R2, 256),
8098 			BPF_LDX_MEM(BPF_W, R0, R1, 256),
8099 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8100 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8101 			BPF_EXIT_INSN(),
8102 		},
8103 		INTERNAL | FLAG_LARGE_MEM,
8104 		{ },
8105 		{ { 512, 0 } },
8106 		.stack_depth = 0,
8107 	},
8108 	{
8109 		"BPF_LDX_MEM | BPF_W, large positive offset",
8110 		.u.insns_int = {
8111 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8112 			BPF_LD_IMM64(R3, 0x0000000085868788ULL),
8113 			BPF_STX_MEM(BPF_W, R1, R2, 16384),
8114 			BPF_LDX_MEM(BPF_W, R0, R1, 16384),
8115 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8116 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8117 			BPF_EXIT_INSN(),
8118 		},
8119 		INTERNAL | FLAG_LARGE_MEM,
8120 		{ },
8121 		{ { 16384 + 16, 0 } },
8122 		.stack_depth = 0,
8123 	},
8124 	{
8125 		"BPF_LDX_MEM | BPF_W, unaligned positive offset",
8126 		.u.insns_int = {
8127 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8128 			BPF_LD_IMM64(R3, 0x0000000085868788ULL),
8129 			BPF_STX_MEM(BPF_W, R1, R2, 13),
8130 			BPF_LDX_MEM(BPF_W, R0, R1, 13),
8131 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8132 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8133 			BPF_EXIT_INSN(),
8134 		},
8135 		INTERNAL | FLAG_LARGE_MEM,
8136 		{ },
8137 		{ { 32, 0 } },
8138 		.stack_depth = 0,
8139 	},
8140 	{
8141 		"BPF_LDX_MEM | BPF_DW, base",
8142 		.u.insns_int = {
8143 			BPF_LD_IMM64(R1, 0x0102030405060708ULL),
8144 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
8145 			BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8146 			BPF_JMP_REG(BPF_JNE, R0, R1, 1),
8147 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8148 			BPF_EXIT_INSN(),
8149 		},
8150 		INTERNAL,
8151 		{ },
8152 		{ { 0, 0 } },
8153 		.stack_depth = 8,
8154 	},
8155 	{
8156 		"BPF_LDX_MEM | BPF_DW, MSB set",
8157 		.u.insns_int = {
8158 			BPF_LD_IMM64(R1, 0x8182838485868788ULL),
8159 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
8160 			BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8161 			BPF_JMP_REG(BPF_JNE, R0, R1, 1),
8162 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8163 			BPF_EXIT_INSN(),
8164 		},
8165 		INTERNAL,
8166 		{ },
8167 		{ { 0, 0 } },
8168 		.stack_depth = 8,
8169 	},
8170 	{
8171 		"BPF_LDX_MEM | BPF_DW, negative offset",
8172 		.u.insns_int = {
8173 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8174 			BPF_ALU64_IMM(BPF_ADD, R1, 512),
8175 			BPF_STX_MEM(BPF_DW, R1, R2, -256),
8176 			BPF_LDX_MEM(BPF_DW, R0, R1, -256),
8177 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8178 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8179 			BPF_EXIT_INSN(),
8180 		},
8181 		INTERNAL | FLAG_LARGE_MEM,
8182 		{ },
8183 		{ { 512, 0 } },
8184 		.stack_depth = 0,
8185 	},
8186 	{
8187 		"BPF_LDX_MEM | BPF_DW, small positive offset",
8188 		.u.insns_int = {
8189 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8190 			BPF_STX_MEM(BPF_DW, R1, R2, 256),
8191 			BPF_LDX_MEM(BPF_DW, R0, R1, 256),
8192 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8193 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8194 			BPF_EXIT_INSN(),
8195 		},
8196 		INTERNAL | FLAG_LARGE_MEM,
8197 		{ },
8198 		{ { 512, 0 } },
8199 		.stack_depth = 8,
8200 	},
8201 	{
8202 		"BPF_LDX_MEM | BPF_DW, large positive offset",
8203 		.u.insns_int = {
8204 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8205 			BPF_STX_MEM(BPF_DW, R1, R2, 32760),
8206 			BPF_LDX_MEM(BPF_DW, R0, R1, 32760),
8207 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8208 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8209 			BPF_EXIT_INSN(),
8210 		},
8211 		INTERNAL | FLAG_LARGE_MEM,
8212 		{ },
8213 		{ { 32768, 0 } },
8214 		.stack_depth = 0,
8215 	},
8216 	{
8217 		"BPF_LDX_MEM | BPF_DW, unaligned positive offset",
8218 		.u.insns_int = {
8219 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8220 			BPF_STX_MEM(BPF_DW, R1, R2, 13),
8221 			BPF_LDX_MEM(BPF_DW, R0, R1, 13),
8222 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8223 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8224 			BPF_EXIT_INSN(),
8225 		},
8226 		INTERNAL | FLAG_LARGE_MEM,
8227 		{ },
8228 		{ { 32, 0 } },
8229 		.stack_depth = 0,
8230 	},
8231 	/* BPF_STX_MEM B/H/W/DW */
8232 	{
8233 		"BPF_STX_MEM | BPF_B",
8234 		.u.insns_int = {
8235 			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8236 			BPF_LD_IMM64(R2, 0x0102030405060708ULL),
8237 			BPF_LD_IMM64(R3, 0x8090a0b0c0d0e008ULL),
8238 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
8239 #ifdef __BIG_ENDIAN
8240 			BPF_STX_MEM(BPF_B, R10, R2, -1),
8241 #else
8242 			BPF_STX_MEM(BPF_B, R10, R2, -8),
8243 #endif
8244 			BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8245 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8246 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8247 			BPF_EXIT_INSN(),
8248 		},
8249 		INTERNAL,
8250 		{ },
8251 		{ { 0, 0 } },
8252 		.stack_depth = 8,
8253 	},
8254 	{
8255 		"BPF_STX_MEM | BPF_B, MSB set",
8256 		.u.insns_int = {
8257 			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8258 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8259 			BPF_LD_IMM64(R3, 0x8090a0b0c0d0e088ULL),
8260 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
8261 #ifdef __BIG_ENDIAN
8262 			BPF_STX_MEM(BPF_B, R10, R2, -1),
8263 #else
8264 			BPF_STX_MEM(BPF_B, R10, R2, -8),
8265 #endif
8266 			BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8267 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8268 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8269 			BPF_EXIT_INSN(),
8270 		},
8271 		INTERNAL,
8272 		{ },
8273 		{ { 0, 0 } },
8274 		.stack_depth = 8,
8275 	},
8276 	{
8277 		"BPF_STX_MEM | BPF_H",
8278 		.u.insns_int = {
8279 			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8280 			BPF_LD_IMM64(R2, 0x0102030405060708ULL),
8281 			BPF_LD_IMM64(R3, 0x8090a0b0c0d00708ULL),
8282 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
8283 #ifdef __BIG_ENDIAN
8284 			BPF_STX_MEM(BPF_H, R10, R2, -2),
8285 #else
8286 			BPF_STX_MEM(BPF_H, R10, R2, -8),
8287 #endif
8288 			BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8289 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8290 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8291 			BPF_EXIT_INSN(),
8292 		},
8293 		INTERNAL,
8294 		{ },
8295 		{ { 0, 0 } },
8296 		.stack_depth = 8,
8297 	},
8298 	{
8299 		"BPF_STX_MEM | BPF_H, MSB set",
8300 		.u.insns_int = {
8301 			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8302 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8303 			BPF_LD_IMM64(R3, 0x8090a0b0c0d08788ULL),
8304 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
8305 #ifdef __BIG_ENDIAN
8306 			BPF_STX_MEM(BPF_H, R10, R2, -2),
8307 #else
8308 			BPF_STX_MEM(BPF_H, R10, R2, -8),
8309 #endif
8310 			BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8311 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8312 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8313 			BPF_EXIT_INSN(),
8314 		},
8315 		INTERNAL,
8316 		{ },
8317 		{ { 0, 0 } },
8318 		.stack_depth = 8,
8319 	},
8320 	{
8321 		"BPF_STX_MEM | BPF_W",
8322 		.u.insns_int = {
8323 			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8324 			BPF_LD_IMM64(R2, 0x0102030405060708ULL),
8325 			BPF_LD_IMM64(R3, 0x8090a0b005060708ULL),
8326 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
8327 #ifdef __BIG_ENDIAN
8328 			BPF_STX_MEM(BPF_W, R10, R2, -4),
8329 #else
8330 			BPF_STX_MEM(BPF_W, R10, R2, -8),
8331 #endif
8332 			BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8333 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8334 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8335 			BPF_EXIT_INSN(),
8336 		},
8337 		INTERNAL,
8338 		{ },
8339 		{ { 0, 0 } },
8340 		.stack_depth = 8,
8341 	},
8342 	{
8343 		"BPF_STX_MEM | BPF_W, MSB set",
8344 		.u.insns_int = {
8345 			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8346 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8347 			BPF_LD_IMM64(R3, 0x8090a0b085868788ULL),
8348 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
8349 #ifdef __BIG_ENDIAN
8350 			BPF_STX_MEM(BPF_W, R10, R2, -4),
8351 #else
8352 			BPF_STX_MEM(BPF_W, R10, R2, -8),
8353 #endif
8354 			BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8355 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8356 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8357 			BPF_EXIT_INSN(),
8358 		},
8359 		INTERNAL,
8360 		{ },
8361 		{ { 0, 0 } },
8362 		.stack_depth = 8,
8363 	},
8364 	/* BPF_ST(X) | BPF_MEM | BPF_B/H/W/DW */
8365 	{
8366 		"ST_MEM_B: Store/Load byte: max negative",
8367 		.u.insns_int = {
8368 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8369 			BPF_ST_MEM(BPF_B, R10, -40, 0xff),
8370 			BPF_LDX_MEM(BPF_B, R0, R10, -40),
8371 			BPF_EXIT_INSN(),
8372 		},
8373 		INTERNAL,
8374 		{ },
8375 		{ { 0, 0xff } },
8376 		.stack_depth = 40,
8377 	},
8378 	{
8379 		"ST_MEM_B: Store/Load byte: max positive",
8380 		.u.insns_int = {
8381 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8382 			BPF_ST_MEM(BPF_H, R10, -40, 0x7f),
8383 			BPF_LDX_MEM(BPF_H, R0, R10, -40),
8384 			BPF_EXIT_INSN(),
8385 		},
8386 		INTERNAL,
8387 		{ },
8388 		{ { 0, 0x7f } },
8389 		.stack_depth = 40,
8390 	},
8391 	{
8392 		"STX_MEM_B: Store/Load byte: max negative",
8393 		.u.insns_int = {
8394 			BPF_LD_IMM64(R0, 0),
8395 			BPF_LD_IMM64(R1, 0xffLL),
8396 			BPF_STX_MEM(BPF_B, R10, R1, -40),
8397 			BPF_LDX_MEM(BPF_B, R0, R10, -40),
8398 			BPF_EXIT_INSN(),
8399 		},
8400 		INTERNAL,
8401 		{ },
8402 		{ { 0, 0xff } },
8403 		.stack_depth = 40,
8404 	},
8405 	{
8406 		"ST_MEM_H: Store/Load half word: max negative",
8407 		.u.insns_int = {
8408 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8409 			BPF_ST_MEM(BPF_H, R10, -40, 0xffff),
8410 			BPF_LDX_MEM(BPF_H, R0, R10, -40),
8411 			BPF_EXIT_INSN(),
8412 		},
8413 		INTERNAL,
8414 		{ },
8415 		{ { 0, 0xffff } },
8416 		.stack_depth = 40,
8417 	},
8418 	{
8419 		"ST_MEM_H: Store/Load half word: max positive",
8420 		.u.insns_int = {
8421 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8422 			BPF_ST_MEM(BPF_H, R10, -40, 0x7fff),
8423 			BPF_LDX_MEM(BPF_H, R0, R10, -40),
8424 			BPF_EXIT_INSN(),
8425 		},
8426 		INTERNAL,
8427 		{ },
8428 		{ { 0, 0x7fff } },
8429 		.stack_depth = 40,
8430 	},
8431 	{
8432 		"STX_MEM_H: Store/Load half word: max negative",
8433 		.u.insns_int = {
8434 			BPF_LD_IMM64(R0, 0),
8435 			BPF_LD_IMM64(R1, 0xffffLL),
8436 			BPF_STX_MEM(BPF_H, R10, R1, -40),
8437 			BPF_LDX_MEM(BPF_H, R0, R10, -40),
8438 			BPF_EXIT_INSN(),
8439 		},
8440 		INTERNAL,
8441 		{ },
8442 		{ { 0, 0xffff } },
8443 		.stack_depth = 40,
8444 	},
8445 	{
8446 		"ST_MEM_W: Store/Load word: max negative",
8447 		.u.insns_int = {
8448 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8449 			BPF_ST_MEM(BPF_W, R10, -40, 0xffffffff),
8450 			BPF_LDX_MEM(BPF_W, R0, R10, -40),
8451 			BPF_EXIT_INSN(),
8452 		},
8453 		INTERNAL,
8454 		{ },
8455 		{ { 0, 0xffffffff } },
8456 		.stack_depth = 40,
8457 	},
8458 	{
8459 		"ST_MEM_W: Store/Load word: max positive",
8460 		.u.insns_int = {
8461 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8462 			BPF_ST_MEM(BPF_W, R10, -40, 0x7fffffff),
8463 			BPF_LDX_MEM(BPF_W, R0, R10, -40),
8464 			BPF_EXIT_INSN(),
8465 		},
8466 		INTERNAL,
8467 		{ },
8468 		{ { 0, 0x7fffffff } },
8469 		.stack_depth = 40,
8470 	},
8471 	{
8472 		"STX_MEM_W: Store/Load word: max negative",
8473 		.u.insns_int = {
8474 			BPF_LD_IMM64(R0, 0),
8475 			BPF_LD_IMM64(R1, 0xffffffffLL),
8476 			BPF_STX_MEM(BPF_W, R10, R1, -40),
8477 			BPF_LDX_MEM(BPF_W, R0, R10, -40),
8478 			BPF_EXIT_INSN(),
8479 		},
8480 		INTERNAL,
8481 		{ },
8482 		{ { 0, 0xffffffff } },
8483 		.stack_depth = 40,
8484 	},
8485 	{
8486 		"ST_MEM_DW: Store/Load double word: max negative",
8487 		.u.insns_int = {
8488 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8489 			BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
8490 			BPF_LDX_MEM(BPF_DW, R0, R10, -40),
8491 			BPF_EXIT_INSN(),
8492 		},
8493 		INTERNAL,
8494 		{ },
8495 		{ { 0, 0xffffffff } },
8496 		.stack_depth = 40,
8497 	},
8498 	{
8499 		"ST_MEM_DW: Store/Load double word: max negative 2",
8500 		.u.insns_int = {
8501 			BPF_LD_IMM64(R2, 0xffff00000000ffffLL),
8502 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
8503 			BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
8504 			BPF_LDX_MEM(BPF_DW, R2, R10, -40),
8505 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
8506 			BPF_MOV32_IMM(R0, 2),
8507 			BPF_EXIT_INSN(),
8508 			BPF_MOV32_IMM(R0, 1),
8509 			BPF_EXIT_INSN(),
8510 		},
8511 		INTERNAL,
8512 		{ },
8513 		{ { 0, 0x1 } },
8514 		.stack_depth = 40,
8515 	},
8516 	{
8517 		"ST_MEM_DW: Store/Load double word: max positive",
8518 		.u.insns_int = {
8519 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8520 			BPF_ST_MEM(BPF_DW, R10, -40, 0x7fffffff),
8521 			BPF_LDX_MEM(BPF_DW, R0, R10, -40),
8522 			BPF_EXIT_INSN(),
8523 		},
8524 		INTERNAL,
8525 		{ },
8526 		{ { 0, 0x7fffffff } },
8527 		.stack_depth = 40,
8528 	},
8529 	{
8530 		"STX_MEM_DW: Store/Load double word: max negative",
8531 		.u.insns_int = {
8532 			BPF_LD_IMM64(R0, 0),
8533 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
8534 			BPF_STX_MEM(BPF_DW, R10, R1, -40),
8535 			BPF_LDX_MEM(BPF_DW, R0, R10, -40),
8536 			BPF_EXIT_INSN(),
8537 		},
8538 		INTERNAL,
8539 		{ },
8540 		{ { 0, 0xffffffff } },
8541 		.stack_depth = 40,
8542 	},
8543 	{
8544 		"STX_MEM_DW: Store double word: first word in memory",
8545 		.u.insns_int = {
8546 			BPF_LD_IMM64(R0, 0),
8547 			BPF_LD_IMM64(R1, 0x0123456789abcdefLL),
8548 			BPF_STX_MEM(BPF_DW, R10, R1, -40),
8549 			BPF_LDX_MEM(BPF_W, R0, R10, -40),
8550 			BPF_EXIT_INSN(),
8551 		},
8552 		INTERNAL,
8553 		{ },
8554 #ifdef __BIG_ENDIAN
8555 		{ { 0, 0x01234567 } },
8556 #else
8557 		{ { 0, 0x89abcdef } },
8558 #endif
8559 		.stack_depth = 40,
8560 	},
8561 	{
8562 		"STX_MEM_DW: Store double word: second word in memory",
8563 		.u.insns_int = {
8564 			BPF_LD_IMM64(R0, 0),
8565 			BPF_LD_IMM64(R1, 0x0123456789abcdefLL),
8566 			BPF_STX_MEM(BPF_DW, R10, R1, -40),
8567 			BPF_LDX_MEM(BPF_W, R0, R10, -36),
8568 			BPF_EXIT_INSN(),
8569 		},
8570 		INTERNAL,
8571 		{ },
8572 #ifdef __BIG_ENDIAN
8573 		{ { 0, 0x89abcdef } },
8574 #else
8575 		{ { 0, 0x01234567 } },
8576 #endif
8577 		.stack_depth = 40,
8578 	},
8579 	/* BPF_STX | BPF_ATOMIC | BPF_W/DW */
8580 	{
8581 		"STX_XADD_W: X + 1 + 1 + 1 + ...",
8582 		{ },
8583 		INTERNAL,
8584 		{ },
8585 		{ { 0, 4134 } },
8586 		.fill_helper = bpf_fill_stxw,
8587 	},
8588 	{
8589 		"STX_XADD_DW: X + 1 + 1 + 1 + ...",
8590 		{ },
8591 		INTERNAL,
8592 		{ },
8593 		{ { 0, 4134 } },
8594 		.fill_helper = bpf_fill_stxdw,
8595 	},
8596 	/*
8597 	 * Exhaustive tests of atomic operation variants.
8598 	 * Individual tests are expanded from template macros for all
8599 	 * combinations of ALU operation, word size and fetching.
8600 	 */
8601 #define BPF_ATOMIC_POISON(width) ((width) == BPF_W ? (0xbaadf00dULL << 32) : 0)
8602 
8603 #define BPF_ATOMIC_OP_TEST1(width, op, logic, old, update, result)	\
8604 {									\
8605 	"BPF_ATOMIC | " #width ", " #op ": Test: "			\
8606 		#old " " #logic " " #update " = " #result,		\
8607 	.u.insns_int = {						\
8608 		BPF_LD_IMM64(R5, (update) | BPF_ATOMIC_POISON(width)),	\
8609 		BPF_ST_MEM(width, R10, -40, old),			\
8610 		BPF_ATOMIC_OP(width, op, R10, R5, -40),			\
8611 		BPF_LDX_MEM(width, R0, R10, -40),			\
8612 		BPF_ALU64_REG(BPF_MOV, R1, R0),				\
8613 		BPF_ALU64_IMM(BPF_RSH, R1, 32),				\
8614 		BPF_ALU64_REG(BPF_OR, R0, R1),				\
8615 		BPF_EXIT_INSN(),					\
8616 	},								\
8617 	INTERNAL,							\
8618 	{ },								\
8619 	{ { 0, result } },						\
8620 	.stack_depth = 40,						\
8621 }
8622 #define BPF_ATOMIC_OP_TEST2(width, op, logic, old, update, result)	\
8623 {									\
8624 	"BPF_ATOMIC | " #width ", " #op ": Test side effects, r10: "	\
8625 		#old " " #logic " " #update " = " #result,		\
8626 	.u.insns_int = {						\
8627 		BPF_ALU64_REG(BPF_MOV, R1, R10),			\
8628 		BPF_LD_IMM64(R0, (update) | BPF_ATOMIC_POISON(width)),	\
8629 		BPF_ST_MEM(BPF_W, R10, -40, old),			\
8630 		BPF_ATOMIC_OP(width, op, R10, R0, -40),			\
8631 		BPF_ALU64_REG(BPF_MOV, R0, R10),			\
8632 		BPF_ALU64_REG(BPF_SUB, R0, R1),				\
8633 		BPF_ALU64_REG(BPF_MOV, R1, R0),				\
8634 		BPF_ALU64_IMM(BPF_RSH, R1, 32),				\
8635 		BPF_ALU64_REG(BPF_OR, R0, R1),				\
8636 		BPF_EXIT_INSN(),					\
8637 	},								\
8638 	INTERNAL,							\
8639 	{ },								\
8640 	{ { 0, 0 } },							\
8641 	.stack_depth = 40,						\
8642 }
8643 #define BPF_ATOMIC_OP_TEST3(width, op, logic, old, update, result)	\
8644 {									\
8645 	"BPF_ATOMIC | " #width ", " #op ": Test side effects, r0: "	\
8646 		#old " " #logic " " #update " = " #result,		\
8647 	.u.insns_int = {						\
8648 		BPF_ALU64_REG(BPF_MOV, R0, R10),			\
8649 		BPF_LD_IMM64(R1, (update) | BPF_ATOMIC_POISON(width)),	\
8650 		BPF_ST_MEM(width, R10, -40, old),			\
8651 		BPF_ATOMIC_OP(width, op, R10, R1, -40),			\
8652 		BPF_ALU64_REG(BPF_SUB, R0, R10),			\
8653 		BPF_ALU64_REG(BPF_MOV, R1, R0),				\
8654 		BPF_ALU64_IMM(BPF_RSH, R1, 32),				\
8655 		BPF_ALU64_REG(BPF_OR, R0, R1),				\
8656 		BPF_EXIT_INSN(),					\
8657 	},								\
8658 	INTERNAL,                                                       \
8659 	{ },                                                            \
8660 	{ { 0, 0 } },                                                   \
8661 	.stack_depth = 40,                                              \
8662 }
8663 #define BPF_ATOMIC_OP_TEST4(width, op, logic, old, update, result)	\
8664 {									\
8665 	"BPF_ATOMIC | " #width ", " #op ": Test fetch: "		\
8666 		#old " " #logic " " #update " = " #result,		\
8667 	.u.insns_int = {						\
8668 		BPF_LD_IMM64(R3, (update) | BPF_ATOMIC_POISON(width)),	\
8669 		BPF_ST_MEM(width, R10, -40, old),			\
8670 		BPF_ATOMIC_OP(width, op, R10, R3, -40),			\
8671 		BPF_ALU32_REG(BPF_MOV, R0, R3),                         \
8672 		BPF_EXIT_INSN(),					\
8673 	},								\
8674 	INTERNAL,                                                       \
8675 	{ },                                                            \
8676 	{ { 0, (op) & BPF_FETCH ? old : update } },			\
8677 	.stack_depth = 40,                                              \
8678 }
8679 	/* BPF_ATOMIC | BPF_W: BPF_ADD */
8680 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
8681 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
8682 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
8683 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
8684 	/* BPF_ATOMIC | BPF_W: BPF_ADD | BPF_FETCH */
8685 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
8686 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
8687 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
8688 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
8689 	/* BPF_ATOMIC | BPF_DW: BPF_ADD */
8690 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
8691 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
8692 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
8693 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
8694 	/* BPF_ATOMIC | BPF_DW: BPF_ADD | BPF_FETCH */
8695 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
8696 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
8697 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
8698 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
8699 	/* BPF_ATOMIC | BPF_W: BPF_AND */
8700 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
8701 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
8702 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
8703 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
8704 	/* BPF_ATOMIC | BPF_W: BPF_AND | BPF_FETCH */
8705 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
8706 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
8707 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
8708 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
8709 	/* BPF_ATOMIC | BPF_DW: BPF_AND */
8710 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
8711 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
8712 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
8713 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
8714 	/* BPF_ATOMIC | BPF_DW: BPF_AND | BPF_FETCH */
8715 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
8716 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
8717 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
8718 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
8719 	/* BPF_ATOMIC | BPF_W: BPF_OR */
8720 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
8721 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
8722 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
8723 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
8724 	/* BPF_ATOMIC | BPF_W: BPF_OR | BPF_FETCH */
8725 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
8726 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
8727 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
8728 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
8729 	/* BPF_ATOMIC | BPF_DW: BPF_OR */
8730 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
8731 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
8732 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
8733 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
8734 	/* BPF_ATOMIC | BPF_DW: BPF_OR | BPF_FETCH */
8735 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
8736 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
8737 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
8738 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
8739 	/* BPF_ATOMIC | BPF_W: BPF_XOR */
8740 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
8741 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
8742 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
8743 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
8744 	/* BPF_ATOMIC | BPF_W: BPF_XOR | BPF_FETCH */
8745 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
8746 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
8747 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
8748 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
8749 	/* BPF_ATOMIC | BPF_DW: BPF_XOR */
8750 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
8751 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
8752 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
8753 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
8754 	/* BPF_ATOMIC | BPF_DW: BPF_XOR | BPF_FETCH */
8755 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
8756 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
8757 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
8758 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
8759 	/* BPF_ATOMIC | BPF_W: BPF_XCHG */
8760 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
8761 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
8762 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
8763 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
8764 	/* BPF_ATOMIC | BPF_DW: BPF_XCHG */
8765 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
8766 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
8767 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
8768 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
8769 #undef BPF_ATOMIC_POISON
8770 #undef BPF_ATOMIC_OP_TEST1
8771 #undef BPF_ATOMIC_OP_TEST2
8772 #undef BPF_ATOMIC_OP_TEST3
8773 #undef BPF_ATOMIC_OP_TEST4
8774 	/* BPF_ATOMIC | BPF_W, BPF_CMPXCHG */
8775 	{
8776 		"BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test successful return",
8777 		.u.insns_int = {
8778 			BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
8779 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
8780 			BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
8781 			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
8782 			BPF_EXIT_INSN(),
8783 		},
8784 		INTERNAL,
8785 		{ },
8786 		{ { 0, 0x01234567 } },
8787 		.stack_depth = 40,
8788 	},
8789 	{
8790 		"BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test successful store",
8791 		.u.insns_int = {
8792 			BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
8793 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
8794 			BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
8795 			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
8796 			BPF_LDX_MEM(BPF_W, R0, R10, -40),
8797 			BPF_EXIT_INSN(),
8798 		},
8799 		INTERNAL,
8800 		{ },
8801 		{ { 0, 0x89abcdef } },
8802 		.stack_depth = 40,
8803 	},
8804 	{
8805 		"BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test failure return",
8806 		.u.insns_int = {
8807 			BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
8808 			BPF_ALU32_IMM(BPF_MOV, R0, 0x76543210),
8809 			BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
8810 			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
8811 			BPF_EXIT_INSN(),
8812 		},
8813 		INTERNAL,
8814 		{ },
8815 		{ { 0, 0x01234567 } },
8816 		.stack_depth = 40,
8817 	},
8818 	{
8819 		"BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test failure store",
8820 		.u.insns_int = {
8821 			BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
8822 			BPF_ALU32_IMM(BPF_MOV, R0, 0x76543210),
8823 			BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
8824 			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
8825 			BPF_LDX_MEM(BPF_W, R0, R10, -40),
8826 			BPF_EXIT_INSN(),
8827 		},
8828 		INTERNAL,
8829 		{ },
8830 		{ { 0, 0x01234567 } },
8831 		.stack_depth = 40,
8832 	},
8833 	{
8834 		"BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test side effects",
8835 		.u.insns_int = {
8836 			BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
8837 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
8838 			BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
8839 			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
8840 			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
8841 			BPF_ALU32_REG(BPF_MOV, R0, R3),
8842 			BPF_EXIT_INSN(),
8843 		},
8844 		INTERNAL,
8845 		{ },
8846 		{ { 0, 0x89abcdef } },
8847 		.stack_depth = 40,
8848 	},
8849 	/* BPF_ATOMIC | BPF_DW, BPF_CMPXCHG */
8850 	{
8851 		"BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test successful return",
8852 		.u.insns_int = {
8853 			BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
8854 			BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
8855 			BPF_ALU64_REG(BPF_MOV, R0, R1),
8856 			BPF_STX_MEM(BPF_DW, R10, R1, -40),
8857 			BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
8858 			BPF_JMP_REG(BPF_JNE, R0, R1, 1),
8859 			BPF_ALU64_REG(BPF_SUB, R0, R1),
8860 			BPF_EXIT_INSN(),
8861 		},
8862 		INTERNAL,
8863 		{ },
8864 		{ { 0, 0 } },
8865 		.stack_depth = 40,
8866 	},
8867 	{
8868 		"BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test successful store",
8869 		.u.insns_int = {
8870 			BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
8871 			BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
8872 			BPF_ALU64_REG(BPF_MOV, R0, R1),
8873 			BPF_STX_MEM(BPF_DW, R10, R0, -40),
8874 			BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
8875 			BPF_LDX_MEM(BPF_DW, R0, R10, -40),
8876 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8877 			BPF_ALU64_REG(BPF_SUB, R0, R2),
8878 			BPF_EXIT_INSN(),
8879 		},
8880 		INTERNAL,
8881 		{ },
8882 		{ { 0, 0 } },
8883 		.stack_depth = 40,
8884 	},
8885 	{
8886 		"BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test failure return",
8887 		.u.insns_int = {
8888 			BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
8889 			BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
8890 			BPF_ALU64_REG(BPF_MOV, R0, R1),
8891 			BPF_ALU64_IMM(BPF_ADD, R0, 1),
8892 			BPF_STX_MEM(BPF_DW, R10, R1, -40),
8893 			BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
8894 			BPF_JMP_REG(BPF_JNE, R0, R1, 1),
8895 			BPF_ALU64_REG(BPF_SUB, R0, R1),
8896 			BPF_EXIT_INSN(),
8897 		},
8898 		INTERNAL,
8899 		{ },
8900 		{ { 0, 0 } },
8901 		.stack_depth = 40,
8902 	},
8903 	{
8904 		"BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test failure store",
8905 		.u.insns_int = {
8906 			BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
8907 			BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
8908 			BPF_ALU64_REG(BPF_MOV, R0, R1),
8909 			BPF_ALU64_IMM(BPF_ADD, R0, 1),
8910 			BPF_STX_MEM(BPF_DW, R10, R1, -40),
8911 			BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
8912 			BPF_LDX_MEM(BPF_DW, R0, R10, -40),
8913 			BPF_JMP_REG(BPF_JNE, R0, R1, 1),
8914 			BPF_ALU64_REG(BPF_SUB, R0, R1),
8915 			BPF_EXIT_INSN(),
8916 		},
8917 		INTERNAL,
8918 		{ },
8919 		{ { 0, 0 } },
8920 		.stack_depth = 40,
8921 	},
8922 	{
8923 		"BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test side effects",
8924 		.u.insns_int = {
8925 			BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
8926 			BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
8927 			BPF_ALU64_REG(BPF_MOV, R0, R1),
8928 			BPF_STX_MEM(BPF_DW, R10, R1, -40),
8929 			BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
8930 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
8931 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8932 			BPF_ALU64_REG(BPF_SUB, R0, R2),
8933 			BPF_EXIT_INSN(),
8934 		},
8935 		INTERNAL,
8936 		{ },
8937 		{ { 0, 0 } },
8938 		.stack_depth = 40,
8939 	},
8940 	/* BPF_JMP32 | BPF_JEQ | BPF_K */
8941 	{
8942 		"JMP32_JEQ_K: Small immediate",
8943 		.u.insns_int = {
8944 			BPF_ALU32_IMM(BPF_MOV, R0, 123),
8945 			BPF_JMP32_IMM(BPF_JEQ, R0, 321, 1),
8946 			BPF_JMP32_IMM(BPF_JEQ, R0, 123, 1),
8947 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8948 			BPF_EXIT_INSN(),
8949 		},
8950 		INTERNAL,
8951 		{ },
8952 		{ { 0, 123 } }
8953 	},
8954 	{
8955 		"JMP32_JEQ_K: Large immediate",
8956 		.u.insns_int = {
8957 			BPF_ALU32_IMM(BPF_MOV, R0, 12345678),
8958 			BPF_JMP32_IMM(BPF_JEQ, R0, 12345678 & 0xffff, 1),
8959 			BPF_JMP32_IMM(BPF_JEQ, R0, 12345678, 1),
8960 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8961 			BPF_EXIT_INSN(),
8962 		},
8963 		INTERNAL,
8964 		{ },
8965 		{ { 0, 12345678 } }
8966 	},
8967 	{
8968 		"JMP32_JEQ_K: negative immediate",
8969 		.u.insns_int = {
8970 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
8971 			BPF_JMP32_IMM(BPF_JEQ, R0,  123, 1),
8972 			BPF_JMP32_IMM(BPF_JEQ, R0, -123, 1),
8973 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8974 			BPF_EXIT_INSN(),
8975 		},
8976 		INTERNAL,
8977 		{ },
8978 		{ { 0, -123 } }
8979 	},
8980 	/* BPF_JMP32 | BPF_JEQ | BPF_X */
8981 	{
8982 		"JMP32_JEQ_X",
8983 		.u.insns_int = {
8984 			BPF_ALU32_IMM(BPF_MOV, R0, 1234),
8985 			BPF_ALU32_IMM(BPF_MOV, R1, 4321),
8986 			BPF_JMP32_REG(BPF_JEQ, R0, R1, 2),
8987 			BPF_ALU32_IMM(BPF_MOV, R1, 1234),
8988 			BPF_JMP32_REG(BPF_JEQ, R0, R1, 1),
8989 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8990 			BPF_EXIT_INSN(),
8991 		},
8992 		INTERNAL,
8993 		{ },
8994 		{ { 0, 1234 } }
8995 	},
8996 	/* BPF_JMP32 | BPF_JNE | BPF_K */
8997 	{
8998 		"JMP32_JNE_K: Small immediate",
8999 		.u.insns_int = {
9000 			BPF_ALU32_IMM(BPF_MOV, R0, 123),
9001 			BPF_JMP32_IMM(BPF_JNE, R0, 123, 1),
9002 			BPF_JMP32_IMM(BPF_JNE, R0, 321, 1),
9003 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9004 			BPF_EXIT_INSN(),
9005 		},
9006 		INTERNAL,
9007 		{ },
9008 		{ { 0, 123 } }
9009 	},
9010 	{
9011 		"JMP32_JNE_K: Large immediate",
9012 		.u.insns_int = {
9013 			BPF_ALU32_IMM(BPF_MOV, R0, 12345678),
9014 			BPF_JMP32_IMM(BPF_JNE, R0, 12345678, 1),
9015 			BPF_JMP32_IMM(BPF_JNE, R0, 12345678 & 0xffff, 1),
9016 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9017 			BPF_EXIT_INSN(),
9018 		},
9019 		INTERNAL,
9020 		{ },
9021 		{ { 0, 12345678 } }
9022 	},
9023 	{
9024 		"JMP32_JNE_K: negative immediate",
9025 		.u.insns_int = {
9026 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
9027 			BPF_JMP32_IMM(BPF_JNE, R0, -123, 1),
9028 			BPF_JMP32_IMM(BPF_JNE, R0,  123, 1),
9029 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9030 			BPF_EXIT_INSN(),
9031 		},
9032 		INTERNAL,
9033 		{ },
9034 		{ { 0, -123 } }
9035 	},
9036 	/* BPF_JMP32 | BPF_JNE | BPF_X */
9037 	{
9038 		"JMP32_JNE_X",
9039 		.u.insns_int = {
9040 			BPF_ALU32_IMM(BPF_MOV, R0, 1234),
9041 			BPF_ALU32_IMM(BPF_MOV, R1, 1234),
9042 			BPF_JMP32_REG(BPF_JNE, R0, R1, 2),
9043 			BPF_ALU32_IMM(BPF_MOV, R1, 4321),
9044 			BPF_JMP32_REG(BPF_JNE, R0, R1, 1),
9045 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9046 			BPF_EXIT_INSN(),
9047 		},
9048 		INTERNAL,
9049 		{ },
9050 		{ { 0, 1234 } }
9051 	},
9052 	/* BPF_JMP32 | BPF_JSET | BPF_K */
9053 	{
9054 		"JMP32_JSET_K: Small immediate",
9055 		.u.insns_int = {
9056 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9057 			BPF_JMP32_IMM(BPF_JSET, R0, 2, 1),
9058 			BPF_JMP32_IMM(BPF_JSET, R0, 3, 1),
9059 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9060 			BPF_EXIT_INSN(),
9061 		},
9062 		INTERNAL,
9063 		{ },
9064 		{ { 0, 1 } }
9065 	},
9066 	{
9067 		"JMP32_JSET_K: Large immediate",
9068 		.u.insns_int = {
9069 			BPF_ALU32_IMM(BPF_MOV, R0, 0x40000000),
9070 			BPF_JMP32_IMM(BPF_JSET, R0, 0x3fffffff, 1),
9071 			BPF_JMP32_IMM(BPF_JSET, R0, 0x60000000, 1),
9072 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9073 			BPF_EXIT_INSN(),
9074 		},
9075 		INTERNAL,
9076 		{ },
9077 		{ { 0, 0x40000000 } }
9078 	},
9079 	{
9080 		"JMP32_JSET_K: negative immediate",
9081 		.u.insns_int = {
9082 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
9083 			BPF_JMP32_IMM(BPF_JSET, R0, -1, 1),
9084 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9085 			BPF_EXIT_INSN(),
9086 		},
9087 		INTERNAL,
9088 		{ },
9089 		{ { 0, -123 } }
9090 	},
9091 	/* BPF_JMP32 | BPF_JSET | BPF_X */
9092 	{
9093 		"JMP32_JSET_X",
9094 		.u.insns_int = {
9095 			BPF_ALU32_IMM(BPF_MOV, R0, 8),
9096 			BPF_ALU32_IMM(BPF_MOV, R1, 7),
9097 			BPF_JMP32_REG(BPF_JSET, R0, R1, 2),
9098 			BPF_ALU32_IMM(BPF_MOV, R1, 8 | 2),
9099 			BPF_JMP32_REG(BPF_JNE, R0, R1, 1),
9100 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9101 			BPF_EXIT_INSN(),
9102 		},
9103 		INTERNAL,
9104 		{ },
9105 		{ { 0, 8 } }
9106 	},
9107 	/* BPF_JMP32 | BPF_JGT | BPF_K */
9108 	{
9109 		"JMP32_JGT_K: Small immediate",
9110 		.u.insns_int = {
9111 			BPF_ALU32_IMM(BPF_MOV, R0, 123),
9112 			BPF_JMP32_IMM(BPF_JGT, R0, 123, 1),
9113 			BPF_JMP32_IMM(BPF_JGT, R0, 122, 1),
9114 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9115 			BPF_EXIT_INSN(),
9116 		},
9117 		INTERNAL,
9118 		{ },
9119 		{ { 0, 123 } }
9120 	},
9121 	{
9122 		"JMP32_JGT_K: Large immediate",
9123 		.u.insns_int = {
9124 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9125 			BPF_JMP32_IMM(BPF_JGT, R0, 0xffffffff, 1),
9126 			BPF_JMP32_IMM(BPF_JGT, R0, 0xfffffffd, 1),
9127 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9128 			BPF_EXIT_INSN(),
9129 		},
9130 		INTERNAL,
9131 		{ },
9132 		{ { 0, 0xfffffffe } }
9133 	},
9134 	/* BPF_JMP32 | BPF_JGT | BPF_X */
9135 	{
9136 		"JMP32_JGT_X",
9137 		.u.insns_int = {
9138 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9139 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
9140 			BPF_JMP32_REG(BPF_JGT, R0, R1, 2),
9141 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
9142 			BPF_JMP32_REG(BPF_JGT, R0, R1, 1),
9143 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9144 			BPF_EXIT_INSN(),
9145 		},
9146 		INTERNAL,
9147 		{ },
9148 		{ { 0, 0xfffffffe } }
9149 	},
9150 	/* BPF_JMP32 | BPF_JGE | BPF_K */
9151 	{
9152 		"JMP32_JGE_K: Small immediate",
9153 		.u.insns_int = {
9154 			BPF_ALU32_IMM(BPF_MOV, R0, 123),
9155 			BPF_JMP32_IMM(BPF_JGE, R0, 124, 1),
9156 			BPF_JMP32_IMM(BPF_JGE, R0, 123, 1),
9157 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9158 			BPF_EXIT_INSN(),
9159 		},
9160 		INTERNAL,
9161 		{ },
9162 		{ { 0, 123 } }
9163 	},
9164 	{
9165 		"JMP32_JGE_K: Large immediate",
9166 		.u.insns_int = {
9167 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9168 			BPF_JMP32_IMM(BPF_JGE, R0, 0xffffffff, 1),
9169 			BPF_JMP32_IMM(BPF_JGE, R0, 0xfffffffe, 1),
9170 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9171 			BPF_EXIT_INSN(),
9172 		},
9173 		INTERNAL,
9174 		{ },
9175 		{ { 0, 0xfffffffe } }
9176 	},
9177 	/* BPF_JMP32 | BPF_JGE | BPF_X */
9178 	{
9179 		"JMP32_JGE_X",
9180 		.u.insns_int = {
9181 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9182 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
9183 			BPF_JMP32_REG(BPF_JGE, R0, R1, 2),
9184 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffe),
9185 			BPF_JMP32_REG(BPF_JGE, R0, R1, 1),
9186 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9187 			BPF_EXIT_INSN(),
9188 		},
9189 		INTERNAL,
9190 		{ },
9191 		{ { 0, 0xfffffffe } }
9192 	},
9193 	/* BPF_JMP32 | BPF_JLT | BPF_K */
9194 	{
9195 		"JMP32_JLT_K: Small immediate",
9196 		.u.insns_int = {
9197 			BPF_ALU32_IMM(BPF_MOV, R0, 123),
9198 			BPF_JMP32_IMM(BPF_JLT, R0, 123, 1),
9199 			BPF_JMP32_IMM(BPF_JLT, R0, 124, 1),
9200 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9201 			BPF_EXIT_INSN(),
9202 		},
9203 		INTERNAL,
9204 		{ },
9205 		{ { 0, 123 } }
9206 	},
9207 	{
9208 		"JMP32_JLT_K: Large immediate",
9209 		.u.insns_int = {
9210 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9211 			BPF_JMP32_IMM(BPF_JLT, R0, 0xfffffffd, 1),
9212 			BPF_JMP32_IMM(BPF_JLT, R0, 0xffffffff, 1),
9213 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9214 			BPF_EXIT_INSN(),
9215 		},
9216 		INTERNAL,
9217 		{ },
9218 		{ { 0, 0xfffffffe } }
9219 	},
9220 	/* BPF_JMP32 | BPF_JLT | BPF_X */
9221 	{
9222 		"JMP32_JLT_X",
9223 		.u.insns_int = {
9224 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9225 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
9226 			BPF_JMP32_REG(BPF_JLT, R0, R1, 2),
9227 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
9228 			BPF_JMP32_REG(BPF_JLT, R0, R1, 1),
9229 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9230 			BPF_EXIT_INSN(),
9231 		},
9232 		INTERNAL,
9233 		{ },
9234 		{ { 0, 0xfffffffe } }
9235 	},
9236 	/* BPF_JMP32 | BPF_JLE | BPF_K */
9237 	{
9238 		"JMP32_JLE_K: Small immediate",
9239 		.u.insns_int = {
9240 			BPF_ALU32_IMM(BPF_MOV, R0, 123),
9241 			BPF_JMP32_IMM(BPF_JLE, R0, 122, 1),
9242 			BPF_JMP32_IMM(BPF_JLE, R0, 123, 1),
9243 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9244 			BPF_EXIT_INSN(),
9245 		},
9246 		INTERNAL,
9247 		{ },
9248 		{ { 0, 123 } }
9249 	},
9250 	{
9251 		"JMP32_JLE_K: Large immediate",
9252 		.u.insns_int = {
9253 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9254 			BPF_JMP32_IMM(BPF_JLE, R0, 0xfffffffd, 1),
9255 			BPF_JMP32_IMM(BPF_JLE, R0, 0xfffffffe, 1),
9256 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9257 			BPF_EXIT_INSN(),
9258 		},
9259 		INTERNAL,
9260 		{ },
9261 		{ { 0, 0xfffffffe } }
9262 	},
9263 	/* BPF_JMP32 | BPF_JLE | BPF_X */
9264 	{
9265 		"JMP32_JLE_X",
9266 		.u.insns_int = {
9267 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9268 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
9269 			BPF_JMP32_REG(BPF_JLE, R0, R1, 2),
9270 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffe),
9271 			BPF_JMP32_REG(BPF_JLE, R0, R1, 1),
9272 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9273 			BPF_EXIT_INSN(),
9274 		},
9275 		INTERNAL,
9276 		{ },
9277 		{ { 0, 0xfffffffe } }
9278 	},
9279 	/* BPF_JMP32 | BPF_JSGT | BPF_K */
9280 	{
9281 		"JMP32_JSGT_K: Small immediate",
9282 		.u.insns_int = {
9283 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
9284 			BPF_JMP32_IMM(BPF_JSGT, R0, -123, 1),
9285 			BPF_JMP32_IMM(BPF_JSGT, R0, -124, 1),
9286 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9287 			BPF_EXIT_INSN(),
9288 		},
9289 		INTERNAL,
9290 		{ },
9291 		{ { 0, -123 } }
9292 	},
9293 	{
9294 		"JMP32_JSGT_K: Large immediate",
9295 		.u.insns_int = {
9296 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9297 			BPF_JMP32_IMM(BPF_JSGT, R0, -12345678, 1),
9298 			BPF_JMP32_IMM(BPF_JSGT, R0, -12345679, 1),
9299 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9300 			BPF_EXIT_INSN(),
9301 		},
9302 		INTERNAL,
9303 		{ },
9304 		{ { 0, -12345678 } }
9305 	},
9306 	/* BPF_JMP32 | BPF_JSGT | BPF_X */
9307 	{
9308 		"JMP32_JSGT_X",
9309 		.u.insns_int = {
9310 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9311 			BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
9312 			BPF_JMP32_REG(BPF_JSGT, R0, R1, 2),
9313 			BPF_ALU32_IMM(BPF_MOV, R1, -12345679),
9314 			BPF_JMP32_REG(BPF_JSGT, R0, R1, 1),
9315 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9316 			BPF_EXIT_INSN(),
9317 		},
9318 		INTERNAL,
9319 		{ },
9320 		{ { 0, -12345678 } }
9321 	},
9322 	/* BPF_JMP32 | BPF_JSGE | BPF_K */
9323 	{
9324 		"JMP32_JSGE_K: Small immediate",
9325 		.u.insns_int = {
9326 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
9327 			BPF_JMP32_IMM(BPF_JSGE, R0, -122, 1),
9328 			BPF_JMP32_IMM(BPF_JSGE, R0, -123, 1),
9329 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9330 			BPF_EXIT_INSN(),
9331 		},
9332 		INTERNAL,
9333 		{ },
9334 		{ { 0, -123 } }
9335 	},
9336 	{
9337 		"JMP32_JSGE_K: Large immediate",
9338 		.u.insns_int = {
9339 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9340 			BPF_JMP32_IMM(BPF_JSGE, R0, -12345677, 1),
9341 			BPF_JMP32_IMM(BPF_JSGE, R0, -12345678, 1),
9342 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9343 			BPF_EXIT_INSN(),
9344 		},
9345 		INTERNAL,
9346 		{ },
9347 		{ { 0, -12345678 } }
9348 	},
9349 	/* BPF_JMP32 | BPF_JSGE | BPF_X */
9350 	{
9351 		"JMP32_JSGE_X",
9352 		.u.insns_int = {
9353 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9354 			BPF_ALU32_IMM(BPF_MOV, R1, -12345677),
9355 			BPF_JMP32_REG(BPF_JSGE, R0, R1, 2),
9356 			BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
9357 			BPF_JMP32_REG(BPF_JSGE, R0, R1, 1),
9358 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9359 			BPF_EXIT_INSN(),
9360 		},
9361 		INTERNAL,
9362 		{ },
9363 		{ { 0, -12345678 } }
9364 	},
9365 	/* BPF_JMP32 | BPF_JSLT | BPF_K */
9366 	{
9367 		"JMP32_JSLT_K: Small immediate",
9368 		.u.insns_int = {
9369 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
9370 			BPF_JMP32_IMM(BPF_JSLT, R0, -123, 1),
9371 			BPF_JMP32_IMM(BPF_JSLT, R0, -122, 1),
9372 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9373 			BPF_EXIT_INSN(),
9374 		},
9375 		INTERNAL,
9376 		{ },
9377 		{ { 0, -123 } }
9378 	},
9379 	{
9380 		"JMP32_JSLT_K: Large immediate",
9381 		.u.insns_int = {
9382 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9383 			BPF_JMP32_IMM(BPF_JSLT, R0, -12345678, 1),
9384 			BPF_JMP32_IMM(BPF_JSLT, R0, -12345677, 1),
9385 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9386 			BPF_EXIT_INSN(),
9387 		},
9388 		INTERNAL,
9389 		{ },
9390 		{ { 0, -12345678 } }
9391 	},
9392 	/* BPF_JMP32 | BPF_JSLT | BPF_X */
9393 	{
9394 		"JMP32_JSLT_X",
9395 		.u.insns_int = {
9396 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9397 			BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
9398 			BPF_JMP32_REG(BPF_JSLT, R0, R1, 2),
9399 			BPF_ALU32_IMM(BPF_MOV, R1, -12345677),
9400 			BPF_JMP32_REG(BPF_JSLT, R0, R1, 1),
9401 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9402 			BPF_EXIT_INSN(),
9403 		},
9404 		INTERNAL,
9405 		{ },
9406 		{ { 0, -12345678 } }
9407 	},
9408 	/* BPF_JMP32 | BPF_JSLE | BPF_K */
9409 	{
9410 		"JMP32_JSLE_K: Small immediate",
9411 		.u.insns_int = {
9412 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
9413 			BPF_JMP32_IMM(BPF_JSLE, R0, -124, 1),
9414 			BPF_JMP32_IMM(BPF_JSLE, R0, -123, 1),
9415 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9416 			BPF_EXIT_INSN(),
9417 		},
9418 		INTERNAL,
9419 		{ },
9420 		{ { 0, -123 } }
9421 	},
9422 	{
9423 		"JMP32_JSLE_K: Large immediate",
9424 		.u.insns_int = {
9425 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9426 			BPF_JMP32_IMM(BPF_JSLE, R0, -12345679, 1),
9427 			BPF_JMP32_IMM(BPF_JSLE, R0, -12345678, 1),
9428 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9429 			BPF_EXIT_INSN(),
9430 		},
9431 		INTERNAL,
9432 		{ },
9433 		{ { 0, -12345678 } }
9434 	},
9435 	/* BPF_JMP32 | BPF_JSLE | BPF_K */
9436 	{
9437 		"JMP32_JSLE_X",
9438 		.u.insns_int = {
9439 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9440 			BPF_ALU32_IMM(BPF_MOV, R1, -12345679),
9441 			BPF_JMP32_REG(BPF_JSLE, R0, R1, 2),
9442 			BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
9443 			BPF_JMP32_REG(BPF_JSLE, R0, R1, 1),
9444 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9445 			BPF_EXIT_INSN(),
9446 		},
9447 		INTERNAL,
9448 		{ },
9449 		{ { 0, -12345678 } }
9450 	},
9451 	/* BPF_JMP | BPF_EXIT */
9452 	{
9453 		"JMP_EXIT",
9454 		.u.insns_int = {
9455 			BPF_ALU32_IMM(BPF_MOV, R0, 0x4711),
9456 			BPF_EXIT_INSN(),
9457 			BPF_ALU32_IMM(BPF_MOV, R0, 0x4712),
9458 		},
9459 		INTERNAL,
9460 		{ },
9461 		{ { 0, 0x4711 } },
9462 	},
9463 	/* BPF_JMP | BPF_JA */
9464 	{
9465 		"JMP_JA: Unconditional jump: if (true) return 1",
9466 		.u.insns_int = {
9467 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9468 			BPF_JMP_IMM(BPF_JA, 0, 0, 1),
9469 			BPF_EXIT_INSN(),
9470 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9471 			BPF_EXIT_INSN(),
9472 		},
9473 		INTERNAL,
9474 		{ },
9475 		{ { 0, 1 } },
9476 	},
9477 	/* BPF_JMP | BPF_JSLT | BPF_K */
9478 	{
9479 		"JMP_JSLT_K: Signed jump: if (-2 < -1) return 1",
9480 		.u.insns_int = {
9481 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9482 			BPF_LD_IMM64(R1, 0xfffffffffffffffeLL),
9483 			BPF_JMP_IMM(BPF_JSLT, R1, -1, 1),
9484 			BPF_EXIT_INSN(),
9485 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9486 			BPF_EXIT_INSN(),
9487 		},
9488 		INTERNAL,
9489 		{ },
9490 		{ { 0, 1 } },
9491 	},
9492 	{
9493 		"JMP_JSLT_K: Signed jump: if (-1 < -1) return 0",
9494 		.u.insns_int = {
9495 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9496 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9497 			BPF_JMP_IMM(BPF_JSLT, R1, -1, 1),
9498 			BPF_EXIT_INSN(),
9499 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9500 			BPF_EXIT_INSN(),
9501 		},
9502 		INTERNAL,
9503 		{ },
9504 		{ { 0, 1 } },
9505 	},
9506 	/* BPF_JMP | BPF_JSGT | BPF_K */
9507 	{
9508 		"JMP_JSGT_K: Signed jump: if (-1 > -2) return 1",
9509 		.u.insns_int = {
9510 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9511 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9512 			BPF_JMP_IMM(BPF_JSGT, R1, -2, 1),
9513 			BPF_EXIT_INSN(),
9514 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9515 			BPF_EXIT_INSN(),
9516 		},
9517 		INTERNAL,
9518 		{ },
9519 		{ { 0, 1 } },
9520 	},
9521 	{
9522 		"JMP_JSGT_K: Signed jump: if (-1 > -1) return 0",
9523 		.u.insns_int = {
9524 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9525 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9526 			BPF_JMP_IMM(BPF_JSGT, R1, -1, 1),
9527 			BPF_EXIT_INSN(),
9528 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9529 			BPF_EXIT_INSN(),
9530 		},
9531 		INTERNAL,
9532 		{ },
9533 		{ { 0, 1 } },
9534 	},
9535 	/* BPF_JMP | BPF_JSLE | BPF_K */
9536 	{
9537 		"JMP_JSLE_K: Signed jump: if (-2 <= -1) return 1",
9538 		.u.insns_int = {
9539 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9540 			BPF_LD_IMM64(R1, 0xfffffffffffffffeLL),
9541 			BPF_JMP_IMM(BPF_JSLE, R1, -1, 1),
9542 			BPF_EXIT_INSN(),
9543 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9544 			BPF_EXIT_INSN(),
9545 		},
9546 		INTERNAL,
9547 		{ },
9548 		{ { 0, 1 } },
9549 	},
9550 	{
9551 		"JMP_JSLE_K: Signed jump: if (-1 <= -1) return 1",
9552 		.u.insns_int = {
9553 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9554 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9555 			BPF_JMP_IMM(BPF_JSLE, R1, -1, 1),
9556 			BPF_EXIT_INSN(),
9557 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9558 			BPF_EXIT_INSN(),
9559 		},
9560 		INTERNAL,
9561 		{ },
9562 		{ { 0, 1 } },
9563 	},
9564 	{
9565 		"JMP_JSLE_K: Signed jump: value walk 1",
9566 		.u.insns_int = {
9567 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9568 			BPF_LD_IMM64(R1, 3),
9569 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 6),
9570 			BPF_ALU64_IMM(BPF_SUB, R1, 1),
9571 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 4),
9572 			BPF_ALU64_IMM(BPF_SUB, R1, 1),
9573 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 2),
9574 			BPF_ALU64_IMM(BPF_SUB, R1, 1),
9575 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 1),
9576 			BPF_EXIT_INSN(),		/* bad exit */
9577 			BPF_ALU32_IMM(BPF_MOV, R0, 1),	/* good exit */
9578 			BPF_EXIT_INSN(),
9579 		},
9580 		INTERNAL,
9581 		{ },
9582 		{ { 0, 1 } },
9583 	},
9584 	{
9585 		"JMP_JSLE_K: Signed jump: value walk 2",
9586 		.u.insns_int = {
9587 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9588 			BPF_LD_IMM64(R1, 3),
9589 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 4),
9590 			BPF_ALU64_IMM(BPF_SUB, R1, 2),
9591 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 2),
9592 			BPF_ALU64_IMM(BPF_SUB, R1, 2),
9593 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 1),
9594 			BPF_EXIT_INSN(),		/* bad exit */
9595 			BPF_ALU32_IMM(BPF_MOV, R0, 1),	/* good exit */
9596 			BPF_EXIT_INSN(),
9597 		},
9598 		INTERNAL,
9599 		{ },
9600 		{ { 0, 1 } },
9601 	},
9602 	/* BPF_JMP | BPF_JSGE | BPF_K */
9603 	{
9604 		"JMP_JSGE_K: Signed jump: if (-1 >= -2) return 1",
9605 		.u.insns_int = {
9606 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9607 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9608 			BPF_JMP_IMM(BPF_JSGE, R1, -2, 1),
9609 			BPF_EXIT_INSN(),
9610 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9611 			BPF_EXIT_INSN(),
9612 		},
9613 		INTERNAL,
9614 		{ },
9615 		{ { 0, 1 } },
9616 	},
9617 	{
9618 		"JMP_JSGE_K: Signed jump: if (-1 >= -1) return 1",
9619 		.u.insns_int = {
9620 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9621 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9622 			BPF_JMP_IMM(BPF_JSGE, R1, -1, 1),
9623 			BPF_EXIT_INSN(),
9624 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9625 			BPF_EXIT_INSN(),
9626 		},
9627 		INTERNAL,
9628 		{ },
9629 		{ { 0, 1 } },
9630 	},
9631 	{
9632 		"JMP_JSGE_K: Signed jump: value walk 1",
9633 		.u.insns_int = {
9634 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9635 			BPF_LD_IMM64(R1, -3),
9636 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 6),
9637 			BPF_ALU64_IMM(BPF_ADD, R1, 1),
9638 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 4),
9639 			BPF_ALU64_IMM(BPF_ADD, R1, 1),
9640 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 2),
9641 			BPF_ALU64_IMM(BPF_ADD, R1, 1),
9642 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 1),
9643 			BPF_EXIT_INSN(),		/* bad exit */
9644 			BPF_ALU32_IMM(BPF_MOV, R0, 1),	/* good exit */
9645 			BPF_EXIT_INSN(),
9646 		},
9647 		INTERNAL,
9648 		{ },
9649 		{ { 0, 1 } },
9650 	},
9651 	{
9652 		"JMP_JSGE_K: Signed jump: value walk 2",
9653 		.u.insns_int = {
9654 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9655 			BPF_LD_IMM64(R1, -3),
9656 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 4),
9657 			BPF_ALU64_IMM(BPF_ADD, R1, 2),
9658 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 2),
9659 			BPF_ALU64_IMM(BPF_ADD, R1, 2),
9660 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 1),
9661 			BPF_EXIT_INSN(),		/* bad exit */
9662 			BPF_ALU32_IMM(BPF_MOV, R0, 1),	/* good exit */
9663 			BPF_EXIT_INSN(),
9664 		},
9665 		INTERNAL,
9666 		{ },
9667 		{ { 0, 1 } },
9668 	},
9669 	/* BPF_JMP | BPF_JGT | BPF_K */
9670 	{
9671 		"JMP_JGT_K: if (3 > 2) return 1",
9672 		.u.insns_int = {
9673 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9674 			BPF_LD_IMM64(R1, 3),
9675 			BPF_JMP_IMM(BPF_JGT, R1, 2, 1),
9676 			BPF_EXIT_INSN(),
9677 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9678 			BPF_EXIT_INSN(),
9679 		},
9680 		INTERNAL,
9681 		{ },
9682 		{ { 0, 1 } },
9683 	},
9684 	{
9685 		"JMP_JGT_K: Unsigned jump: if (-1 > 1) return 1",
9686 		.u.insns_int = {
9687 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9688 			BPF_LD_IMM64(R1, -1),
9689 			BPF_JMP_IMM(BPF_JGT, R1, 1, 1),
9690 			BPF_EXIT_INSN(),
9691 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9692 			BPF_EXIT_INSN(),
9693 		},
9694 		INTERNAL,
9695 		{ },
9696 		{ { 0, 1 } },
9697 	},
9698 	/* BPF_JMP | BPF_JLT | BPF_K */
9699 	{
9700 		"JMP_JLT_K: if (2 < 3) return 1",
9701 		.u.insns_int = {
9702 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9703 			BPF_LD_IMM64(R1, 2),
9704 			BPF_JMP_IMM(BPF_JLT, R1, 3, 1),
9705 			BPF_EXIT_INSN(),
9706 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9707 			BPF_EXIT_INSN(),
9708 		},
9709 		INTERNAL,
9710 		{ },
9711 		{ { 0, 1 } },
9712 	},
9713 	{
9714 		"JMP_JGT_K: Unsigned jump: if (1 < -1) return 1",
9715 		.u.insns_int = {
9716 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9717 			BPF_LD_IMM64(R1, 1),
9718 			BPF_JMP_IMM(BPF_JLT, R1, -1, 1),
9719 			BPF_EXIT_INSN(),
9720 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9721 			BPF_EXIT_INSN(),
9722 		},
9723 		INTERNAL,
9724 		{ },
9725 		{ { 0, 1 } },
9726 	},
9727 	/* BPF_JMP | BPF_JGE | BPF_K */
9728 	{
9729 		"JMP_JGE_K: if (3 >= 2) return 1",
9730 		.u.insns_int = {
9731 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9732 			BPF_LD_IMM64(R1, 3),
9733 			BPF_JMP_IMM(BPF_JGE, R1, 2, 1),
9734 			BPF_EXIT_INSN(),
9735 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9736 			BPF_EXIT_INSN(),
9737 		},
9738 		INTERNAL,
9739 		{ },
9740 		{ { 0, 1 } },
9741 	},
9742 	/* BPF_JMP | BPF_JLE | BPF_K */
9743 	{
9744 		"JMP_JLE_K: if (2 <= 3) return 1",
9745 		.u.insns_int = {
9746 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9747 			BPF_LD_IMM64(R1, 2),
9748 			BPF_JMP_IMM(BPF_JLE, R1, 3, 1),
9749 			BPF_EXIT_INSN(),
9750 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9751 			BPF_EXIT_INSN(),
9752 		},
9753 		INTERNAL,
9754 		{ },
9755 		{ { 0, 1 } },
9756 	},
9757 	/* BPF_JMP | BPF_JGT | BPF_K jump backwards */
9758 	{
9759 		"JMP_JGT_K: if (3 > 2) return 1 (jump backwards)",
9760 		.u.insns_int = {
9761 			BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
9762 			BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */
9763 			BPF_EXIT_INSN(),
9764 			BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
9765 			BPF_LD_IMM64(R1, 3), /* note: this takes 2 insns */
9766 			BPF_JMP_IMM(BPF_JGT, R1, 2, -6), /* goto out */
9767 			BPF_EXIT_INSN(),
9768 		},
9769 		INTERNAL,
9770 		{ },
9771 		{ { 0, 1 } },
9772 	},
9773 	{
9774 		"JMP_JGE_K: if (3 >= 3) return 1",
9775 		.u.insns_int = {
9776 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9777 			BPF_LD_IMM64(R1, 3),
9778 			BPF_JMP_IMM(BPF_JGE, R1, 3, 1),
9779 			BPF_EXIT_INSN(),
9780 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9781 			BPF_EXIT_INSN(),
9782 		},
9783 		INTERNAL,
9784 		{ },
9785 		{ { 0, 1 } },
9786 	},
9787 	/* BPF_JMP | BPF_JLT | BPF_K jump backwards */
9788 	{
9789 		"JMP_JGT_K: if (2 < 3) return 1 (jump backwards)",
9790 		.u.insns_int = {
9791 			BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
9792 			BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */
9793 			BPF_EXIT_INSN(),
9794 			BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
9795 			BPF_LD_IMM64(R1, 2), /* note: this takes 2 insns */
9796 			BPF_JMP_IMM(BPF_JLT, R1, 3, -6), /* goto out */
9797 			BPF_EXIT_INSN(),
9798 		},
9799 		INTERNAL,
9800 		{ },
9801 		{ { 0, 1 } },
9802 	},
9803 	{
9804 		"JMP_JLE_K: if (3 <= 3) return 1",
9805 		.u.insns_int = {
9806 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9807 			BPF_LD_IMM64(R1, 3),
9808 			BPF_JMP_IMM(BPF_JLE, R1, 3, 1),
9809 			BPF_EXIT_INSN(),
9810 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9811 			BPF_EXIT_INSN(),
9812 		},
9813 		INTERNAL,
9814 		{ },
9815 		{ { 0, 1 } },
9816 	},
9817 	/* BPF_JMP | BPF_JNE | BPF_K */
9818 	{
9819 		"JMP_JNE_K: if (3 != 2) return 1",
9820 		.u.insns_int = {
9821 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9822 			BPF_LD_IMM64(R1, 3),
9823 			BPF_JMP_IMM(BPF_JNE, R1, 2, 1),
9824 			BPF_EXIT_INSN(),
9825 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9826 			BPF_EXIT_INSN(),
9827 		},
9828 		INTERNAL,
9829 		{ },
9830 		{ { 0, 1 } },
9831 	},
9832 	/* BPF_JMP | BPF_JEQ | BPF_K */
9833 	{
9834 		"JMP_JEQ_K: if (3 == 3) return 1",
9835 		.u.insns_int = {
9836 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9837 			BPF_LD_IMM64(R1, 3),
9838 			BPF_JMP_IMM(BPF_JEQ, R1, 3, 1),
9839 			BPF_EXIT_INSN(),
9840 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9841 			BPF_EXIT_INSN(),
9842 		},
9843 		INTERNAL,
9844 		{ },
9845 		{ { 0, 1 } },
9846 	},
9847 	/* BPF_JMP | BPF_JSET | BPF_K */
9848 	{
9849 		"JMP_JSET_K: if (0x3 & 0x2) return 1",
9850 		.u.insns_int = {
9851 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9852 			BPF_LD_IMM64(R1, 3),
9853 			BPF_JMP_IMM(BPF_JSET, R1, 2, 1),
9854 			BPF_EXIT_INSN(),
9855 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9856 			BPF_EXIT_INSN(),
9857 		},
9858 		INTERNAL,
9859 		{ },
9860 		{ { 0, 1 } },
9861 	},
9862 	{
9863 		"JMP_JSET_K: if (0x3 & 0xffffffff) return 1",
9864 		.u.insns_int = {
9865 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9866 			BPF_LD_IMM64(R1, 3),
9867 			BPF_JMP_IMM(BPF_JSET, R1, 0xffffffff, 1),
9868 			BPF_EXIT_INSN(),
9869 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9870 			BPF_EXIT_INSN(),
9871 		},
9872 		INTERNAL,
9873 		{ },
9874 		{ { 0, 1 } },
9875 	},
9876 	/* BPF_JMP | BPF_JSGT | BPF_X */
9877 	{
9878 		"JMP_JSGT_X: Signed jump: if (-1 > -2) return 1",
9879 		.u.insns_int = {
9880 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9881 			BPF_LD_IMM64(R1, -1),
9882 			BPF_LD_IMM64(R2, -2),
9883 			BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
9884 			BPF_EXIT_INSN(),
9885 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9886 			BPF_EXIT_INSN(),
9887 		},
9888 		INTERNAL,
9889 		{ },
9890 		{ { 0, 1 } },
9891 	},
9892 	{
9893 		"JMP_JSGT_X: Signed jump: if (-1 > -1) return 0",
9894 		.u.insns_int = {
9895 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9896 			BPF_LD_IMM64(R1, -1),
9897 			BPF_LD_IMM64(R2, -1),
9898 			BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
9899 			BPF_EXIT_INSN(),
9900 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9901 			BPF_EXIT_INSN(),
9902 		},
9903 		INTERNAL,
9904 		{ },
9905 		{ { 0, 1 } },
9906 	},
9907 	/* BPF_JMP | BPF_JSLT | BPF_X */
9908 	{
9909 		"JMP_JSLT_X: Signed jump: if (-2 < -1) return 1",
9910 		.u.insns_int = {
9911 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9912 			BPF_LD_IMM64(R1, -1),
9913 			BPF_LD_IMM64(R2, -2),
9914 			BPF_JMP_REG(BPF_JSLT, R2, R1, 1),
9915 			BPF_EXIT_INSN(),
9916 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9917 			BPF_EXIT_INSN(),
9918 		},
9919 		INTERNAL,
9920 		{ },
9921 		{ { 0, 1 } },
9922 	},
9923 	{
9924 		"JMP_JSLT_X: Signed jump: if (-1 < -1) return 0",
9925 		.u.insns_int = {
9926 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9927 			BPF_LD_IMM64(R1, -1),
9928 			BPF_LD_IMM64(R2, -1),
9929 			BPF_JMP_REG(BPF_JSLT, R1, R2, 1),
9930 			BPF_EXIT_INSN(),
9931 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9932 			BPF_EXIT_INSN(),
9933 		},
9934 		INTERNAL,
9935 		{ },
9936 		{ { 0, 1 } },
9937 	},
9938 	/* BPF_JMP | BPF_JSGE | BPF_X */
9939 	{
9940 		"JMP_JSGE_X: Signed jump: if (-1 >= -2) return 1",
9941 		.u.insns_int = {
9942 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9943 			BPF_LD_IMM64(R1, -1),
9944 			BPF_LD_IMM64(R2, -2),
9945 			BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
9946 			BPF_EXIT_INSN(),
9947 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9948 			BPF_EXIT_INSN(),
9949 		},
9950 		INTERNAL,
9951 		{ },
9952 		{ { 0, 1 } },
9953 	},
9954 	{
9955 		"JMP_JSGE_X: Signed jump: if (-1 >= -1) return 1",
9956 		.u.insns_int = {
9957 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9958 			BPF_LD_IMM64(R1, -1),
9959 			BPF_LD_IMM64(R2, -1),
9960 			BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
9961 			BPF_EXIT_INSN(),
9962 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9963 			BPF_EXIT_INSN(),
9964 		},
9965 		INTERNAL,
9966 		{ },
9967 		{ { 0, 1 } },
9968 	},
9969 	/* BPF_JMP | BPF_JSLE | BPF_X */
9970 	{
9971 		"JMP_JSLE_X: Signed jump: if (-2 <= -1) return 1",
9972 		.u.insns_int = {
9973 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9974 			BPF_LD_IMM64(R1, -1),
9975 			BPF_LD_IMM64(R2, -2),
9976 			BPF_JMP_REG(BPF_JSLE, R2, R1, 1),
9977 			BPF_EXIT_INSN(),
9978 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9979 			BPF_EXIT_INSN(),
9980 		},
9981 		INTERNAL,
9982 		{ },
9983 		{ { 0, 1 } },
9984 	},
9985 	{
9986 		"JMP_JSLE_X: Signed jump: if (-1 <= -1) return 1",
9987 		.u.insns_int = {
9988 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9989 			BPF_LD_IMM64(R1, -1),
9990 			BPF_LD_IMM64(R2, -1),
9991 			BPF_JMP_REG(BPF_JSLE, R1, R2, 1),
9992 			BPF_EXIT_INSN(),
9993 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9994 			BPF_EXIT_INSN(),
9995 		},
9996 		INTERNAL,
9997 		{ },
9998 		{ { 0, 1 } },
9999 	},
10000 	/* BPF_JMP | BPF_JGT | BPF_X */
10001 	{
10002 		"JMP_JGT_X: if (3 > 2) return 1",
10003 		.u.insns_int = {
10004 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10005 			BPF_LD_IMM64(R1, 3),
10006 			BPF_LD_IMM64(R2, 2),
10007 			BPF_JMP_REG(BPF_JGT, R1, R2, 1),
10008 			BPF_EXIT_INSN(),
10009 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10010 			BPF_EXIT_INSN(),
10011 		},
10012 		INTERNAL,
10013 		{ },
10014 		{ { 0, 1 } },
10015 	},
10016 	{
10017 		"JMP_JGT_X: Unsigned jump: if (-1 > 1) return 1",
10018 		.u.insns_int = {
10019 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10020 			BPF_LD_IMM64(R1, -1),
10021 			BPF_LD_IMM64(R2, 1),
10022 			BPF_JMP_REG(BPF_JGT, R1, R2, 1),
10023 			BPF_EXIT_INSN(),
10024 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10025 			BPF_EXIT_INSN(),
10026 		},
10027 		INTERNAL,
10028 		{ },
10029 		{ { 0, 1 } },
10030 	},
10031 	/* BPF_JMP | BPF_JLT | BPF_X */
10032 	{
10033 		"JMP_JLT_X: if (2 < 3) return 1",
10034 		.u.insns_int = {
10035 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10036 			BPF_LD_IMM64(R1, 3),
10037 			BPF_LD_IMM64(R2, 2),
10038 			BPF_JMP_REG(BPF_JLT, R2, R1, 1),
10039 			BPF_EXIT_INSN(),
10040 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10041 			BPF_EXIT_INSN(),
10042 		},
10043 		INTERNAL,
10044 		{ },
10045 		{ { 0, 1 } },
10046 	},
10047 	{
10048 		"JMP_JLT_X: Unsigned jump: if (1 < -1) return 1",
10049 		.u.insns_int = {
10050 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10051 			BPF_LD_IMM64(R1, -1),
10052 			BPF_LD_IMM64(R2, 1),
10053 			BPF_JMP_REG(BPF_JLT, R2, R1, 1),
10054 			BPF_EXIT_INSN(),
10055 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10056 			BPF_EXIT_INSN(),
10057 		},
10058 		INTERNAL,
10059 		{ },
10060 		{ { 0, 1 } },
10061 	},
10062 	/* BPF_JMP | BPF_JGE | BPF_X */
10063 	{
10064 		"JMP_JGE_X: if (3 >= 2) return 1",
10065 		.u.insns_int = {
10066 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10067 			BPF_LD_IMM64(R1, 3),
10068 			BPF_LD_IMM64(R2, 2),
10069 			BPF_JMP_REG(BPF_JGE, R1, R2, 1),
10070 			BPF_EXIT_INSN(),
10071 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10072 			BPF_EXIT_INSN(),
10073 		},
10074 		INTERNAL,
10075 		{ },
10076 		{ { 0, 1 } },
10077 	},
10078 	{
10079 		"JMP_JGE_X: if (3 >= 3) return 1",
10080 		.u.insns_int = {
10081 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10082 			BPF_LD_IMM64(R1, 3),
10083 			BPF_LD_IMM64(R2, 3),
10084 			BPF_JMP_REG(BPF_JGE, R1, R2, 1),
10085 			BPF_EXIT_INSN(),
10086 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10087 			BPF_EXIT_INSN(),
10088 		},
10089 		INTERNAL,
10090 		{ },
10091 		{ { 0, 1 } },
10092 	},
10093 	/* BPF_JMP | BPF_JLE | BPF_X */
10094 	{
10095 		"JMP_JLE_X: if (2 <= 3) return 1",
10096 		.u.insns_int = {
10097 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10098 			BPF_LD_IMM64(R1, 3),
10099 			BPF_LD_IMM64(R2, 2),
10100 			BPF_JMP_REG(BPF_JLE, R2, R1, 1),
10101 			BPF_EXIT_INSN(),
10102 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10103 			BPF_EXIT_INSN(),
10104 		},
10105 		INTERNAL,
10106 		{ },
10107 		{ { 0, 1 } },
10108 	},
10109 	{
10110 		"JMP_JLE_X: if (3 <= 3) return 1",
10111 		.u.insns_int = {
10112 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10113 			BPF_LD_IMM64(R1, 3),
10114 			BPF_LD_IMM64(R2, 3),
10115 			BPF_JMP_REG(BPF_JLE, R1, R2, 1),
10116 			BPF_EXIT_INSN(),
10117 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10118 			BPF_EXIT_INSN(),
10119 		},
10120 		INTERNAL,
10121 		{ },
10122 		{ { 0, 1 } },
10123 	},
10124 	{
10125 		/* Mainly testing JIT + imm64 here. */
10126 		"JMP_JGE_X: ldimm64 test 1",
10127 		.u.insns_int = {
10128 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10129 			BPF_LD_IMM64(R1, 3),
10130 			BPF_LD_IMM64(R2, 2),
10131 			BPF_JMP_REG(BPF_JGE, R1, R2, 2),
10132 			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
10133 			BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
10134 			BPF_EXIT_INSN(),
10135 		},
10136 		INTERNAL,
10137 		{ },
10138 		{ { 0, 0xeeeeeeeeU } },
10139 	},
10140 	{
10141 		"JMP_JGE_X: ldimm64 test 2",
10142 		.u.insns_int = {
10143 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10144 			BPF_LD_IMM64(R1, 3),
10145 			BPF_LD_IMM64(R2, 2),
10146 			BPF_JMP_REG(BPF_JGE, R1, R2, 0),
10147 			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
10148 			BPF_EXIT_INSN(),
10149 		},
10150 		INTERNAL,
10151 		{ },
10152 		{ { 0, 0xffffffffU } },
10153 	},
10154 	{
10155 		"JMP_JGE_X: ldimm64 test 3",
10156 		.u.insns_int = {
10157 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10158 			BPF_LD_IMM64(R1, 3),
10159 			BPF_LD_IMM64(R2, 2),
10160 			BPF_JMP_REG(BPF_JGE, R1, R2, 4),
10161 			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
10162 			BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
10163 			BPF_EXIT_INSN(),
10164 		},
10165 		INTERNAL,
10166 		{ },
10167 		{ { 0, 1 } },
10168 	},
10169 	{
10170 		"JMP_JLE_X: ldimm64 test 1",
10171 		.u.insns_int = {
10172 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10173 			BPF_LD_IMM64(R1, 3),
10174 			BPF_LD_IMM64(R2, 2),
10175 			BPF_JMP_REG(BPF_JLE, R2, R1, 2),
10176 			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
10177 			BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
10178 			BPF_EXIT_INSN(),
10179 		},
10180 		INTERNAL,
10181 		{ },
10182 		{ { 0, 0xeeeeeeeeU } },
10183 	},
10184 	{
10185 		"JMP_JLE_X: ldimm64 test 2",
10186 		.u.insns_int = {
10187 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10188 			BPF_LD_IMM64(R1, 3),
10189 			BPF_LD_IMM64(R2, 2),
10190 			BPF_JMP_REG(BPF_JLE, R2, R1, 0),
10191 			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
10192 			BPF_EXIT_INSN(),
10193 		},
10194 		INTERNAL,
10195 		{ },
10196 		{ { 0, 0xffffffffU } },
10197 	},
10198 	{
10199 		"JMP_JLE_X: ldimm64 test 3",
10200 		.u.insns_int = {
10201 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10202 			BPF_LD_IMM64(R1, 3),
10203 			BPF_LD_IMM64(R2, 2),
10204 			BPF_JMP_REG(BPF_JLE, R2, R1, 4),
10205 			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
10206 			BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
10207 			BPF_EXIT_INSN(),
10208 		},
10209 		INTERNAL,
10210 		{ },
10211 		{ { 0, 1 } },
10212 	},
10213 	/* BPF_JMP | BPF_JNE | BPF_X */
10214 	{
10215 		"JMP_JNE_X: if (3 != 2) return 1",
10216 		.u.insns_int = {
10217 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10218 			BPF_LD_IMM64(R1, 3),
10219 			BPF_LD_IMM64(R2, 2),
10220 			BPF_JMP_REG(BPF_JNE, R1, R2, 1),
10221 			BPF_EXIT_INSN(),
10222 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10223 			BPF_EXIT_INSN(),
10224 		},
10225 		INTERNAL,
10226 		{ },
10227 		{ { 0, 1 } },
10228 	},
10229 	/* BPF_JMP | BPF_JEQ | BPF_X */
10230 	{
10231 		"JMP_JEQ_X: if (3 == 3) return 1",
10232 		.u.insns_int = {
10233 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10234 			BPF_LD_IMM64(R1, 3),
10235 			BPF_LD_IMM64(R2, 3),
10236 			BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
10237 			BPF_EXIT_INSN(),
10238 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10239 			BPF_EXIT_INSN(),
10240 		},
10241 		INTERNAL,
10242 		{ },
10243 		{ { 0, 1 } },
10244 	},
10245 	/* BPF_JMP | BPF_JSET | BPF_X */
10246 	{
10247 		"JMP_JSET_X: if (0x3 & 0x2) return 1",
10248 		.u.insns_int = {
10249 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10250 			BPF_LD_IMM64(R1, 3),
10251 			BPF_LD_IMM64(R2, 2),
10252 			BPF_JMP_REG(BPF_JSET, R1, R2, 1),
10253 			BPF_EXIT_INSN(),
10254 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10255 			BPF_EXIT_INSN(),
10256 		},
10257 		INTERNAL,
10258 		{ },
10259 		{ { 0, 1 } },
10260 	},
10261 	{
10262 		"JMP_JSET_X: if (0x3 & 0xffffffff) return 1",
10263 		.u.insns_int = {
10264 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10265 			BPF_LD_IMM64(R1, 3),
10266 			BPF_LD_IMM64(R2, 0xffffffff),
10267 			BPF_JMP_REG(BPF_JSET, R1, R2, 1),
10268 			BPF_EXIT_INSN(),
10269 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10270 			BPF_EXIT_INSN(),
10271 		},
10272 		INTERNAL,
10273 		{ },
10274 		{ { 0, 1 } },
10275 	},
10276 	{
10277 		"JMP_JA: Jump, gap, jump, ...",
10278 		{ },
10279 		CLASSIC | FLAG_NO_DATA,
10280 		{ },
10281 		{ { 0, 0xababcbac } },
10282 		.fill_helper = bpf_fill_ja,
10283 	},
10284 	{	/* Mainly checking JIT here. */
10285 		"BPF_MAXINSNS: Maximum possible literals",
10286 		{ },
10287 		CLASSIC | FLAG_NO_DATA,
10288 		{ },
10289 		{ { 0, 0xffffffff } },
10290 		.fill_helper = bpf_fill_maxinsns1,
10291 	},
10292 	{	/* Mainly checking JIT here. */
10293 		"BPF_MAXINSNS: Single literal",
10294 		{ },
10295 		CLASSIC | FLAG_NO_DATA,
10296 		{ },
10297 		{ { 0, 0xfefefefe } },
10298 		.fill_helper = bpf_fill_maxinsns2,
10299 	},
10300 	{	/* Mainly checking JIT here. */
10301 		"BPF_MAXINSNS: Run/add until end",
10302 		{ },
10303 		CLASSIC | FLAG_NO_DATA,
10304 		{ },
10305 		{ { 0, 0x947bf368 } },
10306 		.fill_helper = bpf_fill_maxinsns3,
10307 	},
10308 	{
10309 		"BPF_MAXINSNS: Too many instructions",
10310 		{ },
10311 		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
10312 		{ },
10313 		{ },
10314 		.fill_helper = bpf_fill_maxinsns4,
10315 		.expected_errcode = -EINVAL,
10316 	},
10317 	{	/* Mainly checking JIT here. */
10318 		"BPF_MAXINSNS: Very long jump",
10319 		{ },
10320 		CLASSIC | FLAG_NO_DATA,
10321 		{ },
10322 		{ { 0, 0xabababab } },
10323 		.fill_helper = bpf_fill_maxinsns5,
10324 	},
10325 	{	/* Mainly checking JIT here. */
10326 		"BPF_MAXINSNS: Ctx heavy transformations",
10327 		{ },
10328 		CLASSIC,
10329 		{ },
10330 		{
10331 			{  1, SKB_VLAN_PRESENT },
10332 			{ 10, SKB_VLAN_PRESENT }
10333 		},
10334 		.fill_helper = bpf_fill_maxinsns6,
10335 	},
10336 	{	/* Mainly checking JIT here. */
10337 		"BPF_MAXINSNS: Call heavy transformations",
10338 		{ },
10339 		CLASSIC | FLAG_NO_DATA,
10340 		{ },
10341 		{ { 1, 0 }, { 10, 0 } },
10342 		.fill_helper = bpf_fill_maxinsns7,
10343 	},
10344 	{	/* Mainly checking JIT here. */
10345 		"BPF_MAXINSNS: Jump heavy test",
10346 		{ },
10347 		CLASSIC | FLAG_NO_DATA,
10348 		{ },
10349 		{ { 0, 0xffffffff } },
10350 		.fill_helper = bpf_fill_maxinsns8,
10351 	},
10352 	{	/* Mainly checking JIT here. */
10353 		"BPF_MAXINSNS: Very long jump backwards",
10354 		{ },
10355 		INTERNAL | FLAG_NO_DATA,
10356 		{ },
10357 		{ { 0, 0xcbababab } },
10358 		.fill_helper = bpf_fill_maxinsns9,
10359 	},
10360 	{	/* Mainly checking JIT here. */
10361 		"BPF_MAXINSNS: Edge hopping nuthouse",
10362 		{ },
10363 		INTERNAL | FLAG_NO_DATA,
10364 		{ },
10365 		{ { 0, 0xabababac } },
10366 		.fill_helper = bpf_fill_maxinsns10,
10367 	},
10368 	{
10369 		"BPF_MAXINSNS: Jump, gap, jump, ...",
10370 		{ },
10371 		CLASSIC | FLAG_NO_DATA,
10372 		{ },
10373 		{ { 0, 0xababcbac } },
10374 		.fill_helper = bpf_fill_maxinsns11,
10375 	},
10376 	{
10377 		"BPF_MAXINSNS: jump over MSH",
10378 		{ },
10379 		CLASSIC | FLAG_EXPECTED_FAIL,
10380 		{ 0xfa, 0xfb, 0xfc, 0xfd, },
10381 		{ { 4, 0xabababab } },
10382 		.fill_helper = bpf_fill_maxinsns12,
10383 		.expected_errcode = -EINVAL,
10384 	},
10385 	{
10386 		"BPF_MAXINSNS: exec all MSH",
10387 		{ },
10388 		CLASSIC,
10389 		{ 0xfa, 0xfb, 0xfc, 0xfd, },
10390 		{ { 4, 0xababab83 } },
10391 		.fill_helper = bpf_fill_maxinsns13,
10392 	},
10393 	{
10394 		"BPF_MAXINSNS: ld_abs+get_processor_id",
10395 		{ },
10396 		CLASSIC,
10397 		{ },
10398 		{ { 1, 0xbee } },
10399 		.fill_helper = bpf_fill_ld_abs_get_processor_id,
10400 	},
10401 	/*
10402 	 * LD_IND / LD_ABS on fragmented SKBs
10403 	 */
10404 	{
10405 		"LD_IND byte frag",
10406 		.u.insns = {
10407 			BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
10408 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x0),
10409 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10410 		},
10411 		CLASSIC | FLAG_SKB_FRAG,
10412 		{ },
10413 		{ {0x40, 0x42} },
10414 		.frag_data = {
10415 			0x42, 0x00, 0x00, 0x00,
10416 			0x43, 0x44, 0x00, 0x00,
10417 			0x21, 0x07, 0x19, 0x83,
10418 		},
10419 	},
10420 	{
10421 		"LD_IND halfword frag",
10422 		.u.insns = {
10423 			BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
10424 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x4),
10425 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10426 		},
10427 		CLASSIC | FLAG_SKB_FRAG,
10428 		{ },
10429 		{ {0x40, 0x4344} },
10430 		.frag_data = {
10431 			0x42, 0x00, 0x00, 0x00,
10432 			0x43, 0x44, 0x00, 0x00,
10433 			0x21, 0x07, 0x19, 0x83,
10434 		},
10435 	},
10436 	{
10437 		"LD_IND word frag",
10438 		.u.insns = {
10439 			BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
10440 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x8),
10441 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10442 		},
10443 		CLASSIC | FLAG_SKB_FRAG,
10444 		{ },
10445 		{ {0x40, 0x21071983} },
10446 		.frag_data = {
10447 			0x42, 0x00, 0x00, 0x00,
10448 			0x43, 0x44, 0x00, 0x00,
10449 			0x21, 0x07, 0x19, 0x83,
10450 		},
10451 	},
10452 	{
10453 		"LD_IND halfword mixed head/frag",
10454 		.u.insns = {
10455 			BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
10456 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
10457 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10458 		},
10459 		CLASSIC | FLAG_SKB_FRAG,
10460 		{ [0x3e] = 0x25, [0x3f] = 0x05, },
10461 		{ {0x40, 0x0519} },
10462 		.frag_data = { 0x19, 0x82 },
10463 	},
10464 	{
10465 		"LD_IND word mixed head/frag",
10466 		.u.insns = {
10467 			BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
10468 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
10469 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10470 		},
10471 		CLASSIC | FLAG_SKB_FRAG,
10472 		{ [0x3e] = 0x25, [0x3f] = 0x05, },
10473 		{ {0x40, 0x25051982} },
10474 		.frag_data = { 0x19, 0x82 },
10475 	},
10476 	{
10477 		"LD_ABS byte frag",
10478 		.u.insns = {
10479 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x40),
10480 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10481 		},
10482 		CLASSIC | FLAG_SKB_FRAG,
10483 		{ },
10484 		{ {0x40, 0x42} },
10485 		.frag_data = {
10486 			0x42, 0x00, 0x00, 0x00,
10487 			0x43, 0x44, 0x00, 0x00,
10488 			0x21, 0x07, 0x19, 0x83,
10489 		},
10490 	},
10491 	{
10492 		"LD_ABS halfword frag",
10493 		.u.insns = {
10494 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x44),
10495 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10496 		},
10497 		CLASSIC | FLAG_SKB_FRAG,
10498 		{ },
10499 		{ {0x40, 0x4344} },
10500 		.frag_data = {
10501 			0x42, 0x00, 0x00, 0x00,
10502 			0x43, 0x44, 0x00, 0x00,
10503 			0x21, 0x07, 0x19, 0x83,
10504 		},
10505 	},
10506 	{
10507 		"LD_ABS word frag",
10508 		.u.insns = {
10509 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x48),
10510 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10511 		},
10512 		CLASSIC | FLAG_SKB_FRAG,
10513 		{ },
10514 		{ {0x40, 0x21071983} },
10515 		.frag_data = {
10516 			0x42, 0x00, 0x00, 0x00,
10517 			0x43, 0x44, 0x00, 0x00,
10518 			0x21, 0x07, 0x19, 0x83,
10519 		},
10520 	},
10521 	{
10522 		"LD_ABS halfword mixed head/frag",
10523 		.u.insns = {
10524 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f),
10525 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10526 		},
10527 		CLASSIC | FLAG_SKB_FRAG,
10528 		{ [0x3e] = 0x25, [0x3f] = 0x05, },
10529 		{ {0x40, 0x0519} },
10530 		.frag_data = { 0x19, 0x82 },
10531 	},
10532 	{
10533 		"LD_ABS word mixed head/frag",
10534 		.u.insns = {
10535 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3e),
10536 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10537 		},
10538 		CLASSIC | FLAG_SKB_FRAG,
10539 		{ [0x3e] = 0x25, [0x3f] = 0x05, },
10540 		{ {0x40, 0x25051982} },
10541 		.frag_data = { 0x19, 0x82 },
10542 	},
10543 	/*
10544 	 * LD_IND / LD_ABS on non fragmented SKBs
10545 	 */
10546 	{
10547 		/*
10548 		 * this tests that the JIT/interpreter correctly resets X
10549 		 * before using it in an LD_IND instruction.
10550 		 */
10551 		"LD_IND byte default X",
10552 		.u.insns = {
10553 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
10554 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10555 		},
10556 		CLASSIC,
10557 		{ [0x1] = 0x42 },
10558 		{ {0x40, 0x42 } },
10559 	},
10560 	{
10561 		"LD_IND byte positive offset",
10562 		.u.insns = {
10563 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10564 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
10565 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10566 		},
10567 		CLASSIC,
10568 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10569 		{ {0x40, 0x82 } },
10570 	},
10571 	{
10572 		"LD_IND byte negative offset",
10573 		.u.insns = {
10574 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10575 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x1),
10576 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10577 		},
10578 		CLASSIC,
10579 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10580 		{ {0x40, 0x05 } },
10581 	},
10582 	{
10583 		"LD_IND byte positive offset, all ff",
10584 		.u.insns = {
10585 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10586 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
10587 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10588 		},
10589 		CLASSIC,
10590 		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
10591 		{ {0x40, 0xff } },
10592 	},
10593 	{
10594 		"LD_IND byte positive offset, out of bounds",
10595 		.u.insns = {
10596 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10597 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
10598 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10599 		},
10600 		CLASSIC,
10601 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10602 		{ {0x3f, 0 }, },
10603 	},
10604 	{
10605 		"LD_IND byte negative offset, out of bounds",
10606 		.u.insns = {
10607 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10608 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x3f),
10609 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10610 		},
10611 		CLASSIC,
10612 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10613 		{ {0x3f, 0 } },
10614 	},
10615 	{
10616 		"LD_IND byte negative offset, multiple calls",
10617 		.u.insns = {
10618 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3b),
10619 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 1),
10620 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 2),
10621 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 3),
10622 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 4),
10623 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10624 		},
10625 		CLASSIC,
10626 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10627 		{ {0x40, 0x82 }, },
10628 	},
10629 	{
10630 		"LD_IND halfword positive offset",
10631 		.u.insns = {
10632 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
10633 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x2),
10634 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10635 		},
10636 		CLASSIC,
10637 		{
10638 			[0x1c] = 0xaa, [0x1d] = 0x55,
10639 			[0x1e] = 0xbb, [0x1f] = 0x66,
10640 			[0x20] = 0xcc, [0x21] = 0x77,
10641 			[0x22] = 0xdd, [0x23] = 0x88,
10642 		},
10643 		{ {0x40, 0xdd88 } },
10644 	},
10645 	{
10646 		"LD_IND halfword negative offset",
10647 		.u.insns = {
10648 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
10649 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x2),
10650 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10651 		},
10652 		CLASSIC,
10653 		{
10654 			[0x1c] = 0xaa, [0x1d] = 0x55,
10655 			[0x1e] = 0xbb, [0x1f] = 0x66,
10656 			[0x20] = 0xcc, [0x21] = 0x77,
10657 			[0x22] = 0xdd, [0x23] = 0x88,
10658 		},
10659 		{ {0x40, 0xbb66 } },
10660 	},
10661 	{
10662 		"LD_IND halfword unaligned",
10663 		.u.insns = {
10664 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
10665 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
10666 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10667 		},
10668 		CLASSIC,
10669 		{
10670 			[0x1c] = 0xaa, [0x1d] = 0x55,
10671 			[0x1e] = 0xbb, [0x1f] = 0x66,
10672 			[0x20] = 0xcc, [0x21] = 0x77,
10673 			[0x22] = 0xdd, [0x23] = 0x88,
10674 		},
10675 		{ {0x40, 0x66cc } },
10676 	},
10677 	{
10678 		"LD_IND halfword positive offset, all ff",
10679 		.u.insns = {
10680 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3d),
10681 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1),
10682 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10683 		},
10684 		CLASSIC,
10685 		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
10686 		{ {0x40, 0xffff } },
10687 	},
10688 	{
10689 		"LD_IND halfword positive offset, out of bounds",
10690 		.u.insns = {
10691 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10692 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1),
10693 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10694 		},
10695 		CLASSIC,
10696 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10697 		{ {0x3f, 0 }, },
10698 	},
10699 	{
10700 		"LD_IND halfword negative offset, out of bounds",
10701 		.u.insns = {
10702 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10703 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x3f),
10704 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10705 		},
10706 		CLASSIC,
10707 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10708 		{ {0x3f, 0 } },
10709 	},
10710 	{
10711 		"LD_IND word positive offset",
10712 		.u.insns = {
10713 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
10714 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x4),
10715 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10716 		},
10717 		CLASSIC,
10718 		{
10719 			[0x1c] = 0xaa, [0x1d] = 0x55,
10720 			[0x1e] = 0xbb, [0x1f] = 0x66,
10721 			[0x20] = 0xcc, [0x21] = 0x77,
10722 			[0x22] = 0xdd, [0x23] = 0x88,
10723 			[0x24] = 0xee, [0x25] = 0x99,
10724 			[0x26] = 0xff, [0x27] = 0xaa,
10725 		},
10726 		{ {0x40, 0xee99ffaa } },
10727 	},
10728 	{
10729 		"LD_IND word negative offset",
10730 		.u.insns = {
10731 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
10732 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x4),
10733 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10734 		},
10735 		CLASSIC,
10736 		{
10737 			[0x1c] = 0xaa, [0x1d] = 0x55,
10738 			[0x1e] = 0xbb, [0x1f] = 0x66,
10739 			[0x20] = 0xcc, [0x21] = 0x77,
10740 			[0x22] = 0xdd, [0x23] = 0x88,
10741 			[0x24] = 0xee, [0x25] = 0x99,
10742 			[0x26] = 0xff, [0x27] = 0xaa,
10743 		},
10744 		{ {0x40, 0xaa55bb66 } },
10745 	},
10746 	{
10747 		"LD_IND word unaligned (addr & 3 == 2)",
10748 		.u.insns = {
10749 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
10750 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
10751 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10752 		},
10753 		CLASSIC,
10754 		{
10755 			[0x1c] = 0xaa, [0x1d] = 0x55,
10756 			[0x1e] = 0xbb, [0x1f] = 0x66,
10757 			[0x20] = 0xcc, [0x21] = 0x77,
10758 			[0x22] = 0xdd, [0x23] = 0x88,
10759 			[0x24] = 0xee, [0x25] = 0x99,
10760 			[0x26] = 0xff, [0x27] = 0xaa,
10761 		},
10762 		{ {0x40, 0xbb66cc77 } },
10763 	},
10764 	{
10765 		"LD_IND word unaligned (addr & 3 == 1)",
10766 		.u.insns = {
10767 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
10768 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3),
10769 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10770 		},
10771 		CLASSIC,
10772 		{
10773 			[0x1c] = 0xaa, [0x1d] = 0x55,
10774 			[0x1e] = 0xbb, [0x1f] = 0x66,
10775 			[0x20] = 0xcc, [0x21] = 0x77,
10776 			[0x22] = 0xdd, [0x23] = 0x88,
10777 			[0x24] = 0xee, [0x25] = 0x99,
10778 			[0x26] = 0xff, [0x27] = 0xaa,
10779 		},
10780 		{ {0x40, 0x55bb66cc } },
10781 	},
10782 	{
10783 		"LD_IND word unaligned (addr & 3 == 3)",
10784 		.u.insns = {
10785 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
10786 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x1),
10787 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10788 		},
10789 		CLASSIC,
10790 		{
10791 			[0x1c] = 0xaa, [0x1d] = 0x55,
10792 			[0x1e] = 0xbb, [0x1f] = 0x66,
10793 			[0x20] = 0xcc, [0x21] = 0x77,
10794 			[0x22] = 0xdd, [0x23] = 0x88,
10795 			[0x24] = 0xee, [0x25] = 0x99,
10796 			[0x26] = 0xff, [0x27] = 0xaa,
10797 		},
10798 		{ {0x40, 0x66cc77dd } },
10799 	},
10800 	{
10801 		"LD_IND word positive offset, all ff",
10802 		.u.insns = {
10803 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3b),
10804 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1),
10805 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10806 		},
10807 		CLASSIC,
10808 		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
10809 		{ {0x40, 0xffffffff } },
10810 	},
10811 	{
10812 		"LD_IND word positive offset, out of bounds",
10813 		.u.insns = {
10814 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10815 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1),
10816 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10817 		},
10818 		CLASSIC,
10819 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10820 		{ {0x3f, 0 }, },
10821 	},
10822 	{
10823 		"LD_IND word negative offset, out of bounds",
10824 		.u.insns = {
10825 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10826 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3f),
10827 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10828 		},
10829 		CLASSIC,
10830 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10831 		{ {0x3f, 0 } },
10832 	},
10833 	{
10834 		"LD_ABS byte",
10835 		.u.insns = {
10836 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x20),
10837 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10838 		},
10839 		CLASSIC,
10840 		{
10841 			[0x1c] = 0xaa, [0x1d] = 0x55,
10842 			[0x1e] = 0xbb, [0x1f] = 0x66,
10843 			[0x20] = 0xcc, [0x21] = 0x77,
10844 			[0x22] = 0xdd, [0x23] = 0x88,
10845 			[0x24] = 0xee, [0x25] = 0x99,
10846 			[0x26] = 0xff, [0x27] = 0xaa,
10847 		},
10848 		{ {0x40, 0xcc } },
10849 	},
10850 	{
10851 		"LD_ABS byte positive offset, all ff",
10852 		.u.insns = {
10853 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f),
10854 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10855 		},
10856 		CLASSIC,
10857 		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
10858 		{ {0x40, 0xff } },
10859 	},
10860 	{
10861 		"LD_ABS byte positive offset, out of bounds",
10862 		.u.insns = {
10863 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f),
10864 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10865 		},
10866 		CLASSIC,
10867 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10868 		{ {0x3f, 0 }, },
10869 	},
10870 	{
10871 		"LD_ABS byte negative offset, out of bounds load",
10872 		.u.insns = {
10873 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, -1),
10874 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10875 		},
10876 		CLASSIC | FLAG_EXPECTED_FAIL,
10877 		.expected_errcode = -EINVAL,
10878 	},
10879 	{
10880 		"LD_ABS byte negative offset, in bounds",
10881 		.u.insns = {
10882 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
10883 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10884 		},
10885 		CLASSIC,
10886 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10887 		{ {0x40, 0x82 }, },
10888 	},
10889 	{
10890 		"LD_ABS byte negative offset, out of bounds",
10891 		.u.insns = {
10892 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
10893 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10894 		},
10895 		CLASSIC,
10896 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10897 		{ {0x3f, 0 }, },
10898 	},
10899 	{
10900 		"LD_ABS byte negative offset, multiple calls",
10901 		.u.insns = {
10902 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3c),
10903 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3d),
10904 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3e),
10905 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
10906 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10907 		},
10908 		CLASSIC,
10909 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10910 		{ {0x40, 0x82 }, },
10911 	},
10912 	{
10913 		"LD_ABS halfword",
10914 		.u.insns = {
10915 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x22),
10916 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10917 		},
10918 		CLASSIC,
10919 		{
10920 			[0x1c] = 0xaa, [0x1d] = 0x55,
10921 			[0x1e] = 0xbb, [0x1f] = 0x66,
10922 			[0x20] = 0xcc, [0x21] = 0x77,
10923 			[0x22] = 0xdd, [0x23] = 0x88,
10924 			[0x24] = 0xee, [0x25] = 0x99,
10925 			[0x26] = 0xff, [0x27] = 0xaa,
10926 		},
10927 		{ {0x40, 0xdd88 } },
10928 	},
10929 	{
10930 		"LD_ABS halfword unaligned",
10931 		.u.insns = {
10932 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x25),
10933 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10934 		},
10935 		CLASSIC,
10936 		{
10937 			[0x1c] = 0xaa, [0x1d] = 0x55,
10938 			[0x1e] = 0xbb, [0x1f] = 0x66,
10939 			[0x20] = 0xcc, [0x21] = 0x77,
10940 			[0x22] = 0xdd, [0x23] = 0x88,
10941 			[0x24] = 0xee, [0x25] = 0x99,
10942 			[0x26] = 0xff, [0x27] = 0xaa,
10943 		},
10944 		{ {0x40, 0x99ff } },
10945 	},
10946 	{
10947 		"LD_ABS halfword positive offset, all ff",
10948 		.u.insns = {
10949 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3e),
10950 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10951 		},
10952 		CLASSIC,
10953 		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
10954 		{ {0x40, 0xffff } },
10955 	},
10956 	{
10957 		"LD_ABS halfword positive offset, out of bounds",
10958 		.u.insns = {
10959 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f),
10960 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10961 		},
10962 		CLASSIC,
10963 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10964 		{ {0x3f, 0 }, },
10965 	},
10966 	{
10967 		"LD_ABS halfword negative offset, out of bounds load",
10968 		.u.insns = {
10969 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, -1),
10970 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10971 		},
10972 		CLASSIC | FLAG_EXPECTED_FAIL,
10973 		.expected_errcode = -EINVAL,
10974 	},
10975 	{
10976 		"LD_ABS halfword negative offset, in bounds",
10977 		.u.insns = {
10978 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e),
10979 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10980 		},
10981 		CLASSIC,
10982 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10983 		{ {0x40, 0x1982 }, },
10984 	},
10985 	{
10986 		"LD_ABS halfword negative offset, out of bounds",
10987 		.u.insns = {
10988 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e),
10989 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10990 		},
10991 		CLASSIC,
10992 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10993 		{ {0x3f, 0 }, },
10994 	},
10995 	{
10996 		"LD_ABS word",
10997 		.u.insns = {
10998 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x1c),
10999 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11000 		},
11001 		CLASSIC,
11002 		{
11003 			[0x1c] = 0xaa, [0x1d] = 0x55,
11004 			[0x1e] = 0xbb, [0x1f] = 0x66,
11005 			[0x20] = 0xcc, [0x21] = 0x77,
11006 			[0x22] = 0xdd, [0x23] = 0x88,
11007 			[0x24] = 0xee, [0x25] = 0x99,
11008 			[0x26] = 0xff, [0x27] = 0xaa,
11009 		},
11010 		{ {0x40, 0xaa55bb66 } },
11011 	},
11012 	{
11013 		"LD_ABS word unaligned (addr & 3 == 2)",
11014 		.u.insns = {
11015 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x22),
11016 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11017 		},
11018 		CLASSIC,
11019 		{
11020 			[0x1c] = 0xaa, [0x1d] = 0x55,
11021 			[0x1e] = 0xbb, [0x1f] = 0x66,
11022 			[0x20] = 0xcc, [0x21] = 0x77,
11023 			[0x22] = 0xdd, [0x23] = 0x88,
11024 			[0x24] = 0xee, [0x25] = 0x99,
11025 			[0x26] = 0xff, [0x27] = 0xaa,
11026 		},
11027 		{ {0x40, 0xdd88ee99 } },
11028 	},
11029 	{
11030 		"LD_ABS word unaligned (addr & 3 == 1)",
11031 		.u.insns = {
11032 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x21),
11033 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11034 		},
11035 		CLASSIC,
11036 		{
11037 			[0x1c] = 0xaa, [0x1d] = 0x55,
11038 			[0x1e] = 0xbb, [0x1f] = 0x66,
11039 			[0x20] = 0xcc, [0x21] = 0x77,
11040 			[0x22] = 0xdd, [0x23] = 0x88,
11041 			[0x24] = 0xee, [0x25] = 0x99,
11042 			[0x26] = 0xff, [0x27] = 0xaa,
11043 		},
11044 		{ {0x40, 0x77dd88ee } },
11045 	},
11046 	{
11047 		"LD_ABS word unaligned (addr & 3 == 3)",
11048 		.u.insns = {
11049 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x23),
11050 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11051 		},
11052 		CLASSIC,
11053 		{
11054 			[0x1c] = 0xaa, [0x1d] = 0x55,
11055 			[0x1e] = 0xbb, [0x1f] = 0x66,
11056 			[0x20] = 0xcc, [0x21] = 0x77,
11057 			[0x22] = 0xdd, [0x23] = 0x88,
11058 			[0x24] = 0xee, [0x25] = 0x99,
11059 			[0x26] = 0xff, [0x27] = 0xaa,
11060 		},
11061 		{ {0x40, 0x88ee99ff } },
11062 	},
11063 	{
11064 		"LD_ABS word positive offset, all ff",
11065 		.u.insns = {
11066 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3c),
11067 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11068 		},
11069 		CLASSIC,
11070 		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
11071 		{ {0x40, 0xffffffff } },
11072 	},
11073 	{
11074 		"LD_ABS word positive offset, out of bounds",
11075 		.u.insns = {
11076 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3f),
11077 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11078 		},
11079 		CLASSIC,
11080 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11081 		{ {0x3f, 0 }, },
11082 	},
11083 	{
11084 		"LD_ABS word negative offset, out of bounds load",
11085 		.u.insns = {
11086 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, -1),
11087 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11088 		},
11089 		CLASSIC | FLAG_EXPECTED_FAIL,
11090 		.expected_errcode = -EINVAL,
11091 	},
11092 	{
11093 		"LD_ABS word negative offset, in bounds",
11094 		.u.insns = {
11095 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c),
11096 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11097 		},
11098 		CLASSIC,
11099 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11100 		{ {0x40, 0x25051982 }, },
11101 	},
11102 	{
11103 		"LD_ABS word negative offset, out of bounds",
11104 		.u.insns = {
11105 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c),
11106 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11107 		},
11108 		CLASSIC,
11109 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11110 		{ {0x3f, 0 }, },
11111 	},
11112 	{
11113 		"LDX_MSH standalone, preserved A",
11114 		.u.insns = {
11115 			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
11116 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
11117 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11118 		},
11119 		CLASSIC,
11120 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11121 		{ {0x40, 0xffeebbaa }, },
11122 	},
11123 	{
11124 		"LDX_MSH standalone, preserved A 2",
11125 		.u.insns = {
11126 			BPF_STMT(BPF_LD | BPF_IMM, 0x175e9d63),
11127 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
11128 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3d),
11129 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e),
11130 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3f),
11131 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11132 		},
11133 		CLASSIC,
11134 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11135 		{ {0x40, 0x175e9d63 }, },
11136 	},
11137 	{
11138 		"LDX_MSH standalone, test result 1",
11139 		.u.insns = {
11140 			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
11141 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
11142 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
11143 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11144 		},
11145 		CLASSIC,
11146 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11147 		{ {0x40, 0x14 }, },
11148 	},
11149 	{
11150 		"LDX_MSH standalone, test result 2",
11151 		.u.insns = {
11152 			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
11153 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e),
11154 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
11155 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11156 		},
11157 		CLASSIC,
11158 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11159 		{ {0x40, 0x24 }, },
11160 	},
11161 	{
11162 		"LDX_MSH standalone, negative offset",
11163 		.u.insns = {
11164 			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
11165 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, -1),
11166 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
11167 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11168 		},
11169 		CLASSIC,
11170 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11171 		{ {0x40, 0 }, },
11172 	},
11173 	{
11174 		"LDX_MSH standalone, negative offset 2",
11175 		.u.insns = {
11176 			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
11177 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, SKF_LL_OFF + 0x3e),
11178 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
11179 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11180 		},
11181 		CLASSIC,
11182 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11183 		{ {0x40, 0x24 }, },
11184 	},
11185 	{
11186 		"LDX_MSH standalone, out of bounds",
11187 		.u.insns = {
11188 			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
11189 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x40),
11190 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
11191 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11192 		},
11193 		CLASSIC,
11194 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11195 		{ {0x40, 0 }, },
11196 	},
11197 	/*
11198 	 * verify that the interpreter or JIT correctly sets A and X
11199 	 * to 0.
11200 	 */
11201 	{
11202 		"ADD default X",
11203 		.u.insns = {
11204 			/*
11205 			 * A = 0x42
11206 			 * A = A + X
11207 			 * ret A
11208 			 */
11209 			BPF_STMT(BPF_LD | BPF_IMM, 0x42),
11210 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
11211 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11212 		},
11213 		CLASSIC | FLAG_NO_DATA,
11214 		{},
11215 		{ {0x1, 0x42 } },
11216 	},
11217 	{
11218 		"ADD default A",
11219 		.u.insns = {
11220 			/*
11221 			 * A = A + 0x42
11222 			 * ret A
11223 			 */
11224 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0x42),
11225 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11226 		},
11227 		CLASSIC | FLAG_NO_DATA,
11228 		{},
11229 		{ {0x1, 0x42 } },
11230 	},
11231 	{
11232 		"SUB default X",
11233 		.u.insns = {
11234 			/*
11235 			 * A = 0x66
11236 			 * A = A - X
11237 			 * ret A
11238 			 */
11239 			BPF_STMT(BPF_LD | BPF_IMM, 0x66),
11240 			BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
11241 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11242 		},
11243 		CLASSIC | FLAG_NO_DATA,
11244 		{},
11245 		{ {0x1, 0x66 } },
11246 	},
11247 	{
11248 		"SUB default A",
11249 		.u.insns = {
11250 			/*
11251 			 * A = A - -0x66
11252 			 * ret A
11253 			 */
11254 			BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, -0x66),
11255 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11256 		},
11257 		CLASSIC | FLAG_NO_DATA,
11258 		{},
11259 		{ {0x1, 0x66 } },
11260 	},
11261 	{
11262 		"MUL default X",
11263 		.u.insns = {
11264 			/*
11265 			 * A = 0x42
11266 			 * A = A * X
11267 			 * ret A
11268 			 */
11269 			BPF_STMT(BPF_LD | BPF_IMM, 0x42),
11270 			BPF_STMT(BPF_ALU | BPF_MUL | BPF_X, 0),
11271 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11272 		},
11273 		CLASSIC | FLAG_NO_DATA,
11274 		{},
11275 		{ {0x1, 0x0 } },
11276 	},
11277 	{
11278 		"MUL default A",
11279 		.u.insns = {
11280 			/*
11281 			 * A = A * 0x66
11282 			 * ret A
11283 			 */
11284 			BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 0x66),
11285 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11286 		},
11287 		CLASSIC | FLAG_NO_DATA,
11288 		{},
11289 		{ {0x1, 0x0 } },
11290 	},
11291 	{
11292 		"DIV default X",
11293 		.u.insns = {
11294 			/*
11295 			 * A = 0x42
11296 			 * A = A / X ; this halt the filter execution if X is 0
11297 			 * ret 0x42
11298 			 */
11299 			BPF_STMT(BPF_LD | BPF_IMM, 0x42),
11300 			BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
11301 			BPF_STMT(BPF_RET | BPF_K, 0x42),
11302 		},
11303 		CLASSIC | FLAG_NO_DATA,
11304 		{},
11305 		{ {0x1, 0x0 } },
11306 	},
11307 	{
11308 		"DIV default A",
11309 		.u.insns = {
11310 			/*
11311 			 * A = A / 1
11312 			 * ret A
11313 			 */
11314 			BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x1),
11315 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11316 		},
11317 		CLASSIC | FLAG_NO_DATA,
11318 		{},
11319 		{ {0x1, 0x0 } },
11320 	},
11321 	{
11322 		"MOD default X",
11323 		.u.insns = {
11324 			/*
11325 			 * A = 0x42
11326 			 * A = A mod X ; this halt the filter execution if X is 0
11327 			 * ret 0x42
11328 			 */
11329 			BPF_STMT(BPF_LD | BPF_IMM, 0x42),
11330 			BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
11331 			BPF_STMT(BPF_RET | BPF_K, 0x42),
11332 		},
11333 		CLASSIC | FLAG_NO_DATA,
11334 		{},
11335 		{ {0x1, 0x0 } },
11336 	},
11337 	{
11338 		"MOD default A",
11339 		.u.insns = {
11340 			/*
11341 			 * A = A mod 1
11342 			 * ret A
11343 			 */
11344 			BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x1),
11345 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11346 		},
11347 		CLASSIC | FLAG_NO_DATA,
11348 		{},
11349 		{ {0x1, 0x0 } },
11350 	},
11351 	{
11352 		"JMP EQ default A",
11353 		.u.insns = {
11354 			/*
11355 			 * cmp A, 0x0, 0, 1
11356 			 * ret 0x42
11357 			 * ret 0x66
11358 			 */
11359 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0, 0, 1),
11360 			BPF_STMT(BPF_RET | BPF_K, 0x42),
11361 			BPF_STMT(BPF_RET | BPF_K, 0x66),
11362 		},
11363 		CLASSIC | FLAG_NO_DATA,
11364 		{},
11365 		{ {0x1, 0x42 } },
11366 	},
11367 	{
11368 		"JMP EQ default X",
11369 		.u.insns = {
11370 			/*
11371 			 * A = 0x0
11372 			 * cmp A, X, 0, 1
11373 			 * ret 0x42
11374 			 * ret 0x66
11375 			 */
11376 			BPF_STMT(BPF_LD | BPF_IMM, 0x0),
11377 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0x0, 0, 1),
11378 			BPF_STMT(BPF_RET | BPF_K, 0x42),
11379 			BPF_STMT(BPF_RET | BPF_K, 0x66),
11380 		},
11381 		CLASSIC | FLAG_NO_DATA,
11382 		{},
11383 		{ {0x1, 0x42 } },
11384 	},
11385 	/* Checking interpreter vs JIT wrt signed extended imms. */
11386 	{
11387 		"JNE signed compare, test 1",
11388 		.u.insns_int = {
11389 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
11390 			BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
11391 			BPF_MOV64_REG(R2, R1),
11392 			BPF_ALU64_REG(BPF_AND, R2, R3),
11393 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
11394 			BPF_JMP_IMM(BPF_JNE, R2, -17104896, 1),
11395 			BPF_ALU32_IMM(BPF_MOV, R0, 2),
11396 			BPF_EXIT_INSN(),
11397 		},
11398 		INTERNAL,
11399 		{ },
11400 		{ { 0, 1 } },
11401 	},
11402 	{
11403 		"JNE signed compare, test 2",
11404 		.u.insns_int = {
11405 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
11406 			BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
11407 			BPF_MOV64_REG(R2, R1),
11408 			BPF_ALU64_REG(BPF_AND, R2, R3),
11409 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
11410 			BPF_JMP_IMM(BPF_JNE, R2, 0xfefb0000, 1),
11411 			BPF_ALU32_IMM(BPF_MOV, R0, 2),
11412 			BPF_EXIT_INSN(),
11413 		},
11414 		INTERNAL,
11415 		{ },
11416 		{ { 0, 1 } },
11417 	},
11418 	{
11419 		"JNE signed compare, test 3",
11420 		.u.insns_int = {
11421 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
11422 			BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
11423 			BPF_ALU32_IMM(BPF_MOV, R4, 0xfefb0000),
11424 			BPF_MOV64_REG(R2, R1),
11425 			BPF_ALU64_REG(BPF_AND, R2, R3),
11426 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
11427 			BPF_JMP_REG(BPF_JNE, R2, R4, 1),
11428 			BPF_ALU32_IMM(BPF_MOV, R0, 2),
11429 			BPF_EXIT_INSN(),
11430 		},
11431 		INTERNAL,
11432 		{ },
11433 		{ { 0, 2 } },
11434 	},
11435 	{
11436 		"JNE signed compare, test 4",
11437 		.u.insns_int = {
11438 			BPF_LD_IMM64(R1, -17104896),
11439 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
11440 			BPF_JMP_IMM(BPF_JNE, R1, -17104896, 1),
11441 			BPF_ALU32_IMM(BPF_MOV, R0, 2),
11442 			BPF_EXIT_INSN(),
11443 		},
11444 		INTERNAL,
11445 		{ },
11446 		{ { 0, 2 } },
11447 	},
11448 	{
11449 		"JNE signed compare, test 5",
11450 		.u.insns_int = {
11451 			BPF_LD_IMM64(R1, 0xfefb0000),
11452 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
11453 			BPF_JMP_IMM(BPF_JNE, R1, 0xfefb0000, 1),
11454 			BPF_ALU32_IMM(BPF_MOV, R0, 2),
11455 			BPF_EXIT_INSN(),
11456 		},
11457 		INTERNAL,
11458 		{ },
11459 		{ { 0, 1 } },
11460 	},
11461 	{
11462 		"JNE signed compare, test 6",
11463 		.u.insns_int = {
11464 			BPF_LD_IMM64(R1, 0x7efb0000),
11465 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
11466 			BPF_JMP_IMM(BPF_JNE, R1, 0x7efb0000, 1),
11467 			BPF_ALU32_IMM(BPF_MOV, R0, 2),
11468 			BPF_EXIT_INSN(),
11469 		},
11470 		INTERNAL,
11471 		{ },
11472 		{ { 0, 2 } },
11473 	},
11474 	{
11475 		"JNE signed compare, test 7",
11476 		.u.insns = {
11477 			BPF_STMT(BPF_LD | BPF_IMM, 0xffff0000),
11478 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
11479 			BPF_STMT(BPF_LD | BPF_IMM, 0xfefbbc12),
11480 			BPF_STMT(BPF_ALU | BPF_AND | BPF_X, 0),
11481 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0xfefb0000, 1, 0),
11482 			BPF_STMT(BPF_RET | BPF_K, 1),
11483 			BPF_STMT(BPF_RET | BPF_K, 2),
11484 		},
11485 		CLASSIC | FLAG_NO_DATA,
11486 		{},
11487 		{ { 0, 2 } },
11488 	},
11489 	/* BPF_LDX_MEM with operand aliasing */
11490 	{
11491 		"LDX_MEM_B: operand register aliasing",
11492 		.u.insns_int = {
11493 			BPF_ST_MEM(BPF_B, R10, -8, 123),
11494 			BPF_MOV64_REG(R0, R10),
11495 			BPF_LDX_MEM(BPF_B, R0, R0, -8),
11496 			BPF_EXIT_INSN(),
11497 		},
11498 		INTERNAL,
11499 		{ },
11500 		{ { 0, 123 } },
11501 		.stack_depth = 8,
11502 	},
11503 	{
11504 		"LDX_MEM_H: operand register aliasing",
11505 		.u.insns_int = {
11506 			BPF_ST_MEM(BPF_H, R10, -8, 12345),
11507 			BPF_MOV64_REG(R0, R10),
11508 			BPF_LDX_MEM(BPF_H, R0, R0, -8),
11509 			BPF_EXIT_INSN(),
11510 		},
11511 		INTERNAL,
11512 		{ },
11513 		{ { 0, 12345 } },
11514 		.stack_depth = 8,
11515 	},
11516 	{
11517 		"LDX_MEM_W: operand register aliasing",
11518 		.u.insns_int = {
11519 			BPF_ST_MEM(BPF_W, R10, -8, 123456789),
11520 			BPF_MOV64_REG(R0, R10),
11521 			BPF_LDX_MEM(BPF_W, R0, R0, -8),
11522 			BPF_EXIT_INSN(),
11523 		},
11524 		INTERNAL,
11525 		{ },
11526 		{ { 0, 123456789 } },
11527 		.stack_depth = 8,
11528 	},
11529 	{
11530 		"LDX_MEM_DW: operand register aliasing",
11531 		.u.insns_int = {
11532 			BPF_LD_IMM64(R1, 0x123456789abcdefULL),
11533 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
11534 			BPF_MOV64_REG(R0, R10),
11535 			BPF_LDX_MEM(BPF_DW, R0, R0, -8),
11536 			BPF_ALU64_REG(BPF_SUB, R0, R1),
11537 			BPF_MOV64_REG(R1, R0),
11538 			BPF_ALU64_IMM(BPF_RSH, R1, 32),
11539 			BPF_ALU64_REG(BPF_OR, R0, R1),
11540 			BPF_EXIT_INSN(),
11541 		},
11542 		INTERNAL,
11543 		{ },
11544 		{ { 0, 0 } },
11545 		.stack_depth = 8,
11546 	},
11547 	/*
11548 	 * Register (non-)clobbering tests for the case where a JIT implements
11549 	 * complex ALU or ATOMIC operations via function calls. If so, the
11550 	 * function call must be transparent to the eBPF registers. The JIT
11551 	 * must therefore save and restore relevant registers across the call.
11552 	 * The following tests check that the eBPF registers retain their
11553 	 * values after such an operation. Mainly intended for complex ALU
11554 	 * and atomic operation, but we run it for all. You never know...
11555 	 *
11556 	 * Note that each operations should be tested twice with different
11557 	 * destinations, to check preservation for all registers.
11558 	 */
11559 #define BPF_TEST_CLOBBER_ALU(alu, op, dst, src)			\
11560 	{							\
11561 		#alu "_" #op " to " #dst ": no clobbering",	\
11562 		.u.insns_int = {				\
11563 			BPF_ALU64_IMM(BPF_MOV, R0, R0),		\
11564 			BPF_ALU64_IMM(BPF_MOV, R1, R1),		\
11565 			BPF_ALU64_IMM(BPF_MOV, R2, R2),		\
11566 			BPF_ALU64_IMM(BPF_MOV, R3, R3),		\
11567 			BPF_ALU64_IMM(BPF_MOV, R4, R4),		\
11568 			BPF_ALU64_IMM(BPF_MOV, R5, R5),		\
11569 			BPF_ALU64_IMM(BPF_MOV, R6, R6),		\
11570 			BPF_ALU64_IMM(BPF_MOV, R7, R7),		\
11571 			BPF_ALU64_IMM(BPF_MOV, R8, R8),		\
11572 			BPF_ALU64_IMM(BPF_MOV, R9, R9),		\
11573 			BPF_##alu(BPF_ ##op, dst, src),		\
11574 			BPF_ALU32_IMM(BPF_MOV, dst, dst),	\
11575 			BPF_JMP_IMM(BPF_JNE, R0, R0, 10),	\
11576 			BPF_JMP_IMM(BPF_JNE, R1, R1, 9),	\
11577 			BPF_JMP_IMM(BPF_JNE, R2, R2, 8),	\
11578 			BPF_JMP_IMM(BPF_JNE, R3, R3, 7),	\
11579 			BPF_JMP_IMM(BPF_JNE, R4, R4, 6),	\
11580 			BPF_JMP_IMM(BPF_JNE, R5, R5, 5),	\
11581 			BPF_JMP_IMM(BPF_JNE, R6, R6, 4),	\
11582 			BPF_JMP_IMM(BPF_JNE, R7, R7, 3),	\
11583 			BPF_JMP_IMM(BPF_JNE, R8, R8, 2),	\
11584 			BPF_JMP_IMM(BPF_JNE, R9, R9, 1),	\
11585 			BPF_ALU64_IMM(BPF_MOV, R0, 1),		\
11586 			BPF_EXIT_INSN(),			\
11587 		},						\
11588 		INTERNAL,					\
11589 		{ },						\
11590 		{ { 0, 1 } }					\
11591 	}
11592 	/* ALU64 operations, register clobbering */
11593 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, AND, R8, 123456789),
11594 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, AND, R9, 123456789),
11595 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, OR, R8, 123456789),
11596 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, OR, R9, 123456789),
11597 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, XOR, R8, 123456789),
11598 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, XOR, R9, 123456789),
11599 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, LSH, R8, 12),
11600 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, LSH, R9, 12),
11601 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, RSH, R8, 12),
11602 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, RSH, R9, 12),
11603 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, ARSH, R8, 12),
11604 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, ARSH, R9, 12),
11605 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, ADD, R8, 123456789),
11606 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, ADD, R9, 123456789),
11607 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, SUB, R8, 123456789),
11608 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, SUB, R9, 123456789),
11609 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, MUL, R8, 123456789),
11610 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, MUL, R9, 123456789),
11611 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, DIV, R8, 123456789),
11612 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, DIV, R9, 123456789),
11613 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, MOD, R8, 123456789),
11614 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, MOD, R9, 123456789),
11615 	/* ALU32 immediate operations, register clobbering */
11616 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, AND, R8, 123456789),
11617 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, AND, R9, 123456789),
11618 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, OR, R8, 123456789),
11619 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, OR, R9, 123456789),
11620 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, XOR, R8, 123456789),
11621 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, XOR, R9, 123456789),
11622 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, LSH, R8, 12),
11623 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, LSH, R9, 12),
11624 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, RSH, R8, 12),
11625 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, RSH, R9, 12),
11626 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, ARSH, R8, 12),
11627 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, ARSH, R9, 12),
11628 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, ADD, R8, 123456789),
11629 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, ADD, R9, 123456789),
11630 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, SUB, R8, 123456789),
11631 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, SUB, R9, 123456789),
11632 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, MUL, R8, 123456789),
11633 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, MUL, R9, 123456789),
11634 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, DIV, R8, 123456789),
11635 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, DIV, R9, 123456789),
11636 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, MOD, R8, 123456789),
11637 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, MOD, R9, 123456789),
11638 	/* ALU64 register operations, register clobbering */
11639 	BPF_TEST_CLOBBER_ALU(ALU64_REG, AND, R8, R1),
11640 	BPF_TEST_CLOBBER_ALU(ALU64_REG, AND, R9, R1),
11641 	BPF_TEST_CLOBBER_ALU(ALU64_REG, OR, R8, R1),
11642 	BPF_TEST_CLOBBER_ALU(ALU64_REG, OR, R9, R1),
11643 	BPF_TEST_CLOBBER_ALU(ALU64_REG, XOR, R8, R1),
11644 	BPF_TEST_CLOBBER_ALU(ALU64_REG, XOR, R9, R1),
11645 	BPF_TEST_CLOBBER_ALU(ALU64_REG, LSH, R8, R1),
11646 	BPF_TEST_CLOBBER_ALU(ALU64_REG, LSH, R9, R1),
11647 	BPF_TEST_CLOBBER_ALU(ALU64_REG, RSH, R8, R1),
11648 	BPF_TEST_CLOBBER_ALU(ALU64_REG, RSH, R9, R1),
11649 	BPF_TEST_CLOBBER_ALU(ALU64_REG, ARSH, R8, R1),
11650 	BPF_TEST_CLOBBER_ALU(ALU64_REG, ARSH, R9, R1),
11651 	BPF_TEST_CLOBBER_ALU(ALU64_REG, ADD, R8, R1),
11652 	BPF_TEST_CLOBBER_ALU(ALU64_REG, ADD, R9, R1),
11653 	BPF_TEST_CLOBBER_ALU(ALU64_REG, SUB, R8, R1),
11654 	BPF_TEST_CLOBBER_ALU(ALU64_REG, SUB, R9, R1),
11655 	BPF_TEST_CLOBBER_ALU(ALU64_REG, MUL, R8, R1),
11656 	BPF_TEST_CLOBBER_ALU(ALU64_REG, MUL, R9, R1),
11657 	BPF_TEST_CLOBBER_ALU(ALU64_REG, DIV, R8, R1),
11658 	BPF_TEST_CLOBBER_ALU(ALU64_REG, DIV, R9, R1),
11659 	BPF_TEST_CLOBBER_ALU(ALU64_REG, MOD, R8, R1),
11660 	BPF_TEST_CLOBBER_ALU(ALU64_REG, MOD, R9, R1),
11661 	/* ALU32 register operations, register clobbering */
11662 	BPF_TEST_CLOBBER_ALU(ALU32_REG, AND, R8, R1),
11663 	BPF_TEST_CLOBBER_ALU(ALU32_REG, AND, R9, R1),
11664 	BPF_TEST_CLOBBER_ALU(ALU32_REG, OR, R8, R1),
11665 	BPF_TEST_CLOBBER_ALU(ALU32_REG, OR, R9, R1),
11666 	BPF_TEST_CLOBBER_ALU(ALU32_REG, XOR, R8, R1),
11667 	BPF_TEST_CLOBBER_ALU(ALU32_REG, XOR, R9, R1),
11668 	BPF_TEST_CLOBBER_ALU(ALU32_REG, LSH, R8, R1),
11669 	BPF_TEST_CLOBBER_ALU(ALU32_REG, LSH, R9, R1),
11670 	BPF_TEST_CLOBBER_ALU(ALU32_REG, RSH, R8, R1),
11671 	BPF_TEST_CLOBBER_ALU(ALU32_REG, RSH, R9, R1),
11672 	BPF_TEST_CLOBBER_ALU(ALU32_REG, ARSH, R8, R1),
11673 	BPF_TEST_CLOBBER_ALU(ALU32_REG, ARSH, R9, R1),
11674 	BPF_TEST_CLOBBER_ALU(ALU32_REG, ADD, R8, R1),
11675 	BPF_TEST_CLOBBER_ALU(ALU32_REG, ADD, R9, R1),
11676 	BPF_TEST_CLOBBER_ALU(ALU32_REG, SUB, R8, R1),
11677 	BPF_TEST_CLOBBER_ALU(ALU32_REG, SUB, R9, R1),
11678 	BPF_TEST_CLOBBER_ALU(ALU32_REG, MUL, R8, R1),
11679 	BPF_TEST_CLOBBER_ALU(ALU32_REG, MUL, R9, R1),
11680 	BPF_TEST_CLOBBER_ALU(ALU32_REG, DIV, R8, R1),
11681 	BPF_TEST_CLOBBER_ALU(ALU32_REG, DIV, R9, R1),
11682 	BPF_TEST_CLOBBER_ALU(ALU32_REG, MOD, R8, R1),
11683 	BPF_TEST_CLOBBER_ALU(ALU32_REG, MOD, R9, R1),
11684 #undef BPF_TEST_CLOBBER_ALU
11685 #define BPF_TEST_CLOBBER_ATOMIC(width, op)			\
11686 	{							\
11687 		"Atomic_" #width " " #op ": no clobbering",	\
11688 		.u.insns_int = {				\
11689 			BPF_ALU64_IMM(BPF_MOV, R0, 0),		\
11690 			BPF_ALU64_IMM(BPF_MOV, R1, 1),		\
11691 			BPF_ALU64_IMM(BPF_MOV, R2, 2),		\
11692 			BPF_ALU64_IMM(BPF_MOV, R3, 3),		\
11693 			BPF_ALU64_IMM(BPF_MOV, R4, 4),		\
11694 			BPF_ALU64_IMM(BPF_MOV, R5, 5),		\
11695 			BPF_ALU64_IMM(BPF_MOV, R6, 6),		\
11696 			BPF_ALU64_IMM(BPF_MOV, R7, 7),		\
11697 			BPF_ALU64_IMM(BPF_MOV, R8, 8),		\
11698 			BPF_ALU64_IMM(BPF_MOV, R9, 9),		\
11699 			BPF_ST_MEM(width, R10, -8,		\
11700 				   (op) == BPF_CMPXCHG ? 0 :	\
11701 				   (op) & BPF_FETCH ? 1 : 0),	\
11702 			BPF_ATOMIC_OP(width, op, R10, R1, -8),	\
11703 			BPF_JMP_IMM(BPF_JNE, R0, 0, 10),	\
11704 			BPF_JMP_IMM(BPF_JNE, R1, 1, 9),		\
11705 			BPF_JMP_IMM(BPF_JNE, R2, 2, 8),		\
11706 			BPF_JMP_IMM(BPF_JNE, R3, 3, 7),		\
11707 			BPF_JMP_IMM(BPF_JNE, R4, 4, 6),		\
11708 			BPF_JMP_IMM(BPF_JNE, R5, 5, 5),		\
11709 			BPF_JMP_IMM(BPF_JNE, R6, 6, 4),		\
11710 			BPF_JMP_IMM(BPF_JNE, R7, 7, 3),		\
11711 			BPF_JMP_IMM(BPF_JNE, R8, 8, 2),		\
11712 			BPF_JMP_IMM(BPF_JNE, R9, 9, 1),		\
11713 			BPF_ALU64_IMM(BPF_MOV, R0, 1),		\
11714 			BPF_EXIT_INSN(),			\
11715 		},						\
11716 		INTERNAL,					\
11717 		{ },						\
11718 		{ { 0, 1 } },					\
11719 		.stack_depth = 8,				\
11720 	}
11721 	/* 64-bit atomic operations, register clobbering */
11722 	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_ADD),
11723 	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_AND),
11724 	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_OR),
11725 	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_XOR),
11726 	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_ADD | BPF_FETCH),
11727 	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_AND | BPF_FETCH),
11728 	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_OR | BPF_FETCH),
11729 	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_XOR | BPF_FETCH),
11730 	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_XCHG),
11731 	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_CMPXCHG),
11732 	/* 32-bit atomic operations, register clobbering */
11733 	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_ADD),
11734 	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_AND),
11735 	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_OR),
11736 	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_XOR),
11737 	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_ADD | BPF_FETCH),
11738 	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_AND | BPF_FETCH),
11739 	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_OR | BPF_FETCH),
11740 	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_XOR | BPF_FETCH),
11741 	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_XCHG),
11742 	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_CMPXCHG),
11743 #undef BPF_TEST_CLOBBER_ATOMIC
11744 	/* Checking that ALU32 src is not zero extended in place */
11745 #define BPF_ALU32_SRC_ZEXT(op)					\
11746 	{							\
11747 		"ALU32_" #op "_X: src preserved in zext",	\
11748 		.u.insns_int = {				\
11749 			BPF_LD_IMM64(R1, 0x0123456789acbdefULL),\
11750 			BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),\
11751 			BPF_ALU64_REG(BPF_MOV, R0, R1),		\
11752 			BPF_ALU32_REG(BPF_##op, R2, R1),	\
11753 			BPF_ALU64_REG(BPF_SUB, R0, R1),		\
11754 			BPF_ALU64_REG(BPF_MOV, R1, R0),		\
11755 			BPF_ALU64_IMM(BPF_RSH, R1, 32),		\
11756 			BPF_ALU64_REG(BPF_OR, R0, R1),		\
11757 			BPF_EXIT_INSN(),			\
11758 		},						\
11759 		INTERNAL,					\
11760 		{ },						\
11761 		{ { 0, 0 } },					\
11762 	}
11763 	BPF_ALU32_SRC_ZEXT(MOV),
11764 	BPF_ALU32_SRC_ZEXT(AND),
11765 	BPF_ALU32_SRC_ZEXT(OR),
11766 	BPF_ALU32_SRC_ZEXT(XOR),
11767 	BPF_ALU32_SRC_ZEXT(ADD),
11768 	BPF_ALU32_SRC_ZEXT(SUB),
11769 	BPF_ALU32_SRC_ZEXT(MUL),
11770 	BPF_ALU32_SRC_ZEXT(DIV),
11771 	BPF_ALU32_SRC_ZEXT(MOD),
11772 #undef BPF_ALU32_SRC_ZEXT
11773 	/* Checking that ATOMIC32 src is not zero extended in place */
11774 #define BPF_ATOMIC32_SRC_ZEXT(op)					\
11775 	{								\
11776 		"ATOMIC_W_" #op ": src preserved in zext",		\
11777 		.u.insns_int = {					\
11778 			BPF_LD_IMM64(R0, 0x0123456789acbdefULL),	\
11779 			BPF_ALU64_REG(BPF_MOV, R1, R0),			\
11780 			BPF_ST_MEM(BPF_W, R10, -4, 0),			\
11781 			BPF_ATOMIC_OP(BPF_W, BPF_##op, R10, R1, -4),	\
11782 			BPF_ALU64_REG(BPF_SUB, R0, R1),			\
11783 			BPF_ALU64_REG(BPF_MOV, R1, R0),			\
11784 			BPF_ALU64_IMM(BPF_RSH, R1, 32),			\
11785 			BPF_ALU64_REG(BPF_OR, R0, R1),			\
11786 			BPF_EXIT_INSN(),				\
11787 		},							\
11788 		INTERNAL,						\
11789 		{ },							\
11790 		{ { 0, 0 } },						\
11791 		.stack_depth = 8,					\
11792 	}
11793 	BPF_ATOMIC32_SRC_ZEXT(ADD),
11794 	BPF_ATOMIC32_SRC_ZEXT(AND),
11795 	BPF_ATOMIC32_SRC_ZEXT(OR),
11796 	BPF_ATOMIC32_SRC_ZEXT(XOR),
11797 #undef BPF_ATOMIC32_SRC_ZEXT
11798 	/* Checking that CMPXCHG32 src is not zero extended in place */
11799 	{
11800 		"ATOMIC_W_CMPXCHG: src preserved in zext",
11801 		.u.insns_int = {
11802 			BPF_LD_IMM64(R1, 0x0123456789acbdefULL),
11803 			BPF_ALU64_REG(BPF_MOV, R2, R1),
11804 			BPF_ALU64_REG(BPF_MOV, R0, 0),
11805 			BPF_ST_MEM(BPF_W, R10, -4, 0),
11806 			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R1, -4),
11807 			BPF_ALU64_REG(BPF_SUB, R1, R2),
11808 			BPF_ALU64_REG(BPF_MOV, R2, R1),
11809 			BPF_ALU64_IMM(BPF_RSH, R2, 32),
11810 			BPF_ALU64_REG(BPF_OR, R1, R2),
11811 			BPF_ALU64_REG(BPF_MOV, R0, R1),
11812 			BPF_EXIT_INSN(),
11813 		},
11814 		INTERNAL,
11815 		{ },
11816 		{ { 0, 0 } },
11817 		.stack_depth = 8,
11818 	},
11819 	/* Checking that JMP32 immediate src is not zero extended in place */
11820 #define BPF_JMP32_IMM_ZEXT(op)					\
11821 	{							\
11822 		"JMP32_" #op "_K: operand preserved in zext",	\
11823 		.u.insns_int = {				\
11824 			BPF_LD_IMM64(R0, 0x0123456789acbdefULL),\
11825 			BPF_ALU64_REG(BPF_MOV, R1, R0),		\
11826 			BPF_JMP32_IMM(BPF_##op, R0, 1234, 1),	\
11827 			BPF_JMP_A(0), /* Nop */			\
11828 			BPF_ALU64_REG(BPF_SUB, R0, R1),		\
11829 			BPF_ALU64_REG(BPF_MOV, R1, R0),		\
11830 			BPF_ALU64_IMM(BPF_RSH, R1, 32),		\
11831 			BPF_ALU64_REG(BPF_OR, R0, R1),		\
11832 			BPF_EXIT_INSN(),			\
11833 		},						\
11834 		INTERNAL,					\
11835 		{ },						\
11836 		{ { 0, 0 } },					\
11837 	}
11838 	BPF_JMP32_IMM_ZEXT(JEQ),
11839 	BPF_JMP32_IMM_ZEXT(JNE),
11840 	BPF_JMP32_IMM_ZEXT(JSET),
11841 	BPF_JMP32_IMM_ZEXT(JGT),
11842 	BPF_JMP32_IMM_ZEXT(JGE),
11843 	BPF_JMP32_IMM_ZEXT(JLT),
11844 	BPF_JMP32_IMM_ZEXT(JLE),
11845 	BPF_JMP32_IMM_ZEXT(JSGT),
11846 	BPF_JMP32_IMM_ZEXT(JSGE),
11847 	BPF_JMP32_IMM_ZEXT(JSGT),
11848 	BPF_JMP32_IMM_ZEXT(JSLT),
11849 	BPF_JMP32_IMM_ZEXT(JSLE),
11850 #undef BPF_JMP2_IMM_ZEXT
11851 	/* Checking that JMP32 dst & src are not zero extended in place */
11852 #define BPF_JMP32_REG_ZEXT(op)					\
11853 	{							\
11854 		"JMP32_" #op "_X: operands preserved in zext",	\
11855 		.u.insns_int = {				\
11856 			BPF_LD_IMM64(R0, 0x0123456789acbdefULL),\
11857 			BPF_LD_IMM64(R1, 0xfedcba9876543210ULL),\
11858 			BPF_ALU64_REG(BPF_MOV, R2, R0),		\
11859 			BPF_ALU64_REG(BPF_MOV, R3, R1),		\
11860 			BPF_JMP32_IMM(BPF_##op, R0, R1, 1),	\
11861 			BPF_JMP_A(0), /* Nop */			\
11862 			BPF_ALU64_REG(BPF_SUB, R0, R2),		\
11863 			BPF_ALU64_REG(BPF_SUB, R1, R3),		\
11864 			BPF_ALU64_REG(BPF_OR, R0, R1),		\
11865 			BPF_ALU64_REG(BPF_MOV, R1, R0),		\
11866 			BPF_ALU64_IMM(BPF_RSH, R1, 32),		\
11867 			BPF_ALU64_REG(BPF_OR, R0, R1),		\
11868 			BPF_EXIT_INSN(),			\
11869 		},						\
11870 		INTERNAL,					\
11871 		{ },						\
11872 		{ { 0, 0 } },					\
11873 	}
11874 	BPF_JMP32_REG_ZEXT(JEQ),
11875 	BPF_JMP32_REG_ZEXT(JNE),
11876 	BPF_JMP32_REG_ZEXT(JSET),
11877 	BPF_JMP32_REG_ZEXT(JGT),
11878 	BPF_JMP32_REG_ZEXT(JGE),
11879 	BPF_JMP32_REG_ZEXT(JLT),
11880 	BPF_JMP32_REG_ZEXT(JLE),
11881 	BPF_JMP32_REG_ZEXT(JSGT),
11882 	BPF_JMP32_REG_ZEXT(JSGE),
11883 	BPF_JMP32_REG_ZEXT(JSGT),
11884 	BPF_JMP32_REG_ZEXT(JSLT),
11885 	BPF_JMP32_REG_ZEXT(JSLE),
11886 #undef BPF_JMP2_REG_ZEXT
11887 	/* ALU64 K register combinations */
11888 	{
11889 		"ALU64_MOV_K: registers",
11890 		{ },
11891 		INTERNAL,
11892 		{ },
11893 		{ { 0, 1 } },
11894 		.fill_helper = bpf_fill_alu64_mov_imm_regs,
11895 	},
11896 	{
11897 		"ALU64_AND_K: registers",
11898 		{ },
11899 		INTERNAL,
11900 		{ },
11901 		{ { 0, 1 } },
11902 		.fill_helper = bpf_fill_alu64_and_imm_regs,
11903 	},
11904 	{
11905 		"ALU64_OR_K: registers",
11906 		{ },
11907 		INTERNAL,
11908 		{ },
11909 		{ { 0, 1 } },
11910 		.fill_helper = bpf_fill_alu64_or_imm_regs,
11911 	},
11912 	{
11913 		"ALU64_XOR_K: registers",
11914 		{ },
11915 		INTERNAL,
11916 		{ },
11917 		{ { 0, 1 } },
11918 		.fill_helper = bpf_fill_alu64_xor_imm_regs,
11919 	},
11920 	{
11921 		"ALU64_LSH_K: registers",
11922 		{ },
11923 		INTERNAL,
11924 		{ },
11925 		{ { 0, 1 } },
11926 		.fill_helper = bpf_fill_alu64_lsh_imm_regs,
11927 	},
11928 	{
11929 		"ALU64_RSH_K: registers",
11930 		{ },
11931 		INTERNAL,
11932 		{ },
11933 		{ { 0, 1 } },
11934 		.fill_helper = bpf_fill_alu64_rsh_imm_regs,
11935 	},
11936 	{
11937 		"ALU64_ARSH_K: registers",
11938 		{ },
11939 		INTERNAL,
11940 		{ },
11941 		{ { 0, 1 } },
11942 		.fill_helper = bpf_fill_alu64_arsh_imm_regs,
11943 	},
11944 	{
11945 		"ALU64_ADD_K: registers",
11946 		{ },
11947 		INTERNAL,
11948 		{ },
11949 		{ { 0, 1 } },
11950 		.fill_helper = bpf_fill_alu64_add_imm_regs,
11951 	},
11952 	{
11953 		"ALU64_SUB_K: registers",
11954 		{ },
11955 		INTERNAL,
11956 		{ },
11957 		{ { 0, 1 } },
11958 		.fill_helper = bpf_fill_alu64_sub_imm_regs,
11959 	},
11960 	{
11961 		"ALU64_MUL_K: registers",
11962 		{ },
11963 		INTERNAL,
11964 		{ },
11965 		{ { 0, 1 } },
11966 		.fill_helper = bpf_fill_alu64_mul_imm_regs,
11967 	},
11968 	{
11969 		"ALU64_DIV_K: registers",
11970 		{ },
11971 		INTERNAL,
11972 		{ },
11973 		{ { 0, 1 } },
11974 		.fill_helper = bpf_fill_alu64_div_imm_regs,
11975 	},
11976 	{
11977 		"ALU64_MOD_K: registers",
11978 		{ },
11979 		INTERNAL,
11980 		{ },
11981 		{ { 0, 1 } },
11982 		.fill_helper = bpf_fill_alu64_mod_imm_regs,
11983 	},
11984 	/* ALU32 K registers */
11985 	{
11986 		"ALU32_MOV_K: registers",
11987 		{ },
11988 		INTERNAL,
11989 		{ },
11990 		{ { 0, 1 } },
11991 		.fill_helper = bpf_fill_alu32_mov_imm_regs,
11992 	},
11993 	{
11994 		"ALU32_AND_K: registers",
11995 		{ },
11996 		INTERNAL,
11997 		{ },
11998 		{ { 0, 1 } },
11999 		.fill_helper = bpf_fill_alu32_and_imm_regs,
12000 	},
12001 	{
12002 		"ALU32_OR_K: registers",
12003 		{ },
12004 		INTERNAL,
12005 		{ },
12006 		{ { 0, 1 } },
12007 		.fill_helper = bpf_fill_alu32_or_imm_regs,
12008 	},
12009 	{
12010 		"ALU32_XOR_K: registers",
12011 		{ },
12012 		INTERNAL,
12013 		{ },
12014 		{ { 0, 1 } },
12015 		.fill_helper = bpf_fill_alu32_xor_imm_regs,
12016 	},
12017 	{
12018 		"ALU32_LSH_K: registers",
12019 		{ },
12020 		INTERNAL,
12021 		{ },
12022 		{ { 0, 1 } },
12023 		.fill_helper = bpf_fill_alu32_lsh_imm_regs,
12024 	},
12025 	{
12026 		"ALU32_RSH_K: registers",
12027 		{ },
12028 		INTERNAL,
12029 		{ },
12030 		{ { 0, 1 } },
12031 		.fill_helper = bpf_fill_alu32_rsh_imm_regs,
12032 	},
12033 	{
12034 		"ALU32_ARSH_K: registers",
12035 		{ },
12036 		INTERNAL,
12037 		{ },
12038 		{ { 0, 1 } },
12039 		.fill_helper = bpf_fill_alu32_arsh_imm_regs,
12040 	},
12041 	{
12042 		"ALU32_ADD_K: registers",
12043 		{ },
12044 		INTERNAL,
12045 		{ },
12046 		{ { 0, 1 } },
12047 		.fill_helper = bpf_fill_alu32_add_imm_regs,
12048 	},
12049 	{
12050 		"ALU32_SUB_K: registers",
12051 		{ },
12052 		INTERNAL,
12053 		{ },
12054 		{ { 0, 1 } },
12055 		.fill_helper = bpf_fill_alu32_sub_imm_regs,
12056 	},
12057 	{
12058 		"ALU32_MUL_K: registers",
12059 		{ },
12060 		INTERNAL,
12061 		{ },
12062 		{ { 0, 1 } },
12063 		.fill_helper = bpf_fill_alu32_mul_imm_regs,
12064 	},
12065 	{
12066 		"ALU32_DIV_K: registers",
12067 		{ },
12068 		INTERNAL,
12069 		{ },
12070 		{ { 0, 1 } },
12071 		.fill_helper = bpf_fill_alu32_div_imm_regs,
12072 	},
12073 	{
12074 		"ALU32_MOD_K: registers",
12075 		{ },
12076 		INTERNAL,
12077 		{ },
12078 		{ { 0, 1 } },
12079 		.fill_helper = bpf_fill_alu32_mod_imm_regs,
12080 	},
12081 	/* ALU64 X register combinations */
12082 	{
12083 		"ALU64_MOV_X: register combinations",
12084 		{ },
12085 		INTERNAL,
12086 		{ },
12087 		{ { 0, 1 } },
12088 		.fill_helper = bpf_fill_alu64_mov_reg_pairs,
12089 	},
12090 	{
12091 		"ALU64_AND_X: register combinations",
12092 		{ },
12093 		INTERNAL,
12094 		{ },
12095 		{ { 0, 1 } },
12096 		.fill_helper = bpf_fill_alu64_and_reg_pairs,
12097 	},
12098 	{
12099 		"ALU64_OR_X: register combinations",
12100 		{ },
12101 		INTERNAL,
12102 		{ },
12103 		{ { 0, 1 } },
12104 		.fill_helper = bpf_fill_alu64_or_reg_pairs,
12105 	},
12106 	{
12107 		"ALU64_XOR_X: register combinations",
12108 		{ },
12109 		INTERNAL,
12110 		{ },
12111 		{ { 0, 1 } },
12112 		.fill_helper = bpf_fill_alu64_xor_reg_pairs,
12113 	},
12114 	{
12115 		"ALU64_LSH_X: register combinations",
12116 		{ },
12117 		INTERNAL,
12118 		{ },
12119 		{ { 0, 1 } },
12120 		.fill_helper = bpf_fill_alu64_lsh_reg_pairs,
12121 	},
12122 	{
12123 		"ALU64_RSH_X: register combinations",
12124 		{ },
12125 		INTERNAL,
12126 		{ },
12127 		{ { 0, 1 } },
12128 		.fill_helper = bpf_fill_alu64_rsh_reg_pairs,
12129 	},
12130 	{
12131 		"ALU64_ARSH_X: register combinations",
12132 		{ },
12133 		INTERNAL,
12134 		{ },
12135 		{ { 0, 1 } },
12136 		.fill_helper = bpf_fill_alu64_arsh_reg_pairs,
12137 	},
12138 	{
12139 		"ALU64_ADD_X: register combinations",
12140 		{ },
12141 		INTERNAL,
12142 		{ },
12143 		{ { 0, 1 } },
12144 		.fill_helper = bpf_fill_alu64_add_reg_pairs,
12145 	},
12146 	{
12147 		"ALU64_SUB_X: register combinations",
12148 		{ },
12149 		INTERNAL,
12150 		{ },
12151 		{ { 0, 1 } },
12152 		.fill_helper = bpf_fill_alu64_sub_reg_pairs,
12153 	},
12154 	{
12155 		"ALU64_MUL_X: register combinations",
12156 		{ },
12157 		INTERNAL,
12158 		{ },
12159 		{ { 0, 1 } },
12160 		.fill_helper = bpf_fill_alu64_mul_reg_pairs,
12161 	},
12162 	{
12163 		"ALU64_DIV_X: register combinations",
12164 		{ },
12165 		INTERNAL,
12166 		{ },
12167 		{ { 0, 1 } },
12168 		.fill_helper = bpf_fill_alu64_div_reg_pairs,
12169 	},
12170 	{
12171 		"ALU64_MOD_X: register combinations",
12172 		{ },
12173 		INTERNAL,
12174 		{ },
12175 		{ { 0, 1 } },
12176 		.fill_helper = bpf_fill_alu64_mod_reg_pairs,
12177 	},
12178 	/* ALU32 X register combinations */
12179 	{
12180 		"ALU32_MOV_X: register combinations",
12181 		{ },
12182 		INTERNAL,
12183 		{ },
12184 		{ { 0, 1 } },
12185 		.fill_helper = bpf_fill_alu32_mov_reg_pairs,
12186 	},
12187 	{
12188 		"ALU32_AND_X: register combinations",
12189 		{ },
12190 		INTERNAL,
12191 		{ },
12192 		{ { 0, 1 } },
12193 		.fill_helper = bpf_fill_alu32_and_reg_pairs,
12194 	},
12195 	{
12196 		"ALU32_OR_X: register combinations",
12197 		{ },
12198 		INTERNAL,
12199 		{ },
12200 		{ { 0, 1 } },
12201 		.fill_helper = bpf_fill_alu32_or_reg_pairs,
12202 	},
12203 	{
12204 		"ALU32_XOR_X: register combinations",
12205 		{ },
12206 		INTERNAL,
12207 		{ },
12208 		{ { 0, 1 } },
12209 		.fill_helper = bpf_fill_alu32_xor_reg_pairs,
12210 	},
12211 	{
12212 		"ALU32_LSH_X: register combinations",
12213 		{ },
12214 		INTERNAL,
12215 		{ },
12216 		{ { 0, 1 } },
12217 		.fill_helper = bpf_fill_alu32_lsh_reg_pairs,
12218 	},
12219 	{
12220 		"ALU32_RSH_X: register combinations",
12221 		{ },
12222 		INTERNAL,
12223 		{ },
12224 		{ { 0, 1 } },
12225 		.fill_helper = bpf_fill_alu32_rsh_reg_pairs,
12226 	},
12227 	{
12228 		"ALU32_ARSH_X: register combinations",
12229 		{ },
12230 		INTERNAL,
12231 		{ },
12232 		{ { 0, 1 } },
12233 		.fill_helper = bpf_fill_alu32_arsh_reg_pairs,
12234 	},
12235 	{
12236 		"ALU32_ADD_X: register combinations",
12237 		{ },
12238 		INTERNAL,
12239 		{ },
12240 		{ { 0, 1 } },
12241 		.fill_helper = bpf_fill_alu32_add_reg_pairs,
12242 	},
12243 	{
12244 		"ALU32_SUB_X: register combinations",
12245 		{ },
12246 		INTERNAL,
12247 		{ },
12248 		{ { 0, 1 } },
12249 		.fill_helper = bpf_fill_alu32_sub_reg_pairs,
12250 	},
12251 	{
12252 		"ALU32_MUL_X: register combinations",
12253 		{ },
12254 		INTERNAL,
12255 		{ },
12256 		{ { 0, 1 } },
12257 		.fill_helper = bpf_fill_alu32_mul_reg_pairs,
12258 	},
12259 	{
12260 		"ALU32_DIV_X: register combinations",
12261 		{ },
12262 		INTERNAL,
12263 		{ },
12264 		{ { 0, 1 } },
12265 		.fill_helper = bpf_fill_alu32_div_reg_pairs,
12266 	},
12267 	{
12268 		"ALU32_MOD_X register combinations",
12269 		{ },
12270 		INTERNAL,
12271 		{ },
12272 		{ { 0, 1 } },
12273 		.fill_helper = bpf_fill_alu32_mod_reg_pairs,
12274 	},
12275 	/* Exhaustive test of ALU64 shift operations */
12276 	{
12277 		"ALU64_LSH_K: all shift values",
12278 		{ },
12279 		INTERNAL | FLAG_NO_DATA,
12280 		{ },
12281 		{ { 0, 1 } },
12282 		.fill_helper = bpf_fill_alu64_lsh_imm,
12283 	},
12284 	{
12285 		"ALU64_RSH_K: all shift values",
12286 		{ },
12287 		INTERNAL | FLAG_NO_DATA,
12288 		{ },
12289 		{ { 0, 1 } },
12290 		.fill_helper = bpf_fill_alu64_rsh_imm,
12291 	},
12292 	{
12293 		"ALU64_ARSH_K: all shift values",
12294 		{ },
12295 		INTERNAL | FLAG_NO_DATA,
12296 		{ },
12297 		{ { 0, 1 } },
12298 		.fill_helper = bpf_fill_alu64_arsh_imm,
12299 	},
12300 	{
12301 		"ALU64_LSH_X: all shift values",
12302 		{ },
12303 		INTERNAL | FLAG_NO_DATA,
12304 		{ },
12305 		{ { 0, 1 } },
12306 		.fill_helper = bpf_fill_alu64_lsh_reg,
12307 	},
12308 	{
12309 		"ALU64_RSH_X: all shift values",
12310 		{ },
12311 		INTERNAL | FLAG_NO_DATA,
12312 		{ },
12313 		{ { 0, 1 } },
12314 		.fill_helper = bpf_fill_alu64_rsh_reg,
12315 	},
12316 	{
12317 		"ALU64_ARSH_X: all shift values",
12318 		{ },
12319 		INTERNAL | FLAG_NO_DATA,
12320 		{ },
12321 		{ { 0, 1 } },
12322 		.fill_helper = bpf_fill_alu64_arsh_reg,
12323 	},
12324 	/* Exhaustive test of ALU32 shift operations */
12325 	{
12326 		"ALU32_LSH_K: all shift values",
12327 		{ },
12328 		INTERNAL | FLAG_NO_DATA,
12329 		{ },
12330 		{ { 0, 1 } },
12331 		.fill_helper = bpf_fill_alu32_lsh_imm,
12332 	},
12333 	{
12334 		"ALU32_RSH_K: all shift values",
12335 		{ },
12336 		INTERNAL | FLAG_NO_DATA,
12337 		{ },
12338 		{ { 0, 1 } },
12339 		.fill_helper = bpf_fill_alu32_rsh_imm,
12340 	},
12341 	{
12342 		"ALU32_ARSH_K: all shift values",
12343 		{ },
12344 		INTERNAL | FLAG_NO_DATA,
12345 		{ },
12346 		{ { 0, 1 } },
12347 		.fill_helper = bpf_fill_alu32_arsh_imm,
12348 	},
12349 	{
12350 		"ALU32_LSH_X: all shift values",
12351 		{ },
12352 		INTERNAL | FLAG_NO_DATA,
12353 		{ },
12354 		{ { 0, 1 } },
12355 		.fill_helper = bpf_fill_alu32_lsh_reg,
12356 	},
12357 	{
12358 		"ALU32_RSH_X: all shift values",
12359 		{ },
12360 		INTERNAL | FLAG_NO_DATA,
12361 		{ },
12362 		{ { 0, 1 } },
12363 		.fill_helper = bpf_fill_alu32_rsh_reg,
12364 	},
12365 	{
12366 		"ALU32_ARSH_X: all shift values",
12367 		{ },
12368 		INTERNAL | FLAG_NO_DATA,
12369 		{ },
12370 		{ { 0, 1 } },
12371 		.fill_helper = bpf_fill_alu32_arsh_reg,
12372 	},
12373 	/*
12374 	 * Exhaustive test of ALU64 shift operations when
12375 	 * source and destination register are the same.
12376 	 */
12377 	{
12378 		"ALU64_LSH_X: all shift values with the same register",
12379 		{ },
12380 		INTERNAL | FLAG_NO_DATA,
12381 		{ },
12382 		{ { 0, 1 } },
12383 		.fill_helper = bpf_fill_alu64_lsh_same_reg,
12384 	},
12385 	{
12386 		"ALU64_RSH_X: all shift values with the same register",
12387 		{ },
12388 		INTERNAL | FLAG_NO_DATA,
12389 		{ },
12390 		{ { 0, 1 } },
12391 		.fill_helper = bpf_fill_alu64_rsh_same_reg,
12392 	},
12393 	{
12394 		"ALU64_ARSH_X: all shift values with the same register",
12395 		{ },
12396 		INTERNAL | FLAG_NO_DATA,
12397 		{ },
12398 		{ { 0, 1 } },
12399 		.fill_helper = bpf_fill_alu64_arsh_same_reg,
12400 	},
12401 	/*
12402 	 * Exhaustive test of ALU32 shift operations when
12403 	 * source and destination register are the same.
12404 	 */
12405 	{
12406 		"ALU32_LSH_X: all shift values with the same register",
12407 		{ },
12408 		INTERNAL | FLAG_NO_DATA,
12409 		{ },
12410 		{ { 0, 1 } },
12411 		.fill_helper = bpf_fill_alu32_lsh_same_reg,
12412 	},
12413 	{
12414 		"ALU32_RSH_X: all shift values with the same register",
12415 		{ },
12416 		INTERNAL | FLAG_NO_DATA,
12417 		{ },
12418 		{ { 0, 1 } },
12419 		.fill_helper = bpf_fill_alu32_rsh_same_reg,
12420 	},
12421 	{
12422 		"ALU32_ARSH_X: all shift values with the same register",
12423 		{ },
12424 		INTERNAL | FLAG_NO_DATA,
12425 		{ },
12426 		{ { 0, 1 } },
12427 		.fill_helper = bpf_fill_alu32_arsh_same_reg,
12428 	},
12429 	/* ALU64 immediate magnitudes */
12430 	{
12431 		"ALU64_MOV_K: all immediate value magnitudes",
12432 		{ },
12433 		INTERNAL | FLAG_NO_DATA,
12434 		{ },
12435 		{ { 0, 1 } },
12436 		.fill_helper = bpf_fill_alu64_mov_imm,
12437 		.nr_testruns = NR_PATTERN_RUNS,
12438 	},
12439 	{
12440 		"ALU64_AND_K: all immediate value magnitudes",
12441 		{ },
12442 		INTERNAL | FLAG_NO_DATA,
12443 		{ },
12444 		{ { 0, 1 } },
12445 		.fill_helper = bpf_fill_alu64_and_imm,
12446 		.nr_testruns = NR_PATTERN_RUNS,
12447 	},
12448 	{
12449 		"ALU64_OR_K: all immediate value magnitudes",
12450 		{ },
12451 		INTERNAL | FLAG_NO_DATA,
12452 		{ },
12453 		{ { 0, 1 } },
12454 		.fill_helper = bpf_fill_alu64_or_imm,
12455 		.nr_testruns = NR_PATTERN_RUNS,
12456 	},
12457 	{
12458 		"ALU64_XOR_K: all immediate value magnitudes",
12459 		{ },
12460 		INTERNAL | FLAG_NO_DATA,
12461 		{ },
12462 		{ { 0, 1 } },
12463 		.fill_helper = bpf_fill_alu64_xor_imm,
12464 		.nr_testruns = NR_PATTERN_RUNS,
12465 	},
12466 	{
12467 		"ALU64_ADD_K: all immediate value magnitudes",
12468 		{ },
12469 		INTERNAL | FLAG_NO_DATA,
12470 		{ },
12471 		{ { 0, 1 } },
12472 		.fill_helper = bpf_fill_alu64_add_imm,
12473 		.nr_testruns = NR_PATTERN_RUNS,
12474 	},
12475 	{
12476 		"ALU64_SUB_K: all immediate value magnitudes",
12477 		{ },
12478 		INTERNAL | FLAG_NO_DATA,
12479 		{ },
12480 		{ { 0, 1 } },
12481 		.fill_helper = bpf_fill_alu64_sub_imm,
12482 		.nr_testruns = NR_PATTERN_RUNS,
12483 	},
12484 	{
12485 		"ALU64_MUL_K: all immediate value magnitudes",
12486 		{ },
12487 		INTERNAL | FLAG_NO_DATA,
12488 		{ },
12489 		{ { 0, 1 } },
12490 		.fill_helper = bpf_fill_alu64_mul_imm,
12491 		.nr_testruns = NR_PATTERN_RUNS,
12492 	},
12493 	{
12494 		"ALU64_DIV_K: all immediate value magnitudes",
12495 		{ },
12496 		INTERNAL | FLAG_NO_DATA,
12497 		{ },
12498 		{ { 0, 1 } },
12499 		.fill_helper = bpf_fill_alu64_div_imm,
12500 		.nr_testruns = NR_PATTERN_RUNS,
12501 	},
12502 	{
12503 		"ALU64_MOD_K: all immediate value magnitudes",
12504 		{ },
12505 		INTERNAL | FLAG_NO_DATA,
12506 		{ },
12507 		{ { 0, 1 } },
12508 		.fill_helper = bpf_fill_alu64_mod_imm,
12509 		.nr_testruns = NR_PATTERN_RUNS,
12510 	},
12511 	/* ALU32 immediate magnitudes */
12512 	{
12513 		"ALU32_MOV_K: all immediate value magnitudes",
12514 		{ },
12515 		INTERNAL | FLAG_NO_DATA,
12516 		{ },
12517 		{ { 0, 1 } },
12518 		.fill_helper = bpf_fill_alu32_mov_imm,
12519 		.nr_testruns = NR_PATTERN_RUNS,
12520 	},
12521 	{
12522 		"ALU32_AND_K: all immediate value magnitudes",
12523 		{ },
12524 		INTERNAL | FLAG_NO_DATA,
12525 		{ },
12526 		{ { 0, 1 } },
12527 		.fill_helper = bpf_fill_alu32_and_imm,
12528 		.nr_testruns = NR_PATTERN_RUNS,
12529 	},
12530 	{
12531 		"ALU32_OR_K: all immediate value magnitudes",
12532 		{ },
12533 		INTERNAL | FLAG_NO_DATA,
12534 		{ },
12535 		{ { 0, 1 } },
12536 		.fill_helper = bpf_fill_alu32_or_imm,
12537 		.nr_testruns = NR_PATTERN_RUNS,
12538 	},
12539 	{
12540 		"ALU32_XOR_K: all immediate value magnitudes",
12541 		{ },
12542 		INTERNAL | FLAG_NO_DATA,
12543 		{ },
12544 		{ { 0, 1 } },
12545 		.fill_helper = bpf_fill_alu32_xor_imm,
12546 		.nr_testruns = NR_PATTERN_RUNS,
12547 	},
12548 	{
12549 		"ALU32_ADD_K: all immediate value magnitudes",
12550 		{ },
12551 		INTERNAL | FLAG_NO_DATA,
12552 		{ },
12553 		{ { 0, 1 } },
12554 		.fill_helper = bpf_fill_alu32_add_imm,
12555 		.nr_testruns = NR_PATTERN_RUNS,
12556 	},
12557 	{
12558 		"ALU32_SUB_K: all immediate value magnitudes",
12559 		{ },
12560 		INTERNAL | FLAG_NO_DATA,
12561 		{ },
12562 		{ { 0, 1 } },
12563 		.fill_helper = bpf_fill_alu32_sub_imm,
12564 		.nr_testruns = NR_PATTERN_RUNS,
12565 	},
12566 	{
12567 		"ALU32_MUL_K: all immediate value magnitudes",
12568 		{ },
12569 		INTERNAL | FLAG_NO_DATA,
12570 		{ },
12571 		{ { 0, 1 } },
12572 		.fill_helper = bpf_fill_alu32_mul_imm,
12573 		.nr_testruns = NR_PATTERN_RUNS,
12574 	},
12575 	{
12576 		"ALU32_DIV_K: all immediate value magnitudes",
12577 		{ },
12578 		INTERNAL | FLAG_NO_DATA,
12579 		{ },
12580 		{ { 0, 1 } },
12581 		.fill_helper = bpf_fill_alu32_div_imm,
12582 		.nr_testruns = NR_PATTERN_RUNS,
12583 	},
12584 	{
12585 		"ALU32_MOD_K: all immediate value magnitudes",
12586 		{ },
12587 		INTERNAL | FLAG_NO_DATA,
12588 		{ },
12589 		{ { 0, 1 } },
12590 		.fill_helper = bpf_fill_alu32_mod_imm,
12591 		.nr_testruns = NR_PATTERN_RUNS,
12592 	},
12593 	/* ALU64 register magnitudes */
12594 	{
12595 		"ALU64_MOV_X: all register value magnitudes",
12596 		{ },
12597 		INTERNAL | FLAG_NO_DATA,
12598 		{ },
12599 		{ { 0, 1 } },
12600 		.fill_helper = bpf_fill_alu64_mov_reg,
12601 		.nr_testruns = NR_PATTERN_RUNS,
12602 	},
12603 	{
12604 		"ALU64_AND_X: all register value magnitudes",
12605 		{ },
12606 		INTERNAL | FLAG_NO_DATA,
12607 		{ },
12608 		{ { 0, 1 } },
12609 		.fill_helper = bpf_fill_alu64_and_reg,
12610 		.nr_testruns = NR_PATTERN_RUNS,
12611 	},
12612 	{
12613 		"ALU64_OR_X: all register value magnitudes",
12614 		{ },
12615 		INTERNAL | FLAG_NO_DATA,
12616 		{ },
12617 		{ { 0, 1 } },
12618 		.fill_helper = bpf_fill_alu64_or_reg,
12619 		.nr_testruns = NR_PATTERN_RUNS,
12620 	},
12621 	{
12622 		"ALU64_XOR_X: all register value magnitudes",
12623 		{ },
12624 		INTERNAL | FLAG_NO_DATA,
12625 		{ },
12626 		{ { 0, 1 } },
12627 		.fill_helper = bpf_fill_alu64_xor_reg,
12628 		.nr_testruns = NR_PATTERN_RUNS,
12629 	},
12630 	{
12631 		"ALU64_ADD_X: all register value magnitudes",
12632 		{ },
12633 		INTERNAL | FLAG_NO_DATA,
12634 		{ },
12635 		{ { 0, 1 } },
12636 		.fill_helper = bpf_fill_alu64_add_reg,
12637 		.nr_testruns = NR_PATTERN_RUNS,
12638 	},
12639 	{
12640 		"ALU64_SUB_X: all register value magnitudes",
12641 		{ },
12642 		INTERNAL | FLAG_NO_DATA,
12643 		{ },
12644 		{ { 0, 1 } },
12645 		.fill_helper = bpf_fill_alu64_sub_reg,
12646 		.nr_testruns = NR_PATTERN_RUNS,
12647 	},
12648 	{
12649 		"ALU64_MUL_X: all register value magnitudes",
12650 		{ },
12651 		INTERNAL | FLAG_NO_DATA,
12652 		{ },
12653 		{ { 0, 1 } },
12654 		.fill_helper = bpf_fill_alu64_mul_reg,
12655 		.nr_testruns = NR_PATTERN_RUNS,
12656 	},
12657 	{
12658 		"ALU64_DIV_X: all register value magnitudes",
12659 		{ },
12660 		INTERNAL | FLAG_NO_DATA,
12661 		{ },
12662 		{ { 0, 1 } },
12663 		.fill_helper = bpf_fill_alu64_div_reg,
12664 		.nr_testruns = NR_PATTERN_RUNS,
12665 	},
12666 	{
12667 		"ALU64_MOD_X: all register value magnitudes",
12668 		{ },
12669 		INTERNAL | FLAG_NO_DATA,
12670 		{ },
12671 		{ { 0, 1 } },
12672 		.fill_helper = bpf_fill_alu64_mod_reg,
12673 		.nr_testruns = NR_PATTERN_RUNS,
12674 	},
12675 	/* ALU32 register magnitudes */
12676 	{
12677 		"ALU32_MOV_X: all register value magnitudes",
12678 		{ },
12679 		INTERNAL | FLAG_NO_DATA,
12680 		{ },
12681 		{ { 0, 1 } },
12682 		.fill_helper = bpf_fill_alu32_mov_reg,
12683 		.nr_testruns = NR_PATTERN_RUNS,
12684 	},
12685 	{
12686 		"ALU32_AND_X: all register value magnitudes",
12687 		{ },
12688 		INTERNAL | FLAG_NO_DATA,
12689 		{ },
12690 		{ { 0, 1 } },
12691 		.fill_helper = bpf_fill_alu32_and_reg,
12692 		.nr_testruns = NR_PATTERN_RUNS,
12693 	},
12694 	{
12695 		"ALU32_OR_X: all register value magnitudes",
12696 		{ },
12697 		INTERNAL | FLAG_NO_DATA,
12698 		{ },
12699 		{ { 0, 1 } },
12700 		.fill_helper = bpf_fill_alu32_or_reg,
12701 		.nr_testruns = NR_PATTERN_RUNS,
12702 	},
12703 	{
12704 		"ALU32_XOR_X: all register value magnitudes",
12705 		{ },
12706 		INTERNAL | FLAG_NO_DATA,
12707 		{ },
12708 		{ { 0, 1 } },
12709 		.fill_helper = bpf_fill_alu32_xor_reg,
12710 		.nr_testruns = NR_PATTERN_RUNS,
12711 	},
12712 	{
12713 		"ALU32_ADD_X: all register value magnitudes",
12714 		{ },
12715 		INTERNAL | FLAG_NO_DATA,
12716 		{ },
12717 		{ { 0, 1 } },
12718 		.fill_helper = bpf_fill_alu32_add_reg,
12719 		.nr_testruns = NR_PATTERN_RUNS,
12720 	},
12721 	{
12722 		"ALU32_SUB_X: all register value magnitudes",
12723 		{ },
12724 		INTERNAL | FLAG_NO_DATA,
12725 		{ },
12726 		{ { 0, 1 } },
12727 		.fill_helper = bpf_fill_alu32_sub_reg,
12728 		.nr_testruns = NR_PATTERN_RUNS,
12729 	},
12730 	{
12731 		"ALU32_MUL_X: all register value magnitudes",
12732 		{ },
12733 		INTERNAL | FLAG_NO_DATA,
12734 		{ },
12735 		{ { 0, 1 } },
12736 		.fill_helper = bpf_fill_alu32_mul_reg,
12737 		.nr_testruns = NR_PATTERN_RUNS,
12738 	},
12739 	{
12740 		"ALU32_DIV_X: all register value magnitudes",
12741 		{ },
12742 		INTERNAL | FLAG_NO_DATA,
12743 		{ },
12744 		{ { 0, 1 } },
12745 		.fill_helper = bpf_fill_alu32_div_reg,
12746 		.nr_testruns = NR_PATTERN_RUNS,
12747 	},
12748 	{
12749 		"ALU32_MOD_X: all register value magnitudes",
12750 		{ },
12751 		INTERNAL | FLAG_NO_DATA,
12752 		{ },
12753 		{ { 0, 1 } },
12754 		.fill_helper = bpf_fill_alu32_mod_reg,
12755 		.nr_testruns = NR_PATTERN_RUNS,
12756 	},
12757 	/* LD_IMM64 immediate magnitudes and byte patterns */
12758 	{
12759 		"LD_IMM64: all immediate value magnitudes",
12760 		{ },
12761 		INTERNAL | FLAG_NO_DATA,
12762 		{ },
12763 		{ { 0, 1 } },
12764 		.fill_helper = bpf_fill_ld_imm64_magn,
12765 	},
12766 	{
12767 		"LD_IMM64: checker byte patterns",
12768 		{ },
12769 		INTERNAL | FLAG_NO_DATA,
12770 		{ },
12771 		{ { 0, 1 } },
12772 		.fill_helper = bpf_fill_ld_imm64_checker,
12773 	},
12774 	{
12775 		"LD_IMM64: random positive and zero byte patterns",
12776 		{ },
12777 		INTERNAL | FLAG_NO_DATA,
12778 		{ },
12779 		{ { 0, 1 } },
12780 		.fill_helper = bpf_fill_ld_imm64_pos_zero,
12781 	},
12782 	{
12783 		"LD_IMM64: random negative and zero byte patterns",
12784 		{ },
12785 		INTERNAL | FLAG_NO_DATA,
12786 		{ },
12787 		{ { 0, 1 } },
12788 		.fill_helper = bpf_fill_ld_imm64_neg_zero,
12789 	},
12790 	{
12791 		"LD_IMM64: random positive and negative byte patterns",
12792 		{ },
12793 		INTERNAL | FLAG_NO_DATA,
12794 		{ },
12795 		{ { 0, 1 } },
12796 		.fill_helper = bpf_fill_ld_imm64_pos_neg,
12797 	},
12798 	/* 64-bit ATOMIC register combinations */
12799 	{
12800 		"ATOMIC_DW_ADD: register combinations",
12801 		{ },
12802 		INTERNAL,
12803 		{ },
12804 		{ { 0, 1 } },
12805 		.fill_helper = bpf_fill_atomic64_add_reg_pairs,
12806 		.stack_depth = 8,
12807 	},
12808 	{
12809 		"ATOMIC_DW_AND: register combinations",
12810 		{ },
12811 		INTERNAL,
12812 		{ },
12813 		{ { 0, 1 } },
12814 		.fill_helper = bpf_fill_atomic64_and_reg_pairs,
12815 		.stack_depth = 8,
12816 	},
12817 	{
12818 		"ATOMIC_DW_OR: register combinations",
12819 		{ },
12820 		INTERNAL,
12821 		{ },
12822 		{ { 0, 1 } },
12823 		.fill_helper = bpf_fill_atomic64_or_reg_pairs,
12824 		.stack_depth = 8,
12825 	},
12826 	{
12827 		"ATOMIC_DW_XOR: register combinations",
12828 		{ },
12829 		INTERNAL,
12830 		{ },
12831 		{ { 0, 1 } },
12832 		.fill_helper = bpf_fill_atomic64_xor_reg_pairs,
12833 		.stack_depth = 8,
12834 	},
12835 	{
12836 		"ATOMIC_DW_ADD_FETCH: register combinations",
12837 		{ },
12838 		INTERNAL,
12839 		{ },
12840 		{ { 0, 1 } },
12841 		.fill_helper = bpf_fill_atomic64_add_fetch_reg_pairs,
12842 		.stack_depth = 8,
12843 	},
12844 	{
12845 		"ATOMIC_DW_AND_FETCH: register combinations",
12846 		{ },
12847 		INTERNAL,
12848 		{ },
12849 		{ { 0, 1 } },
12850 		.fill_helper = bpf_fill_atomic64_and_fetch_reg_pairs,
12851 		.stack_depth = 8,
12852 	},
12853 	{
12854 		"ATOMIC_DW_OR_FETCH: register combinations",
12855 		{ },
12856 		INTERNAL,
12857 		{ },
12858 		{ { 0, 1 } },
12859 		.fill_helper = bpf_fill_atomic64_or_fetch_reg_pairs,
12860 		.stack_depth = 8,
12861 	},
12862 	{
12863 		"ATOMIC_DW_XOR_FETCH: register combinations",
12864 		{ },
12865 		INTERNAL,
12866 		{ },
12867 		{ { 0, 1 } },
12868 		.fill_helper = bpf_fill_atomic64_xor_fetch_reg_pairs,
12869 		.stack_depth = 8,
12870 	},
12871 	{
12872 		"ATOMIC_DW_XCHG: register combinations",
12873 		{ },
12874 		INTERNAL,
12875 		{ },
12876 		{ { 0, 1 } },
12877 		.fill_helper = bpf_fill_atomic64_xchg_reg_pairs,
12878 		.stack_depth = 8,
12879 	},
12880 	{
12881 		"ATOMIC_DW_CMPXCHG: register combinations",
12882 		{ },
12883 		INTERNAL,
12884 		{ },
12885 		{ { 0, 1 } },
12886 		.fill_helper = bpf_fill_atomic64_cmpxchg_reg_pairs,
12887 		.stack_depth = 8,
12888 	},
12889 	/* 32-bit ATOMIC register combinations */
12890 	{
12891 		"ATOMIC_W_ADD: register combinations",
12892 		{ },
12893 		INTERNAL,
12894 		{ },
12895 		{ { 0, 1 } },
12896 		.fill_helper = bpf_fill_atomic32_add_reg_pairs,
12897 		.stack_depth = 8,
12898 	},
12899 	{
12900 		"ATOMIC_W_AND: register combinations",
12901 		{ },
12902 		INTERNAL,
12903 		{ },
12904 		{ { 0, 1 } },
12905 		.fill_helper = bpf_fill_atomic32_and_reg_pairs,
12906 		.stack_depth = 8,
12907 	},
12908 	{
12909 		"ATOMIC_W_OR: register combinations",
12910 		{ },
12911 		INTERNAL,
12912 		{ },
12913 		{ { 0, 1 } },
12914 		.fill_helper = bpf_fill_atomic32_or_reg_pairs,
12915 		.stack_depth = 8,
12916 	},
12917 	{
12918 		"ATOMIC_W_XOR: register combinations",
12919 		{ },
12920 		INTERNAL,
12921 		{ },
12922 		{ { 0, 1 } },
12923 		.fill_helper = bpf_fill_atomic32_xor_reg_pairs,
12924 		.stack_depth = 8,
12925 	},
12926 	{
12927 		"ATOMIC_W_ADD_FETCH: register combinations",
12928 		{ },
12929 		INTERNAL,
12930 		{ },
12931 		{ { 0, 1 } },
12932 		.fill_helper = bpf_fill_atomic32_add_fetch_reg_pairs,
12933 		.stack_depth = 8,
12934 	},
12935 	{
12936 		"ATOMIC_W_AND_FETCH: register combinations",
12937 		{ },
12938 		INTERNAL,
12939 		{ },
12940 		{ { 0, 1 } },
12941 		.fill_helper = bpf_fill_atomic32_and_fetch_reg_pairs,
12942 		.stack_depth = 8,
12943 	},
12944 	{
12945 		"ATOMIC_W_OR_FETCH: register combinations",
12946 		{ },
12947 		INTERNAL,
12948 		{ },
12949 		{ { 0, 1 } },
12950 		.fill_helper = bpf_fill_atomic32_or_fetch_reg_pairs,
12951 		.stack_depth = 8,
12952 	},
12953 	{
12954 		"ATOMIC_W_XOR_FETCH: register combinations",
12955 		{ },
12956 		INTERNAL,
12957 		{ },
12958 		{ { 0, 1 } },
12959 		.fill_helper = bpf_fill_atomic32_xor_fetch_reg_pairs,
12960 		.stack_depth = 8,
12961 	},
12962 	{
12963 		"ATOMIC_W_XCHG: register combinations",
12964 		{ },
12965 		INTERNAL,
12966 		{ },
12967 		{ { 0, 1 } },
12968 		.fill_helper = bpf_fill_atomic32_xchg_reg_pairs,
12969 		.stack_depth = 8,
12970 	},
12971 	{
12972 		"ATOMIC_W_CMPXCHG: register combinations",
12973 		{ },
12974 		INTERNAL,
12975 		{ },
12976 		{ { 0, 1 } },
12977 		.fill_helper = bpf_fill_atomic32_cmpxchg_reg_pairs,
12978 		.stack_depth = 8,
12979 	},
12980 	/* 64-bit ATOMIC magnitudes */
12981 	{
12982 		"ATOMIC_DW_ADD: all operand magnitudes",
12983 		{ },
12984 		INTERNAL | FLAG_NO_DATA,
12985 		{ },
12986 		{ { 0, 1 } },
12987 		.fill_helper = bpf_fill_atomic64_add,
12988 		.stack_depth = 8,
12989 		.nr_testruns = NR_PATTERN_RUNS,
12990 	},
12991 	{
12992 		"ATOMIC_DW_AND: all operand magnitudes",
12993 		{ },
12994 		INTERNAL | FLAG_NO_DATA,
12995 		{ },
12996 		{ { 0, 1 } },
12997 		.fill_helper = bpf_fill_atomic64_and,
12998 		.stack_depth = 8,
12999 		.nr_testruns = NR_PATTERN_RUNS,
13000 	},
13001 	{
13002 		"ATOMIC_DW_OR: all operand magnitudes",
13003 		{ },
13004 		INTERNAL | FLAG_NO_DATA,
13005 		{ },
13006 		{ { 0, 1 } },
13007 		.fill_helper = bpf_fill_atomic64_or,
13008 		.stack_depth = 8,
13009 		.nr_testruns = NR_PATTERN_RUNS,
13010 	},
13011 	{
13012 		"ATOMIC_DW_XOR: all operand magnitudes",
13013 		{ },
13014 		INTERNAL | FLAG_NO_DATA,
13015 		{ },
13016 		{ { 0, 1 } },
13017 		.fill_helper = bpf_fill_atomic64_xor,
13018 		.stack_depth = 8,
13019 		.nr_testruns = NR_PATTERN_RUNS,
13020 	},
13021 	{
13022 		"ATOMIC_DW_ADD_FETCH: all operand magnitudes",
13023 		{ },
13024 		INTERNAL | FLAG_NO_DATA,
13025 		{ },
13026 		{ { 0, 1 } },
13027 		.fill_helper = bpf_fill_atomic64_add_fetch,
13028 		.stack_depth = 8,
13029 		.nr_testruns = NR_PATTERN_RUNS,
13030 	},
13031 	{
13032 		"ATOMIC_DW_AND_FETCH: all operand magnitudes",
13033 		{ },
13034 		INTERNAL | FLAG_NO_DATA,
13035 		{ },
13036 		{ { 0, 1 } },
13037 		.fill_helper = bpf_fill_atomic64_and_fetch,
13038 		.stack_depth = 8,
13039 		.nr_testruns = NR_PATTERN_RUNS,
13040 	},
13041 	{
13042 		"ATOMIC_DW_OR_FETCH: all operand magnitudes",
13043 		{ },
13044 		INTERNAL | FLAG_NO_DATA,
13045 		{ },
13046 		{ { 0, 1 } },
13047 		.fill_helper = bpf_fill_atomic64_or_fetch,
13048 		.stack_depth = 8,
13049 		.nr_testruns = NR_PATTERN_RUNS,
13050 	},
13051 	{
13052 		"ATOMIC_DW_XOR_FETCH: all operand magnitudes",
13053 		{ },
13054 		INTERNAL | FLAG_NO_DATA,
13055 		{ },
13056 		{ { 0, 1 } },
13057 		.fill_helper = bpf_fill_atomic64_xor_fetch,
13058 		.stack_depth = 8,
13059 		.nr_testruns = NR_PATTERN_RUNS,
13060 	},
13061 	{
13062 		"ATOMIC_DW_XCHG: all operand magnitudes",
13063 		{ },
13064 		INTERNAL | FLAG_NO_DATA,
13065 		{ },
13066 		{ { 0, 1 } },
13067 		.fill_helper = bpf_fill_atomic64_xchg,
13068 		.stack_depth = 8,
13069 		.nr_testruns = NR_PATTERN_RUNS,
13070 	},
13071 	{
13072 		"ATOMIC_DW_CMPXCHG: all operand magnitudes",
13073 		{ },
13074 		INTERNAL | FLAG_NO_DATA,
13075 		{ },
13076 		{ { 0, 1 } },
13077 		.fill_helper = bpf_fill_cmpxchg64,
13078 		.stack_depth = 8,
13079 		.nr_testruns = NR_PATTERN_RUNS,
13080 	},
13081 	/* 64-bit atomic magnitudes */
13082 	{
13083 		"ATOMIC_W_ADD: all operand magnitudes",
13084 		{ },
13085 		INTERNAL | FLAG_NO_DATA,
13086 		{ },
13087 		{ { 0, 1 } },
13088 		.fill_helper = bpf_fill_atomic32_add,
13089 		.stack_depth = 8,
13090 		.nr_testruns = NR_PATTERN_RUNS,
13091 	},
13092 	{
13093 		"ATOMIC_W_AND: all operand magnitudes",
13094 		{ },
13095 		INTERNAL | FLAG_NO_DATA,
13096 		{ },
13097 		{ { 0, 1 } },
13098 		.fill_helper = bpf_fill_atomic32_and,
13099 		.stack_depth = 8,
13100 		.nr_testruns = NR_PATTERN_RUNS,
13101 	},
13102 	{
13103 		"ATOMIC_W_OR: all operand magnitudes",
13104 		{ },
13105 		INTERNAL | FLAG_NO_DATA,
13106 		{ },
13107 		{ { 0, 1 } },
13108 		.fill_helper = bpf_fill_atomic32_or,
13109 		.stack_depth = 8,
13110 		.nr_testruns = NR_PATTERN_RUNS,
13111 	},
13112 	{
13113 		"ATOMIC_W_XOR: all operand magnitudes",
13114 		{ },
13115 		INTERNAL | FLAG_NO_DATA,
13116 		{ },
13117 		{ { 0, 1 } },
13118 		.fill_helper = bpf_fill_atomic32_xor,
13119 		.stack_depth = 8,
13120 		.nr_testruns = NR_PATTERN_RUNS,
13121 	},
13122 	{
13123 		"ATOMIC_W_ADD_FETCH: all operand magnitudes",
13124 		{ },
13125 		INTERNAL | FLAG_NO_DATA,
13126 		{ },
13127 		{ { 0, 1 } },
13128 		.fill_helper = bpf_fill_atomic32_add_fetch,
13129 		.stack_depth = 8,
13130 		.nr_testruns = NR_PATTERN_RUNS,
13131 	},
13132 	{
13133 		"ATOMIC_W_AND_FETCH: all operand magnitudes",
13134 		{ },
13135 		INTERNAL | FLAG_NO_DATA,
13136 		{ },
13137 		{ { 0, 1 } },
13138 		.fill_helper = bpf_fill_atomic32_and_fetch,
13139 		.stack_depth = 8,
13140 		.nr_testruns = NR_PATTERN_RUNS,
13141 	},
13142 	{
13143 		"ATOMIC_W_OR_FETCH: all operand magnitudes",
13144 		{ },
13145 		INTERNAL | FLAG_NO_DATA,
13146 		{ },
13147 		{ { 0, 1 } },
13148 		.fill_helper = bpf_fill_atomic32_or_fetch,
13149 		.stack_depth = 8,
13150 		.nr_testruns = NR_PATTERN_RUNS,
13151 	},
13152 	{
13153 		"ATOMIC_W_XOR_FETCH: all operand magnitudes",
13154 		{ },
13155 		INTERNAL | FLAG_NO_DATA,
13156 		{ },
13157 		{ { 0, 1 } },
13158 		.fill_helper = bpf_fill_atomic32_xor_fetch,
13159 		.stack_depth = 8,
13160 		.nr_testruns = NR_PATTERN_RUNS,
13161 	},
13162 	{
13163 		"ATOMIC_W_XCHG: all operand magnitudes",
13164 		{ },
13165 		INTERNAL | FLAG_NO_DATA,
13166 		{ },
13167 		{ { 0, 1 } },
13168 		.fill_helper = bpf_fill_atomic32_xchg,
13169 		.stack_depth = 8,
13170 		.nr_testruns = NR_PATTERN_RUNS,
13171 	},
13172 	{
13173 		"ATOMIC_W_CMPXCHG: all operand magnitudes",
13174 		{ },
13175 		INTERNAL | FLAG_NO_DATA,
13176 		{ },
13177 		{ { 0, 1 } },
13178 		.fill_helper = bpf_fill_cmpxchg32,
13179 		.stack_depth = 8,
13180 		.nr_testruns = NR_PATTERN_RUNS,
13181 	},
13182 	/* JMP immediate magnitudes */
13183 	{
13184 		"JMP_JSET_K: all immediate value magnitudes",
13185 		{ },
13186 		INTERNAL | FLAG_NO_DATA,
13187 		{ },
13188 		{ { 0, 1 } },
13189 		.fill_helper = bpf_fill_jmp_jset_imm,
13190 		.nr_testruns = NR_PATTERN_RUNS,
13191 	},
13192 	{
13193 		"JMP_JEQ_K: all immediate value magnitudes",
13194 		{ },
13195 		INTERNAL | FLAG_NO_DATA,
13196 		{ },
13197 		{ { 0, 1 } },
13198 		.fill_helper = bpf_fill_jmp_jeq_imm,
13199 		.nr_testruns = NR_PATTERN_RUNS,
13200 	},
13201 	{
13202 		"JMP_JNE_K: all immediate value magnitudes",
13203 		{ },
13204 		INTERNAL | FLAG_NO_DATA,
13205 		{ },
13206 		{ { 0, 1 } },
13207 		.fill_helper = bpf_fill_jmp_jne_imm,
13208 		.nr_testruns = NR_PATTERN_RUNS,
13209 	},
13210 	{
13211 		"JMP_JGT_K: all immediate value magnitudes",
13212 		{ },
13213 		INTERNAL | FLAG_NO_DATA,
13214 		{ },
13215 		{ { 0, 1 } },
13216 		.fill_helper = bpf_fill_jmp_jgt_imm,
13217 		.nr_testruns = NR_PATTERN_RUNS,
13218 	},
13219 	{
13220 		"JMP_JGE_K: all immediate value magnitudes",
13221 		{ },
13222 		INTERNAL | FLAG_NO_DATA,
13223 		{ },
13224 		{ { 0, 1 } },
13225 		.fill_helper = bpf_fill_jmp_jge_imm,
13226 		.nr_testruns = NR_PATTERN_RUNS,
13227 	},
13228 	{
13229 		"JMP_JLT_K: all immediate value magnitudes",
13230 		{ },
13231 		INTERNAL | FLAG_NO_DATA,
13232 		{ },
13233 		{ { 0, 1 } },
13234 		.fill_helper = bpf_fill_jmp_jlt_imm,
13235 		.nr_testruns = NR_PATTERN_RUNS,
13236 	},
13237 	{
13238 		"JMP_JLE_K: all immediate value magnitudes",
13239 		{ },
13240 		INTERNAL | FLAG_NO_DATA,
13241 		{ },
13242 		{ { 0, 1 } },
13243 		.fill_helper = bpf_fill_jmp_jle_imm,
13244 		.nr_testruns = NR_PATTERN_RUNS,
13245 	},
13246 	{
13247 		"JMP_JSGT_K: all immediate value magnitudes",
13248 		{ },
13249 		INTERNAL | FLAG_NO_DATA,
13250 		{ },
13251 		{ { 0, 1 } },
13252 		.fill_helper = bpf_fill_jmp_jsgt_imm,
13253 		.nr_testruns = NR_PATTERN_RUNS,
13254 	},
13255 	{
13256 		"JMP_JSGE_K: all immediate value magnitudes",
13257 		{ },
13258 		INTERNAL | FLAG_NO_DATA,
13259 		{ },
13260 		{ { 0, 1 } },
13261 		.fill_helper = bpf_fill_jmp_jsge_imm,
13262 		.nr_testruns = NR_PATTERN_RUNS,
13263 	},
13264 	{
13265 		"JMP_JSLT_K: all immediate value magnitudes",
13266 		{ },
13267 		INTERNAL | FLAG_NO_DATA,
13268 		{ },
13269 		{ { 0, 1 } },
13270 		.fill_helper = bpf_fill_jmp_jslt_imm,
13271 		.nr_testruns = NR_PATTERN_RUNS,
13272 	},
13273 	{
13274 		"JMP_JSLE_K: all immediate value magnitudes",
13275 		{ },
13276 		INTERNAL | FLAG_NO_DATA,
13277 		{ },
13278 		{ { 0, 1 } },
13279 		.fill_helper = bpf_fill_jmp_jsle_imm,
13280 		.nr_testruns = NR_PATTERN_RUNS,
13281 	},
13282 	/* JMP register magnitudes */
13283 	{
13284 		"JMP_JSET_X: all register value magnitudes",
13285 		{ },
13286 		INTERNAL | FLAG_NO_DATA,
13287 		{ },
13288 		{ { 0, 1 } },
13289 		.fill_helper = bpf_fill_jmp_jset_reg,
13290 		.nr_testruns = NR_PATTERN_RUNS,
13291 	},
13292 	{
13293 		"JMP_JEQ_X: all register value magnitudes",
13294 		{ },
13295 		INTERNAL | FLAG_NO_DATA,
13296 		{ },
13297 		{ { 0, 1 } },
13298 		.fill_helper = bpf_fill_jmp_jeq_reg,
13299 		.nr_testruns = NR_PATTERN_RUNS,
13300 	},
13301 	{
13302 		"JMP_JNE_X: all register value magnitudes",
13303 		{ },
13304 		INTERNAL | FLAG_NO_DATA,
13305 		{ },
13306 		{ { 0, 1 } },
13307 		.fill_helper = bpf_fill_jmp_jne_reg,
13308 		.nr_testruns = NR_PATTERN_RUNS,
13309 	},
13310 	{
13311 		"JMP_JGT_X: all register value magnitudes",
13312 		{ },
13313 		INTERNAL | FLAG_NO_DATA,
13314 		{ },
13315 		{ { 0, 1 } },
13316 		.fill_helper = bpf_fill_jmp_jgt_reg,
13317 		.nr_testruns = NR_PATTERN_RUNS,
13318 	},
13319 	{
13320 		"JMP_JGE_X: all register value magnitudes",
13321 		{ },
13322 		INTERNAL | FLAG_NO_DATA,
13323 		{ },
13324 		{ { 0, 1 } },
13325 		.fill_helper = bpf_fill_jmp_jge_reg,
13326 		.nr_testruns = NR_PATTERN_RUNS,
13327 	},
13328 	{
13329 		"JMP_JLT_X: all register value magnitudes",
13330 		{ },
13331 		INTERNAL | FLAG_NO_DATA,
13332 		{ },
13333 		{ { 0, 1 } },
13334 		.fill_helper = bpf_fill_jmp_jlt_reg,
13335 		.nr_testruns = NR_PATTERN_RUNS,
13336 	},
13337 	{
13338 		"JMP_JLE_X: all register value magnitudes",
13339 		{ },
13340 		INTERNAL | FLAG_NO_DATA,
13341 		{ },
13342 		{ { 0, 1 } },
13343 		.fill_helper = bpf_fill_jmp_jle_reg,
13344 		.nr_testruns = NR_PATTERN_RUNS,
13345 	},
13346 	{
13347 		"JMP_JSGT_X: all register value magnitudes",
13348 		{ },
13349 		INTERNAL | FLAG_NO_DATA,
13350 		{ },
13351 		{ { 0, 1 } },
13352 		.fill_helper = bpf_fill_jmp_jsgt_reg,
13353 		.nr_testruns = NR_PATTERN_RUNS,
13354 	},
13355 	{
13356 		"JMP_JSGE_X: all register value magnitudes",
13357 		{ },
13358 		INTERNAL | FLAG_NO_DATA,
13359 		{ },
13360 		{ { 0, 1 } },
13361 		.fill_helper = bpf_fill_jmp_jsge_reg,
13362 		.nr_testruns = NR_PATTERN_RUNS,
13363 	},
13364 	{
13365 		"JMP_JSLT_X: all register value magnitudes",
13366 		{ },
13367 		INTERNAL | FLAG_NO_DATA,
13368 		{ },
13369 		{ { 0, 1 } },
13370 		.fill_helper = bpf_fill_jmp_jslt_reg,
13371 		.nr_testruns = NR_PATTERN_RUNS,
13372 	},
13373 	{
13374 		"JMP_JSLE_X: all register value magnitudes",
13375 		{ },
13376 		INTERNAL | FLAG_NO_DATA,
13377 		{ },
13378 		{ { 0, 1 } },
13379 		.fill_helper = bpf_fill_jmp_jsle_reg,
13380 		.nr_testruns = NR_PATTERN_RUNS,
13381 	},
13382 	/* JMP32 immediate magnitudes */
13383 	{
13384 		"JMP32_JSET_K: all immediate value magnitudes",
13385 		{ },
13386 		INTERNAL | FLAG_NO_DATA,
13387 		{ },
13388 		{ { 0, 1 } },
13389 		.fill_helper = bpf_fill_jmp32_jset_imm,
13390 		.nr_testruns = NR_PATTERN_RUNS,
13391 	},
13392 	{
13393 		"JMP32_JEQ_K: all immediate value magnitudes",
13394 		{ },
13395 		INTERNAL | FLAG_NO_DATA,
13396 		{ },
13397 		{ { 0, 1 } },
13398 		.fill_helper = bpf_fill_jmp32_jeq_imm,
13399 		.nr_testruns = NR_PATTERN_RUNS,
13400 	},
13401 	{
13402 		"JMP32_JNE_K: all immediate value magnitudes",
13403 		{ },
13404 		INTERNAL | FLAG_NO_DATA,
13405 		{ },
13406 		{ { 0, 1 } },
13407 		.fill_helper = bpf_fill_jmp32_jne_imm,
13408 		.nr_testruns = NR_PATTERN_RUNS,
13409 	},
13410 	{
13411 		"JMP32_JGT_K: all immediate value magnitudes",
13412 		{ },
13413 		INTERNAL | FLAG_NO_DATA,
13414 		{ },
13415 		{ { 0, 1 } },
13416 		.fill_helper = bpf_fill_jmp32_jgt_imm,
13417 		.nr_testruns = NR_PATTERN_RUNS,
13418 	},
13419 	{
13420 		"JMP32_JGE_K: all immediate value magnitudes",
13421 		{ },
13422 		INTERNAL | FLAG_NO_DATA,
13423 		{ },
13424 		{ { 0, 1 } },
13425 		.fill_helper = bpf_fill_jmp32_jge_imm,
13426 		.nr_testruns = NR_PATTERN_RUNS,
13427 	},
13428 	{
13429 		"JMP32_JLT_K: all immediate value magnitudes",
13430 		{ },
13431 		INTERNAL | FLAG_NO_DATA,
13432 		{ },
13433 		{ { 0, 1 } },
13434 		.fill_helper = bpf_fill_jmp32_jlt_imm,
13435 		.nr_testruns = NR_PATTERN_RUNS,
13436 	},
13437 	{
13438 		"JMP32_JLE_K: all immediate value magnitudes",
13439 		{ },
13440 		INTERNAL | FLAG_NO_DATA,
13441 		{ },
13442 		{ { 0, 1 } },
13443 		.fill_helper = bpf_fill_jmp32_jle_imm,
13444 		.nr_testruns = NR_PATTERN_RUNS,
13445 	},
13446 	{
13447 		"JMP32_JSGT_K: all immediate value magnitudes",
13448 		{ },
13449 		INTERNAL | FLAG_NO_DATA,
13450 		{ },
13451 		{ { 0, 1 } },
13452 		.fill_helper = bpf_fill_jmp32_jsgt_imm,
13453 		.nr_testruns = NR_PATTERN_RUNS,
13454 	},
13455 	{
13456 		"JMP32_JSGE_K: all immediate value magnitudes",
13457 		{ },
13458 		INTERNAL | FLAG_NO_DATA,
13459 		{ },
13460 		{ { 0, 1 } },
13461 		.fill_helper = bpf_fill_jmp32_jsge_imm,
13462 		.nr_testruns = NR_PATTERN_RUNS,
13463 	},
13464 	{
13465 		"JMP32_JSLT_K: all immediate value magnitudes",
13466 		{ },
13467 		INTERNAL | FLAG_NO_DATA,
13468 		{ },
13469 		{ { 0, 1 } },
13470 		.fill_helper = bpf_fill_jmp32_jslt_imm,
13471 		.nr_testruns = NR_PATTERN_RUNS,
13472 	},
13473 	{
13474 		"JMP32_JSLE_K: all immediate value magnitudes",
13475 		{ },
13476 		INTERNAL | FLAG_NO_DATA,
13477 		{ },
13478 		{ { 0, 1 } },
13479 		.fill_helper = bpf_fill_jmp32_jsle_imm,
13480 		.nr_testruns = NR_PATTERN_RUNS,
13481 	},
13482 	/* JMP32 register magnitudes */
13483 	{
13484 		"JMP32_JSET_X: all register value magnitudes",
13485 		{ },
13486 		INTERNAL | FLAG_NO_DATA,
13487 		{ },
13488 		{ { 0, 1 } },
13489 		.fill_helper = bpf_fill_jmp32_jset_reg,
13490 		.nr_testruns = NR_PATTERN_RUNS,
13491 	},
13492 	{
13493 		"JMP32_JEQ_X: all register value magnitudes",
13494 		{ },
13495 		INTERNAL | FLAG_NO_DATA,
13496 		{ },
13497 		{ { 0, 1 } },
13498 		.fill_helper = bpf_fill_jmp32_jeq_reg,
13499 		.nr_testruns = NR_PATTERN_RUNS,
13500 	},
13501 	{
13502 		"JMP32_JNE_X: all register value magnitudes",
13503 		{ },
13504 		INTERNAL | FLAG_NO_DATA,
13505 		{ },
13506 		{ { 0, 1 } },
13507 		.fill_helper = bpf_fill_jmp32_jne_reg,
13508 		.nr_testruns = NR_PATTERN_RUNS,
13509 	},
13510 	{
13511 		"JMP32_JGT_X: all register value magnitudes",
13512 		{ },
13513 		INTERNAL | FLAG_NO_DATA,
13514 		{ },
13515 		{ { 0, 1 } },
13516 		.fill_helper = bpf_fill_jmp32_jgt_reg,
13517 		.nr_testruns = NR_PATTERN_RUNS,
13518 	},
13519 	{
13520 		"JMP32_JGE_X: all register value magnitudes",
13521 		{ },
13522 		INTERNAL | FLAG_NO_DATA,
13523 		{ },
13524 		{ { 0, 1 } },
13525 		.fill_helper = bpf_fill_jmp32_jge_reg,
13526 		.nr_testruns = NR_PATTERN_RUNS,
13527 	},
13528 	{
13529 		"JMP32_JLT_X: all register value magnitudes",
13530 		{ },
13531 		INTERNAL | FLAG_NO_DATA,
13532 		{ },
13533 		{ { 0, 1 } },
13534 		.fill_helper = bpf_fill_jmp32_jlt_reg,
13535 		.nr_testruns = NR_PATTERN_RUNS,
13536 	},
13537 	{
13538 		"JMP32_JLE_X: all register value magnitudes",
13539 		{ },
13540 		INTERNAL | FLAG_NO_DATA,
13541 		{ },
13542 		{ { 0, 1 } },
13543 		.fill_helper = bpf_fill_jmp32_jle_reg,
13544 		.nr_testruns = NR_PATTERN_RUNS,
13545 	},
13546 	{
13547 		"JMP32_JSGT_X: all register value magnitudes",
13548 		{ },
13549 		INTERNAL | FLAG_NO_DATA,
13550 		{ },
13551 		{ { 0, 1 } },
13552 		.fill_helper = bpf_fill_jmp32_jsgt_reg,
13553 		.nr_testruns = NR_PATTERN_RUNS,
13554 	},
13555 	{
13556 		"JMP32_JSGE_X: all register value magnitudes",
13557 		{ },
13558 		INTERNAL | FLAG_NO_DATA,
13559 		{ },
13560 		{ { 0, 1 } },
13561 		.fill_helper = bpf_fill_jmp32_jsge_reg,
13562 		.nr_testruns = NR_PATTERN_RUNS,
13563 	},
13564 	{
13565 		"JMP32_JSLT_X: all register value magnitudes",
13566 		{ },
13567 		INTERNAL | FLAG_NO_DATA,
13568 		{ },
13569 		{ { 0, 1 } },
13570 		.fill_helper = bpf_fill_jmp32_jslt_reg,
13571 		.nr_testruns = NR_PATTERN_RUNS,
13572 	},
13573 	{
13574 		"JMP32_JSLE_X: all register value magnitudes",
13575 		{ },
13576 		INTERNAL | FLAG_NO_DATA,
13577 		{ },
13578 		{ { 0, 1 } },
13579 		.fill_helper = bpf_fill_jmp32_jsle_reg,
13580 		.nr_testruns = NR_PATTERN_RUNS,
13581 	},
13582 	/* Conditional jumps with constant decision */
13583 	{
13584 		"JMP_JSET_K: imm = 0 -> never taken",
13585 		.u.insns_int = {
13586 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13587 			BPF_JMP_IMM(BPF_JSET, R1, 0, 1),
13588 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13589 			BPF_EXIT_INSN(),
13590 		},
13591 		INTERNAL | FLAG_NO_DATA,
13592 		{ },
13593 		{ { 0, 0 } },
13594 	},
13595 	{
13596 		"JMP_JLT_K: imm = 0 -> never taken",
13597 		.u.insns_int = {
13598 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13599 			BPF_JMP_IMM(BPF_JLT, R1, 0, 1),
13600 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13601 			BPF_EXIT_INSN(),
13602 		},
13603 		INTERNAL | FLAG_NO_DATA,
13604 		{ },
13605 		{ { 0, 0 } },
13606 	},
13607 	{
13608 		"JMP_JGE_K: imm = 0 -> always taken",
13609 		.u.insns_int = {
13610 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13611 			BPF_JMP_IMM(BPF_JGE, R1, 0, 1),
13612 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13613 			BPF_EXIT_INSN(),
13614 		},
13615 		INTERNAL | FLAG_NO_DATA,
13616 		{ },
13617 		{ { 0, 1 } },
13618 	},
13619 	{
13620 		"JMP_JGT_K: imm = 0xffffffff -> never taken",
13621 		.u.insns_int = {
13622 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13623 			BPF_JMP_IMM(BPF_JGT, R1, U32_MAX, 1),
13624 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13625 			BPF_EXIT_INSN(),
13626 		},
13627 		INTERNAL | FLAG_NO_DATA,
13628 		{ },
13629 		{ { 0, 0 } },
13630 	},
13631 	{
13632 		"JMP_JLE_K: imm = 0xffffffff -> always taken",
13633 		.u.insns_int = {
13634 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13635 			BPF_JMP_IMM(BPF_JLE, R1, U32_MAX, 1),
13636 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13637 			BPF_EXIT_INSN(),
13638 		},
13639 		INTERNAL | FLAG_NO_DATA,
13640 		{ },
13641 		{ { 0, 1 } },
13642 	},
13643 	{
13644 		"JMP32_JSGT_K: imm = 0x7fffffff -> never taken",
13645 		.u.insns_int = {
13646 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13647 			BPF_JMP32_IMM(BPF_JSGT, R1, S32_MAX, 1),
13648 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13649 			BPF_EXIT_INSN(),
13650 		},
13651 		INTERNAL | FLAG_NO_DATA,
13652 		{ },
13653 		{ { 0, 0 } },
13654 	},
13655 	{
13656 		"JMP32_JSGE_K: imm = -0x80000000 -> always taken",
13657 		.u.insns_int = {
13658 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13659 			BPF_JMP32_IMM(BPF_JSGE, R1, S32_MIN, 1),
13660 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13661 			BPF_EXIT_INSN(),
13662 		},
13663 		INTERNAL | FLAG_NO_DATA,
13664 		{ },
13665 		{ { 0, 1 } },
13666 	},
13667 	{
13668 		"JMP32_JSLT_K: imm = -0x80000000 -> never taken",
13669 		.u.insns_int = {
13670 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13671 			BPF_JMP32_IMM(BPF_JSLT, R1, S32_MIN, 1),
13672 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13673 			BPF_EXIT_INSN(),
13674 		},
13675 		INTERNAL | FLAG_NO_DATA,
13676 		{ },
13677 		{ { 0, 0 } },
13678 	},
13679 	{
13680 		"JMP32_JSLE_K: imm = 0x7fffffff -> always taken",
13681 		.u.insns_int = {
13682 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13683 			BPF_JMP32_IMM(BPF_JSLE, R1, S32_MAX, 1),
13684 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13685 			BPF_EXIT_INSN(),
13686 		},
13687 		INTERNAL | FLAG_NO_DATA,
13688 		{ },
13689 		{ { 0, 1 } },
13690 	},
13691 	{
13692 		"JMP_JEQ_X: dst = src -> always taken",
13693 		.u.insns_int = {
13694 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13695 			BPF_JMP_REG(BPF_JEQ, R1, R1, 1),
13696 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13697 			BPF_EXIT_INSN(),
13698 		},
13699 		INTERNAL | FLAG_NO_DATA,
13700 		{ },
13701 		{ { 0, 1 } },
13702 	},
13703 	{
13704 		"JMP_JGE_X: dst = src -> always taken",
13705 		.u.insns_int = {
13706 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13707 			BPF_JMP_REG(BPF_JGE, R1, R1, 1),
13708 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13709 			BPF_EXIT_INSN(),
13710 		},
13711 		INTERNAL | FLAG_NO_DATA,
13712 		{ },
13713 		{ { 0, 1 } },
13714 	},
13715 	{
13716 		"JMP_JLE_X: dst = src -> always taken",
13717 		.u.insns_int = {
13718 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13719 			BPF_JMP_REG(BPF_JLE, R1, R1, 1),
13720 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13721 			BPF_EXIT_INSN(),
13722 		},
13723 		INTERNAL | FLAG_NO_DATA,
13724 		{ },
13725 		{ { 0, 1 } },
13726 	},
13727 	{
13728 		"JMP_JSGE_X: dst = src -> always taken",
13729 		.u.insns_int = {
13730 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13731 			BPF_JMP_REG(BPF_JSGE, R1, R1, 1),
13732 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13733 			BPF_EXIT_INSN(),
13734 		},
13735 		INTERNAL | FLAG_NO_DATA,
13736 		{ },
13737 		{ { 0, 1 } },
13738 	},
13739 	{
13740 		"JMP_JSLE_X: dst = src -> always taken",
13741 		.u.insns_int = {
13742 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13743 			BPF_JMP_REG(BPF_JSLE, R1, R1, 1),
13744 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13745 			BPF_EXIT_INSN(),
13746 		},
13747 		INTERNAL | FLAG_NO_DATA,
13748 		{ },
13749 		{ { 0, 1 } },
13750 	},
13751 	{
13752 		"JMP_JNE_X: dst = src -> never taken",
13753 		.u.insns_int = {
13754 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13755 			BPF_JMP_REG(BPF_JNE, R1, R1, 1),
13756 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13757 			BPF_EXIT_INSN(),
13758 		},
13759 		INTERNAL | FLAG_NO_DATA,
13760 		{ },
13761 		{ { 0, 0 } },
13762 	},
13763 	{
13764 		"JMP_JGT_X: dst = src -> never taken",
13765 		.u.insns_int = {
13766 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13767 			BPF_JMP_REG(BPF_JGT, R1, R1, 1),
13768 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13769 			BPF_EXIT_INSN(),
13770 		},
13771 		INTERNAL | FLAG_NO_DATA,
13772 		{ },
13773 		{ { 0, 0 } },
13774 	},
13775 	{
13776 		"JMP_JLT_X: dst = src -> never taken",
13777 		.u.insns_int = {
13778 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13779 			BPF_JMP_REG(BPF_JLT, R1, R1, 1),
13780 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13781 			BPF_EXIT_INSN(),
13782 		},
13783 		INTERNAL | FLAG_NO_DATA,
13784 		{ },
13785 		{ { 0, 0 } },
13786 	},
13787 	{
13788 		"JMP_JSGT_X: dst = src -> never taken",
13789 		.u.insns_int = {
13790 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13791 			BPF_JMP_REG(BPF_JSGT, R1, R1, 1),
13792 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13793 			BPF_EXIT_INSN(),
13794 		},
13795 		INTERNAL | FLAG_NO_DATA,
13796 		{ },
13797 		{ { 0, 0 } },
13798 	},
13799 	{
13800 		"JMP_JSLT_X: dst = src -> never taken",
13801 		.u.insns_int = {
13802 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13803 			BPF_JMP_REG(BPF_JSLT, R1, R1, 1),
13804 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13805 			BPF_EXIT_INSN(),
13806 		},
13807 		INTERNAL | FLAG_NO_DATA,
13808 		{ },
13809 		{ { 0, 0 } },
13810 	},
13811 	/* Short relative jumps */
13812 	{
13813 		"Short relative jump: offset=0",
13814 		.u.insns_int = {
13815 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13816 			BPF_JMP_IMM(BPF_JEQ, R0, 0, 0),
13817 			BPF_EXIT_INSN(),
13818 			BPF_ALU32_IMM(BPF_MOV, R0, -1),
13819 		},
13820 		INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
13821 		{ },
13822 		{ { 0, 0 } },
13823 	},
13824 	{
13825 		"Short relative jump: offset=1",
13826 		.u.insns_int = {
13827 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13828 			BPF_JMP_IMM(BPF_JEQ, R0, 0, 1),
13829 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
13830 			BPF_EXIT_INSN(),
13831 			BPF_ALU32_IMM(BPF_MOV, R0, -1),
13832 		},
13833 		INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
13834 		{ },
13835 		{ { 0, 0 } },
13836 	},
13837 	{
13838 		"Short relative jump: offset=2",
13839 		.u.insns_int = {
13840 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13841 			BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
13842 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
13843 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
13844 			BPF_EXIT_INSN(),
13845 			BPF_ALU32_IMM(BPF_MOV, R0, -1),
13846 		},
13847 		INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
13848 		{ },
13849 		{ { 0, 0 } },
13850 	},
13851 	{
13852 		"Short relative jump: offset=3",
13853 		.u.insns_int = {
13854 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13855 			BPF_JMP_IMM(BPF_JEQ, R0, 0, 3),
13856 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
13857 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
13858 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
13859 			BPF_EXIT_INSN(),
13860 			BPF_ALU32_IMM(BPF_MOV, R0, -1),
13861 		},
13862 		INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
13863 		{ },
13864 		{ { 0, 0 } },
13865 	},
13866 	{
13867 		"Short relative jump: offset=4",
13868 		.u.insns_int = {
13869 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13870 			BPF_JMP_IMM(BPF_JEQ, R0, 0, 4),
13871 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
13872 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
13873 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
13874 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
13875 			BPF_EXIT_INSN(),
13876 			BPF_ALU32_IMM(BPF_MOV, R0, -1),
13877 		},
13878 		INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
13879 		{ },
13880 		{ { 0, 0 } },
13881 	},
13882 	/* Conditional branch conversions */
13883 	{
13884 		"Long conditional jump: taken at runtime",
13885 		{ },
13886 		INTERNAL | FLAG_NO_DATA,
13887 		{ },
13888 		{ { 0, 1 } },
13889 		.fill_helper = bpf_fill_max_jmp_taken,
13890 	},
13891 	{
13892 		"Long conditional jump: not taken at runtime",
13893 		{ },
13894 		INTERNAL | FLAG_NO_DATA,
13895 		{ },
13896 		{ { 0, 2 } },
13897 		.fill_helper = bpf_fill_max_jmp_not_taken,
13898 	},
13899 	{
13900 		"Long conditional jump: always taken, known at JIT time",
13901 		{ },
13902 		INTERNAL | FLAG_NO_DATA,
13903 		{ },
13904 		{ { 0, 1 } },
13905 		.fill_helper = bpf_fill_max_jmp_always_taken,
13906 	},
13907 	{
13908 		"Long conditional jump: never taken, known at JIT time",
13909 		{ },
13910 		INTERNAL | FLAG_NO_DATA,
13911 		{ },
13912 		{ { 0, 2 } },
13913 		.fill_helper = bpf_fill_max_jmp_never_taken,
13914 	},
13915 	/* Staggered jump sequences, immediate */
13916 	{
13917 		"Staggered jumps: JMP_JA",
13918 		{ },
13919 		INTERNAL | FLAG_NO_DATA,
13920 		{ },
13921 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13922 		.fill_helper = bpf_fill_staggered_ja,
13923 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13924 	},
13925 	{
13926 		"Staggered jumps: JMP_JEQ_K",
13927 		{ },
13928 		INTERNAL | FLAG_NO_DATA,
13929 		{ },
13930 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13931 		.fill_helper = bpf_fill_staggered_jeq_imm,
13932 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13933 	},
13934 	{
13935 		"Staggered jumps: JMP_JNE_K",
13936 		{ },
13937 		INTERNAL | FLAG_NO_DATA,
13938 		{ },
13939 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13940 		.fill_helper = bpf_fill_staggered_jne_imm,
13941 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13942 	},
13943 	{
13944 		"Staggered jumps: JMP_JSET_K",
13945 		{ },
13946 		INTERNAL | FLAG_NO_DATA,
13947 		{ },
13948 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13949 		.fill_helper = bpf_fill_staggered_jset_imm,
13950 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13951 	},
13952 	{
13953 		"Staggered jumps: JMP_JGT_K",
13954 		{ },
13955 		INTERNAL | FLAG_NO_DATA,
13956 		{ },
13957 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13958 		.fill_helper = bpf_fill_staggered_jgt_imm,
13959 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13960 	},
13961 	{
13962 		"Staggered jumps: JMP_JGE_K",
13963 		{ },
13964 		INTERNAL | FLAG_NO_DATA,
13965 		{ },
13966 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13967 		.fill_helper = bpf_fill_staggered_jge_imm,
13968 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13969 	},
13970 	{
13971 		"Staggered jumps: JMP_JLT_K",
13972 		{ },
13973 		INTERNAL | FLAG_NO_DATA,
13974 		{ },
13975 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13976 		.fill_helper = bpf_fill_staggered_jlt_imm,
13977 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13978 	},
13979 	{
13980 		"Staggered jumps: JMP_JLE_K",
13981 		{ },
13982 		INTERNAL | FLAG_NO_DATA,
13983 		{ },
13984 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13985 		.fill_helper = bpf_fill_staggered_jle_imm,
13986 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13987 	},
13988 	{
13989 		"Staggered jumps: JMP_JSGT_K",
13990 		{ },
13991 		INTERNAL | FLAG_NO_DATA,
13992 		{ },
13993 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13994 		.fill_helper = bpf_fill_staggered_jsgt_imm,
13995 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13996 	},
13997 	{
13998 		"Staggered jumps: JMP_JSGE_K",
13999 		{ },
14000 		INTERNAL | FLAG_NO_DATA,
14001 		{ },
14002 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14003 		.fill_helper = bpf_fill_staggered_jsge_imm,
14004 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14005 	},
14006 	{
14007 		"Staggered jumps: JMP_JSLT_K",
14008 		{ },
14009 		INTERNAL | FLAG_NO_DATA,
14010 		{ },
14011 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14012 		.fill_helper = bpf_fill_staggered_jslt_imm,
14013 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14014 	},
14015 	{
14016 		"Staggered jumps: JMP_JSLE_K",
14017 		{ },
14018 		INTERNAL | FLAG_NO_DATA,
14019 		{ },
14020 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14021 		.fill_helper = bpf_fill_staggered_jsle_imm,
14022 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14023 	},
14024 	/* Staggered jump sequences, register */
14025 	{
14026 		"Staggered jumps: JMP_JEQ_X",
14027 		{ },
14028 		INTERNAL | FLAG_NO_DATA,
14029 		{ },
14030 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14031 		.fill_helper = bpf_fill_staggered_jeq_reg,
14032 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14033 	},
14034 	{
14035 		"Staggered jumps: JMP_JNE_X",
14036 		{ },
14037 		INTERNAL | FLAG_NO_DATA,
14038 		{ },
14039 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14040 		.fill_helper = bpf_fill_staggered_jne_reg,
14041 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14042 	},
14043 	{
14044 		"Staggered jumps: JMP_JSET_X",
14045 		{ },
14046 		INTERNAL | FLAG_NO_DATA,
14047 		{ },
14048 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14049 		.fill_helper = bpf_fill_staggered_jset_reg,
14050 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14051 	},
14052 	{
14053 		"Staggered jumps: JMP_JGT_X",
14054 		{ },
14055 		INTERNAL | FLAG_NO_DATA,
14056 		{ },
14057 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14058 		.fill_helper = bpf_fill_staggered_jgt_reg,
14059 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14060 	},
14061 	{
14062 		"Staggered jumps: JMP_JGE_X",
14063 		{ },
14064 		INTERNAL | FLAG_NO_DATA,
14065 		{ },
14066 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14067 		.fill_helper = bpf_fill_staggered_jge_reg,
14068 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14069 	},
14070 	{
14071 		"Staggered jumps: JMP_JLT_X",
14072 		{ },
14073 		INTERNAL | FLAG_NO_DATA,
14074 		{ },
14075 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14076 		.fill_helper = bpf_fill_staggered_jlt_reg,
14077 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14078 	},
14079 	{
14080 		"Staggered jumps: JMP_JLE_X",
14081 		{ },
14082 		INTERNAL | FLAG_NO_DATA,
14083 		{ },
14084 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14085 		.fill_helper = bpf_fill_staggered_jle_reg,
14086 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14087 	},
14088 	{
14089 		"Staggered jumps: JMP_JSGT_X",
14090 		{ },
14091 		INTERNAL | FLAG_NO_DATA,
14092 		{ },
14093 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14094 		.fill_helper = bpf_fill_staggered_jsgt_reg,
14095 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14096 	},
14097 	{
14098 		"Staggered jumps: JMP_JSGE_X",
14099 		{ },
14100 		INTERNAL | FLAG_NO_DATA,
14101 		{ },
14102 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14103 		.fill_helper = bpf_fill_staggered_jsge_reg,
14104 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14105 	},
14106 	{
14107 		"Staggered jumps: JMP_JSLT_X",
14108 		{ },
14109 		INTERNAL | FLAG_NO_DATA,
14110 		{ },
14111 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14112 		.fill_helper = bpf_fill_staggered_jslt_reg,
14113 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14114 	},
14115 	{
14116 		"Staggered jumps: JMP_JSLE_X",
14117 		{ },
14118 		INTERNAL | FLAG_NO_DATA,
14119 		{ },
14120 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14121 		.fill_helper = bpf_fill_staggered_jsle_reg,
14122 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14123 	},
14124 	/* Staggered jump sequences, JMP32 immediate */
14125 	{
14126 		"Staggered jumps: JMP32_JEQ_K",
14127 		{ },
14128 		INTERNAL | FLAG_NO_DATA,
14129 		{ },
14130 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14131 		.fill_helper = bpf_fill_staggered_jeq32_imm,
14132 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14133 	},
14134 	{
14135 		"Staggered jumps: JMP32_JNE_K",
14136 		{ },
14137 		INTERNAL | FLAG_NO_DATA,
14138 		{ },
14139 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14140 		.fill_helper = bpf_fill_staggered_jne32_imm,
14141 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14142 	},
14143 	{
14144 		"Staggered jumps: JMP32_JSET_K",
14145 		{ },
14146 		INTERNAL | FLAG_NO_DATA,
14147 		{ },
14148 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14149 		.fill_helper = bpf_fill_staggered_jset32_imm,
14150 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14151 	},
14152 	{
14153 		"Staggered jumps: JMP32_JGT_K",
14154 		{ },
14155 		INTERNAL | FLAG_NO_DATA,
14156 		{ },
14157 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14158 		.fill_helper = bpf_fill_staggered_jgt32_imm,
14159 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14160 	},
14161 	{
14162 		"Staggered jumps: JMP32_JGE_K",
14163 		{ },
14164 		INTERNAL | FLAG_NO_DATA,
14165 		{ },
14166 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14167 		.fill_helper = bpf_fill_staggered_jge32_imm,
14168 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14169 	},
14170 	{
14171 		"Staggered jumps: JMP32_JLT_K",
14172 		{ },
14173 		INTERNAL | FLAG_NO_DATA,
14174 		{ },
14175 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14176 		.fill_helper = bpf_fill_staggered_jlt32_imm,
14177 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14178 	},
14179 	{
14180 		"Staggered jumps: JMP32_JLE_K",
14181 		{ },
14182 		INTERNAL | FLAG_NO_DATA,
14183 		{ },
14184 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14185 		.fill_helper = bpf_fill_staggered_jle32_imm,
14186 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14187 	},
14188 	{
14189 		"Staggered jumps: JMP32_JSGT_K",
14190 		{ },
14191 		INTERNAL | FLAG_NO_DATA,
14192 		{ },
14193 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14194 		.fill_helper = bpf_fill_staggered_jsgt32_imm,
14195 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14196 	},
14197 	{
14198 		"Staggered jumps: JMP32_JSGE_K",
14199 		{ },
14200 		INTERNAL | FLAG_NO_DATA,
14201 		{ },
14202 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14203 		.fill_helper = bpf_fill_staggered_jsge32_imm,
14204 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14205 	},
14206 	{
14207 		"Staggered jumps: JMP32_JSLT_K",
14208 		{ },
14209 		INTERNAL | FLAG_NO_DATA,
14210 		{ },
14211 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14212 		.fill_helper = bpf_fill_staggered_jslt32_imm,
14213 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14214 	},
14215 	{
14216 		"Staggered jumps: JMP32_JSLE_K",
14217 		{ },
14218 		INTERNAL | FLAG_NO_DATA,
14219 		{ },
14220 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14221 		.fill_helper = bpf_fill_staggered_jsle32_imm,
14222 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14223 	},
14224 	/* Staggered jump sequences, JMP32 register */
14225 	{
14226 		"Staggered jumps: JMP32_JEQ_X",
14227 		{ },
14228 		INTERNAL | FLAG_NO_DATA,
14229 		{ },
14230 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14231 		.fill_helper = bpf_fill_staggered_jeq32_reg,
14232 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14233 	},
14234 	{
14235 		"Staggered jumps: JMP32_JNE_X",
14236 		{ },
14237 		INTERNAL | FLAG_NO_DATA,
14238 		{ },
14239 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14240 		.fill_helper = bpf_fill_staggered_jne32_reg,
14241 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14242 	},
14243 	{
14244 		"Staggered jumps: JMP32_JSET_X",
14245 		{ },
14246 		INTERNAL | FLAG_NO_DATA,
14247 		{ },
14248 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14249 		.fill_helper = bpf_fill_staggered_jset32_reg,
14250 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14251 	},
14252 	{
14253 		"Staggered jumps: JMP32_JGT_X",
14254 		{ },
14255 		INTERNAL | FLAG_NO_DATA,
14256 		{ },
14257 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14258 		.fill_helper = bpf_fill_staggered_jgt32_reg,
14259 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14260 	},
14261 	{
14262 		"Staggered jumps: JMP32_JGE_X",
14263 		{ },
14264 		INTERNAL | FLAG_NO_DATA,
14265 		{ },
14266 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14267 		.fill_helper = bpf_fill_staggered_jge32_reg,
14268 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14269 	},
14270 	{
14271 		"Staggered jumps: JMP32_JLT_X",
14272 		{ },
14273 		INTERNAL | FLAG_NO_DATA,
14274 		{ },
14275 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14276 		.fill_helper = bpf_fill_staggered_jlt32_reg,
14277 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14278 	},
14279 	{
14280 		"Staggered jumps: JMP32_JLE_X",
14281 		{ },
14282 		INTERNAL | FLAG_NO_DATA,
14283 		{ },
14284 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14285 		.fill_helper = bpf_fill_staggered_jle32_reg,
14286 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14287 	},
14288 	{
14289 		"Staggered jumps: JMP32_JSGT_X",
14290 		{ },
14291 		INTERNAL | FLAG_NO_DATA,
14292 		{ },
14293 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14294 		.fill_helper = bpf_fill_staggered_jsgt32_reg,
14295 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14296 	},
14297 	{
14298 		"Staggered jumps: JMP32_JSGE_X",
14299 		{ },
14300 		INTERNAL | FLAG_NO_DATA,
14301 		{ },
14302 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14303 		.fill_helper = bpf_fill_staggered_jsge32_reg,
14304 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14305 	},
14306 	{
14307 		"Staggered jumps: JMP32_JSLT_X",
14308 		{ },
14309 		INTERNAL | FLAG_NO_DATA,
14310 		{ },
14311 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14312 		.fill_helper = bpf_fill_staggered_jslt32_reg,
14313 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14314 	},
14315 	{
14316 		"Staggered jumps: JMP32_JSLE_X",
14317 		{ },
14318 		INTERNAL | FLAG_NO_DATA,
14319 		{ },
14320 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14321 		.fill_helper = bpf_fill_staggered_jsle32_reg,
14322 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14323 	},
14324 };
14325 
14326 static struct net_device dev;
14327 
14328 static struct sk_buff *populate_skb(char *buf, int size)
14329 {
14330 	struct sk_buff *skb;
14331 
14332 	if (size >= MAX_DATA)
14333 		return NULL;
14334 
14335 	skb = alloc_skb(MAX_DATA, GFP_KERNEL);
14336 	if (!skb)
14337 		return NULL;
14338 
14339 	__skb_put_data(skb, buf, size);
14340 
14341 	/* Initialize a fake skb with test pattern. */
14342 	skb_reset_mac_header(skb);
14343 	skb->protocol = htons(ETH_P_IP);
14344 	skb->pkt_type = SKB_TYPE;
14345 	skb->mark = SKB_MARK;
14346 	skb->hash = SKB_HASH;
14347 	skb->queue_mapping = SKB_QUEUE_MAP;
14348 	skb->vlan_tci = SKB_VLAN_TCI;
14349 	skb->vlan_proto = htons(ETH_P_IP);
14350 	dev_net_set(&dev, &init_net);
14351 	skb->dev = &dev;
14352 	skb->dev->ifindex = SKB_DEV_IFINDEX;
14353 	skb->dev->type = SKB_DEV_TYPE;
14354 	skb_set_network_header(skb, min(size, ETH_HLEN));
14355 
14356 	return skb;
14357 }
14358 
14359 static void *generate_test_data(struct bpf_test *test, int sub)
14360 {
14361 	struct sk_buff *skb;
14362 	struct page *page;
14363 
14364 	if (test->aux & FLAG_NO_DATA)
14365 		return NULL;
14366 
14367 	if (test->aux & FLAG_LARGE_MEM)
14368 		return kmalloc(test->test[sub].data_size, GFP_KERNEL);
14369 
14370 	/* Test case expects an skb, so populate one. Various
14371 	 * subtests generate skbs of different sizes based on
14372 	 * the same data.
14373 	 */
14374 	skb = populate_skb(test->data, test->test[sub].data_size);
14375 	if (!skb)
14376 		return NULL;
14377 
14378 	if (test->aux & FLAG_SKB_FRAG) {
14379 		/*
14380 		 * when the test requires a fragmented skb, add a
14381 		 * single fragment to the skb, filled with
14382 		 * test->frag_data.
14383 		 */
14384 		void *ptr;
14385 
14386 		page = alloc_page(GFP_KERNEL);
14387 
14388 		if (!page)
14389 			goto err_kfree_skb;
14390 
14391 		ptr = kmap(page);
14392 		if (!ptr)
14393 			goto err_free_page;
14394 		memcpy(ptr, test->frag_data, MAX_DATA);
14395 		kunmap(page);
14396 		skb_add_rx_frag(skb, 0, page, 0, MAX_DATA, MAX_DATA);
14397 	}
14398 
14399 	return skb;
14400 
14401 err_free_page:
14402 	__free_page(page);
14403 err_kfree_skb:
14404 	kfree_skb(skb);
14405 	return NULL;
14406 }
14407 
14408 static void release_test_data(const struct bpf_test *test, void *data)
14409 {
14410 	if (test->aux & FLAG_NO_DATA)
14411 		return;
14412 
14413 	if (test->aux & FLAG_LARGE_MEM)
14414 		kfree(data);
14415 	else
14416 		kfree_skb(data);
14417 }
14418 
14419 static int filter_length(int which)
14420 {
14421 	struct sock_filter *fp;
14422 	int len;
14423 
14424 	if (tests[which].fill_helper)
14425 		return tests[which].u.ptr.len;
14426 
14427 	fp = tests[which].u.insns;
14428 	for (len = MAX_INSNS - 1; len > 0; --len)
14429 		if (fp[len].code != 0 || fp[len].k != 0)
14430 			break;
14431 
14432 	return len + 1;
14433 }
14434 
14435 static void *filter_pointer(int which)
14436 {
14437 	if (tests[which].fill_helper)
14438 		return tests[which].u.ptr.insns;
14439 	else
14440 		return tests[which].u.insns;
14441 }
14442 
14443 static struct bpf_prog *generate_filter(int which, int *err)
14444 {
14445 	__u8 test_type = tests[which].aux & TEST_TYPE_MASK;
14446 	unsigned int flen = filter_length(which);
14447 	void *fptr = filter_pointer(which);
14448 	struct sock_fprog_kern fprog;
14449 	struct bpf_prog *fp;
14450 
14451 	switch (test_type) {
14452 	case CLASSIC:
14453 		fprog.filter = fptr;
14454 		fprog.len = flen;
14455 
14456 		*err = bpf_prog_create(&fp, &fprog);
14457 		if (tests[which].aux & FLAG_EXPECTED_FAIL) {
14458 			if (*err == tests[which].expected_errcode) {
14459 				pr_cont("PASS\n");
14460 				/* Verifier rejected filter as expected. */
14461 				*err = 0;
14462 				return NULL;
14463 			} else {
14464 				pr_cont("UNEXPECTED_PASS\n");
14465 				/* Verifier didn't reject the test that's
14466 				 * bad enough, just return!
14467 				 */
14468 				*err = -EINVAL;
14469 				return NULL;
14470 			}
14471 		}
14472 		if (*err) {
14473 			pr_cont("FAIL to prog_create err=%d len=%d\n",
14474 				*err, fprog.len);
14475 			return NULL;
14476 		}
14477 		break;
14478 
14479 	case INTERNAL:
14480 		fp = bpf_prog_alloc(bpf_prog_size(flen), 0);
14481 		if (fp == NULL) {
14482 			pr_cont("UNEXPECTED_FAIL no memory left\n");
14483 			*err = -ENOMEM;
14484 			return NULL;
14485 		}
14486 
14487 		fp->len = flen;
14488 		/* Type doesn't really matter here as long as it's not unspec. */
14489 		fp->type = BPF_PROG_TYPE_SOCKET_FILTER;
14490 		memcpy(fp->insnsi, fptr, fp->len * sizeof(struct bpf_insn));
14491 		fp->aux->stack_depth = tests[which].stack_depth;
14492 		fp->aux->verifier_zext = !!(tests[which].aux &
14493 					    FLAG_VERIFIER_ZEXT);
14494 
14495 		/* We cannot error here as we don't need type compatibility
14496 		 * checks.
14497 		 */
14498 		fp = bpf_prog_select_runtime(fp, err);
14499 		if (*err) {
14500 			pr_cont("FAIL to select_runtime err=%d\n", *err);
14501 			return NULL;
14502 		}
14503 		break;
14504 	}
14505 
14506 	*err = 0;
14507 	return fp;
14508 }
14509 
14510 static void release_filter(struct bpf_prog *fp, int which)
14511 {
14512 	__u8 test_type = tests[which].aux & TEST_TYPE_MASK;
14513 
14514 	switch (test_type) {
14515 	case CLASSIC:
14516 		bpf_prog_destroy(fp);
14517 		break;
14518 	case INTERNAL:
14519 		bpf_prog_free(fp);
14520 		break;
14521 	}
14522 }
14523 
14524 static int __run_one(const struct bpf_prog *fp, const void *data,
14525 		     int runs, u64 *duration)
14526 {
14527 	u64 start, finish;
14528 	int ret = 0, i;
14529 
14530 	migrate_disable();
14531 	start = ktime_get_ns();
14532 
14533 	for (i = 0; i < runs; i++)
14534 		ret = bpf_prog_run(fp, data);
14535 
14536 	finish = ktime_get_ns();
14537 	migrate_enable();
14538 
14539 	*duration = finish - start;
14540 	do_div(*duration, runs);
14541 
14542 	return ret;
14543 }
14544 
14545 static int run_one(const struct bpf_prog *fp, struct bpf_test *test)
14546 {
14547 	int err_cnt = 0, i, runs = MAX_TESTRUNS;
14548 
14549 	if (test->nr_testruns)
14550 		runs = min(test->nr_testruns, MAX_TESTRUNS);
14551 
14552 	for (i = 0; i < MAX_SUBTESTS; i++) {
14553 		void *data;
14554 		u64 duration;
14555 		u32 ret;
14556 
14557 		/*
14558 		 * NOTE: Several sub-tests may be present, in which case
14559 		 * a zero {data_size, result} tuple indicates the end of
14560 		 * the sub-test array. The first test is always run,
14561 		 * even if both data_size and result happen to be zero.
14562 		 */
14563 		if (i > 0 &&
14564 		    test->test[i].data_size == 0 &&
14565 		    test->test[i].result == 0)
14566 			break;
14567 
14568 		data = generate_test_data(test, i);
14569 		if (!data && !(test->aux & FLAG_NO_DATA)) {
14570 			pr_cont("data generation failed ");
14571 			err_cnt++;
14572 			break;
14573 		}
14574 		ret = __run_one(fp, data, runs, &duration);
14575 		release_test_data(test, data);
14576 
14577 		if (ret == test->test[i].result) {
14578 			pr_cont("%lld ", duration);
14579 		} else {
14580 			pr_cont("ret %d != %d ", ret,
14581 				test->test[i].result);
14582 			err_cnt++;
14583 		}
14584 	}
14585 
14586 	return err_cnt;
14587 }
14588 
14589 static char test_name[64];
14590 module_param_string(test_name, test_name, sizeof(test_name), 0);
14591 
14592 static int test_id = -1;
14593 module_param(test_id, int, 0);
14594 
14595 static int test_range[2] = { 0, INT_MAX };
14596 module_param_array(test_range, int, NULL, 0);
14597 
14598 static bool exclude_test(int test_id)
14599 {
14600 	return test_id < test_range[0] || test_id > test_range[1];
14601 }
14602 
14603 static __init struct sk_buff *build_test_skb(void)
14604 {
14605 	u32 headroom = NET_SKB_PAD + NET_IP_ALIGN + ETH_HLEN;
14606 	struct sk_buff *skb[2];
14607 	struct page *page[2];
14608 	int i, data_size = 8;
14609 
14610 	for (i = 0; i < 2; i++) {
14611 		page[i] = alloc_page(GFP_KERNEL);
14612 		if (!page[i]) {
14613 			if (i == 0)
14614 				goto err_page0;
14615 			else
14616 				goto err_page1;
14617 		}
14618 
14619 		/* this will set skb[i]->head_frag */
14620 		skb[i] = dev_alloc_skb(headroom + data_size);
14621 		if (!skb[i]) {
14622 			if (i == 0)
14623 				goto err_skb0;
14624 			else
14625 				goto err_skb1;
14626 		}
14627 
14628 		skb_reserve(skb[i], headroom);
14629 		skb_put(skb[i], data_size);
14630 		skb[i]->protocol = htons(ETH_P_IP);
14631 		skb_reset_network_header(skb[i]);
14632 		skb_set_mac_header(skb[i], -ETH_HLEN);
14633 
14634 		skb_add_rx_frag(skb[i], 0, page[i], 0, 64, 64);
14635 		// skb_headlen(skb[i]): 8, skb[i]->head_frag = 1
14636 	}
14637 
14638 	/* setup shinfo */
14639 	skb_shinfo(skb[0])->gso_size = 1448;
14640 	skb_shinfo(skb[0])->gso_type = SKB_GSO_TCPV4;
14641 	skb_shinfo(skb[0])->gso_type |= SKB_GSO_DODGY;
14642 	skb_shinfo(skb[0])->gso_segs = 0;
14643 	skb_shinfo(skb[0])->frag_list = skb[1];
14644 	skb_shinfo(skb[0])->hwtstamps.hwtstamp = 1000;
14645 
14646 	/* adjust skb[0]'s len */
14647 	skb[0]->len += skb[1]->len;
14648 	skb[0]->data_len += skb[1]->data_len;
14649 	skb[0]->truesize += skb[1]->truesize;
14650 
14651 	return skb[0];
14652 
14653 err_skb1:
14654 	__free_page(page[1]);
14655 err_page1:
14656 	kfree_skb(skb[0]);
14657 err_skb0:
14658 	__free_page(page[0]);
14659 err_page0:
14660 	return NULL;
14661 }
14662 
14663 static __init struct sk_buff *build_test_skb_linear_no_head_frag(void)
14664 {
14665 	unsigned int alloc_size = 2000;
14666 	unsigned int headroom = 102, doffset = 72, data_size = 1308;
14667 	struct sk_buff *skb[2];
14668 	int i;
14669 
14670 	/* skbs linked in a frag_list, both with linear data, with head_frag=0
14671 	 * (data allocated by kmalloc), both have tcp data of 1308 bytes
14672 	 * (total payload is 2616 bytes).
14673 	 * Data offset is 72 bytes (40 ipv6 hdr, 32 tcp hdr). Some headroom.
14674 	 */
14675 	for (i = 0; i < 2; i++) {
14676 		skb[i] = alloc_skb(alloc_size, GFP_KERNEL);
14677 		if (!skb[i]) {
14678 			if (i == 0)
14679 				goto err_skb0;
14680 			else
14681 				goto err_skb1;
14682 		}
14683 
14684 		skb[i]->protocol = htons(ETH_P_IPV6);
14685 		skb_reserve(skb[i], headroom);
14686 		skb_put(skb[i], doffset + data_size);
14687 		skb_reset_network_header(skb[i]);
14688 		if (i == 0)
14689 			skb_reset_mac_header(skb[i]);
14690 		else
14691 			skb_set_mac_header(skb[i], -ETH_HLEN);
14692 		__skb_pull(skb[i], doffset);
14693 	}
14694 
14695 	/* setup shinfo.
14696 	 * mimic bpf_skb_proto_4_to_6, which resets gso_segs and assigns a
14697 	 * reduced gso_size.
14698 	 */
14699 	skb_shinfo(skb[0])->gso_size = 1288;
14700 	skb_shinfo(skb[0])->gso_type = SKB_GSO_TCPV6 | SKB_GSO_DODGY;
14701 	skb_shinfo(skb[0])->gso_segs = 0;
14702 	skb_shinfo(skb[0])->frag_list = skb[1];
14703 
14704 	/* adjust skb[0]'s len */
14705 	skb[0]->len += skb[1]->len;
14706 	skb[0]->data_len += skb[1]->len;
14707 	skb[0]->truesize += skb[1]->truesize;
14708 
14709 	return skb[0];
14710 
14711 err_skb1:
14712 	kfree_skb(skb[0]);
14713 err_skb0:
14714 	return NULL;
14715 }
14716 
14717 struct skb_segment_test {
14718 	const char *descr;
14719 	struct sk_buff *(*build_skb)(void);
14720 	netdev_features_t features;
14721 };
14722 
14723 static struct skb_segment_test skb_segment_tests[] __initconst = {
14724 	{
14725 		.descr = "gso_with_rx_frags",
14726 		.build_skb = build_test_skb,
14727 		.features = NETIF_F_SG | NETIF_F_GSO_PARTIAL | NETIF_F_IP_CSUM |
14728 			    NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM
14729 	},
14730 	{
14731 		.descr = "gso_linear_no_head_frag",
14732 		.build_skb = build_test_skb_linear_no_head_frag,
14733 		.features = NETIF_F_SG | NETIF_F_FRAGLIST |
14734 			    NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_GSO |
14735 			    NETIF_F_LLTX | NETIF_F_GRO |
14736 			    NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM |
14737 			    NETIF_F_HW_VLAN_STAG_TX
14738 	}
14739 };
14740 
14741 static __init int test_skb_segment_single(const struct skb_segment_test *test)
14742 {
14743 	struct sk_buff *skb, *segs;
14744 	int ret = -1;
14745 
14746 	skb = test->build_skb();
14747 	if (!skb) {
14748 		pr_info("%s: failed to build_test_skb", __func__);
14749 		goto done;
14750 	}
14751 
14752 	segs = skb_segment(skb, test->features);
14753 	if (!IS_ERR(segs)) {
14754 		kfree_skb_list(segs);
14755 		ret = 0;
14756 	}
14757 	kfree_skb(skb);
14758 done:
14759 	return ret;
14760 }
14761 
14762 static __init int test_skb_segment(void)
14763 {
14764 	int i, err_cnt = 0, pass_cnt = 0;
14765 
14766 	for (i = 0; i < ARRAY_SIZE(skb_segment_tests); i++) {
14767 		const struct skb_segment_test *test = &skb_segment_tests[i];
14768 
14769 		cond_resched();
14770 		if (exclude_test(i))
14771 			continue;
14772 
14773 		pr_info("#%d %s ", i, test->descr);
14774 
14775 		if (test_skb_segment_single(test)) {
14776 			pr_cont("FAIL\n");
14777 			err_cnt++;
14778 		} else {
14779 			pr_cont("PASS\n");
14780 			pass_cnt++;
14781 		}
14782 	}
14783 
14784 	pr_info("%s: Summary: %d PASSED, %d FAILED\n", __func__,
14785 		pass_cnt, err_cnt);
14786 	return err_cnt ? -EINVAL : 0;
14787 }
14788 
14789 static __init int test_bpf(void)
14790 {
14791 	int i, err_cnt = 0, pass_cnt = 0;
14792 	int jit_cnt = 0, run_cnt = 0;
14793 
14794 	for (i = 0; i < ARRAY_SIZE(tests); i++) {
14795 		struct bpf_prog *fp;
14796 		int err;
14797 
14798 		cond_resched();
14799 		if (exclude_test(i))
14800 			continue;
14801 
14802 		pr_info("#%d %s ", i, tests[i].descr);
14803 
14804 		if (tests[i].fill_helper &&
14805 		    tests[i].fill_helper(&tests[i]) < 0) {
14806 			pr_cont("FAIL to prog_fill\n");
14807 			continue;
14808 		}
14809 
14810 		fp = generate_filter(i, &err);
14811 
14812 		if (tests[i].fill_helper) {
14813 			kfree(tests[i].u.ptr.insns);
14814 			tests[i].u.ptr.insns = NULL;
14815 		}
14816 
14817 		if (fp == NULL) {
14818 			if (err == 0) {
14819 				pass_cnt++;
14820 				continue;
14821 			}
14822 			err_cnt++;
14823 			continue;
14824 		}
14825 
14826 		pr_cont("jited:%u ", fp->jited);
14827 
14828 		run_cnt++;
14829 		if (fp->jited)
14830 			jit_cnt++;
14831 
14832 		err = run_one(fp, &tests[i]);
14833 		release_filter(fp, i);
14834 
14835 		if (err) {
14836 			pr_cont("FAIL (%d times)\n", err);
14837 			err_cnt++;
14838 		} else {
14839 			pr_cont("PASS\n");
14840 			pass_cnt++;
14841 		}
14842 	}
14843 
14844 	pr_info("Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n",
14845 		pass_cnt, err_cnt, jit_cnt, run_cnt);
14846 
14847 	return err_cnt ? -EINVAL : 0;
14848 }
14849 
14850 struct tail_call_test {
14851 	const char *descr;
14852 	struct bpf_insn insns[MAX_INSNS];
14853 	int flags;
14854 	int result;
14855 	int stack_depth;
14856 };
14857 
14858 /* Flags that can be passed to tail call test cases */
14859 #define FLAG_NEED_STATE		BIT(0)
14860 #define FLAG_RESULT_IN_STATE	BIT(1)
14861 
14862 /*
14863  * Magic marker used in test snippets for tail calls below.
14864  * BPF_LD/MOV to R2 and R2 with this immediate value is replaced
14865  * with the proper values by the test runner.
14866  */
14867 #define TAIL_CALL_MARKER 0x7a11ca11
14868 
14869 /* Special offset to indicate a NULL call target */
14870 #define TAIL_CALL_NULL 0x7fff
14871 
14872 /* Special offset to indicate an out-of-range index */
14873 #define TAIL_CALL_INVALID 0x7ffe
14874 
14875 #define TAIL_CALL(offset)			       \
14876 	BPF_LD_IMM64(R2, TAIL_CALL_MARKER),	       \
14877 	BPF_RAW_INSN(BPF_ALU | BPF_MOV | BPF_K, R3, 0, \
14878 		     offset, TAIL_CALL_MARKER),	       \
14879 	BPF_JMP_IMM(BPF_TAIL_CALL, 0, 0, 0)
14880 
14881 /*
14882  * A test function to be called from a BPF program, clobbering a lot of
14883  * CPU registers in the process. A JITed BPF program calling this function
14884  * must save and restore any caller-saved registers it uses for internal
14885  * state, for example the current tail call count.
14886  */
14887 BPF_CALL_1(bpf_test_func, u64, arg)
14888 {
14889 	char buf[64];
14890 	long a = 0;
14891 	long b = 1;
14892 	long c = 2;
14893 	long d = 3;
14894 	long e = 4;
14895 	long f = 5;
14896 	long g = 6;
14897 	long h = 7;
14898 
14899 	return snprintf(buf, sizeof(buf),
14900 			"%ld %lu %lx %ld %lu %lx %ld %lu %x",
14901 			a, b, c, d, e, f, g, h, (int)arg);
14902 }
14903 #define BPF_FUNC_test_func __BPF_FUNC_MAX_ID
14904 
14905 /*
14906  * Tail call tests. Each test case may call any other test in the table,
14907  * including itself, specified as a relative index offset from the calling
14908  * test. The index TAIL_CALL_NULL can be used to specify a NULL target
14909  * function to test the JIT error path. Similarly, the index TAIL_CALL_INVALID
14910  * results in a target index that is out of range.
14911  */
14912 static struct tail_call_test tail_call_tests[] = {
14913 	{
14914 		"Tail call leaf",
14915 		.insns = {
14916 			BPF_ALU64_REG(BPF_MOV, R0, R1),
14917 			BPF_ALU64_IMM(BPF_ADD, R0, 1),
14918 			BPF_EXIT_INSN(),
14919 		},
14920 		.result = 1,
14921 	},
14922 	{
14923 		"Tail call 2",
14924 		.insns = {
14925 			BPF_ALU64_IMM(BPF_ADD, R1, 2),
14926 			TAIL_CALL(-1),
14927 			BPF_ALU64_IMM(BPF_MOV, R0, -1),
14928 			BPF_EXIT_INSN(),
14929 		},
14930 		.result = 3,
14931 	},
14932 	{
14933 		"Tail call 3",
14934 		.insns = {
14935 			BPF_ALU64_IMM(BPF_ADD, R1, 3),
14936 			TAIL_CALL(-1),
14937 			BPF_ALU64_IMM(BPF_MOV, R0, -1),
14938 			BPF_EXIT_INSN(),
14939 		},
14940 		.result = 6,
14941 	},
14942 	{
14943 		"Tail call 4",
14944 		.insns = {
14945 			BPF_ALU64_IMM(BPF_ADD, R1, 4),
14946 			TAIL_CALL(-1),
14947 			BPF_ALU64_IMM(BPF_MOV, R0, -1),
14948 			BPF_EXIT_INSN(),
14949 		},
14950 		.result = 10,
14951 	},
14952 	{
14953 		"Tail call load/store leaf",
14954 		.insns = {
14955 			BPF_ALU64_IMM(BPF_MOV, R1, 1),
14956 			BPF_ALU64_IMM(BPF_MOV, R2, 2),
14957 			BPF_ALU64_REG(BPF_MOV, R3, BPF_REG_FP),
14958 			BPF_STX_MEM(BPF_DW, R3, R1, -8),
14959 			BPF_STX_MEM(BPF_DW, R3, R2, -16),
14960 			BPF_LDX_MEM(BPF_DW, R0, BPF_REG_FP, -8),
14961 			BPF_JMP_REG(BPF_JNE, R0, R1, 3),
14962 			BPF_LDX_MEM(BPF_DW, R0, BPF_REG_FP, -16),
14963 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
14964 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14965 			BPF_EXIT_INSN(),
14966 		},
14967 		.result = 0,
14968 		.stack_depth = 32,
14969 	},
14970 	{
14971 		"Tail call load/store",
14972 		.insns = {
14973 			BPF_ALU64_IMM(BPF_MOV, R0, 3),
14974 			BPF_STX_MEM(BPF_DW, BPF_REG_FP, R0, -8),
14975 			TAIL_CALL(-1),
14976 			BPF_ALU64_IMM(BPF_MOV, R0, -1),
14977 			BPF_EXIT_INSN(),
14978 		},
14979 		.result = 0,
14980 		.stack_depth = 16,
14981 	},
14982 	{
14983 		"Tail call error path, max count reached",
14984 		.insns = {
14985 			BPF_LDX_MEM(BPF_W, R2, R1, 0),
14986 			BPF_ALU64_IMM(BPF_ADD, R2, 1),
14987 			BPF_STX_MEM(BPF_W, R1, R2, 0),
14988 			TAIL_CALL(0),
14989 			BPF_EXIT_INSN(),
14990 		},
14991 		.flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE,
14992 		.result = (MAX_TAIL_CALL_CNT + 1) * MAX_TESTRUNS,
14993 	},
14994 	{
14995 		"Tail call count preserved across function calls",
14996 		.insns = {
14997 			BPF_LDX_MEM(BPF_W, R2, R1, 0),
14998 			BPF_ALU64_IMM(BPF_ADD, R2, 1),
14999 			BPF_STX_MEM(BPF_W, R1, R2, 0),
15000 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
15001 			BPF_CALL_REL(BPF_FUNC_get_numa_node_id),
15002 			BPF_CALL_REL(BPF_FUNC_ktime_get_ns),
15003 			BPF_CALL_REL(BPF_FUNC_ktime_get_boot_ns),
15004 			BPF_CALL_REL(BPF_FUNC_ktime_get_coarse_ns),
15005 			BPF_CALL_REL(BPF_FUNC_jiffies64),
15006 			BPF_CALL_REL(BPF_FUNC_test_func),
15007 			BPF_LDX_MEM(BPF_DW, R1, R10, -8),
15008 			BPF_ALU32_REG(BPF_MOV, R0, R1),
15009 			TAIL_CALL(0),
15010 			BPF_EXIT_INSN(),
15011 		},
15012 		.stack_depth = 8,
15013 		.flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE,
15014 		.result = (MAX_TAIL_CALL_CNT + 1) * MAX_TESTRUNS,
15015 	},
15016 	{
15017 		"Tail call error path, NULL target",
15018 		.insns = {
15019 			BPF_LDX_MEM(BPF_W, R2, R1, 0),
15020 			BPF_ALU64_IMM(BPF_ADD, R2, 1),
15021 			BPF_STX_MEM(BPF_W, R1, R2, 0),
15022 			TAIL_CALL(TAIL_CALL_NULL),
15023 			BPF_EXIT_INSN(),
15024 		},
15025 		.flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE,
15026 		.result = MAX_TESTRUNS,
15027 	},
15028 	{
15029 		"Tail call error path, index out of range",
15030 		.insns = {
15031 			BPF_LDX_MEM(BPF_W, R2, R1, 0),
15032 			BPF_ALU64_IMM(BPF_ADD, R2, 1),
15033 			BPF_STX_MEM(BPF_W, R1, R2, 0),
15034 			TAIL_CALL(TAIL_CALL_INVALID),
15035 			BPF_EXIT_INSN(),
15036 		},
15037 		.flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE,
15038 		.result = MAX_TESTRUNS,
15039 	},
15040 };
15041 
15042 static void __init destroy_tail_call_tests(struct bpf_array *progs)
15043 {
15044 	int i;
15045 
15046 	for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++)
15047 		if (progs->ptrs[i])
15048 			bpf_prog_free(progs->ptrs[i]);
15049 	kfree(progs);
15050 }
15051 
15052 static __init int prepare_tail_call_tests(struct bpf_array **pprogs)
15053 {
15054 	int ntests = ARRAY_SIZE(tail_call_tests);
15055 	struct bpf_array *progs;
15056 	int which, err;
15057 
15058 	/* Allocate the table of programs to be used for tall calls */
15059 	progs = kzalloc(sizeof(*progs) + (ntests + 1) * sizeof(progs->ptrs[0]),
15060 			GFP_KERNEL);
15061 	if (!progs)
15062 		goto out_nomem;
15063 
15064 	/* Create all eBPF programs and populate the table */
15065 	for (which = 0; which < ntests; which++) {
15066 		struct tail_call_test *test = &tail_call_tests[which];
15067 		struct bpf_prog *fp;
15068 		int len, i;
15069 
15070 		/* Compute the number of program instructions */
15071 		for (len = 0; len < MAX_INSNS; len++) {
15072 			struct bpf_insn *insn = &test->insns[len];
15073 
15074 			if (len < MAX_INSNS - 1 &&
15075 			    insn->code == (BPF_LD | BPF_DW | BPF_IMM))
15076 				len++;
15077 			if (insn->code == 0)
15078 				break;
15079 		}
15080 
15081 		/* Allocate and initialize the program */
15082 		fp = bpf_prog_alloc(bpf_prog_size(len), 0);
15083 		if (!fp)
15084 			goto out_nomem;
15085 
15086 		fp->len = len;
15087 		fp->type = BPF_PROG_TYPE_SOCKET_FILTER;
15088 		fp->aux->stack_depth = test->stack_depth;
15089 		memcpy(fp->insnsi, test->insns, len * sizeof(struct bpf_insn));
15090 
15091 		/* Relocate runtime tail call offsets and addresses */
15092 		for (i = 0; i < len; i++) {
15093 			struct bpf_insn *insn = &fp->insnsi[i];
15094 			long addr = 0;
15095 
15096 			switch (insn->code) {
15097 			case BPF_LD | BPF_DW | BPF_IMM:
15098 				if (insn->imm != TAIL_CALL_MARKER)
15099 					break;
15100 				insn[0].imm = (u32)(long)progs;
15101 				insn[1].imm = ((u64)(long)progs) >> 32;
15102 				break;
15103 
15104 			case BPF_ALU | BPF_MOV | BPF_K:
15105 				if (insn->imm != TAIL_CALL_MARKER)
15106 					break;
15107 				if (insn->off == TAIL_CALL_NULL)
15108 					insn->imm = ntests;
15109 				else if (insn->off == TAIL_CALL_INVALID)
15110 					insn->imm = ntests + 1;
15111 				else
15112 					insn->imm = which + insn->off;
15113 				insn->off = 0;
15114 				break;
15115 
15116 			case BPF_JMP | BPF_CALL:
15117 				if (insn->src_reg != BPF_PSEUDO_CALL)
15118 					break;
15119 				switch (insn->imm) {
15120 				case BPF_FUNC_get_numa_node_id:
15121 					addr = (long)&numa_node_id;
15122 					break;
15123 				case BPF_FUNC_ktime_get_ns:
15124 					addr = (long)&ktime_get_ns;
15125 					break;
15126 				case BPF_FUNC_ktime_get_boot_ns:
15127 					addr = (long)&ktime_get_boot_fast_ns;
15128 					break;
15129 				case BPF_FUNC_ktime_get_coarse_ns:
15130 					addr = (long)&ktime_get_coarse_ns;
15131 					break;
15132 				case BPF_FUNC_jiffies64:
15133 					addr = (long)&get_jiffies_64;
15134 					break;
15135 				case BPF_FUNC_test_func:
15136 					addr = (long)&bpf_test_func;
15137 					break;
15138 				default:
15139 					err = -EFAULT;
15140 					goto out_err;
15141 				}
15142 				*insn = BPF_EMIT_CALL(addr);
15143 				if ((long)__bpf_call_base + insn->imm != addr)
15144 					*insn = BPF_JMP_A(0); /* Skip: NOP */
15145 				break;
15146 			}
15147 		}
15148 
15149 		fp = bpf_prog_select_runtime(fp, &err);
15150 		if (err)
15151 			goto out_err;
15152 
15153 		progs->ptrs[which] = fp;
15154 	}
15155 
15156 	/* The last entry contains a NULL program pointer */
15157 	progs->map.max_entries = ntests + 1;
15158 	*pprogs = progs;
15159 	return 0;
15160 
15161 out_nomem:
15162 	err = -ENOMEM;
15163 
15164 out_err:
15165 	if (progs)
15166 		destroy_tail_call_tests(progs);
15167 	return err;
15168 }
15169 
15170 static __init int test_tail_calls(struct bpf_array *progs)
15171 {
15172 	int i, err_cnt = 0, pass_cnt = 0;
15173 	int jit_cnt = 0, run_cnt = 0;
15174 
15175 	for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++) {
15176 		struct tail_call_test *test = &tail_call_tests[i];
15177 		struct bpf_prog *fp = progs->ptrs[i];
15178 		int *data = NULL;
15179 		int state = 0;
15180 		u64 duration;
15181 		int ret;
15182 
15183 		cond_resched();
15184 		if (exclude_test(i))
15185 			continue;
15186 
15187 		pr_info("#%d %s ", i, test->descr);
15188 		if (!fp) {
15189 			err_cnt++;
15190 			continue;
15191 		}
15192 		pr_cont("jited:%u ", fp->jited);
15193 
15194 		run_cnt++;
15195 		if (fp->jited)
15196 			jit_cnt++;
15197 
15198 		if (test->flags & FLAG_NEED_STATE)
15199 			data = &state;
15200 		ret = __run_one(fp, data, MAX_TESTRUNS, &duration);
15201 		if (test->flags & FLAG_RESULT_IN_STATE)
15202 			ret = state;
15203 		if (ret == test->result) {
15204 			pr_cont("%lld PASS", duration);
15205 			pass_cnt++;
15206 		} else {
15207 			pr_cont("ret %d != %d FAIL", ret, test->result);
15208 			err_cnt++;
15209 		}
15210 	}
15211 
15212 	pr_info("%s: Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n",
15213 		__func__, pass_cnt, err_cnt, jit_cnt, run_cnt);
15214 
15215 	return err_cnt ? -EINVAL : 0;
15216 }
15217 
15218 static char test_suite[32];
15219 module_param_string(test_suite, test_suite, sizeof(test_suite), 0);
15220 
15221 static __init int find_test_index(const char *test_name)
15222 {
15223 	int i;
15224 
15225 	if (!strcmp(test_suite, "test_bpf")) {
15226 		for (i = 0; i < ARRAY_SIZE(tests); i++) {
15227 			if (!strcmp(tests[i].descr, test_name))
15228 				return i;
15229 		}
15230 	}
15231 
15232 	if (!strcmp(test_suite, "test_tail_calls")) {
15233 		for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++) {
15234 			if (!strcmp(tail_call_tests[i].descr, test_name))
15235 				return i;
15236 		}
15237 	}
15238 
15239 	if (!strcmp(test_suite, "test_skb_segment")) {
15240 		for (i = 0; i < ARRAY_SIZE(skb_segment_tests); i++) {
15241 			if (!strcmp(skb_segment_tests[i].descr, test_name))
15242 				return i;
15243 		}
15244 	}
15245 
15246 	return -1;
15247 }
15248 
15249 static __init int prepare_test_range(void)
15250 {
15251 	int valid_range;
15252 
15253 	if (!strcmp(test_suite, "test_bpf"))
15254 		valid_range = ARRAY_SIZE(tests);
15255 	else if (!strcmp(test_suite, "test_tail_calls"))
15256 		valid_range = ARRAY_SIZE(tail_call_tests);
15257 	else if (!strcmp(test_suite, "test_skb_segment"))
15258 		valid_range = ARRAY_SIZE(skb_segment_tests);
15259 	else
15260 		return 0;
15261 
15262 	if (test_id >= 0) {
15263 		/*
15264 		 * if a test_id was specified, use test_range to
15265 		 * cover only that test.
15266 		 */
15267 		if (test_id >= valid_range) {
15268 			pr_err("test_bpf: invalid test_id specified for '%s' suite.\n",
15269 			       test_suite);
15270 			return -EINVAL;
15271 		}
15272 
15273 		test_range[0] = test_id;
15274 		test_range[1] = test_id;
15275 	} else if (*test_name) {
15276 		/*
15277 		 * if a test_name was specified, find it and setup
15278 		 * test_range to cover only that test.
15279 		 */
15280 		int idx = find_test_index(test_name);
15281 
15282 		if (idx < 0) {
15283 			pr_err("test_bpf: no test named '%s' found for '%s' suite.\n",
15284 			       test_name, test_suite);
15285 			return -EINVAL;
15286 		}
15287 		test_range[0] = idx;
15288 		test_range[1] = idx;
15289 	} else if (test_range[0] != 0 || test_range[1] != INT_MAX) {
15290 		/*
15291 		 * check that the supplied test_range is valid.
15292 		 */
15293 		if (test_range[0] < 0 || test_range[1] >= valid_range) {
15294 			pr_err("test_bpf: test_range is out of bound for '%s' suite.\n",
15295 			       test_suite);
15296 			return -EINVAL;
15297 		}
15298 
15299 		if (test_range[1] < test_range[0]) {
15300 			pr_err("test_bpf: test_range is ending before it starts.\n");
15301 			return -EINVAL;
15302 		}
15303 	}
15304 
15305 	return 0;
15306 }
15307 
15308 static int __init test_bpf_init(void)
15309 {
15310 	struct bpf_array *progs = NULL;
15311 	int ret;
15312 
15313 	if (strlen(test_suite) &&
15314 	    strcmp(test_suite, "test_bpf") &&
15315 	    strcmp(test_suite, "test_tail_calls") &&
15316 	    strcmp(test_suite, "test_skb_segment")) {
15317 		pr_err("test_bpf: invalid test_suite '%s' specified.\n", test_suite);
15318 		return -EINVAL;
15319 	}
15320 
15321 	/*
15322 	 * if test_suite is not specified, but test_id, test_name or test_range
15323 	 * is specified, set 'test_bpf' as the default test suite.
15324 	 */
15325 	if (!strlen(test_suite) &&
15326 	    (test_id != -1 || strlen(test_name) ||
15327 	    (test_range[0] != 0 || test_range[1] != INT_MAX))) {
15328 		pr_info("test_bpf: set 'test_bpf' as the default test_suite.\n");
15329 		strscpy(test_suite, "test_bpf", sizeof(test_suite));
15330 	}
15331 
15332 	ret = prepare_test_range();
15333 	if (ret < 0)
15334 		return ret;
15335 
15336 	if (!strlen(test_suite) || !strcmp(test_suite, "test_bpf")) {
15337 		ret = test_bpf();
15338 		if (ret)
15339 			return ret;
15340 	}
15341 
15342 	if (!strlen(test_suite) || !strcmp(test_suite, "test_tail_calls")) {
15343 		ret = prepare_tail_call_tests(&progs);
15344 		if (ret)
15345 			return ret;
15346 		ret = test_tail_calls(progs);
15347 		destroy_tail_call_tests(progs);
15348 		if (ret)
15349 			return ret;
15350 	}
15351 
15352 	if (!strlen(test_suite) || !strcmp(test_suite, "test_skb_segment"))
15353 		return test_skb_segment();
15354 
15355 	return 0;
15356 }
15357 
15358 static void __exit test_bpf_exit(void)
15359 {
15360 }
15361 
15362 module_init(test_bpf_init);
15363 module_exit(test_bpf_exit);
15364 
15365 MODULE_LICENSE("GPL");
15366