xref: /linux/lib/test_bpf.c (revision 58d416351e6df1a41d415958ccdd8eb9c2173fed) 
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Testsuite for BPF interpreter and BPF JIT compiler
4  *
5  * Copyright (c) 2011-2014 PLUMgrid, http://plumgrid.com
6  */
7 
8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
9 
10 #include <linux/init.h>
11 #include <linux/module.h>
12 #include <linux/filter.h>
13 #include <linux/bpf.h>
14 #include <linux/skbuff.h>
15 #include <linux/netdevice.h>
16 #include <linux/if_vlan.h>
17 #include <linux/random.h>
18 #include <linux/highmem.h>
19 #include <linux/sched.h>
20 
21 /* General test specific settings */
22 #define MAX_SUBTESTS	3
23 #define MAX_TESTRUNS	1000
24 #define MAX_DATA	128
25 #define MAX_INSNS	512
26 #define MAX_K		0xffffFFFF
27 
28 /* Few constants used to init test 'skb' */
29 #define SKB_TYPE	3
30 #define SKB_MARK	0x1234aaaa
31 #define SKB_HASH	0x1234aaab
32 #define SKB_QUEUE_MAP	123
33 #define SKB_VLAN_TCI	0xffff
34 #define SKB_VLAN_PRESENT	1
35 #define SKB_DEV_IFINDEX	577
36 #define SKB_DEV_TYPE	588
37 
38 /* Redefine REGs to make tests less verbose */
39 #define R0		BPF_REG_0
40 #define R1		BPF_REG_1
41 #define R2		BPF_REG_2
42 #define R3		BPF_REG_3
43 #define R4		BPF_REG_4
44 #define R5		BPF_REG_5
45 #define R6		BPF_REG_6
46 #define R7		BPF_REG_7
47 #define R8		BPF_REG_8
48 #define R9		BPF_REG_9
49 #define R10		BPF_REG_10
50 
51 /* Flags that can be passed to test cases */
52 #define FLAG_NO_DATA		BIT(0)
53 #define FLAG_EXPECTED_FAIL	BIT(1)
54 #define FLAG_SKB_FRAG		BIT(2)
55 #define FLAG_VERIFIER_ZEXT	BIT(3)
56 
57 enum {
58 	CLASSIC  = BIT(6),	/* Old BPF instructions only. */
59 	INTERNAL = BIT(7),	/* Extended instruction set.  */
60 };
61 
62 #define TEST_TYPE_MASK		(CLASSIC | INTERNAL)
63 
64 struct bpf_test {
65 	const char *descr;
66 	union {
67 		struct sock_filter insns[MAX_INSNS];
68 		struct bpf_insn insns_int[MAX_INSNS];
69 		struct {
70 			void *insns;
71 			unsigned int len;
72 		} ptr;
73 	} u;
74 	__u8 aux;
75 	__u8 data[MAX_DATA];
76 	struct {
77 		int data_size;
78 		__u32 result;
79 	} test[MAX_SUBTESTS];
80 	int (*fill_helper)(struct bpf_test *self);
81 	int expected_errcode; /* used when FLAG_EXPECTED_FAIL is set in the aux */
82 	__u8 frag_data[MAX_DATA];
83 	int stack_depth; /* for eBPF only, since tests don't call verifier */
84 	int nr_testruns; /* Custom run count, defaults to MAX_TESTRUNS if 0 */
85 };
86 
87 /* Large test cases need separate allocation and fill handler. */
88 
89 static int bpf_fill_maxinsns1(struct bpf_test *self)
90 {
91 	unsigned int len = BPF_MAXINSNS;
92 	struct sock_filter *insn;
93 	__u32 k = ~0;
94 	int i;
95 
96 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
97 	if (!insn)
98 		return -ENOMEM;
99 
100 	for (i = 0; i < len; i++, k--)
101 		insn[i] = __BPF_STMT(BPF_RET | BPF_K, k);
102 
103 	self->u.ptr.insns = insn;
104 	self->u.ptr.len = len;
105 
106 	return 0;
107 }
108 
109 static int bpf_fill_maxinsns2(struct bpf_test *self)
110 {
111 	unsigned int len = BPF_MAXINSNS;
112 	struct sock_filter *insn;
113 	int i;
114 
115 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
116 	if (!insn)
117 		return -ENOMEM;
118 
119 	for (i = 0; i < len; i++)
120 		insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
121 
122 	self->u.ptr.insns = insn;
123 	self->u.ptr.len = len;
124 
125 	return 0;
126 }
127 
128 static int bpf_fill_maxinsns3(struct bpf_test *self)
129 {
130 	unsigned int len = BPF_MAXINSNS;
131 	struct sock_filter *insn;
132 	struct rnd_state rnd;
133 	int i;
134 
135 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
136 	if (!insn)
137 		return -ENOMEM;
138 
139 	prandom_seed_state(&rnd, 3141592653589793238ULL);
140 
141 	for (i = 0; i < len - 1; i++) {
142 		__u32 k = prandom_u32_state(&rnd);
143 
144 		insn[i] = __BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, k);
145 	}
146 
147 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
148 
149 	self->u.ptr.insns = insn;
150 	self->u.ptr.len = len;
151 
152 	return 0;
153 }
154 
155 static int bpf_fill_maxinsns4(struct bpf_test *self)
156 {
157 	unsigned int len = BPF_MAXINSNS + 1;
158 	struct sock_filter *insn;
159 	int i;
160 
161 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
162 	if (!insn)
163 		return -ENOMEM;
164 
165 	for (i = 0; i < len; i++)
166 		insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
167 
168 	self->u.ptr.insns = insn;
169 	self->u.ptr.len = len;
170 
171 	return 0;
172 }
173 
174 static int bpf_fill_maxinsns5(struct bpf_test *self)
175 {
176 	unsigned int len = BPF_MAXINSNS;
177 	struct sock_filter *insn;
178 	int i;
179 
180 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
181 	if (!insn)
182 		return -ENOMEM;
183 
184 	insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0);
185 
186 	for (i = 1; i < len - 1; i++)
187 		insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
188 
189 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab);
190 
191 	self->u.ptr.insns = insn;
192 	self->u.ptr.len = len;
193 
194 	return 0;
195 }
196 
197 static int bpf_fill_maxinsns6(struct bpf_test *self)
198 {
199 	unsigned int len = BPF_MAXINSNS;
200 	struct sock_filter *insn;
201 	int i;
202 
203 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
204 	if (!insn)
205 		return -ENOMEM;
206 
207 	for (i = 0; i < len - 1; i++)
208 		insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
209 				     SKF_AD_VLAN_TAG_PRESENT);
210 
211 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
212 
213 	self->u.ptr.insns = insn;
214 	self->u.ptr.len = len;
215 
216 	return 0;
217 }
218 
219 static int bpf_fill_maxinsns7(struct bpf_test *self)
220 {
221 	unsigned int len = BPF_MAXINSNS;
222 	struct sock_filter *insn;
223 	int i;
224 
225 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
226 	if (!insn)
227 		return -ENOMEM;
228 
229 	for (i = 0; i < len - 4; i++)
230 		insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
231 				     SKF_AD_CPU);
232 
233 	insn[len - 4] = __BPF_STMT(BPF_MISC | BPF_TAX, 0);
234 	insn[len - 3] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
235 				   SKF_AD_CPU);
236 	insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0);
237 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
238 
239 	self->u.ptr.insns = insn;
240 	self->u.ptr.len = len;
241 
242 	return 0;
243 }
244 
245 static int bpf_fill_maxinsns8(struct bpf_test *self)
246 {
247 	unsigned int len = BPF_MAXINSNS;
248 	struct sock_filter *insn;
249 	int i, jmp_off = len - 3;
250 
251 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
252 	if (!insn)
253 		return -ENOMEM;
254 
255 	insn[0] = __BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff);
256 
257 	for (i = 1; i < len - 1; i++)
258 		insn[i] = __BPF_JUMP(BPF_JMP | BPF_JGT, 0xffffffff, jmp_off--, 0);
259 
260 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
261 
262 	self->u.ptr.insns = insn;
263 	self->u.ptr.len = len;
264 
265 	return 0;
266 }
267 
268 static int bpf_fill_maxinsns9(struct bpf_test *self)
269 {
270 	unsigned int len = BPF_MAXINSNS;
271 	struct bpf_insn *insn;
272 	int i;
273 
274 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
275 	if (!insn)
276 		return -ENOMEM;
277 
278 	insn[0] = BPF_JMP_IMM(BPF_JA, 0, 0, len - 2);
279 	insn[1] = BPF_ALU32_IMM(BPF_MOV, R0, 0xcbababab);
280 	insn[2] = BPF_EXIT_INSN();
281 
282 	for (i = 3; i < len - 2; i++)
283 		insn[i] = BPF_ALU32_IMM(BPF_MOV, R0, 0xfefefefe);
284 
285 	insn[len - 2] = BPF_EXIT_INSN();
286 	insn[len - 1] = BPF_JMP_IMM(BPF_JA, 0, 0, -(len - 1));
287 
288 	self->u.ptr.insns = insn;
289 	self->u.ptr.len = len;
290 
291 	return 0;
292 }
293 
294 static int bpf_fill_maxinsns10(struct bpf_test *self)
295 {
296 	unsigned int len = BPF_MAXINSNS, hlen = len - 2;
297 	struct bpf_insn *insn;
298 	int i;
299 
300 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
301 	if (!insn)
302 		return -ENOMEM;
303 
304 	for (i = 0; i < hlen / 2; i++)
305 		insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 2 - 2 * i);
306 	for (i = hlen - 1; i > hlen / 2; i--)
307 		insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 1 - 2 * i);
308 
309 	insn[hlen / 2] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen / 2 - 1);
310 	insn[hlen]     = BPF_ALU32_IMM(BPF_MOV, R0, 0xabababac);
311 	insn[hlen + 1] = BPF_EXIT_INSN();
312 
313 	self->u.ptr.insns = insn;
314 	self->u.ptr.len = len;
315 
316 	return 0;
317 }
318 
319 static int __bpf_fill_ja(struct bpf_test *self, unsigned int len,
320 			 unsigned int plen)
321 {
322 	struct sock_filter *insn;
323 	unsigned int rlen;
324 	int i, j;
325 
326 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
327 	if (!insn)
328 		return -ENOMEM;
329 
330 	rlen = (len % plen) - 1;
331 
332 	for (i = 0; i + plen < len; i += plen)
333 		for (j = 0; j < plen; j++)
334 			insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA,
335 						 plen - 1 - j, 0, 0);
336 	for (j = 0; j < rlen; j++)
337 		insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA, rlen - 1 - j,
338 					 0, 0);
339 
340 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xababcbac);
341 
342 	self->u.ptr.insns = insn;
343 	self->u.ptr.len = len;
344 
345 	return 0;
346 }
347 
348 static int bpf_fill_maxinsns11(struct bpf_test *self)
349 {
350 	/* Hits 70 passes on x86_64 and triggers NOPs padding. */
351 	return __bpf_fill_ja(self, BPF_MAXINSNS, 68);
352 }
353 
354 static int bpf_fill_maxinsns12(struct bpf_test *self)
355 {
356 	unsigned int len = BPF_MAXINSNS;
357 	struct sock_filter *insn;
358 	int i = 0;
359 
360 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
361 	if (!insn)
362 		return -ENOMEM;
363 
364 	insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0);
365 
366 	for (i = 1; i < len - 1; i++)
367 		insn[i] = __BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0);
368 
369 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab);
370 
371 	self->u.ptr.insns = insn;
372 	self->u.ptr.len = len;
373 
374 	return 0;
375 }
376 
377 static int bpf_fill_maxinsns13(struct bpf_test *self)
378 {
379 	unsigned int len = BPF_MAXINSNS;
380 	struct sock_filter *insn;
381 	int i = 0;
382 
383 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
384 	if (!insn)
385 		return -ENOMEM;
386 
387 	for (i = 0; i < len - 3; i++)
388 		insn[i] = __BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0);
389 
390 	insn[len - 3] = __BPF_STMT(BPF_LD | BPF_IMM, 0xabababab);
391 	insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0);
392 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
393 
394 	self->u.ptr.insns = insn;
395 	self->u.ptr.len = len;
396 
397 	return 0;
398 }
399 
400 static int bpf_fill_ja(struct bpf_test *self)
401 {
402 	/* Hits exactly 11 passes on x86_64 JIT. */
403 	return __bpf_fill_ja(self, 12, 9);
404 }
405 
406 static int bpf_fill_ld_abs_get_processor_id(struct bpf_test *self)
407 {
408 	unsigned int len = BPF_MAXINSNS;
409 	struct sock_filter *insn;
410 	int i;
411 
412 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
413 	if (!insn)
414 		return -ENOMEM;
415 
416 	for (i = 0; i < len - 1; i += 2) {
417 		insn[i] = __BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 0);
418 		insn[i + 1] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
419 					 SKF_AD_OFF + SKF_AD_CPU);
420 	}
421 
422 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xbee);
423 
424 	self->u.ptr.insns = insn;
425 	self->u.ptr.len = len;
426 
427 	return 0;
428 }
429 
430 static int __bpf_fill_stxdw(struct bpf_test *self, int size)
431 {
432 	unsigned int len = BPF_MAXINSNS;
433 	struct bpf_insn *insn;
434 	int i;
435 
436 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
437 	if (!insn)
438 		return -ENOMEM;
439 
440 	insn[0] = BPF_ALU32_IMM(BPF_MOV, R0, 1);
441 	insn[1] = BPF_ST_MEM(size, R10, -40, 42);
442 
443 	for (i = 2; i < len - 2; i++)
444 		insn[i] = BPF_STX_XADD(size, R10, R0, -40);
445 
446 	insn[len - 2] = BPF_LDX_MEM(size, R0, R10, -40);
447 	insn[len - 1] = BPF_EXIT_INSN();
448 
449 	self->u.ptr.insns = insn;
450 	self->u.ptr.len = len;
451 	self->stack_depth = 40;
452 
453 	return 0;
454 }
455 
456 static int bpf_fill_stxw(struct bpf_test *self)
457 {
458 	return __bpf_fill_stxdw(self, BPF_W);
459 }
460 
461 static int bpf_fill_stxdw(struct bpf_test *self)
462 {
463 	return __bpf_fill_stxdw(self, BPF_DW);
464 }
465 
466 static int __bpf_ld_imm64(struct bpf_insn insns[2], u8 reg, s64 imm64)
467 {
468 	struct bpf_insn tmp[] = {BPF_LD_IMM64(reg, imm64)};
469 
470 	memcpy(insns, tmp, sizeof(tmp));
471 	return 2;
472 }
473 
474 /*
475  * Branch conversion tests. Complex operations can expand to a lot
476  * of instructions when JITed. This in turn may cause jump offsets
477  * to overflow the field size of the native instruction, triggering
478  * a branch conversion mechanism in some JITs.
479  */
480 static int __bpf_fill_max_jmp(struct bpf_test *self, int jmp, int imm)
481 {
482 	struct bpf_insn *insns;
483 	int len = S16_MAX + 5;
484 	int i;
485 
486 	insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL);
487 	if (!insns)
488 		return -ENOMEM;
489 
490 	i = __bpf_ld_imm64(insns, R1, 0x0123456789abcdefULL);
491 	insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
492 	insns[i++] = BPF_JMP_IMM(jmp, R0, imm, S16_MAX);
493 	insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 2);
494 	insns[i++] = BPF_EXIT_INSN();
495 
496 	while (i < len - 1) {
497 		static const int ops[] = {
498 			BPF_LSH, BPF_RSH, BPF_ARSH, BPF_ADD,
499 			BPF_SUB, BPF_MUL, BPF_DIV, BPF_MOD,
500 		};
501 		int op = ops[(i >> 1) % ARRAY_SIZE(ops)];
502 
503 		if (i & 1)
504 			insns[i++] = BPF_ALU32_REG(op, R0, R1);
505 		else
506 			insns[i++] = BPF_ALU64_REG(op, R0, R1);
507 	}
508 
509 	insns[i++] = BPF_EXIT_INSN();
510 	self->u.ptr.insns = insns;
511 	self->u.ptr.len = len;
512 	BUG_ON(i != len);
513 
514 	return 0;
515 }
516 
517 /* Branch taken by runtime decision */
518 static int bpf_fill_max_jmp_taken(struct bpf_test *self)
519 {
520 	return __bpf_fill_max_jmp(self, BPF_JEQ, 1);
521 }
522 
523 /* Branch not taken by runtime decision */
524 static int bpf_fill_max_jmp_not_taken(struct bpf_test *self)
525 {
526 	return __bpf_fill_max_jmp(self, BPF_JEQ, 0);
527 }
528 
529 /* Branch always taken, known at JIT time */
530 static int bpf_fill_max_jmp_always_taken(struct bpf_test *self)
531 {
532 	return __bpf_fill_max_jmp(self, BPF_JGE, 0);
533 }
534 
535 /* Branch never taken, known at JIT time */
536 static int bpf_fill_max_jmp_never_taken(struct bpf_test *self)
537 {
538 	return __bpf_fill_max_jmp(self, BPF_JLT, 0);
539 }
540 
541 /* ALU result computation used in tests */
542 static bool __bpf_alu_result(u64 *res, u64 v1, u64 v2, u8 op)
543 {
544 	*res = 0;
545 	switch (op) {
546 	case BPF_MOV:
547 		*res = v2;
548 		break;
549 	case BPF_AND:
550 		*res = v1 & v2;
551 		break;
552 	case BPF_OR:
553 		*res = v1 | v2;
554 		break;
555 	case BPF_XOR:
556 		*res = v1 ^ v2;
557 		break;
558 	case BPF_LSH:
559 		*res = v1 << v2;
560 		break;
561 	case BPF_RSH:
562 		*res = v1 >> v2;
563 		break;
564 	case BPF_ARSH:
565 		*res = v1 >> v2;
566 		if (v2 > 0 && v1 > S64_MAX)
567 			*res |= ~0ULL << (64 - v2);
568 		break;
569 	case BPF_ADD:
570 		*res = v1 + v2;
571 		break;
572 	case BPF_SUB:
573 		*res = v1 - v2;
574 		break;
575 	case BPF_MUL:
576 		*res = v1 * v2;
577 		break;
578 	case BPF_DIV:
579 		if (v2 == 0)
580 			return false;
581 		*res = div64_u64(v1, v2);
582 		break;
583 	case BPF_MOD:
584 		if (v2 == 0)
585 			return false;
586 		div64_u64_rem(v1, v2, res);
587 		break;
588 	}
589 	return true;
590 }
591 
592 /* Test an ALU shift operation for all valid shift values */
593 static int __bpf_fill_alu_shift(struct bpf_test *self, u8 op,
594 				u8 mode, bool alu32)
595 {
596 	static const s64 regs[] = {
597 		0x0123456789abcdefLL, /* dword > 0, word < 0 */
598 		0xfedcba9876543210LL, /* dowrd < 0, word > 0 */
599 		0xfedcba0198765432LL, /* dowrd < 0, word < 0 */
600 		0x0123458967abcdefLL, /* dword > 0, word > 0 */
601 	};
602 	int bits = alu32 ? 32 : 64;
603 	int len = (2 + 7 * bits) * ARRAY_SIZE(regs) + 3;
604 	struct bpf_insn *insn;
605 	int imm, k;
606 	int i = 0;
607 
608 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
609 	if (!insn)
610 		return -ENOMEM;
611 
612 	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
613 
614 	for (k = 0; k < ARRAY_SIZE(regs); k++) {
615 		s64 reg = regs[k];
616 
617 		i += __bpf_ld_imm64(&insn[i], R3, reg);
618 
619 		for (imm = 0; imm < bits; imm++) {
620 			u64 val;
621 
622 			/* Perform operation */
623 			insn[i++] = BPF_ALU64_REG(BPF_MOV, R1, R3);
624 			insn[i++] = BPF_ALU64_IMM(BPF_MOV, R2, imm);
625 			if (alu32) {
626 				if (mode == BPF_K)
627 					insn[i++] = BPF_ALU32_IMM(op, R1, imm);
628 				else
629 					insn[i++] = BPF_ALU32_REG(op, R1, R2);
630 
631 				if (op == BPF_ARSH)
632 					reg = (s32)reg;
633 				else
634 					reg = (u32)reg;
635 				__bpf_alu_result(&val, reg, imm, op);
636 				val = (u32)val;
637 			} else {
638 				if (mode == BPF_K)
639 					insn[i++] = BPF_ALU64_IMM(op, R1, imm);
640 				else
641 					insn[i++] = BPF_ALU64_REG(op, R1, R2);
642 				__bpf_alu_result(&val, reg, imm, op);
643 			}
644 
645 			/*
646 			 * When debugging a JIT that fails this test, one
647 			 * can write the immediate value to R0 here to find
648 			 * out which operand values that fail.
649 			 */
650 
651 			/* Load reference and check the result */
652 			i += __bpf_ld_imm64(&insn[i], R4, val);
653 			insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R4, 1);
654 			insn[i++] = BPF_EXIT_INSN();
655 		}
656 	}
657 
658 	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
659 	insn[i++] = BPF_EXIT_INSN();
660 
661 	self->u.ptr.insns = insn;
662 	self->u.ptr.len = len;
663 	BUG_ON(i != len);
664 
665 	return 0;
666 }
667 
668 static int bpf_fill_alu64_lsh_imm(struct bpf_test *self)
669 {
670 	return __bpf_fill_alu_shift(self, BPF_LSH, BPF_K, false);
671 }
672 
673 static int bpf_fill_alu64_rsh_imm(struct bpf_test *self)
674 {
675 	return __bpf_fill_alu_shift(self, BPF_RSH, BPF_K, false);
676 }
677 
678 static int bpf_fill_alu64_arsh_imm(struct bpf_test *self)
679 {
680 	return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_K, false);
681 }
682 
683 static int bpf_fill_alu64_lsh_reg(struct bpf_test *self)
684 {
685 	return __bpf_fill_alu_shift(self, BPF_LSH, BPF_X, false);
686 }
687 
688 static int bpf_fill_alu64_rsh_reg(struct bpf_test *self)
689 {
690 	return __bpf_fill_alu_shift(self, BPF_RSH, BPF_X, false);
691 }
692 
693 static int bpf_fill_alu64_arsh_reg(struct bpf_test *self)
694 {
695 	return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_X, false);
696 }
697 
698 static int bpf_fill_alu32_lsh_imm(struct bpf_test *self)
699 {
700 	return __bpf_fill_alu_shift(self, BPF_LSH, BPF_K, true);
701 }
702 
703 static int bpf_fill_alu32_rsh_imm(struct bpf_test *self)
704 {
705 	return __bpf_fill_alu_shift(self, BPF_RSH, BPF_K, true);
706 }
707 
708 static int bpf_fill_alu32_arsh_imm(struct bpf_test *self)
709 {
710 	return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_K, true);
711 }
712 
713 static int bpf_fill_alu32_lsh_reg(struct bpf_test *self)
714 {
715 	return __bpf_fill_alu_shift(self, BPF_LSH, BPF_X, true);
716 }
717 
718 static int bpf_fill_alu32_rsh_reg(struct bpf_test *self)
719 {
720 	return __bpf_fill_alu_shift(self, BPF_RSH, BPF_X, true);
721 }
722 
723 static int bpf_fill_alu32_arsh_reg(struct bpf_test *self)
724 {
725 	return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_X, true);
726 }
727 
728 /*
729  * Test an ALU register shift operation for all valid shift values
730  * for the case when the source and destination are the same.
731  */
732 static int __bpf_fill_alu_shift_same_reg(struct bpf_test *self, u8 op,
733 					 bool alu32)
734 {
735 	int bits = alu32 ? 32 : 64;
736 	int len = 3 + 6 * bits;
737 	struct bpf_insn *insn;
738 	int i = 0;
739 	u64 val;
740 
741 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
742 	if (!insn)
743 		return -ENOMEM;
744 
745 	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
746 
747 	for (val = 0; val < bits; val++) {
748 		u64 res;
749 
750 		/* Perform operation */
751 		insn[i++] = BPF_ALU64_IMM(BPF_MOV, R1, val);
752 		if (alu32)
753 			insn[i++] = BPF_ALU32_REG(op, R1, R1);
754 		else
755 			insn[i++] = BPF_ALU64_REG(op, R1, R1);
756 
757 		/* Compute the reference result */
758 		__bpf_alu_result(&res, val, val, op);
759 		if (alu32)
760 			res = (u32)res;
761 		i += __bpf_ld_imm64(&insn[i], R2, res);
762 
763 		/* Check the actual result */
764 		insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R2, 1);
765 		insn[i++] = BPF_EXIT_INSN();
766 	}
767 
768 	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
769 	insn[i++] = BPF_EXIT_INSN();
770 
771 	self->u.ptr.insns = insn;
772 	self->u.ptr.len = len;
773 	BUG_ON(i != len);
774 
775 	return 0;
776 }
777 
778 static int bpf_fill_alu64_lsh_same_reg(struct bpf_test *self)
779 {
780 	return __bpf_fill_alu_shift_same_reg(self, BPF_LSH, false);
781 }
782 
783 static int bpf_fill_alu64_rsh_same_reg(struct bpf_test *self)
784 {
785 	return __bpf_fill_alu_shift_same_reg(self, BPF_RSH, false);
786 }
787 
788 static int bpf_fill_alu64_arsh_same_reg(struct bpf_test *self)
789 {
790 	return __bpf_fill_alu_shift_same_reg(self, BPF_ARSH, false);
791 }
792 
793 static int bpf_fill_alu32_lsh_same_reg(struct bpf_test *self)
794 {
795 	return __bpf_fill_alu_shift_same_reg(self, BPF_LSH, true);
796 }
797 
798 static int bpf_fill_alu32_rsh_same_reg(struct bpf_test *self)
799 {
800 	return __bpf_fill_alu_shift_same_reg(self, BPF_RSH, true);
801 }
802 
803 static int bpf_fill_alu32_arsh_same_reg(struct bpf_test *self)
804 {
805 	return __bpf_fill_alu_shift_same_reg(self, BPF_ARSH, true);
806 }
807 
808 /*
809  * Common operand pattern generator for exhaustive power-of-two magnitudes
810  * tests. The block size parameters can be adjusted to increase/reduce the
811  * number of combinatons tested and thereby execution speed and memory
812  * footprint.
813  */
814 
815 static inline s64 value(int msb, int delta, int sign)
816 {
817 	return sign * (1LL << msb) + delta;
818 }
819 
820 static int __bpf_fill_pattern(struct bpf_test *self, void *arg,
821 			      int dbits, int sbits, int block1, int block2,
822 			      int (*emit)(struct bpf_test*, void*,
823 					  struct bpf_insn*, s64, s64))
824 {
825 	static const int sgn[][2] = {{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
826 	struct bpf_insn *insns;
827 	int di, si, bt, db, sb;
828 	int count, len, k;
829 	int extra = 1 + 2;
830 	int i = 0;
831 
832 	/* Total number of iterations for the two pattern */
833 	count = (dbits - 1) * (sbits - 1) * block1 * block1 * ARRAY_SIZE(sgn);
834 	count += (max(dbits, sbits) - 1) * block2 * block2 * ARRAY_SIZE(sgn);
835 
836 	/* Compute the maximum number of insns and allocate the buffer */
837 	len = extra + count * (*emit)(self, arg, NULL, 0, 0);
838 	insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL);
839 	if (!insns)
840 		return -ENOMEM;
841 
842 	/* Add head instruction(s) */
843 	insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
844 
845 	/*
846 	 * Pattern 1: all combinations of power-of-two magnitudes and sign,
847 	 * and with a block of contiguous values around each magnitude.
848 	 */
849 	for (di = 0; di < dbits - 1; di++)                 /* Dst magnitudes */
850 		for (si = 0; si < sbits - 1; si++)         /* Src magnitudes */
851 			for (k = 0; k < ARRAY_SIZE(sgn); k++) /* Sign combos */
852 				for (db = -(block1 / 2);
853 				     db < (block1 + 1) / 2; db++)
854 					for (sb = -(block1 / 2);
855 					     sb < (block1 + 1) / 2; sb++) {
856 						s64 dst, src;
857 
858 						dst = value(di, db, sgn[k][0]);
859 						src = value(si, sb, sgn[k][1]);
860 						i += (*emit)(self, arg,
861 							     &insns[i],
862 							     dst, src);
863 					}
864 	/*
865 	 * Pattern 2: all combinations for a larger block of values
866 	 * for each power-of-two magnitude and sign, where the magnitude is
867 	 * the same for both operands.
868 	 */
869 	for (bt = 0; bt < max(dbits, sbits) - 1; bt++)        /* Magnitude   */
870 		for (k = 0; k < ARRAY_SIZE(sgn); k++)         /* Sign combos */
871 			for (db = -(block2 / 2); db < (block2 + 1) / 2; db++)
872 				for (sb = -(block2 / 2);
873 				     sb < (block2 + 1) / 2; sb++) {
874 					s64 dst, src;
875 
876 					dst = value(bt % dbits, db, sgn[k][0]);
877 					src = value(bt % sbits, sb, sgn[k][1]);
878 					i += (*emit)(self, arg, &insns[i],
879 						     dst, src);
880 				}
881 
882 	/* Append tail instructions */
883 	insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
884 	insns[i++] = BPF_EXIT_INSN();
885 	BUG_ON(i > len);
886 
887 	self->u.ptr.insns = insns;
888 	self->u.ptr.len = i;
889 
890 	return 0;
891 }
892 
893 /*
894  * Block size parameters used in pattern tests below. une as needed to
895  * increase/reduce the number combinations tested, see following examples.
896  *        block   values per operand MSB
897  * ----------------------------------------
898  *           0     none
899  *           1     (1 << MSB)
900  *           2     (1 << MSB) + [-1, 0]
901  *           3     (1 << MSB) + [-1, 0, 1]
902  */
903 #define PATTERN_BLOCK1 1
904 #define PATTERN_BLOCK2 5
905 
906 /* Number of test runs for a pattern test */
907 #define NR_PATTERN_RUNS 1
908 
909 /*
910  * Exhaustive tests of ALU operations for all combinations of power-of-two
911  * magnitudes of the operands, both for positive and negative values. The
912  * test is designed to verify e.g. the ALU and ALU64 operations for JITs that
913  * emit different code depending on the magnitude of the immediate value.
914  */
915 static int __bpf_emit_alu64_imm(struct bpf_test *self, void *arg,
916 				struct bpf_insn *insns, s64 dst, s64 imm)
917 {
918 	int op = *(int *)arg;
919 	int i = 0;
920 	u64 res;
921 
922 	if (!insns)
923 		return 7;
924 
925 	if (__bpf_alu_result(&res, dst, (s32)imm, op)) {
926 		i += __bpf_ld_imm64(&insns[i], R1, dst);
927 		i += __bpf_ld_imm64(&insns[i], R3, res);
928 		insns[i++] = BPF_ALU64_IMM(op, R1, imm);
929 		insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
930 		insns[i++] = BPF_EXIT_INSN();
931 	}
932 
933 	return i;
934 }
935 
936 static int __bpf_emit_alu32_imm(struct bpf_test *self, void *arg,
937 				struct bpf_insn *insns, s64 dst, s64 imm)
938 {
939 	int op = *(int *)arg;
940 	int i = 0;
941 	u64 res;
942 
943 	if (!insns)
944 		return 7;
945 
946 	if (__bpf_alu_result(&res, (u32)dst, (u32)imm, op)) {
947 		i += __bpf_ld_imm64(&insns[i], R1, dst);
948 		i += __bpf_ld_imm64(&insns[i], R3, (u32)res);
949 		insns[i++] = BPF_ALU32_IMM(op, R1, imm);
950 		insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
951 		insns[i++] = BPF_EXIT_INSN();
952 	}
953 
954 	return i;
955 }
956 
957 static int __bpf_emit_alu64_reg(struct bpf_test *self, void *arg,
958 				struct bpf_insn *insns, s64 dst, s64 src)
959 {
960 	int op = *(int *)arg;
961 	int i = 0;
962 	u64 res;
963 
964 	if (!insns)
965 		return 9;
966 
967 	if (__bpf_alu_result(&res, dst, src, op)) {
968 		i += __bpf_ld_imm64(&insns[i], R1, dst);
969 		i += __bpf_ld_imm64(&insns[i], R2, src);
970 		i += __bpf_ld_imm64(&insns[i], R3, res);
971 		insns[i++] = BPF_ALU64_REG(op, R1, R2);
972 		insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
973 		insns[i++] = BPF_EXIT_INSN();
974 	}
975 
976 	return i;
977 }
978 
979 static int __bpf_emit_alu32_reg(struct bpf_test *self, void *arg,
980 				struct bpf_insn *insns, s64 dst, s64 src)
981 {
982 	int op = *(int *)arg;
983 	int i = 0;
984 	u64 res;
985 
986 	if (!insns)
987 		return 9;
988 
989 	if (__bpf_alu_result(&res, (u32)dst, (u32)src, op)) {
990 		i += __bpf_ld_imm64(&insns[i], R1, dst);
991 		i += __bpf_ld_imm64(&insns[i], R2, src);
992 		i += __bpf_ld_imm64(&insns[i], R3, (u32)res);
993 		insns[i++] = BPF_ALU32_REG(op, R1, R2);
994 		insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
995 		insns[i++] = BPF_EXIT_INSN();
996 	}
997 
998 	return i;
999 }
1000 
1001 static int __bpf_fill_alu64_imm(struct bpf_test *self, int op)
1002 {
1003 	return __bpf_fill_pattern(self, &op, 64, 32,
1004 				  PATTERN_BLOCK1, PATTERN_BLOCK2,
1005 				  &__bpf_emit_alu64_imm);
1006 }
1007 
1008 static int __bpf_fill_alu32_imm(struct bpf_test *self, int op)
1009 {
1010 	return __bpf_fill_pattern(self, &op, 64, 32,
1011 				  PATTERN_BLOCK1, PATTERN_BLOCK2,
1012 				  &__bpf_emit_alu32_imm);
1013 }
1014 
1015 static int __bpf_fill_alu64_reg(struct bpf_test *self, int op)
1016 {
1017 	return __bpf_fill_pattern(self, &op, 64, 64,
1018 				  PATTERN_BLOCK1, PATTERN_BLOCK2,
1019 				  &__bpf_emit_alu64_reg);
1020 }
1021 
1022 static int __bpf_fill_alu32_reg(struct bpf_test *self, int op)
1023 {
1024 	return __bpf_fill_pattern(self, &op, 64, 64,
1025 				  PATTERN_BLOCK1, PATTERN_BLOCK2,
1026 				  &__bpf_emit_alu32_reg);
1027 }
1028 
1029 /* ALU64 immediate operations */
1030 static int bpf_fill_alu64_mov_imm(struct bpf_test *self)
1031 {
1032 	return __bpf_fill_alu64_imm(self, BPF_MOV);
1033 }
1034 
1035 static int bpf_fill_alu64_and_imm(struct bpf_test *self)
1036 {
1037 	return __bpf_fill_alu64_imm(self, BPF_AND);
1038 }
1039 
1040 static int bpf_fill_alu64_or_imm(struct bpf_test *self)
1041 {
1042 	return __bpf_fill_alu64_imm(self, BPF_OR);
1043 }
1044 
1045 static int bpf_fill_alu64_xor_imm(struct bpf_test *self)
1046 {
1047 	return __bpf_fill_alu64_imm(self, BPF_XOR);
1048 }
1049 
1050 static int bpf_fill_alu64_add_imm(struct bpf_test *self)
1051 {
1052 	return __bpf_fill_alu64_imm(self, BPF_ADD);
1053 }
1054 
1055 static int bpf_fill_alu64_sub_imm(struct bpf_test *self)
1056 {
1057 	return __bpf_fill_alu64_imm(self, BPF_SUB);
1058 }
1059 
1060 static int bpf_fill_alu64_mul_imm(struct bpf_test *self)
1061 {
1062 	return __bpf_fill_alu64_imm(self, BPF_MUL);
1063 }
1064 
1065 static int bpf_fill_alu64_div_imm(struct bpf_test *self)
1066 {
1067 	return __bpf_fill_alu64_imm(self, BPF_DIV);
1068 }
1069 
1070 static int bpf_fill_alu64_mod_imm(struct bpf_test *self)
1071 {
1072 	return __bpf_fill_alu64_imm(self, BPF_MOD);
1073 }
1074 
1075 /* ALU32 immediate operations */
1076 static int bpf_fill_alu32_mov_imm(struct bpf_test *self)
1077 {
1078 	return __bpf_fill_alu32_imm(self, BPF_MOV);
1079 }
1080 
1081 static int bpf_fill_alu32_and_imm(struct bpf_test *self)
1082 {
1083 	return __bpf_fill_alu32_imm(self, BPF_AND);
1084 }
1085 
1086 static int bpf_fill_alu32_or_imm(struct bpf_test *self)
1087 {
1088 	return __bpf_fill_alu32_imm(self, BPF_OR);
1089 }
1090 
1091 static int bpf_fill_alu32_xor_imm(struct bpf_test *self)
1092 {
1093 	return __bpf_fill_alu32_imm(self, BPF_XOR);
1094 }
1095 
1096 static int bpf_fill_alu32_add_imm(struct bpf_test *self)
1097 {
1098 	return __bpf_fill_alu32_imm(self, BPF_ADD);
1099 }
1100 
1101 static int bpf_fill_alu32_sub_imm(struct bpf_test *self)
1102 {
1103 	return __bpf_fill_alu32_imm(self, BPF_SUB);
1104 }
1105 
1106 static int bpf_fill_alu32_mul_imm(struct bpf_test *self)
1107 {
1108 	return __bpf_fill_alu32_imm(self, BPF_MUL);
1109 }
1110 
1111 static int bpf_fill_alu32_div_imm(struct bpf_test *self)
1112 {
1113 	return __bpf_fill_alu32_imm(self, BPF_DIV);
1114 }
1115 
1116 static int bpf_fill_alu32_mod_imm(struct bpf_test *self)
1117 {
1118 	return __bpf_fill_alu32_imm(self, BPF_MOD);
1119 }
1120 
1121 /* ALU64 register operations */
1122 static int bpf_fill_alu64_mov_reg(struct bpf_test *self)
1123 {
1124 	return __bpf_fill_alu64_reg(self, BPF_MOV);
1125 }
1126 
1127 static int bpf_fill_alu64_and_reg(struct bpf_test *self)
1128 {
1129 	return __bpf_fill_alu64_reg(self, BPF_AND);
1130 }
1131 
1132 static int bpf_fill_alu64_or_reg(struct bpf_test *self)
1133 {
1134 	return __bpf_fill_alu64_reg(self, BPF_OR);
1135 }
1136 
1137 static int bpf_fill_alu64_xor_reg(struct bpf_test *self)
1138 {
1139 	return __bpf_fill_alu64_reg(self, BPF_XOR);
1140 }
1141 
1142 static int bpf_fill_alu64_add_reg(struct bpf_test *self)
1143 {
1144 	return __bpf_fill_alu64_reg(self, BPF_ADD);
1145 }
1146 
1147 static int bpf_fill_alu64_sub_reg(struct bpf_test *self)
1148 {
1149 	return __bpf_fill_alu64_reg(self, BPF_SUB);
1150 }
1151 
1152 static int bpf_fill_alu64_mul_reg(struct bpf_test *self)
1153 {
1154 	return __bpf_fill_alu64_reg(self, BPF_MUL);
1155 }
1156 
1157 static int bpf_fill_alu64_div_reg(struct bpf_test *self)
1158 {
1159 	return __bpf_fill_alu64_reg(self, BPF_DIV);
1160 }
1161 
1162 static int bpf_fill_alu64_mod_reg(struct bpf_test *self)
1163 {
1164 	return __bpf_fill_alu64_reg(self, BPF_MOD);
1165 }
1166 
1167 /* ALU32 register operations */
1168 static int bpf_fill_alu32_mov_reg(struct bpf_test *self)
1169 {
1170 	return __bpf_fill_alu32_reg(self, BPF_MOV);
1171 }
1172 
1173 static int bpf_fill_alu32_and_reg(struct bpf_test *self)
1174 {
1175 	return __bpf_fill_alu32_reg(self, BPF_AND);
1176 }
1177 
1178 static int bpf_fill_alu32_or_reg(struct bpf_test *self)
1179 {
1180 	return __bpf_fill_alu32_reg(self, BPF_OR);
1181 }
1182 
1183 static int bpf_fill_alu32_xor_reg(struct bpf_test *self)
1184 {
1185 	return __bpf_fill_alu32_reg(self, BPF_XOR);
1186 }
1187 
1188 static int bpf_fill_alu32_add_reg(struct bpf_test *self)
1189 {
1190 	return __bpf_fill_alu32_reg(self, BPF_ADD);
1191 }
1192 
1193 static int bpf_fill_alu32_sub_reg(struct bpf_test *self)
1194 {
1195 	return __bpf_fill_alu32_reg(self, BPF_SUB);
1196 }
1197 
1198 static int bpf_fill_alu32_mul_reg(struct bpf_test *self)
1199 {
1200 	return __bpf_fill_alu32_reg(self, BPF_MUL);
1201 }
1202 
1203 static int bpf_fill_alu32_div_reg(struct bpf_test *self)
1204 {
1205 	return __bpf_fill_alu32_reg(self, BPF_DIV);
1206 }
1207 
1208 static int bpf_fill_alu32_mod_reg(struct bpf_test *self)
1209 {
1210 	return __bpf_fill_alu32_reg(self, BPF_MOD);
1211 }
1212 
1213 /*
1214  * Test JITs that implement complex ALU operations as function
1215  * calls, and must re-arrange operands for argument passing.
1216  */
1217 static int __bpf_fill_alu_imm_regs(struct bpf_test *self, u8 op, bool alu32)
1218 {
1219 	int len = 2 + 10 * 10;
1220 	struct bpf_insn *insns;
1221 	u64 dst, res;
1222 	int i = 0;
1223 	u32 imm;
1224 	int rd;
1225 
1226 	insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL);
1227 	if (!insns)
1228 		return -ENOMEM;
1229 
1230 	/* Operand and result values according to operation */
1231 	if (alu32)
1232 		dst = 0x76543210U;
1233 	else
1234 		dst = 0x7edcba9876543210ULL;
1235 	imm = 0x01234567U;
1236 
1237 	if (op == BPF_LSH || op == BPF_RSH || op == BPF_ARSH)
1238 		imm &= 31;
1239 
1240 	__bpf_alu_result(&res, dst, imm, op);
1241 
1242 	if (alu32)
1243 		res = (u32)res;
1244 
1245 	/* Check all operand registers */
1246 	for (rd = R0; rd <= R9; rd++) {
1247 		i += __bpf_ld_imm64(&insns[i], rd, dst);
1248 
1249 		if (alu32)
1250 			insns[i++] = BPF_ALU32_IMM(op, rd, imm);
1251 		else
1252 			insns[i++] = BPF_ALU64_IMM(op, rd, imm);
1253 
1254 		insns[i++] = BPF_JMP32_IMM(BPF_JEQ, rd, res, 2);
1255 		insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1256 		insns[i++] = BPF_EXIT_INSN();
1257 
1258 		insns[i++] = BPF_ALU64_IMM(BPF_RSH, rd, 32);
1259 		insns[i++] = BPF_JMP32_IMM(BPF_JEQ, rd, res >> 32, 2);
1260 		insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1261 		insns[i++] = BPF_EXIT_INSN();
1262 	}
1263 
1264 	insns[i++] = BPF_MOV64_IMM(R0, 1);
1265 	insns[i++] = BPF_EXIT_INSN();
1266 
1267 	self->u.ptr.insns = insns;
1268 	self->u.ptr.len = len;
1269 	BUG_ON(i != len);
1270 
1271 	return 0;
1272 }
1273 
1274 /* ALU64 K registers */
1275 static int bpf_fill_alu64_mov_imm_regs(struct bpf_test *self)
1276 {
1277 	return __bpf_fill_alu_imm_regs(self, BPF_MOV, false);
1278 }
1279 
1280 static int bpf_fill_alu64_and_imm_regs(struct bpf_test *self)
1281 {
1282 	return __bpf_fill_alu_imm_regs(self, BPF_AND, false);
1283 }
1284 
1285 static int bpf_fill_alu64_or_imm_regs(struct bpf_test *self)
1286 {
1287 	return __bpf_fill_alu_imm_regs(self, BPF_OR, false);
1288 }
1289 
1290 static int bpf_fill_alu64_xor_imm_regs(struct bpf_test *self)
1291 {
1292 	return __bpf_fill_alu_imm_regs(self, BPF_XOR, false);
1293 }
1294 
1295 static int bpf_fill_alu64_lsh_imm_regs(struct bpf_test *self)
1296 {
1297 	return __bpf_fill_alu_imm_regs(self, BPF_LSH, false);
1298 }
1299 
1300 static int bpf_fill_alu64_rsh_imm_regs(struct bpf_test *self)
1301 {
1302 	return __bpf_fill_alu_imm_regs(self, BPF_RSH, false);
1303 }
1304 
1305 static int bpf_fill_alu64_arsh_imm_regs(struct bpf_test *self)
1306 {
1307 	return __bpf_fill_alu_imm_regs(self, BPF_ARSH, false);
1308 }
1309 
1310 static int bpf_fill_alu64_add_imm_regs(struct bpf_test *self)
1311 {
1312 	return __bpf_fill_alu_imm_regs(self, BPF_ADD, false);
1313 }
1314 
1315 static int bpf_fill_alu64_sub_imm_regs(struct bpf_test *self)
1316 {
1317 	return __bpf_fill_alu_imm_regs(self, BPF_SUB, false);
1318 }
1319 
1320 static int bpf_fill_alu64_mul_imm_regs(struct bpf_test *self)
1321 {
1322 	return __bpf_fill_alu_imm_regs(self, BPF_MUL, false);
1323 }
1324 
1325 static int bpf_fill_alu64_div_imm_regs(struct bpf_test *self)
1326 {
1327 	return __bpf_fill_alu_imm_regs(self, BPF_DIV, false);
1328 }
1329 
1330 static int bpf_fill_alu64_mod_imm_regs(struct bpf_test *self)
1331 {
1332 	return __bpf_fill_alu_imm_regs(self, BPF_MOD, false);
1333 }
1334 
1335 /* ALU32 K registers */
1336 static int bpf_fill_alu32_mov_imm_regs(struct bpf_test *self)
1337 {
1338 	return __bpf_fill_alu_imm_regs(self, BPF_MOV, true);
1339 }
1340 
1341 static int bpf_fill_alu32_and_imm_regs(struct bpf_test *self)
1342 {
1343 	return __bpf_fill_alu_imm_regs(self, BPF_AND, true);
1344 }
1345 
1346 static int bpf_fill_alu32_or_imm_regs(struct bpf_test *self)
1347 {
1348 	return __bpf_fill_alu_imm_regs(self, BPF_OR, true);
1349 }
1350 
1351 static int bpf_fill_alu32_xor_imm_regs(struct bpf_test *self)
1352 {
1353 	return __bpf_fill_alu_imm_regs(self, BPF_XOR, true);
1354 }
1355 
1356 static int bpf_fill_alu32_lsh_imm_regs(struct bpf_test *self)
1357 {
1358 	return __bpf_fill_alu_imm_regs(self, BPF_LSH, true);
1359 }
1360 
1361 static int bpf_fill_alu32_rsh_imm_regs(struct bpf_test *self)
1362 {
1363 	return __bpf_fill_alu_imm_regs(self, BPF_RSH, true);
1364 }
1365 
1366 static int bpf_fill_alu32_arsh_imm_regs(struct bpf_test *self)
1367 {
1368 	return __bpf_fill_alu_imm_regs(self, BPF_ARSH, true);
1369 }
1370 
1371 static int bpf_fill_alu32_add_imm_regs(struct bpf_test *self)
1372 {
1373 	return __bpf_fill_alu_imm_regs(self, BPF_ADD, true);
1374 }
1375 
1376 static int bpf_fill_alu32_sub_imm_regs(struct bpf_test *self)
1377 {
1378 	return __bpf_fill_alu_imm_regs(self, BPF_SUB, true);
1379 }
1380 
1381 static int bpf_fill_alu32_mul_imm_regs(struct bpf_test *self)
1382 {
1383 	return __bpf_fill_alu_imm_regs(self, BPF_MUL, true);
1384 }
1385 
1386 static int bpf_fill_alu32_div_imm_regs(struct bpf_test *self)
1387 {
1388 	return __bpf_fill_alu_imm_regs(self, BPF_DIV, true);
1389 }
1390 
1391 static int bpf_fill_alu32_mod_imm_regs(struct bpf_test *self)
1392 {
1393 	return __bpf_fill_alu_imm_regs(self, BPF_MOD, true);
1394 }
1395 
1396 /*
1397  * Test JITs that implement complex ALU operations as function
1398  * calls, and must re-arrange operands for argument passing.
1399  */
1400 static int __bpf_fill_alu_reg_pairs(struct bpf_test *self, u8 op, bool alu32)
1401 {
1402 	int len = 2 + 10 * 10 * 12;
1403 	u64 dst, src, res, same;
1404 	struct bpf_insn *insns;
1405 	int rd, rs;
1406 	int i = 0;
1407 
1408 	insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL);
1409 	if (!insns)
1410 		return -ENOMEM;
1411 
1412 	/* Operand and result values according to operation */
1413 	if (alu32) {
1414 		dst = 0x76543210U;
1415 		src = 0x01234567U;
1416 	} else {
1417 		dst = 0x7edcba9876543210ULL;
1418 		src = 0x0123456789abcdefULL;
1419 	}
1420 
1421 	if (op == BPF_LSH || op == BPF_RSH || op == BPF_ARSH)
1422 		src &= 31;
1423 
1424 	__bpf_alu_result(&res, dst, src, op);
1425 	__bpf_alu_result(&same, src, src, op);
1426 
1427 	if (alu32) {
1428 		res = (u32)res;
1429 		same = (u32)same;
1430 	}
1431 
1432 	/* Check all combinations of operand registers */
1433 	for (rd = R0; rd <= R9; rd++) {
1434 		for (rs = R0; rs <= R9; rs++) {
1435 			u64 val = rd == rs ? same : res;
1436 
1437 			i += __bpf_ld_imm64(&insns[i], rd, dst);
1438 			i += __bpf_ld_imm64(&insns[i], rs, src);
1439 
1440 			if (alu32)
1441 				insns[i++] = BPF_ALU32_REG(op, rd, rs);
1442 			else
1443 				insns[i++] = BPF_ALU64_REG(op, rd, rs);
1444 
1445 			insns[i++] = BPF_JMP32_IMM(BPF_JEQ, rd, val, 2);
1446 			insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1447 			insns[i++] = BPF_EXIT_INSN();
1448 
1449 			insns[i++] = BPF_ALU64_IMM(BPF_RSH, rd, 32);
1450 			insns[i++] = BPF_JMP32_IMM(BPF_JEQ, rd, val >> 32, 2);
1451 			insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1452 			insns[i++] = BPF_EXIT_INSN();
1453 		}
1454 	}
1455 
1456 	insns[i++] = BPF_MOV64_IMM(R0, 1);
1457 	insns[i++] = BPF_EXIT_INSN();
1458 
1459 	self->u.ptr.insns = insns;
1460 	self->u.ptr.len = len;
1461 	BUG_ON(i != len);
1462 
1463 	return 0;
1464 }
1465 
1466 /* ALU64 X register combinations */
1467 static int bpf_fill_alu64_mov_reg_pairs(struct bpf_test *self)
1468 {
1469 	return __bpf_fill_alu_reg_pairs(self, BPF_MOV, false);
1470 }
1471 
1472 static int bpf_fill_alu64_and_reg_pairs(struct bpf_test *self)
1473 {
1474 	return __bpf_fill_alu_reg_pairs(self, BPF_AND, false);
1475 }
1476 
1477 static int bpf_fill_alu64_or_reg_pairs(struct bpf_test *self)
1478 {
1479 	return __bpf_fill_alu_reg_pairs(self, BPF_OR, false);
1480 }
1481 
1482 static int bpf_fill_alu64_xor_reg_pairs(struct bpf_test *self)
1483 {
1484 	return __bpf_fill_alu_reg_pairs(self, BPF_XOR, false);
1485 }
1486 
1487 static int bpf_fill_alu64_lsh_reg_pairs(struct bpf_test *self)
1488 {
1489 	return __bpf_fill_alu_reg_pairs(self, BPF_LSH, false);
1490 }
1491 
1492 static int bpf_fill_alu64_rsh_reg_pairs(struct bpf_test *self)
1493 {
1494 	return __bpf_fill_alu_reg_pairs(self, BPF_RSH, false);
1495 }
1496 
1497 static int bpf_fill_alu64_arsh_reg_pairs(struct bpf_test *self)
1498 {
1499 	return __bpf_fill_alu_reg_pairs(self, BPF_ARSH, false);
1500 }
1501 
1502 static int bpf_fill_alu64_add_reg_pairs(struct bpf_test *self)
1503 {
1504 	return __bpf_fill_alu_reg_pairs(self, BPF_ADD, false);
1505 }
1506 
1507 static int bpf_fill_alu64_sub_reg_pairs(struct bpf_test *self)
1508 {
1509 	return __bpf_fill_alu_reg_pairs(self, BPF_SUB, false);
1510 }
1511 
1512 static int bpf_fill_alu64_mul_reg_pairs(struct bpf_test *self)
1513 {
1514 	return __bpf_fill_alu_reg_pairs(self, BPF_MUL, false);
1515 }
1516 
1517 static int bpf_fill_alu64_div_reg_pairs(struct bpf_test *self)
1518 {
1519 	return __bpf_fill_alu_reg_pairs(self, BPF_DIV, false);
1520 }
1521 
1522 static int bpf_fill_alu64_mod_reg_pairs(struct bpf_test *self)
1523 {
1524 	return __bpf_fill_alu_reg_pairs(self, BPF_MOD, false);
1525 }
1526 
1527 /* ALU32 X register combinations */
1528 static int bpf_fill_alu32_mov_reg_pairs(struct bpf_test *self)
1529 {
1530 	return __bpf_fill_alu_reg_pairs(self, BPF_MOV, true);
1531 }
1532 
1533 static int bpf_fill_alu32_and_reg_pairs(struct bpf_test *self)
1534 {
1535 	return __bpf_fill_alu_reg_pairs(self, BPF_AND, true);
1536 }
1537 
1538 static int bpf_fill_alu32_or_reg_pairs(struct bpf_test *self)
1539 {
1540 	return __bpf_fill_alu_reg_pairs(self, BPF_OR, true);
1541 }
1542 
1543 static int bpf_fill_alu32_xor_reg_pairs(struct bpf_test *self)
1544 {
1545 	return __bpf_fill_alu_reg_pairs(self, BPF_XOR, true);
1546 }
1547 
1548 static int bpf_fill_alu32_lsh_reg_pairs(struct bpf_test *self)
1549 {
1550 	return __bpf_fill_alu_reg_pairs(self, BPF_LSH, true);
1551 }
1552 
1553 static int bpf_fill_alu32_rsh_reg_pairs(struct bpf_test *self)
1554 {
1555 	return __bpf_fill_alu_reg_pairs(self, BPF_RSH, true);
1556 }
1557 
1558 static int bpf_fill_alu32_arsh_reg_pairs(struct bpf_test *self)
1559 {
1560 	return __bpf_fill_alu_reg_pairs(self, BPF_ARSH, true);
1561 }
1562 
1563 static int bpf_fill_alu32_add_reg_pairs(struct bpf_test *self)
1564 {
1565 	return __bpf_fill_alu_reg_pairs(self, BPF_ADD, true);
1566 }
1567 
1568 static int bpf_fill_alu32_sub_reg_pairs(struct bpf_test *self)
1569 {
1570 	return __bpf_fill_alu_reg_pairs(self, BPF_SUB, true);
1571 }
1572 
1573 static int bpf_fill_alu32_mul_reg_pairs(struct bpf_test *self)
1574 {
1575 	return __bpf_fill_alu_reg_pairs(self, BPF_MUL, true);
1576 }
1577 
1578 static int bpf_fill_alu32_div_reg_pairs(struct bpf_test *self)
1579 {
1580 	return __bpf_fill_alu_reg_pairs(self, BPF_DIV, true);
1581 }
1582 
1583 static int bpf_fill_alu32_mod_reg_pairs(struct bpf_test *self)
1584 {
1585 	return __bpf_fill_alu_reg_pairs(self, BPF_MOD, true);
1586 }
1587 
1588 /*
1589  * Exhaustive tests of atomic operations for all power-of-two operand
1590  * magnitudes, both for positive and negative values.
1591  */
1592 
1593 static int __bpf_emit_atomic64(struct bpf_test *self, void *arg,
1594 			       struct bpf_insn *insns, s64 dst, s64 src)
1595 {
1596 	int op = *(int *)arg;
1597 	u64 keep, fetch, res;
1598 	int i = 0;
1599 
1600 	if (!insns)
1601 		return 21;
1602 
1603 	switch (op) {
1604 	case BPF_XCHG:
1605 		res = src;
1606 		break;
1607 	default:
1608 		__bpf_alu_result(&res, dst, src, BPF_OP(op));
1609 	}
1610 
1611 	keep = 0x0123456789abcdefULL;
1612 	if (op & BPF_FETCH)
1613 		fetch = dst;
1614 	else
1615 		fetch = src;
1616 
1617 	i += __bpf_ld_imm64(&insns[i], R0, keep);
1618 	i += __bpf_ld_imm64(&insns[i], R1, dst);
1619 	i += __bpf_ld_imm64(&insns[i], R2, src);
1620 	i += __bpf_ld_imm64(&insns[i], R3, res);
1621 	i += __bpf_ld_imm64(&insns[i], R4, fetch);
1622 	i += __bpf_ld_imm64(&insns[i], R5, keep);
1623 
1624 	insns[i++] = BPF_STX_MEM(BPF_DW, R10, R1, -8);
1625 	insns[i++] = BPF_ATOMIC_OP(BPF_DW, op, R10, R2, -8);
1626 	insns[i++] = BPF_LDX_MEM(BPF_DW, R1, R10, -8);
1627 
1628 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
1629 	insns[i++] = BPF_EXIT_INSN();
1630 
1631 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R2, R4, 1);
1632 	insns[i++] = BPF_EXIT_INSN();
1633 
1634 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R5, 1);
1635 	insns[i++] = BPF_EXIT_INSN();
1636 
1637 	return i;
1638 }
1639 
1640 static int __bpf_emit_atomic32(struct bpf_test *self, void *arg,
1641 			       struct bpf_insn *insns, s64 dst, s64 src)
1642 {
1643 	int op = *(int *)arg;
1644 	u64 keep, fetch, res;
1645 	int i = 0;
1646 
1647 	if (!insns)
1648 		return 21;
1649 
1650 	switch (op) {
1651 	case BPF_XCHG:
1652 		res = src;
1653 		break;
1654 	default:
1655 		__bpf_alu_result(&res, (u32)dst, (u32)src, BPF_OP(op));
1656 	}
1657 
1658 	keep = 0x0123456789abcdefULL;
1659 	if (op & BPF_FETCH)
1660 		fetch = (u32)dst;
1661 	else
1662 		fetch = src;
1663 
1664 	i += __bpf_ld_imm64(&insns[i], R0, keep);
1665 	i += __bpf_ld_imm64(&insns[i], R1, (u32)dst);
1666 	i += __bpf_ld_imm64(&insns[i], R2, src);
1667 	i += __bpf_ld_imm64(&insns[i], R3, (u32)res);
1668 	i += __bpf_ld_imm64(&insns[i], R4, fetch);
1669 	i += __bpf_ld_imm64(&insns[i], R5, keep);
1670 
1671 	insns[i++] = BPF_STX_MEM(BPF_W, R10, R1, -4);
1672 	insns[i++] = BPF_ATOMIC_OP(BPF_W, op, R10, R2, -4);
1673 	insns[i++] = BPF_LDX_MEM(BPF_W, R1, R10, -4);
1674 
1675 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
1676 	insns[i++] = BPF_EXIT_INSN();
1677 
1678 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R2, R4, 1);
1679 	insns[i++] = BPF_EXIT_INSN();
1680 
1681 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R5, 1);
1682 	insns[i++] = BPF_EXIT_INSN();
1683 
1684 	return i;
1685 }
1686 
1687 static int __bpf_emit_cmpxchg64(struct bpf_test *self, void *arg,
1688 				struct bpf_insn *insns, s64 dst, s64 src)
1689 {
1690 	int i = 0;
1691 
1692 	if (!insns)
1693 		return 23;
1694 
1695 	i += __bpf_ld_imm64(&insns[i], R0, ~dst);
1696 	i += __bpf_ld_imm64(&insns[i], R1, dst);
1697 	i += __bpf_ld_imm64(&insns[i], R2, src);
1698 
1699 	/* Result unsuccessful */
1700 	insns[i++] = BPF_STX_MEM(BPF_DW, R10, R1, -8);
1701 	insns[i++] = BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -8);
1702 	insns[i++] = BPF_LDX_MEM(BPF_DW, R3, R10, -8);
1703 
1704 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 2);
1705 	insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1706 	insns[i++] = BPF_EXIT_INSN();
1707 
1708 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R3, 2);
1709 	insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1710 	insns[i++] = BPF_EXIT_INSN();
1711 
1712 	/* Result successful */
1713 	insns[i++] = BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -8);
1714 	insns[i++] = BPF_LDX_MEM(BPF_DW, R3, R10, -8);
1715 
1716 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R2, R3, 2);
1717 	insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1718 	insns[i++] = BPF_EXIT_INSN();
1719 
1720 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R1, 2);
1721 	insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1722 	insns[i++] = BPF_EXIT_INSN();
1723 
1724 	return i;
1725 }
1726 
1727 static int __bpf_emit_cmpxchg32(struct bpf_test *self, void *arg,
1728 				struct bpf_insn *insns, s64 dst, s64 src)
1729 {
1730 	int i = 0;
1731 
1732 	if (!insns)
1733 		return 27;
1734 
1735 	i += __bpf_ld_imm64(&insns[i], R0, ~dst);
1736 	i += __bpf_ld_imm64(&insns[i], R1, (u32)dst);
1737 	i += __bpf_ld_imm64(&insns[i], R2, src);
1738 
1739 	/* Result unsuccessful */
1740 	insns[i++] = BPF_STX_MEM(BPF_W, R10, R1, -4);
1741 	insns[i++] = BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R2, -4);
1742 	insns[i++] = BPF_ZEXT_REG(R0), /* Zext always inserted by verifier */
1743 	insns[i++] = BPF_LDX_MEM(BPF_W, R3, R10, -4);
1744 
1745 	insns[i++] = BPF_JMP32_REG(BPF_JEQ, R1, R3, 2);
1746 	insns[i++] = BPF_MOV32_IMM(R0, __LINE__);
1747 	insns[i++] = BPF_EXIT_INSN();
1748 
1749 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R3, 2);
1750 	insns[i++] = BPF_MOV32_IMM(R0, __LINE__);
1751 	insns[i++] = BPF_EXIT_INSN();
1752 
1753 	/* Result successful */
1754 	i += __bpf_ld_imm64(&insns[i], R0, dst);
1755 	insns[i++] = BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R2, -4);
1756 	insns[i++] = BPF_ZEXT_REG(R0), /* Zext always inserted by verifier */
1757 	insns[i++] = BPF_LDX_MEM(BPF_W, R3, R10, -4);
1758 
1759 	insns[i++] = BPF_JMP32_REG(BPF_JEQ, R2, R3, 2);
1760 	insns[i++] = BPF_MOV32_IMM(R0, __LINE__);
1761 	insns[i++] = BPF_EXIT_INSN();
1762 
1763 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R1, 2);
1764 	insns[i++] = BPF_MOV32_IMM(R0, __LINE__);
1765 	insns[i++] = BPF_EXIT_INSN();
1766 
1767 	return i;
1768 }
1769 
1770 static int __bpf_fill_atomic64(struct bpf_test *self, int op)
1771 {
1772 	return __bpf_fill_pattern(self, &op, 64, 64,
1773 				  0, PATTERN_BLOCK2,
1774 				  &__bpf_emit_atomic64);
1775 }
1776 
1777 static int __bpf_fill_atomic32(struct bpf_test *self, int op)
1778 {
1779 	return __bpf_fill_pattern(self, &op, 64, 64,
1780 				  0, PATTERN_BLOCK2,
1781 				  &__bpf_emit_atomic32);
1782 }
1783 
1784 /* 64-bit atomic operations */
1785 static int bpf_fill_atomic64_add(struct bpf_test *self)
1786 {
1787 	return __bpf_fill_atomic64(self, BPF_ADD);
1788 }
1789 
1790 static int bpf_fill_atomic64_and(struct bpf_test *self)
1791 {
1792 	return __bpf_fill_atomic64(self, BPF_AND);
1793 }
1794 
1795 static int bpf_fill_atomic64_or(struct bpf_test *self)
1796 {
1797 	return __bpf_fill_atomic64(self, BPF_OR);
1798 }
1799 
1800 static int bpf_fill_atomic64_xor(struct bpf_test *self)
1801 {
1802 	return __bpf_fill_atomic64(self, BPF_XOR);
1803 }
1804 
1805 static int bpf_fill_atomic64_add_fetch(struct bpf_test *self)
1806 {
1807 	return __bpf_fill_atomic64(self, BPF_ADD | BPF_FETCH);
1808 }
1809 
1810 static int bpf_fill_atomic64_and_fetch(struct bpf_test *self)
1811 {
1812 	return __bpf_fill_atomic64(self, BPF_AND | BPF_FETCH);
1813 }
1814 
1815 static int bpf_fill_atomic64_or_fetch(struct bpf_test *self)
1816 {
1817 	return __bpf_fill_atomic64(self, BPF_OR | BPF_FETCH);
1818 }
1819 
1820 static int bpf_fill_atomic64_xor_fetch(struct bpf_test *self)
1821 {
1822 	return __bpf_fill_atomic64(self, BPF_XOR | BPF_FETCH);
1823 }
1824 
1825 static int bpf_fill_atomic64_xchg(struct bpf_test *self)
1826 {
1827 	return __bpf_fill_atomic64(self, BPF_XCHG);
1828 }
1829 
1830 static int bpf_fill_cmpxchg64(struct bpf_test *self)
1831 {
1832 	return __bpf_fill_pattern(self, NULL, 64, 64, 0, PATTERN_BLOCK2,
1833 				  &__bpf_emit_cmpxchg64);
1834 }
1835 
1836 /* 32-bit atomic operations */
1837 static int bpf_fill_atomic32_add(struct bpf_test *self)
1838 {
1839 	return __bpf_fill_atomic32(self, BPF_ADD);
1840 }
1841 
1842 static int bpf_fill_atomic32_and(struct bpf_test *self)
1843 {
1844 	return __bpf_fill_atomic32(self, BPF_AND);
1845 }
1846 
1847 static int bpf_fill_atomic32_or(struct bpf_test *self)
1848 {
1849 	return __bpf_fill_atomic32(self, BPF_OR);
1850 }
1851 
1852 static int bpf_fill_atomic32_xor(struct bpf_test *self)
1853 {
1854 	return __bpf_fill_atomic32(self, BPF_XOR);
1855 }
1856 
1857 static int bpf_fill_atomic32_add_fetch(struct bpf_test *self)
1858 {
1859 	return __bpf_fill_atomic32(self, BPF_ADD | BPF_FETCH);
1860 }
1861 
1862 static int bpf_fill_atomic32_and_fetch(struct bpf_test *self)
1863 {
1864 	return __bpf_fill_atomic32(self, BPF_AND | BPF_FETCH);
1865 }
1866 
1867 static int bpf_fill_atomic32_or_fetch(struct bpf_test *self)
1868 {
1869 	return __bpf_fill_atomic32(self, BPF_OR | BPF_FETCH);
1870 }
1871 
1872 static int bpf_fill_atomic32_xor_fetch(struct bpf_test *self)
1873 {
1874 	return __bpf_fill_atomic32(self, BPF_XOR | BPF_FETCH);
1875 }
1876 
1877 static int bpf_fill_atomic32_xchg(struct bpf_test *self)
1878 {
1879 	return __bpf_fill_atomic32(self, BPF_XCHG);
1880 }
1881 
1882 static int bpf_fill_cmpxchg32(struct bpf_test *self)
1883 {
1884 	return __bpf_fill_pattern(self, NULL, 64, 64, 0, PATTERN_BLOCK2,
1885 				  &__bpf_emit_cmpxchg32);
1886 }
1887 
1888 /*
1889  * Test JITs that implement ATOMIC operations as function calls or
1890  * other primitives, and must re-arrange operands for argument passing.
1891  */
1892 static int __bpf_fill_atomic_reg_pairs(struct bpf_test *self, u8 width, u8 op)
1893 {
1894 	struct bpf_insn *insn;
1895 	int len = 2 + 34 * 10 * 10;
1896 	u64 mem, upd, res;
1897 	int rd, rs, i = 0;
1898 
1899 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
1900 	if (!insn)
1901 		return -ENOMEM;
1902 
1903 	/* Operand and memory values */
1904 	if (width == BPF_DW) {
1905 		mem = 0x0123456789abcdefULL;
1906 		upd = 0xfedcba9876543210ULL;
1907 	} else { /* BPF_W */
1908 		mem = 0x01234567U;
1909 		upd = 0x76543210U;
1910 	}
1911 
1912 	/* Memory updated according to operation */
1913 	switch (op) {
1914 	case BPF_XCHG:
1915 		res = upd;
1916 		break;
1917 	case BPF_CMPXCHG:
1918 		res = mem;
1919 		break;
1920 	default:
1921 		__bpf_alu_result(&res, mem, upd, BPF_OP(op));
1922 	}
1923 
1924 	/* Test all operand registers */
1925 	for (rd = R0; rd <= R9; rd++) {
1926 		for (rs = R0; rs <= R9; rs++) {
1927 			u64 cmp, src;
1928 
1929 			/* Initialize value in memory */
1930 			i += __bpf_ld_imm64(&insn[i], R0, mem);
1931 			insn[i++] = BPF_STX_MEM(width, R10, R0, -8);
1932 
1933 			/* Initialize registers in order */
1934 			i += __bpf_ld_imm64(&insn[i], R0, ~mem);
1935 			i += __bpf_ld_imm64(&insn[i], rs, upd);
1936 			insn[i++] = BPF_MOV64_REG(rd, R10);
1937 
1938 			/* Perform atomic operation */
1939 			insn[i++] = BPF_ATOMIC_OP(width, op, rd, rs, -8);
1940 			if (op == BPF_CMPXCHG && width == BPF_W)
1941 				insn[i++] = BPF_ZEXT_REG(R0);
1942 
1943 			/* Check R0 register value */
1944 			if (op == BPF_CMPXCHG)
1945 				cmp = mem;  /* Expect value from memory */
1946 			else if (R0 == rd || R0 == rs)
1947 				cmp = 0;    /* Aliased, checked below */
1948 			else
1949 				cmp = ~mem; /* Expect value to be preserved */
1950 			if (cmp) {
1951 				insn[i++] = BPF_JMP32_IMM(BPF_JEQ, R0,
1952 							   (u32)cmp, 2);
1953 				insn[i++] = BPF_MOV32_IMM(R0, __LINE__);
1954 				insn[i++] = BPF_EXIT_INSN();
1955 				insn[i++] = BPF_ALU64_IMM(BPF_RSH, R0, 32);
1956 				insn[i++] = BPF_JMP32_IMM(BPF_JEQ, R0,
1957 							   cmp >> 32, 2);
1958 				insn[i++] = BPF_MOV32_IMM(R0, __LINE__);
1959 				insn[i++] = BPF_EXIT_INSN();
1960 			}
1961 
1962 			/* Check source register value */
1963 			if (rs == R0 && op == BPF_CMPXCHG)
1964 				src = 0;   /* Aliased with R0, checked above */
1965 			else if (rs == rd && (op == BPF_CMPXCHG ||
1966 					      !(op & BPF_FETCH)))
1967 				src = 0;   /* Aliased with rd, checked below */
1968 			else if (op == BPF_CMPXCHG)
1969 				src = upd; /* Expect value to be preserved */
1970 			else if (op & BPF_FETCH)
1971 				src = mem; /* Expect fetched value from mem */
1972 			else /* no fetch */
1973 				src = upd; /* Expect value to be preserved */
1974 			if (src) {
1975 				insn[i++] = BPF_JMP32_IMM(BPF_JEQ, rs,
1976 							   (u32)src, 2);
1977 				insn[i++] = BPF_MOV32_IMM(R0, __LINE__);
1978 				insn[i++] = BPF_EXIT_INSN();
1979 				insn[i++] = BPF_ALU64_IMM(BPF_RSH, rs, 32);
1980 				insn[i++] = BPF_JMP32_IMM(BPF_JEQ, rs,
1981 							   src >> 32, 2);
1982 				insn[i++] = BPF_MOV32_IMM(R0, __LINE__);
1983 				insn[i++] = BPF_EXIT_INSN();
1984 			}
1985 
1986 			/* Check destination register value */
1987 			if (!(rd == R0 && op == BPF_CMPXCHG) &&
1988 			    !(rd == rs && (op & BPF_FETCH))) {
1989 				insn[i++] = BPF_JMP_REG(BPF_JEQ, rd, R10, 2);
1990 				insn[i++] = BPF_MOV32_IMM(R0, __LINE__);
1991 				insn[i++] = BPF_EXIT_INSN();
1992 			}
1993 
1994 			/* Check value in memory */
1995 			if (rs != rd) {                  /* No aliasing */
1996 				i += __bpf_ld_imm64(&insn[i], R1, res);
1997 			} else if (op == BPF_XCHG) {     /* Aliased, XCHG */
1998 				insn[i++] = BPF_MOV64_REG(R1, R10);
1999 			} else if (op == BPF_CMPXCHG) {  /* Aliased, CMPXCHG */
2000 				i += __bpf_ld_imm64(&insn[i], R1, mem);
2001 			} else {                        /* Aliased, ALU oper */
2002 				i += __bpf_ld_imm64(&insn[i], R1, mem);
2003 				insn[i++] = BPF_ALU64_REG(BPF_OP(op), R1, R10);
2004 			}
2005 
2006 			insn[i++] = BPF_LDX_MEM(width, R0, R10, -8);
2007 			if (width == BPF_DW)
2008 				insn[i++] = BPF_JMP_REG(BPF_JEQ, R0, R1, 2);
2009 			else /* width == BPF_W */
2010 				insn[i++] = BPF_JMP32_REG(BPF_JEQ, R0, R1, 2);
2011 			insn[i++] = BPF_MOV32_IMM(R0, __LINE__);
2012 			insn[i++] = BPF_EXIT_INSN();
2013 		}
2014 	}
2015 
2016 	insn[i++] = BPF_MOV64_IMM(R0, 1);
2017 	insn[i++] = BPF_EXIT_INSN();
2018 
2019 	self->u.ptr.insns = insn;
2020 	self->u.ptr.len = i;
2021 	BUG_ON(i > len);
2022 
2023 	return 0;
2024 }
2025 
2026 /* 64-bit atomic register tests */
2027 static int bpf_fill_atomic64_add_reg_pairs(struct bpf_test *self)
2028 {
2029 	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_ADD);
2030 }
2031 
2032 static int bpf_fill_atomic64_and_reg_pairs(struct bpf_test *self)
2033 {
2034 	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_AND);
2035 }
2036 
2037 static int bpf_fill_atomic64_or_reg_pairs(struct bpf_test *self)
2038 {
2039 	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_OR);
2040 }
2041 
2042 static int bpf_fill_atomic64_xor_reg_pairs(struct bpf_test *self)
2043 {
2044 	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_XOR);
2045 }
2046 
2047 static int bpf_fill_atomic64_add_fetch_reg_pairs(struct bpf_test *self)
2048 {
2049 	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_ADD | BPF_FETCH);
2050 }
2051 
2052 static int bpf_fill_atomic64_and_fetch_reg_pairs(struct bpf_test *self)
2053 {
2054 	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_AND | BPF_FETCH);
2055 }
2056 
2057 static int bpf_fill_atomic64_or_fetch_reg_pairs(struct bpf_test *self)
2058 {
2059 	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_OR | BPF_FETCH);
2060 }
2061 
2062 static int bpf_fill_atomic64_xor_fetch_reg_pairs(struct bpf_test *self)
2063 {
2064 	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_XOR | BPF_FETCH);
2065 }
2066 
2067 static int bpf_fill_atomic64_xchg_reg_pairs(struct bpf_test *self)
2068 {
2069 	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_XCHG);
2070 }
2071 
2072 static int bpf_fill_atomic64_cmpxchg_reg_pairs(struct bpf_test *self)
2073 {
2074 	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_CMPXCHG);
2075 }
2076 
2077 /* 32-bit atomic register tests */
2078 static int bpf_fill_atomic32_add_reg_pairs(struct bpf_test *self)
2079 {
2080 	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_ADD);
2081 }
2082 
2083 static int bpf_fill_atomic32_and_reg_pairs(struct bpf_test *self)
2084 {
2085 	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_AND);
2086 }
2087 
2088 static int bpf_fill_atomic32_or_reg_pairs(struct bpf_test *self)
2089 {
2090 	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_OR);
2091 }
2092 
2093 static int bpf_fill_atomic32_xor_reg_pairs(struct bpf_test *self)
2094 {
2095 	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_XOR);
2096 }
2097 
2098 static int bpf_fill_atomic32_add_fetch_reg_pairs(struct bpf_test *self)
2099 {
2100 	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_ADD | BPF_FETCH);
2101 }
2102 
2103 static int bpf_fill_atomic32_and_fetch_reg_pairs(struct bpf_test *self)
2104 {
2105 	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_AND | BPF_FETCH);
2106 }
2107 
2108 static int bpf_fill_atomic32_or_fetch_reg_pairs(struct bpf_test *self)
2109 {
2110 	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_OR | BPF_FETCH);
2111 }
2112 
2113 static int bpf_fill_atomic32_xor_fetch_reg_pairs(struct bpf_test *self)
2114 {
2115 	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_XOR | BPF_FETCH);
2116 }
2117 
2118 static int bpf_fill_atomic32_xchg_reg_pairs(struct bpf_test *self)
2119 {
2120 	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_XCHG);
2121 }
2122 
2123 static int bpf_fill_atomic32_cmpxchg_reg_pairs(struct bpf_test *self)
2124 {
2125 	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_CMPXCHG);
2126 }
2127 
2128 /*
2129  * Test the two-instruction 64-bit immediate load operation for all
2130  * power-of-two magnitudes of the immediate operand. For each MSB, a block
2131  * of immediate values centered around the power-of-two MSB are tested,
2132  * both for positive and negative values. The test is designed to verify
2133  * the operation for JITs that emit different code depending on the magnitude
2134  * of the immediate value. This is often the case if the native instruction
2135  * immediate field width is narrower than 32 bits.
2136  */
2137 static int bpf_fill_ld_imm64_magn(struct bpf_test *self)
2138 {
2139 	int block = 64; /* Increase for more tests per MSB position */
2140 	int len = 3 + 8 * 63 * block * 2;
2141 	struct bpf_insn *insn;
2142 	int bit, adj, sign;
2143 	int i = 0;
2144 
2145 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
2146 	if (!insn)
2147 		return -ENOMEM;
2148 
2149 	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
2150 
2151 	for (bit = 0; bit <= 62; bit++) {
2152 		for (adj = -block / 2; adj < block / 2; adj++) {
2153 			for (sign = -1; sign <= 1; sign += 2) {
2154 				s64 imm = sign * ((1LL << bit) + adj);
2155 
2156 				/* Perform operation */
2157 				i += __bpf_ld_imm64(&insn[i], R1, imm);
2158 
2159 				/* Load reference */
2160 				insn[i++] = BPF_ALU32_IMM(BPF_MOV, R2, imm);
2161 				insn[i++] = BPF_ALU32_IMM(BPF_MOV, R3,
2162 							  (u32)(imm >> 32));
2163 				insn[i++] = BPF_ALU64_IMM(BPF_LSH, R3, 32);
2164 				insn[i++] = BPF_ALU64_REG(BPF_OR, R2, R3);
2165 
2166 				/* Check result */
2167 				insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R2, 1);
2168 				insn[i++] = BPF_EXIT_INSN();
2169 			}
2170 		}
2171 	}
2172 
2173 	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
2174 	insn[i++] = BPF_EXIT_INSN();
2175 
2176 	self->u.ptr.insns = insn;
2177 	self->u.ptr.len = len;
2178 	BUG_ON(i != len);
2179 
2180 	return 0;
2181 }
2182 
2183 /*
2184  * Test the two-instruction 64-bit immediate load operation for different
2185  * combinations of bytes. Each byte in the 64-bit word is constructed as
2186  * (base & mask) | (rand() & ~mask), where rand() is a deterministic LCG.
2187  * All patterns (base1, mask1) and (base2, mask2) bytes are tested.
2188  */
2189 static int __bpf_fill_ld_imm64_bytes(struct bpf_test *self,
2190 				     u8 base1, u8 mask1,
2191 				     u8 base2, u8 mask2)
2192 {
2193 	struct bpf_insn *insn;
2194 	int len = 3 + 8 * BIT(8);
2195 	int pattern, index;
2196 	u32 rand = 1;
2197 	int i = 0;
2198 
2199 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
2200 	if (!insn)
2201 		return -ENOMEM;
2202 
2203 	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
2204 
2205 	for (pattern = 0; pattern < BIT(8); pattern++) {
2206 		u64 imm = 0;
2207 
2208 		for (index = 0; index < 8; index++) {
2209 			int byte;
2210 
2211 			if (pattern & BIT(index))
2212 				byte = (base1 & mask1) | (rand & ~mask1);
2213 			else
2214 				byte = (base2 & mask2) | (rand & ~mask2);
2215 			imm = (imm << 8) | byte;
2216 		}
2217 
2218 		/* Update our LCG */
2219 		rand = rand * 1664525 + 1013904223;
2220 
2221 		/* Perform operation */
2222 		i += __bpf_ld_imm64(&insn[i], R1, imm);
2223 
2224 		/* Load reference */
2225 		insn[i++] = BPF_ALU32_IMM(BPF_MOV, R2, imm);
2226 		insn[i++] = BPF_ALU32_IMM(BPF_MOV, R3, (u32)(imm >> 32));
2227 		insn[i++] = BPF_ALU64_IMM(BPF_LSH, R3, 32);
2228 		insn[i++] = BPF_ALU64_REG(BPF_OR, R2, R3);
2229 
2230 		/* Check result */
2231 		insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R2, 1);
2232 		insn[i++] = BPF_EXIT_INSN();
2233 	}
2234 
2235 	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
2236 	insn[i++] = BPF_EXIT_INSN();
2237 
2238 	self->u.ptr.insns = insn;
2239 	self->u.ptr.len = len;
2240 	BUG_ON(i != len);
2241 
2242 	return 0;
2243 }
2244 
2245 static int bpf_fill_ld_imm64_checker(struct bpf_test *self)
2246 {
2247 	return __bpf_fill_ld_imm64_bytes(self, 0, 0xff, 0xff, 0xff);
2248 }
2249 
2250 static int bpf_fill_ld_imm64_pos_neg(struct bpf_test *self)
2251 {
2252 	return __bpf_fill_ld_imm64_bytes(self, 1, 0x81, 0x80, 0x80);
2253 }
2254 
2255 static int bpf_fill_ld_imm64_pos_zero(struct bpf_test *self)
2256 {
2257 	return __bpf_fill_ld_imm64_bytes(self, 1, 0x81, 0, 0xff);
2258 }
2259 
2260 static int bpf_fill_ld_imm64_neg_zero(struct bpf_test *self)
2261 {
2262 	return __bpf_fill_ld_imm64_bytes(self, 0x80, 0x80, 0, 0xff);
2263 }
2264 
2265 /*
2266  * Exhaustive tests of JMP operations for all combinations of power-of-two
2267  * magnitudes of the operands, both for positive and negative values. The
2268  * test is designed to verify e.g. the JMP and JMP32 operations for JITs that
2269  * emit different code depending on the magnitude of the immediate value.
2270  */
2271 
2272 static bool __bpf_match_jmp_cond(s64 v1, s64 v2, u8 op)
2273 {
2274 	switch (op) {
2275 	case BPF_JSET:
2276 		return !!(v1 & v2);
2277 	case BPF_JEQ:
2278 		return v1 == v2;
2279 	case BPF_JNE:
2280 		return v1 != v2;
2281 	case BPF_JGT:
2282 		return (u64)v1 > (u64)v2;
2283 	case BPF_JGE:
2284 		return (u64)v1 >= (u64)v2;
2285 	case BPF_JLT:
2286 		return (u64)v1 < (u64)v2;
2287 	case BPF_JLE:
2288 		return (u64)v1 <= (u64)v2;
2289 	case BPF_JSGT:
2290 		return v1 > v2;
2291 	case BPF_JSGE:
2292 		return v1 >= v2;
2293 	case BPF_JSLT:
2294 		return v1 < v2;
2295 	case BPF_JSLE:
2296 		return v1 <= v2;
2297 	}
2298 	return false;
2299 }
2300 
2301 static int __bpf_emit_jmp_imm(struct bpf_test *self, void *arg,
2302 			      struct bpf_insn *insns, s64 dst, s64 imm)
2303 {
2304 	int op = *(int *)arg;
2305 
2306 	if (insns) {
2307 		bool match = __bpf_match_jmp_cond(dst, (s32)imm, op);
2308 		int i = 0;
2309 
2310 		insns[i++] = BPF_ALU32_IMM(BPF_MOV, R0, match);
2311 
2312 		i += __bpf_ld_imm64(&insns[i], R1, dst);
2313 		insns[i++] = BPF_JMP_IMM(op, R1, imm, 1);
2314 		if (!match)
2315 			insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
2316 		insns[i++] = BPF_EXIT_INSN();
2317 
2318 		return i;
2319 	}
2320 
2321 	return 5 + 1;
2322 }
2323 
2324 static int __bpf_emit_jmp32_imm(struct bpf_test *self, void *arg,
2325 				struct bpf_insn *insns, s64 dst, s64 imm)
2326 {
2327 	int op = *(int *)arg;
2328 
2329 	if (insns) {
2330 		bool match = __bpf_match_jmp_cond((s32)dst, (s32)imm, op);
2331 		int i = 0;
2332 
2333 		i += __bpf_ld_imm64(&insns[i], R1, dst);
2334 		insns[i++] = BPF_JMP32_IMM(op, R1, imm, 1);
2335 		if (!match)
2336 			insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
2337 		insns[i++] = BPF_EXIT_INSN();
2338 
2339 		return i;
2340 	}
2341 
2342 	return 5;
2343 }
2344 
2345 static int __bpf_emit_jmp_reg(struct bpf_test *self, void *arg,
2346 			      struct bpf_insn *insns, s64 dst, s64 src)
2347 {
2348 	int op = *(int *)arg;
2349 
2350 	if (insns) {
2351 		bool match = __bpf_match_jmp_cond(dst, src, op);
2352 		int i = 0;
2353 
2354 		i += __bpf_ld_imm64(&insns[i], R1, dst);
2355 		i += __bpf_ld_imm64(&insns[i], R2, src);
2356 		insns[i++] = BPF_JMP_REG(op, R1, R2, 1);
2357 		if (!match)
2358 			insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
2359 		insns[i++] = BPF_EXIT_INSN();
2360 
2361 		return i;
2362 	}
2363 
2364 	return 7;
2365 }
2366 
2367 static int __bpf_emit_jmp32_reg(struct bpf_test *self, void *arg,
2368 				struct bpf_insn *insns, s64 dst, s64 src)
2369 {
2370 	int op = *(int *)arg;
2371 
2372 	if (insns) {
2373 		bool match = __bpf_match_jmp_cond((s32)dst, (s32)src, op);
2374 		int i = 0;
2375 
2376 		i += __bpf_ld_imm64(&insns[i], R1, dst);
2377 		i += __bpf_ld_imm64(&insns[i], R2, src);
2378 		insns[i++] = BPF_JMP32_REG(op, R1, R2, 1);
2379 		if (!match)
2380 			insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
2381 		insns[i++] = BPF_EXIT_INSN();
2382 
2383 		return i;
2384 	}
2385 
2386 	return 7;
2387 }
2388 
2389 static int __bpf_fill_jmp_imm(struct bpf_test *self, int op)
2390 {
2391 	return __bpf_fill_pattern(self, &op, 64, 32,
2392 				  PATTERN_BLOCK1, PATTERN_BLOCK2,
2393 				  &__bpf_emit_jmp_imm);
2394 }
2395 
2396 static int __bpf_fill_jmp32_imm(struct bpf_test *self, int op)
2397 {
2398 	return __bpf_fill_pattern(self, &op, 64, 32,
2399 				  PATTERN_BLOCK1, PATTERN_BLOCK2,
2400 				  &__bpf_emit_jmp32_imm);
2401 }
2402 
2403 static int __bpf_fill_jmp_reg(struct bpf_test *self, int op)
2404 {
2405 	return __bpf_fill_pattern(self, &op, 64, 64,
2406 				  PATTERN_BLOCK1, PATTERN_BLOCK2,
2407 				  &__bpf_emit_jmp_reg);
2408 }
2409 
2410 static int __bpf_fill_jmp32_reg(struct bpf_test *self, int op)
2411 {
2412 	return __bpf_fill_pattern(self, &op, 64, 64,
2413 				  PATTERN_BLOCK1, PATTERN_BLOCK2,
2414 				  &__bpf_emit_jmp32_reg);
2415 }
2416 
2417 /* JMP immediate tests */
2418 static int bpf_fill_jmp_jset_imm(struct bpf_test *self)
2419 {
2420 	return __bpf_fill_jmp_imm(self, BPF_JSET);
2421 }
2422 
2423 static int bpf_fill_jmp_jeq_imm(struct bpf_test *self)
2424 {
2425 	return __bpf_fill_jmp_imm(self, BPF_JEQ);
2426 }
2427 
2428 static int bpf_fill_jmp_jne_imm(struct bpf_test *self)
2429 {
2430 	return __bpf_fill_jmp_imm(self, BPF_JNE);
2431 }
2432 
2433 static int bpf_fill_jmp_jgt_imm(struct bpf_test *self)
2434 {
2435 	return __bpf_fill_jmp_imm(self, BPF_JGT);
2436 }
2437 
2438 static int bpf_fill_jmp_jge_imm(struct bpf_test *self)
2439 {
2440 	return __bpf_fill_jmp_imm(self, BPF_JGE);
2441 }
2442 
2443 static int bpf_fill_jmp_jlt_imm(struct bpf_test *self)
2444 {
2445 	return __bpf_fill_jmp_imm(self, BPF_JLT);
2446 }
2447 
2448 static int bpf_fill_jmp_jle_imm(struct bpf_test *self)
2449 {
2450 	return __bpf_fill_jmp_imm(self, BPF_JLE);
2451 }
2452 
2453 static int bpf_fill_jmp_jsgt_imm(struct bpf_test *self)
2454 {
2455 	return __bpf_fill_jmp_imm(self, BPF_JSGT);
2456 }
2457 
2458 static int bpf_fill_jmp_jsge_imm(struct bpf_test *self)
2459 {
2460 	return __bpf_fill_jmp_imm(self, BPF_JSGE);
2461 }
2462 
2463 static int bpf_fill_jmp_jslt_imm(struct bpf_test *self)
2464 {
2465 	return __bpf_fill_jmp_imm(self, BPF_JSLT);
2466 }
2467 
2468 static int bpf_fill_jmp_jsle_imm(struct bpf_test *self)
2469 {
2470 	return __bpf_fill_jmp_imm(self, BPF_JSLE);
2471 }
2472 
2473 /* JMP32 immediate tests */
2474 static int bpf_fill_jmp32_jset_imm(struct bpf_test *self)
2475 {
2476 	return __bpf_fill_jmp32_imm(self, BPF_JSET);
2477 }
2478 
2479 static int bpf_fill_jmp32_jeq_imm(struct bpf_test *self)
2480 {
2481 	return __bpf_fill_jmp32_imm(self, BPF_JEQ);
2482 }
2483 
2484 static int bpf_fill_jmp32_jne_imm(struct bpf_test *self)
2485 {
2486 	return __bpf_fill_jmp32_imm(self, BPF_JNE);
2487 }
2488 
2489 static int bpf_fill_jmp32_jgt_imm(struct bpf_test *self)
2490 {
2491 	return __bpf_fill_jmp32_imm(self, BPF_JGT);
2492 }
2493 
2494 static int bpf_fill_jmp32_jge_imm(struct bpf_test *self)
2495 {
2496 	return __bpf_fill_jmp32_imm(self, BPF_JGE);
2497 }
2498 
2499 static int bpf_fill_jmp32_jlt_imm(struct bpf_test *self)
2500 {
2501 	return __bpf_fill_jmp32_imm(self, BPF_JLT);
2502 }
2503 
2504 static int bpf_fill_jmp32_jle_imm(struct bpf_test *self)
2505 {
2506 	return __bpf_fill_jmp32_imm(self, BPF_JLE);
2507 }
2508 
2509 static int bpf_fill_jmp32_jsgt_imm(struct bpf_test *self)
2510 {
2511 	return __bpf_fill_jmp32_imm(self, BPF_JSGT);
2512 }
2513 
2514 static int bpf_fill_jmp32_jsge_imm(struct bpf_test *self)
2515 {
2516 	return __bpf_fill_jmp32_imm(self, BPF_JSGE);
2517 }
2518 
2519 static int bpf_fill_jmp32_jslt_imm(struct bpf_test *self)
2520 {
2521 	return __bpf_fill_jmp32_imm(self, BPF_JSLT);
2522 }
2523 
2524 static int bpf_fill_jmp32_jsle_imm(struct bpf_test *self)
2525 {
2526 	return __bpf_fill_jmp32_imm(self, BPF_JSLE);
2527 }
2528 
2529 /* JMP register tests */
2530 static int bpf_fill_jmp_jset_reg(struct bpf_test *self)
2531 {
2532 	return __bpf_fill_jmp_reg(self, BPF_JSET);
2533 }
2534 
2535 static int bpf_fill_jmp_jeq_reg(struct bpf_test *self)
2536 {
2537 	return __bpf_fill_jmp_reg(self, BPF_JEQ);
2538 }
2539 
2540 static int bpf_fill_jmp_jne_reg(struct bpf_test *self)
2541 {
2542 	return __bpf_fill_jmp_reg(self, BPF_JNE);
2543 }
2544 
2545 static int bpf_fill_jmp_jgt_reg(struct bpf_test *self)
2546 {
2547 	return __bpf_fill_jmp_reg(self, BPF_JGT);
2548 }
2549 
2550 static int bpf_fill_jmp_jge_reg(struct bpf_test *self)
2551 {
2552 	return __bpf_fill_jmp_reg(self, BPF_JGE);
2553 }
2554 
2555 static int bpf_fill_jmp_jlt_reg(struct bpf_test *self)
2556 {
2557 	return __bpf_fill_jmp_reg(self, BPF_JLT);
2558 }
2559 
2560 static int bpf_fill_jmp_jle_reg(struct bpf_test *self)
2561 {
2562 	return __bpf_fill_jmp_reg(self, BPF_JLE);
2563 }
2564 
2565 static int bpf_fill_jmp_jsgt_reg(struct bpf_test *self)
2566 {
2567 	return __bpf_fill_jmp_reg(self, BPF_JSGT);
2568 }
2569 
2570 static int bpf_fill_jmp_jsge_reg(struct bpf_test *self)
2571 {
2572 	return __bpf_fill_jmp_reg(self, BPF_JSGE);
2573 }
2574 
2575 static int bpf_fill_jmp_jslt_reg(struct bpf_test *self)
2576 {
2577 	return __bpf_fill_jmp_reg(self, BPF_JSLT);
2578 }
2579 
2580 static int bpf_fill_jmp_jsle_reg(struct bpf_test *self)
2581 {
2582 	return __bpf_fill_jmp_reg(self, BPF_JSLE);
2583 }
2584 
2585 /* JMP32 register tests */
2586 static int bpf_fill_jmp32_jset_reg(struct bpf_test *self)
2587 {
2588 	return __bpf_fill_jmp32_reg(self, BPF_JSET);
2589 }
2590 
2591 static int bpf_fill_jmp32_jeq_reg(struct bpf_test *self)
2592 {
2593 	return __bpf_fill_jmp32_reg(self, BPF_JEQ);
2594 }
2595 
2596 static int bpf_fill_jmp32_jne_reg(struct bpf_test *self)
2597 {
2598 	return __bpf_fill_jmp32_reg(self, BPF_JNE);
2599 }
2600 
2601 static int bpf_fill_jmp32_jgt_reg(struct bpf_test *self)
2602 {
2603 	return __bpf_fill_jmp32_reg(self, BPF_JGT);
2604 }
2605 
2606 static int bpf_fill_jmp32_jge_reg(struct bpf_test *self)
2607 {
2608 	return __bpf_fill_jmp32_reg(self, BPF_JGE);
2609 }
2610 
2611 static int bpf_fill_jmp32_jlt_reg(struct bpf_test *self)
2612 {
2613 	return __bpf_fill_jmp32_reg(self, BPF_JLT);
2614 }
2615 
2616 static int bpf_fill_jmp32_jle_reg(struct bpf_test *self)
2617 {
2618 	return __bpf_fill_jmp32_reg(self, BPF_JLE);
2619 }
2620 
2621 static int bpf_fill_jmp32_jsgt_reg(struct bpf_test *self)
2622 {
2623 	return __bpf_fill_jmp32_reg(self, BPF_JSGT);
2624 }
2625 
2626 static int bpf_fill_jmp32_jsge_reg(struct bpf_test *self)
2627 {
2628 	return __bpf_fill_jmp32_reg(self, BPF_JSGE);
2629 }
2630 
2631 static int bpf_fill_jmp32_jslt_reg(struct bpf_test *self)
2632 {
2633 	return __bpf_fill_jmp32_reg(self, BPF_JSLT);
2634 }
2635 
2636 static int bpf_fill_jmp32_jsle_reg(struct bpf_test *self)
2637 {
2638 	return __bpf_fill_jmp32_reg(self, BPF_JSLE);
2639 }
2640 
2641 /*
2642  * Set up a sequence of staggered jumps, forwards and backwards with
2643  * increasing offset. This tests the conversion of relative jumps to
2644  * JITed native jumps. On some architectures, for example MIPS, a large
2645  * PC-relative jump offset may overflow the immediate field of the native
2646  * conditional branch instruction, triggering a conversion to use an
2647  * absolute jump instead. Since this changes the jump offsets, another
2648  * offset computation pass is necessary, and that may in turn trigger
2649  * another branch conversion. This jump sequence is particularly nasty
2650  * in that regard.
2651  *
2652  * The sequence generation is parameterized by size and jump type.
2653  * The size must be even, and the expected result is always size + 1.
2654  * Below is an example with size=8 and result=9.
2655  *
2656  *                     ________________________Start
2657  *                     R0 = 0
2658  *                     R1 = r1
2659  *                     R2 = r2
2660  *            ,------- JMP +4 * 3______________Preamble: 4 insns
2661  * ,----------|-ind 0- if R0 != 7 JMP 8 * 3 + 1 <--------------------.
2662  * |          |        R0 = 8                                        |
2663  * |          |        JMP +7 * 3               ------------------------.
2664  * | ,--------|-----1- if R0 != 5 JMP 7 * 3 + 1 <--------------.     |  |
2665  * | |        |        R0 = 6                                  |     |  |
2666  * | |        |        JMP +5 * 3               ------------------.  |  |
2667  * | | ,------|-----2- if R0 != 3 JMP 6 * 3 + 1 <--------.     |  |  |  |
2668  * | | |      |        R0 = 4                            |     |  |  |  |
2669  * | | |      |        JMP +3 * 3               ------------.  |  |  |  |
2670  * | | | ,----|-----3- if R0 != 1 JMP 5 * 3 + 1 <--.     |  |  |  |  |  |
2671  * | | | |    |        R0 = 2                      |     |  |  |  |  |  |
2672  * | | | |    |        JMP +1 * 3               ------.  |  |  |  |  |  |
2673  * | | | | ,--t=====4> if R0 != 0 JMP 4 * 3 + 1    1  2  3  4  5  6  7  8 loc
2674  * | | | | |           R0 = 1                     -1 +2 -3 +4 -5 +6 -7 +8 off
2675  * | | | | |           JMP -2 * 3               ---'  |  |  |  |  |  |  |
2676  * | | | | | ,------5- if R0 != 2 JMP 3 * 3 + 1 <-----'  |  |  |  |  |  |
2677  * | | | | | |         R0 = 3                            |  |  |  |  |  |
2678  * | | | | | |         JMP -4 * 3               ---------'  |  |  |  |  |
2679  * | | | | | | ,----6- if R0 != 4 JMP 2 * 3 + 1 <-----------'  |  |  |  |
2680  * | | | | | | |       R0 = 5                                  |  |  |  |
2681  * | | | | | | |       JMP -6 * 3               ---------------'  |  |  |
2682  * | | | | | | | ,--7- if R0 != 6 JMP 1 * 3 + 1 <-----------------'  |  |
2683  * | | | | | | | |     R0 = 7                                        |  |
2684  * | | Error | | |     JMP -8 * 3               ---------------------'  |
2685  * | | paths | | | ,8- if R0 != 8 JMP 0 * 3 + 1 <-----------------------'
2686  * | | | | | | | | |   R0 = 9__________________Sequence: 3 * size - 1 insns
2687  * `-+-+-+-+-+-+-+-+-> EXIT____________________Return: 1 insn
2688  *
2689  */
2690 
2691 /* The maximum size parameter */
2692 #define MAX_STAGGERED_JMP_SIZE ((0x7fff / 3) & ~1)
2693 
2694 /* We use a reduced number of iterations to get a reasonable execution time */
2695 #define NR_STAGGERED_JMP_RUNS 10
2696 
2697 static int __bpf_fill_staggered_jumps(struct bpf_test *self,
2698 				      const struct bpf_insn *jmp,
2699 				      u64 r1, u64 r2)
2700 {
2701 	int size = self->test[0].result - 1;
2702 	int len = 4 + 3 * (size + 1);
2703 	struct bpf_insn *insns;
2704 	int off, ind;
2705 
2706 	insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL);
2707 	if (!insns)
2708 		return -ENOMEM;
2709 
2710 	/* Preamble */
2711 	insns[0] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
2712 	insns[1] = BPF_ALU64_IMM(BPF_MOV, R1, r1);
2713 	insns[2] = BPF_ALU64_IMM(BPF_MOV, R2, r2);
2714 	insns[3] = BPF_JMP_IMM(BPF_JA, 0, 0, 3 * size / 2);
2715 
2716 	/* Sequence */
2717 	for (ind = 0, off = size; ind <= size; ind++, off -= 2) {
2718 		struct bpf_insn *ins = &insns[4 + 3 * ind];
2719 		int loc;
2720 
2721 		if (off == 0)
2722 			off--;
2723 
2724 		loc = abs(off);
2725 		ins[0] = BPF_JMP_IMM(BPF_JNE, R0, loc - 1,
2726 				     3 * (size - ind) + 1);
2727 		ins[1] = BPF_ALU64_IMM(BPF_MOV, R0, loc);
2728 		ins[2] = *jmp;
2729 		ins[2].off = 3 * (off - 1);
2730 	}
2731 
2732 	/* Return */
2733 	insns[len - 1] = BPF_EXIT_INSN();
2734 
2735 	self->u.ptr.insns = insns;
2736 	self->u.ptr.len = len;
2737 
2738 	return 0;
2739 }
2740 
2741 /* 64-bit unconditional jump */
2742 static int bpf_fill_staggered_ja(struct bpf_test *self)
2743 {
2744 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JA, 0, 0, 0);
2745 
2746 	return __bpf_fill_staggered_jumps(self, &jmp, 0, 0);
2747 }
2748 
2749 /* 64-bit immediate jumps */
2750 static int bpf_fill_staggered_jeq_imm(struct bpf_test *self)
2751 {
2752 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JEQ, R1, 1234, 0);
2753 
2754 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2755 }
2756 
2757 static int bpf_fill_staggered_jne_imm(struct bpf_test *self)
2758 {
2759 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JNE, R1, 1234, 0);
2760 
2761 	return __bpf_fill_staggered_jumps(self, &jmp, 4321, 0);
2762 }
2763 
2764 static int bpf_fill_staggered_jset_imm(struct bpf_test *self)
2765 {
2766 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSET, R1, 0x82, 0);
2767 
2768 	return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0);
2769 }
2770 
2771 static int bpf_fill_staggered_jgt_imm(struct bpf_test *self)
2772 {
2773 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JGT, R1, 1234, 0);
2774 
2775 	return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 0);
2776 }
2777 
2778 static int bpf_fill_staggered_jge_imm(struct bpf_test *self)
2779 {
2780 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JGE, R1, 1234, 0);
2781 
2782 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2783 }
2784 
2785 static int bpf_fill_staggered_jlt_imm(struct bpf_test *self)
2786 {
2787 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JLT, R1, 0x80000000, 0);
2788 
2789 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2790 }
2791 
2792 static int bpf_fill_staggered_jle_imm(struct bpf_test *self)
2793 {
2794 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JLE, R1, 1234, 0);
2795 
2796 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2797 }
2798 
2799 static int bpf_fill_staggered_jsgt_imm(struct bpf_test *self)
2800 {
2801 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSGT, R1, -2, 0);
2802 
2803 	return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
2804 }
2805 
2806 static int bpf_fill_staggered_jsge_imm(struct bpf_test *self)
2807 {
2808 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSGE, R1, -2, 0);
2809 
2810 	return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
2811 }
2812 
2813 static int bpf_fill_staggered_jslt_imm(struct bpf_test *self)
2814 {
2815 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSLT, R1, -1, 0);
2816 
2817 	return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
2818 }
2819 
2820 static int bpf_fill_staggered_jsle_imm(struct bpf_test *self)
2821 {
2822 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSLE, R1, -1, 0);
2823 
2824 	return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
2825 }
2826 
2827 /* 64-bit register jumps */
2828 static int bpf_fill_staggered_jeq_reg(struct bpf_test *self)
2829 {
2830 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JEQ, R1, R2, 0);
2831 
2832 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
2833 }
2834 
2835 static int bpf_fill_staggered_jne_reg(struct bpf_test *self)
2836 {
2837 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JNE, R1, R2, 0);
2838 
2839 	return __bpf_fill_staggered_jumps(self, &jmp, 4321, 1234);
2840 }
2841 
2842 static int bpf_fill_staggered_jset_reg(struct bpf_test *self)
2843 {
2844 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JSET, R1, R2, 0);
2845 
2846 	return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0x82);
2847 }
2848 
2849 static int bpf_fill_staggered_jgt_reg(struct bpf_test *self)
2850 {
2851 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JGT, R1, R2, 0);
2852 
2853 	return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 1234);
2854 }
2855 
2856 static int bpf_fill_staggered_jge_reg(struct bpf_test *self)
2857 {
2858 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JGE, R1, R2, 0);
2859 
2860 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
2861 }
2862 
2863 static int bpf_fill_staggered_jlt_reg(struct bpf_test *self)
2864 {
2865 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JLT, R1, R2, 0);
2866 
2867 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0x80000000);
2868 }
2869 
2870 static int bpf_fill_staggered_jle_reg(struct bpf_test *self)
2871 {
2872 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JLE, R1, R2, 0);
2873 
2874 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
2875 }
2876 
2877 static int bpf_fill_staggered_jsgt_reg(struct bpf_test *self)
2878 {
2879 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JSGT, R1, R2, 0);
2880 
2881 	return __bpf_fill_staggered_jumps(self, &jmp, -1, -2);
2882 }
2883 
2884 static int bpf_fill_staggered_jsge_reg(struct bpf_test *self)
2885 {
2886 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JSGE, R1, R2, 0);
2887 
2888 	return __bpf_fill_staggered_jumps(self, &jmp, -2, -2);
2889 }
2890 
2891 static int bpf_fill_staggered_jslt_reg(struct bpf_test *self)
2892 {
2893 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JSLT, R1, R2, 0);
2894 
2895 	return __bpf_fill_staggered_jumps(self, &jmp, -2, -1);
2896 }
2897 
2898 static int bpf_fill_staggered_jsle_reg(struct bpf_test *self)
2899 {
2900 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JSLE, R1, R2, 0);
2901 
2902 	return __bpf_fill_staggered_jumps(self, &jmp, -1, -1);
2903 }
2904 
2905 /* 32-bit immediate jumps */
2906 static int bpf_fill_staggered_jeq32_imm(struct bpf_test *self)
2907 {
2908 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JEQ, R1, 1234, 0);
2909 
2910 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2911 }
2912 
2913 static int bpf_fill_staggered_jne32_imm(struct bpf_test *self)
2914 {
2915 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JNE, R1, 1234, 0);
2916 
2917 	return __bpf_fill_staggered_jumps(self, &jmp, 4321, 0);
2918 }
2919 
2920 static int bpf_fill_staggered_jset32_imm(struct bpf_test *self)
2921 {
2922 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSET, R1, 0x82, 0);
2923 
2924 	return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0);
2925 }
2926 
2927 static int bpf_fill_staggered_jgt32_imm(struct bpf_test *self)
2928 {
2929 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JGT, R1, 1234, 0);
2930 
2931 	return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 0);
2932 }
2933 
2934 static int bpf_fill_staggered_jge32_imm(struct bpf_test *self)
2935 {
2936 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JGE, R1, 1234, 0);
2937 
2938 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2939 }
2940 
2941 static int bpf_fill_staggered_jlt32_imm(struct bpf_test *self)
2942 {
2943 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JLT, R1, 0x80000000, 0);
2944 
2945 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2946 }
2947 
2948 static int bpf_fill_staggered_jle32_imm(struct bpf_test *self)
2949 {
2950 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JLE, R1, 1234, 0);
2951 
2952 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2953 }
2954 
2955 static int bpf_fill_staggered_jsgt32_imm(struct bpf_test *self)
2956 {
2957 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSGT, R1, -2, 0);
2958 
2959 	return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
2960 }
2961 
2962 static int bpf_fill_staggered_jsge32_imm(struct bpf_test *self)
2963 {
2964 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSGE, R1, -2, 0);
2965 
2966 	return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
2967 }
2968 
2969 static int bpf_fill_staggered_jslt32_imm(struct bpf_test *self)
2970 {
2971 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSLT, R1, -1, 0);
2972 
2973 	return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
2974 }
2975 
2976 static int bpf_fill_staggered_jsle32_imm(struct bpf_test *self)
2977 {
2978 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSLE, R1, -1, 0);
2979 
2980 	return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
2981 }
2982 
2983 /* 32-bit register jumps */
2984 static int bpf_fill_staggered_jeq32_reg(struct bpf_test *self)
2985 {
2986 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JEQ, R1, R2, 0);
2987 
2988 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
2989 }
2990 
2991 static int bpf_fill_staggered_jne32_reg(struct bpf_test *self)
2992 {
2993 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JNE, R1, R2, 0);
2994 
2995 	return __bpf_fill_staggered_jumps(self, &jmp, 4321, 1234);
2996 }
2997 
2998 static int bpf_fill_staggered_jset32_reg(struct bpf_test *self)
2999 {
3000 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSET, R1, R2, 0);
3001 
3002 	return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0x82);
3003 }
3004 
3005 static int bpf_fill_staggered_jgt32_reg(struct bpf_test *self)
3006 {
3007 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JGT, R1, R2, 0);
3008 
3009 	return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 1234);
3010 }
3011 
3012 static int bpf_fill_staggered_jge32_reg(struct bpf_test *self)
3013 {
3014 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JGE, R1, R2, 0);
3015 
3016 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
3017 }
3018 
3019 static int bpf_fill_staggered_jlt32_reg(struct bpf_test *self)
3020 {
3021 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JLT, R1, R2, 0);
3022 
3023 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0x80000000);
3024 }
3025 
3026 static int bpf_fill_staggered_jle32_reg(struct bpf_test *self)
3027 {
3028 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JLE, R1, R2, 0);
3029 
3030 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
3031 }
3032 
3033 static int bpf_fill_staggered_jsgt32_reg(struct bpf_test *self)
3034 {
3035 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSGT, R1, R2, 0);
3036 
3037 	return __bpf_fill_staggered_jumps(self, &jmp, -1, -2);
3038 }
3039 
3040 static int bpf_fill_staggered_jsge32_reg(struct bpf_test *self)
3041 {
3042 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSGE, R1, R2, 0);
3043 
3044 	return __bpf_fill_staggered_jumps(self, &jmp, -2, -2);
3045 }
3046 
3047 static int bpf_fill_staggered_jslt32_reg(struct bpf_test *self)
3048 {
3049 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSLT, R1, R2, 0);
3050 
3051 	return __bpf_fill_staggered_jumps(self, &jmp, -2, -1);
3052 }
3053 
3054 static int bpf_fill_staggered_jsle32_reg(struct bpf_test *self)
3055 {
3056 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSLE, R1, R2, 0);
3057 
3058 	return __bpf_fill_staggered_jumps(self, &jmp, -1, -1);
3059 }
3060 
3061 
3062 static struct bpf_test tests[] = {
3063 	{
3064 		"TAX",
3065 		.u.insns = {
3066 			BPF_STMT(BPF_LD | BPF_IMM, 1),
3067 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3068 			BPF_STMT(BPF_LD | BPF_IMM, 2),
3069 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3070 			BPF_STMT(BPF_ALU | BPF_NEG, 0), /* A == -3 */
3071 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3072 			BPF_STMT(BPF_LD | BPF_LEN, 0),
3073 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3074 			BPF_STMT(BPF_MISC | BPF_TAX, 0), /* X == len - 3 */
3075 			BPF_STMT(BPF_LD | BPF_B | BPF_IND, 1),
3076 			BPF_STMT(BPF_RET | BPF_A, 0)
3077 		},
3078 		CLASSIC,
3079 		{ 10, 20, 30, 40, 50 },
3080 		{ { 2, 10 }, { 3, 20 }, { 4, 30 } },
3081 	},
3082 	{
3083 		"TXA",
3084 		.u.insns = {
3085 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3086 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
3087 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3088 			BPF_STMT(BPF_RET | BPF_A, 0) /* A == len * 2 */
3089 		},
3090 		CLASSIC,
3091 		{ 10, 20, 30, 40, 50 },
3092 		{ { 1, 2 }, { 3, 6 }, { 4, 8 } },
3093 	},
3094 	{
3095 		"ADD_SUB_MUL_K",
3096 		.u.insns = {
3097 			BPF_STMT(BPF_LD | BPF_IMM, 1),
3098 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 2),
3099 			BPF_STMT(BPF_LDX | BPF_IMM, 3),
3100 			BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
3101 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0xffffffff),
3102 			BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 3),
3103 			BPF_STMT(BPF_RET | BPF_A, 0)
3104 		},
3105 		CLASSIC | FLAG_NO_DATA,
3106 		{ },
3107 		{ { 0, 0xfffffffd } }
3108 	},
3109 	{
3110 		"DIV_MOD_KX",
3111 		.u.insns = {
3112 			BPF_STMT(BPF_LD | BPF_IMM, 8),
3113 			BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 2),
3114 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3115 			BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
3116 			BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
3117 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3118 			BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
3119 			BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x70000000),
3120 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3121 			BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
3122 			BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
3123 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3124 			BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
3125 			BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x70000000),
3126 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3127 			BPF_STMT(BPF_RET | BPF_A, 0)
3128 		},
3129 		CLASSIC | FLAG_NO_DATA,
3130 		{ },
3131 		{ { 0, 0x20000000 } }
3132 	},
3133 	{
3134 		"AND_OR_LSH_K",
3135 		.u.insns = {
3136 			BPF_STMT(BPF_LD | BPF_IMM, 0xff),
3137 			BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
3138 			BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 27),
3139 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3140 			BPF_STMT(BPF_LD | BPF_IMM, 0xf),
3141 			BPF_STMT(BPF_ALU | BPF_OR | BPF_K, 0xf0),
3142 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3143 			BPF_STMT(BPF_RET | BPF_A, 0)
3144 		},
3145 		CLASSIC | FLAG_NO_DATA,
3146 		{ },
3147 		{ { 0, 0x800000ff }, { 1, 0x800000ff } },
3148 	},
3149 	{
3150 		"LD_IMM_0",
3151 		.u.insns = {
3152 			BPF_STMT(BPF_LD | BPF_IMM, 0), /* ld #0 */
3153 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0, 1, 0),
3154 			BPF_STMT(BPF_RET | BPF_K, 0),
3155 			BPF_STMT(BPF_RET | BPF_K, 1),
3156 		},
3157 		CLASSIC,
3158 		{ },
3159 		{ { 1, 1 } },
3160 	},
3161 	{
3162 		"LD_IND",
3163 		.u.insns = {
3164 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3165 			BPF_STMT(BPF_LD | BPF_H | BPF_IND, MAX_K),
3166 			BPF_STMT(BPF_RET | BPF_K, 1)
3167 		},
3168 		CLASSIC,
3169 		{ },
3170 		{ { 1, 0 }, { 10, 0 }, { 60, 0 } },
3171 	},
3172 	{
3173 		"LD_ABS",
3174 		.u.insns = {
3175 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1000),
3176 			BPF_STMT(BPF_RET | BPF_K, 1)
3177 		},
3178 		CLASSIC,
3179 		{ },
3180 		{ { 1, 0 }, { 10, 0 }, { 60, 0 } },
3181 	},
3182 	{
3183 		"LD_ABS_LL",
3184 		.u.insns = {
3185 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF),
3186 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3187 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF + 1),
3188 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3189 			BPF_STMT(BPF_RET | BPF_A, 0)
3190 		},
3191 		CLASSIC,
3192 		{ 1, 2, 3 },
3193 		{ { 1, 0 }, { 2, 3 } },
3194 	},
3195 	{
3196 		"LD_IND_LL",
3197 		.u.insns = {
3198 			BPF_STMT(BPF_LD | BPF_IMM, SKF_LL_OFF - 1),
3199 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3200 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3201 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3202 			BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
3203 			BPF_STMT(BPF_RET | BPF_A, 0)
3204 		},
3205 		CLASSIC,
3206 		{ 1, 2, 3, 0xff },
3207 		{ { 1, 1 }, { 3, 3 }, { 4, 0xff } },
3208 	},
3209 	{
3210 		"LD_ABS_NET",
3211 		.u.insns = {
3212 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF),
3213 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3214 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF + 1),
3215 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3216 			BPF_STMT(BPF_RET | BPF_A, 0)
3217 		},
3218 		CLASSIC,
3219 		{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
3220 		{ { 15, 0 }, { 16, 3 } },
3221 	},
3222 	{
3223 		"LD_IND_NET",
3224 		.u.insns = {
3225 			BPF_STMT(BPF_LD | BPF_IMM, SKF_NET_OFF - 15),
3226 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3227 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3228 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3229 			BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
3230 			BPF_STMT(BPF_RET | BPF_A, 0)
3231 		},
3232 		CLASSIC,
3233 		{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
3234 		{ { 14, 0 }, { 15, 1 }, { 17, 3 } },
3235 	},
3236 	{
3237 		"LD_PKTTYPE",
3238 		.u.insns = {
3239 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3240 				 SKF_AD_OFF + SKF_AD_PKTTYPE),
3241 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
3242 			BPF_STMT(BPF_RET | BPF_K, 1),
3243 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3244 				 SKF_AD_OFF + SKF_AD_PKTTYPE),
3245 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
3246 			BPF_STMT(BPF_RET | BPF_K, 1),
3247 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3248 				 SKF_AD_OFF + SKF_AD_PKTTYPE),
3249 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
3250 			BPF_STMT(BPF_RET | BPF_K, 1),
3251 			BPF_STMT(BPF_RET | BPF_A, 0)
3252 		},
3253 		CLASSIC,
3254 		{ },
3255 		{ { 1, 3 }, { 10, 3 } },
3256 	},
3257 	{
3258 		"LD_MARK",
3259 		.u.insns = {
3260 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3261 				 SKF_AD_OFF + SKF_AD_MARK),
3262 			BPF_STMT(BPF_RET | BPF_A, 0)
3263 		},
3264 		CLASSIC,
3265 		{ },
3266 		{ { 1, SKB_MARK}, { 10, SKB_MARK} },
3267 	},
3268 	{
3269 		"LD_RXHASH",
3270 		.u.insns = {
3271 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3272 				 SKF_AD_OFF + SKF_AD_RXHASH),
3273 			BPF_STMT(BPF_RET | BPF_A, 0)
3274 		},
3275 		CLASSIC,
3276 		{ },
3277 		{ { 1, SKB_HASH}, { 10, SKB_HASH} },
3278 	},
3279 	{
3280 		"LD_QUEUE",
3281 		.u.insns = {
3282 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3283 				 SKF_AD_OFF + SKF_AD_QUEUE),
3284 			BPF_STMT(BPF_RET | BPF_A, 0)
3285 		},
3286 		CLASSIC,
3287 		{ },
3288 		{ { 1, SKB_QUEUE_MAP }, { 10, SKB_QUEUE_MAP } },
3289 	},
3290 	{
3291 		"LD_PROTOCOL",
3292 		.u.insns = {
3293 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 1),
3294 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 20, 1, 0),
3295 			BPF_STMT(BPF_RET | BPF_K, 0),
3296 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3297 				 SKF_AD_OFF + SKF_AD_PROTOCOL),
3298 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3299 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
3300 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 30, 1, 0),
3301 			BPF_STMT(BPF_RET | BPF_K, 0),
3302 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
3303 			BPF_STMT(BPF_RET | BPF_A, 0)
3304 		},
3305 		CLASSIC,
3306 		{ 10, 20, 30 },
3307 		{ { 10, ETH_P_IP }, { 100, ETH_P_IP } },
3308 	},
3309 	{
3310 		"LD_VLAN_TAG",
3311 		.u.insns = {
3312 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3313 				 SKF_AD_OFF + SKF_AD_VLAN_TAG),
3314 			BPF_STMT(BPF_RET | BPF_A, 0)
3315 		},
3316 		CLASSIC,
3317 		{ },
3318 		{
3319 			{ 1, SKB_VLAN_TCI },
3320 			{ 10, SKB_VLAN_TCI }
3321 		},
3322 	},
3323 	{
3324 		"LD_VLAN_TAG_PRESENT",
3325 		.u.insns = {
3326 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3327 				 SKF_AD_OFF + SKF_AD_VLAN_TAG_PRESENT),
3328 			BPF_STMT(BPF_RET | BPF_A, 0)
3329 		},
3330 		CLASSIC,
3331 		{ },
3332 		{
3333 			{ 1, SKB_VLAN_PRESENT },
3334 			{ 10, SKB_VLAN_PRESENT }
3335 		},
3336 	},
3337 	{
3338 		"LD_IFINDEX",
3339 		.u.insns = {
3340 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3341 				 SKF_AD_OFF + SKF_AD_IFINDEX),
3342 			BPF_STMT(BPF_RET | BPF_A, 0)
3343 		},
3344 		CLASSIC,
3345 		{ },
3346 		{ { 1, SKB_DEV_IFINDEX }, { 10, SKB_DEV_IFINDEX } },
3347 	},
3348 	{
3349 		"LD_HATYPE",
3350 		.u.insns = {
3351 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3352 				 SKF_AD_OFF + SKF_AD_HATYPE),
3353 			BPF_STMT(BPF_RET | BPF_A, 0)
3354 		},
3355 		CLASSIC,
3356 		{ },
3357 		{ { 1, SKB_DEV_TYPE }, { 10, SKB_DEV_TYPE } },
3358 	},
3359 	{
3360 		"LD_CPU",
3361 		.u.insns = {
3362 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3363 				 SKF_AD_OFF + SKF_AD_CPU),
3364 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3365 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3366 				 SKF_AD_OFF + SKF_AD_CPU),
3367 			BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
3368 			BPF_STMT(BPF_RET | BPF_A, 0)
3369 		},
3370 		CLASSIC,
3371 		{ },
3372 		{ { 1, 0 }, { 10, 0 } },
3373 	},
3374 	{
3375 		"LD_NLATTR",
3376 		.u.insns = {
3377 			BPF_STMT(BPF_LDX | BPF_IMM, 2),
3378 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
3379 			BPF_STMT(BPF_LDX | BPF_IMM, 3),
3380 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3381 				 SKF_AD_OFF + SKF_AD_NLATTR),
3382 			BPF_STMT(BPF_RET | BPF_A, 0)
3383 		},
3384 		CLASSIC,
3385 #ifdef __BIG_ENDIAN
3386 		{ 0xff, 0xff, 0, 4, 0, 2, 0, 4, 0, 3 },
3387 #else
3388 		{ 0xff, 0xff, 4, 0, 2, 0, 4, 0, 3, 0 },
3389 #endif
3390 		{ { 4, 0 }, { 20, 6 } },
3391 	},
3392 	{
3393 		"LD_NLATTR_NEST",
3394 		.u.insns = {
3395 			BPF_STMT(BPF_LD | BPF_IMM, 2),
3396 			BPF_STMT(BPF_LDX | BPF_IMM, 3),
3397 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3398 				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3399 			BPF_STMT(BPF_LD | BPF_IMM, 2),
3400 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3401 				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3402 			BPF_STMT(BPF_LD | BPF_IMM, 2),
3403 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3404 				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3405 			BPF_STMT(BPF_LD | BPF_IMM, 2),
3406 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3407 				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3408 			BPF_STMT(BPF_LD | BPF_IMM, 2),
3409 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3410 				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3411 			BPF_STMT(BPF_LD | BPF_IMM, 2),
3412 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3413 				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3414 			BPF_STMT(BPF_LD | BPF_IMM, 2),
3415 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3416 				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3417 			BPF_STMT(BPF_LD | BPF_IMM, 2),
3418 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3419 				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3420 			BPF_STMT(BPF_RET | BPF_A, 0)
3421 		},
3422 		CLASSIC,
3423 #ifdef __BIG_ENDIAN
3424 		{ 0xff, 0xff, 0, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3 },
3425 #else
3426 		{ 0xff, 0xff, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3, 0 },
3427 #endif
3428 		{ { 4, 0 }, { 20, 10 } },
3429 	},
3430 	{
3431 		"LD_PAYLOAD_OFF",
3432 		.u.insns = {
3433 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3434 				 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
3435 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3436 				 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
3437 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3438 				 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
3439 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3440 				 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
3441 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3442 				 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
3443 			BPF_STMT(BPF_RET | BPF_A, 0)
3444 		},
3445 		CLASSIC,
3446 		/* 00:00:00:00:00:00 > 00:00:00:00:00:00, ethtype IPv4 (0x0800),
3447 		 * length 98: 127.0.0.1 > 127.0.0.1: ICMP echo request,
3448 		 * id 9737, seq 1, length 64
3449 		 */
3450 		{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3451 		  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3452 		  0x08, 0x00,
3453 		  0x45, 0x00, 0x00, 0x54, 0xac, 0x8b, 0x40, 0x00, 0x40,
3454 		  0x01, 0x90, 0x1b, 0x7f, 0x00, 0x00, 0x01 },
3455 		{ { 30, 0 }, { 100, 42 } },
3456 	},
3457 	{
3458 		"LD_ANC_XOR",
3459 		.u.insns = {
3460 			BPF_STMT(BPF_LD | BPF_IMM, 10),
3461 			BPF_STMT(BPF_LDX | BPF_IMM, 300),
3462 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3463 				 SKF_AD_OFF + SKF_AD_ALU_XOR_X),
3464 			BPF_STMT(BPF_RET | BPF_A, 0)
3465 		},
3466 		CLASSIC,
3467 		{ },
3468 		{ { 4, 0xA ^ 300 }, { 20, 0xA ^ 300 } },
3469 	},
3470 	{
3471 		"SPILL_FILL",
3472 		.u.insns = {
3473 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3474 			BPF_STMT(BPF_LD | BPF_IMM, 2),
3475 			BPF_STMT(BPF_ALU | BPF_RSH, 1),
3476 			BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
3477 			BPF_STMT(BPF_ST, 1), /* M1 = 1 ^ len */
3478 			BPF_STMT(BPF_ALU | BPF_XOR | BPF_K, 0x80000000),
3479 			BPF_STMT(BPF_ST, 2), /* M2 = 1 ^ len ^ 0x80000000 */
3480 			BPF_STMT(BPF_STX, 15), /* M3 = len */
3481 			BPF_STMT(BPF_LDX | BPF_MEM, 1),
3482 			BPF_STMT(BPF_LD | BPF_MEM, 2),
3483 			BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
3484 			BPF_STMT(BPF_LDX | BPF_MEM, 15),
3485 			BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
3486 			BPF_STMT(BPF_RET | BPF_A, 0)
3487 		},
3488 		CLASSIC,
3489 		{ },
3490 		{ { 1, 0x80000001 }, { 2, 0x80000002 }, { 60, 0x80000000 ^ 60 } }
3491 	},
3492 	{
3493 		"JEQ",
3494 		.u.insns = {
3495 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3496 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
3497 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 0, 1),
3498 			BPF_STMT(BPF_RET | BPF_K, 1),
3499 			BPF_STMT(BPF_RET | BPF_K, MAX_K)
3500 		},
3501 		CLASSIC,
3502 		{ 3, 3, 3, 3, 3 },
3503 		{ { 1, 0 }, { 3, 1 }, { 4, MAX_K } },
3504 	},
3505 	{
3506 		"JGT",
3507 		.u.insns = {
3508 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3509 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
3510 			BPF_JUMP(BPF_JMP | BPF_JGT | BPF_X, 0, 0, 1),
3511 			BPF_STMT(BPF_RET | BPF_K, 1),
3512 			BPF_STMT(BPF_RET | BPF_K, MAX_K)
3513 		},
3514 		CLASSIC,
3515 		{ 4, 4, 4, 3, 3 },
3516 		{ { 2, 0 }, { 3, 1 }, { 4, MAX_K } },
3517 	},
3518 	{
3519 		"JGE (jt 0), test 1",
3520 		.u.insns = {
3521 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3522 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
3523 			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 1),
3524 			BPF_STMT(BPF_RET | BPF_K, 1),
3525 			BPF_STMT(BPF_RET | BPF_K, MAX_K)
3526 		},
3527 		CLASSIC,
3528 		{ 4, 4, 4, 3, 3 },
3529 		{ { 2, 0 }, { 3, 1 }, { 4, 1 } },
3530 	},
3531 	{
3532 		"JGE (jt 0), test 2",
3533 		.u.insns = {
3534 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3535 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
3536 			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 1),
3537 			BPF_STMT(BPF_RET | BPF_K, 1),
3538 			BPF_STMT(BPF_RET | BPF_K, MAX_K)
3539 		},
3540 		CLASSIC,
3541 		{ 4, 4, 5, 3, 3 },
3542 		{ { 4, 1 }, { 5, 1 }, { 6, MAX_K } },
3543 	},
3544 	{
3545 		"JGE",
3546 		.u.insns = {
3547 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3548 			BPF_STMT(BPF_LD | BPF_B | BPF_IND, MAX_K),
3549 			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 1, 1, 0),
3550 			BPF_STMT(BPF_RET | BPF_K, 10),
3551 			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 2, 1, 0),
3552 			BPF_STMT(BPF_RET | BPF_K, 20),
3553 			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 3, 1, 0),
3554 			BPF_STMT(BPF_RET | BPF_K, 30),
3555 			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 4, 1, 0),
3556 			BPF_STMT(BPF_RET | BPF_K, 40),
3557 			BPF_STMT(BPF_RET | BPF_K, MAX_K)
3558 		},
3559 		CLASSIC,
3560 		{ 1, 2, 3, 4, 5 },
3561 		{ { 1, 20 }, { 3, 40 }, { 5, MAX_K } },
3562 	},
3563 	{
3564 		"JSET",
3565 		.u.insns = {
3566 			BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
3567 			BPF_JUMP(BPF_JMP | BPF_JA, 1, 1, 1),
3568 			BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
3569 			BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
3570 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3571 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
3572 			BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, 4),
3573 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3574 			BPF_STMT(BPF_LD | BPF_W | BPF_IND, 0),
3575 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 1, 0, 1),
3576 			BPF_STMT(BPF_RET | BPF_K, 10),
3577 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x80000000, 0, 1),
3578 			BPF_STMT(BPF_RET | BPF_K, 20),
3579 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
3580 			BPF_STMT(BPF_RET | BPF_K, 30),
3581 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
3582 			BPF_STMT(BPF_RET | BPF_K, 30),
3583 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
3584 			BPF_STMT(BPF_RET | BPF_K, 30),
3585 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
3586 			BPF_STMT(BPF_RET | BPF_K, 30),
3587 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
3588 			BPF_STMT(BPF_RET | BPF_K, 30),
3589 			BPF_STMT(BPF_RET | BPF_K, MAX_K)
3590 		},
3591 		CLASSIC,
3592 		{ 0, 0xAA, 0x55, 1 },
3593 		{ { 4, 10 }, { 5, 20 }, { 6, MAX_K } },
3594 	},
3595 	{
3596 		"tcpdump port 22",
3597 		.u.insns = {
3598 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
3599 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 0, 8), /* IPv6 */
3600 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 20),
3601 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
3602 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
3603 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 17),
3604 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 54),
3605 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 14, 0),
3606 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 56),
3607 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 12, 13),
3608 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0800, 0, 12), /* IPv4 */
3609 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
3610 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
3611 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
3612 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 8),
3613 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
3614 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 6, 0),
3615 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
3616 			BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
3617 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
3618 			BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
3619 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 1),
3620 			BPF_STMT(BPF_RET | BPF_K, 0xffff),
3621 			BPF_STMT(BPF_RET | BPF_K, 0),
3622 		},
3623 		CLASSIC,
3624 		/* 3c:07:54:43:e5:76 > 10:bf:48:d6:43:d6, ethertype IPv4(0x0800)
3625 		 * length 114: 10.1.1.149.49700 > 10.1.2.10.22: Flags [P.],
3626 		 * seq 1305692979:1305693027, ack 3650467037, win 65535,
3627 		 * options [nop,nop,TS val 2502645400 ecr 3971138], length 48
3628 		 */
3629 		{ 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
3630 		  0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
3631 		  0x08, 0x00,
3632 		  0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
3633 		  0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
3634 		  0x0a, 0x01, 0x01, 0x95, /* ip src */
3635 		  0x0a, 0x01, 0x02, 0x0a, /* ip dst */
3636 		  0xc2, 0x24,
3637 		  0x00, 0x16 /* dst port */ },
3638 		{ { 10, 0 }, { 30, 0 }, { 100, 65535 } },
3639 	},
3640 	{
3641 		"tcpdump complex",
3642 		.u.insns = {
3643 			/* tcpdump -nei eth0 'tcp port 22 and (((ip[2:2] -
3644 			 * ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0) and
3645 			 * (len > 115 or len < 30000000000)' -d
3646 			 */
3647 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
3648 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 30, 0),
3649 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x800, 0, 29),
3650 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
3651 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 0, 27),
3652 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
3653 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 25, 0),
3654 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
3655 			BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
3656 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
3657 			BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
3658 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 20),
3659 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 16),
3660 			BPF_STMT(BPF_ST, 1),
3661 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 14),
3662 			BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf),
3663 			BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 2),
3664 			BPF_STMT(BPF_MISC | BPF_TAX, 0x5), /* libpcap emits K on TAX */
3665 			BPF_STMT(BPF_LD | BPF_MEM, 1),
3666 			BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
3667 			BPF_STMT(BPF_ST, 5),
3668 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
3669 			BPF_STMT(BPF_LD | BPF_B | BPF_IND, 26),
3670 			BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
3671 			BPF_STMT(BPF_ALU | BPF_RSH | BPF_K, 2),
3672 			BPF_STMT(BPF_MISC | BPF_TAX, 0x9), /* libpcap emits K on TAX */
3673 			BPF_STMT(BPF_LD | BPF_MEM, 5),
3674 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 4, 0),
3675 			BPF_STMT(BPF_LD | BPF_LEN, 0),
3676 			BPF_JUMP(BPF_JMP | BPF_JGT | BPF_K, 0x73, 1, 0),
3677 			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 0xfc23ac00, 1, 0),
3678 			BPF_STMT(BPF_RET | BPF_K, 0xffff),
3679 			BPF_STMT(BPF_RET | BPF_K, 0),
3680 		},
3681 		CLASSIC,
3682 		{ 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
3683 		  0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
3684 		  0x08, 0x00,
3685 		  0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
3686 		  0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
3687 		  0x0a, 0x01, 0x01, 0x95, /* ip src */
3688 		  0x0a, 0x01, 0x02, 0x0a, /* ip dst */
3689 		  0xc2, 0x24,
3690 		  0x00, 0x16 /* dst port */ },
3691 		{ { 10, 0 }, { 30, 0 }, { 100, 65535 } },
3692 	},
3693 	{
3694 		"RET_A",
3695 		.u.insns = {
3696 			/* check that uninitialized X and A contain zeros */
3697 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
3698 			BPF_STMT(BPF_RET | BPF_A, 0)
3699 		},
3700 		CLASSIC,
3701 		{ },
3702 		{ {1, 0}, {2, 0} },
3703 	},
3704 	{
3705 		"INT: ADD trivial",
3706 		.u.insns_int = {
3707 			BPF_ALU64_IMM(BPF_MOV, R1, 1),
3708 			BPF_ALU64_IMM(BPF_ADD, R1, 2),
3709 			BPF_ALU64_IMM(BPF_MOV, R2, 3),
3710 			BPF_ALU64_REG(BPF_SUB, R1, R2),
3711 			BPF_ALU64_IMM(BPF_ADD, R1, -1),
3712 			BPF_ALU64_IMM(BPF_MUL, R1, 3),
3713 			BPF_ALU64_REG(BPF_MOV, R0, R1),
3714 			BPF_EXIT_INSN(),
3715 		},
3716 		INTERNAL,
3717 		{ },
3718 		{ { 0, 0xfffffffd } }
3719 	},
3720 	{
3721 		"INT: MUL_X",
3722 		.u.insns_int = {
3723 			BPF_ALU64_IMM(BPF_MOV, R0, -1),
3724 			BPF_ALU64_IMM(BPF_MOV, R1, -1),
3725 			BPF_ALU64_IMM(BPF_MOV, R2, 3),
3726 			BPF_ALU64_REG(BPF_MUL, R1, R2),
3727 			BPF_JMP_IMM(BPF_JEQ, R1, 0xfffffffd, 1),
3728 			BPF_EXIT_INSN(),
3729 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
3730 			BPF_EXIT_INSN(),
3731 		},
3732 		INTERNAL,
3733 		{ },
3734 		{ { 0, 1 } }
3735 	},
3736 	{
3737 		"INT: MUL_X2",
3738 		.u.insns_int = {
3739 			BPF_ALU32_IMM(BPF_MOV, R0, -1),
3740 			BPF_ALU32_IMM(BPF_MOV, R1, -1),
3741 			BPF_ALU32_IMM(BPF_MOV, R2, 3),
3742 			BPF_ALU64_REG(BPF_MUL, R1, R2),
3743 			BPF_ALU64_IMM(BPF_RSH, R1, 8),
3744 			BPF_JMP_IMM(BPF_JEQ, R1, 0x2ffffff, 1),
3745 			BPF_EXIT_INSN(),
3746 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
3747 			BPF_EXIT_INSN(),
3748 		},
3749 		INTERNAL,
3750 		{ },
3751 		{ { 0, 1 } }
3752 	},
3753 	{
3754 		"INT: MUL32_X",
3755 		.u.insns_int = {
3756 			BPF_ALU32_IMM(BPF_MOV, R0, -1),
3757 			BPF_ALU64_IMM(BPF_MOV, R1, -1),
3758 			BPF_ALU32_IMM(BPF_MOV, R2, 3),
3759 			BPF_ALU32_REG(BPF_MUL, R1, R2),
3760 			BPF_ALU64_IMM(BPF_RSH, R1, 8),
3761 			BPF_JMP_IMM(BPF_JEQ, R1, 0xffffff, 1),
3762 			BPF_EXIT_INSN(),
3763 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
3764 			BPF_EXIT_INSN(),
3765 		},
3766 		INTERNAL,
3767 		{ },
3768 		{ { 0, 1 } }
3769 	},
3770 	{
3771 		/* Have to test all register combinations, since
3772 		 * JITing of different registers will produce
3773 		 * different asm code.
3774 		 */
3775 		"INT: ADD 64-bit",
3776 		.u.insns_int = {
3777 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
3778 			BPF_ALU64_IMM(BPF_MOV, R1, 1),
3779 			BPF_ALU64_IMM(BPF_MOV, R2, 2),
3780 			BPF_ALU64_IMM(BPF_MOV, R3, 3),
3781 			BPF_ALU64_IMM(BPF_MOV, R4, 4),
3782 			BPF_ALU64_IMM(BPF_MOV, R5, 5),
3783 			BPF_ALU64_IMM(BPF_MOV, R6, 6),
3784 			BPF_ALU64_IMM(BPF_MOV, R7, 7),
3785 			BPF_ALU64_IMM(BPF_MOV, R8, 8),
3786 			BPF_ALU64_IMM(BPF_MOV, R9, 9),
3787 			BPF_ALU64_IMM(BPF_ADD, R0, 20),
3788 			BPF_ALU64_IMM(BPF_ADD, R1, 20),
3789 			BPF_ALU64_IMM(BPF_ADD, R2, 20),
3790 			BPF_ALU64_IMM(BPF_ADD, R3, 20),
3791 			BPF_ALU64_IMM(BPF_ADD, R4, 20),
3792 			BPF_ALU64_IMM(BPF_ADD, R5, 20),
3793 			BPF_ALU64_IMM(BPF_ADD, R6, 20),
3794 			BPF_ALU64_IMM(BPF_ADD, R7, 20),
3795 			BPF_ALU64_IMM(BPF_ADD, R8, 20),
3796 			BPF_ALU64_IMM(BPF_ADD, R9, 20),
3797 			BPF_ALU64_IMM(BPF_SUB, R0, 10),
3798 			BPF_ALU64_IMM(BPF_SUB, R1, 10),
3799 			BPF_ALU64_IMM(BPF_SUB, R2, 10),
3800 			BPF_ALU64_IMM(BPF_SUB, R3, 10),
3801 			BPF_ALU64_IMM(BPF_SUB, R4, 10),
3802 			BPF_ALU64_IMM(BPF_SUB, R5, 10),
3803 			BPF_ALU64_IMM(BPF_SUB, R6, 10),
3804 			BPF_ALU64_IMM(BPF_SUB, R7, 10),
3805 			BPF_ALU64_IMM(BPF_SUB, R8, 10),
3806 			BPF_ALU64_IMM(BPF_SUB, R9, 10),
3807 			BPF_ALU64_REG(BPF_ADD, R0, R0),
3808 			BPF_ALU64_REG(BPF_ADD, R0, R1),
3809 			BPF_ALU64_REG(BPF_ADD, R0, R2),
3810 			BPF_ALU64_REG(BPF_ADD, R0, R3),
3811 			BPF_ALU64_REG(BPF_ADD, R0, R4),
3812 			BPF_ALU64_REG(BPF_ADD, R0, R5),
3813 			BPF_ALU64_REG(BPF_ADD, R0, R6),
3814 			BPF_ALU64_REG(BPF_ADD, R0, R7),
3815 			BPF_ALU64_REG(BPF_ADD, R0, R8),
3816 			BPF_ALU64_REG(BPF_ADD, R0, R9), /* R0 == 155 */
3817 			BPF_JMP_IMM(BPF_JEQ, R0, 155, 1),
3818 			BPF_EXIT_INSN(),
3819 			BPF_ALU64_REG(BPF_ADD, R1, R0),
3820 			BPF_ALU64_REG(BPF_ADD, R1, R1),
3821 			BPF_ALU64_REG(BPF_ADD, R1, R2),
3822 			BPF_ALU64_REG(BPF_ADD, R1, R3),
3823 			BPF_ALU64_REG(BPF_ADD, R1, R4),
3824 			BPF_ALU64_REG(BPF_ADD, R1, R5),
3825 			BPF_ALU64_REG(BPF_ADD, R1, R6),
3826 			BPF_ALU64_REG(BPF_ADD, R1, R7),
3827 			BPF_ALU64_REG(BPF_ADD, R1, R8),
3828 			BPF_ALU64_REG(BPF_ADD, R1, R9), /* R1 == 456 */
3829 			BPF_JMP_IMM(BPF_JEQ, R1, 456, 1),
3830 			BPF_EXIT_INSN(),
3831 			BPF_ALU64_REG(BPF_ADD, R2, R0),
3832 			BPF_ALU64_REG(BPF_ADD, R2, R1),
3833 			BPF_ALU64_REG(BPF_ADD, R2, R2),
3834 			BPF_ALU64_REG(BPF_ADD, R2, R3),
3835 			BPF_ALU64_REG(BPF_ADD, R2, R4),
3836 			BPF_ALU64_REG(BPF_ADD, R2, R5),
3837 			BPF_ALU64_REG(BPF_ADD, R2, R6),
3838 			BPF_ALU64_REG(BPF_ADD, R2, R7),
3839 			BPF_ALU64_REG(BPF_ADD, R2, R8),
3840 			BPF_ALU64_REG(BPF_ADD, R2, R9), /* R2 == 1358 */
3841 			BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1),
3842 			BPF_EXIT_INSN(),
3843 			BPF_ALU64_REG(BPF_ADD, R3, R0),
3844 			BPF_ALU64_REG(BPF_ADD, R3, R1),
3845 			BPF_ALU64_REG(BPF_ADD, R3, R2),
3846 			BPF_ALU64_REG(BPF_ADD, R3, R3),
3847 			BPF_ALU64_REG(BPF_ADD, R3, R4),
3848 			BPF_ALU64_REG(BPF_ADD, R3, R5),
3849 			BPF_ALU64_REG(BPF_ADD, R3, R6),
3850 			BPF_ALU64_REG(BPF_ADD, R3, R7),
3851 			BPF_ALU64_REG(BPF_ADD, R3, R8),
3852 			BPF_ALU64_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
3853 			BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
3854 			BPF_EXIT_INSN(),
3855 			BPF_ALU64_REG(BPF_ADD, R4, R0),
3856 			BPF_ALU64_REG(BPF_ADD, R4, R1),
3857 			BPF_ALU64_REG(BPF_ADD, R4, R2),
3858 			BPF_ALU64_REG(BPF_ADD, R4, R3),
3859 			BPF_ALU64_REG(BPF_ADD, R4, R4),
3860 			BPF_ALU64_REG(BPF_ADD, R4, R5),
3861 			BPF_ALU64_REG(BPF_ADD, R4, R6),
3862 			BPF_ALU64_REG(BPF_ADD, R4, R7),
3863 			BPF_ALU64_REG(BPF_ADD, R4, R8),
3864 			BPF_ALU64_REG(BPF_ADD, R4, R9), /* R4 == 12177 */
3865 			BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1),
3866 			BPF_EXIT_INSN(),
3867 			BPF_ALU64_REG(BPF_ADD, R5, R0),
3868 			BPF_ALU64_REG(BPF_ADD, R5, R1),
3869 			BPF_ALU64_REG(BPF_ADD, R5, R2),
3870 			BPF_ALU64_REG(BPF_ADD, R5, R3),
3871 			BPF_ALU64_REG(BPF_ADD, R5, R4),
3872 			BPF_ALU64_REG(BPF_ADD, R5, R5),
3873 			BPF_ALU64_REG(BPF_ADD, R5, R6),
3874 			BPF_ALU64_REG(BPF_ADD, R5, R7),
3875 			BPF_ALU64_REG(BPF_ADD, R5, R8),
3876 			BPF_ALU64_REG(BPF_ADD, R5, R9), /* R5 == 36518 */
3877 			BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1),
3878 			BPF_EXIT_INSN(),
3879 			BPF_ALU64_REG(BPF_ADD, R6, R0),
3880 			BPF_ALU64_REG(BPF_ADD, R6, R1),
3881 			BPF_ALU64_REG(BPF_ADD, R6, R2),
3882 			BPF_ALU64_REG(BPF_ADD, R6, R3),
3883 			BPF_ALU64_REG(BPF_ADD, R6, R4),
3884 			BPF_ALU64_REG(BPF_ADD, R6, R5),
3885 			BPF_ALU64_REG(BPF_ADD, R6, R6),
3886 			BPF_ALU64_REG(BPF_ADD, R6, R7),
3887 			BPF_ALU64_REG(BPF_ADD, R6, R8),
3888 			BPF_ALU64_REG(BPF_ADD, R6, R9), /* R6 == 109540 */
3889 			BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1),
3890 			BPF_EXIT_INSN(),
3891 			BPF_ALU64_REG(BPF_ADD, R7, R0),
3892 			BPF_ALU64_REG(BPF_ADD, R7, R1),
3893 			BPF_ALU64_REG(BPF_ADD, R7, R2),
3894 			BPF_ALU64_REG(BPF_ADD, R7, R3),
3895 			BPF_ALU64_REG(BPF_ADD, R7, R4),
3896 			BPF_ALU64_REG(BPF_ADD, R7, R5),
3897 			BPF_ALU64_REG(BPF_ADD, R7, R6),
3898 			BPF_ALU64_REG(BPF_ADD, R7, R7),
3899 			BPF_ALU64_REG(BPF_ADD, R7, R8),
3900 			BPF_ALU64_REG(BPF_ADD, R7, R9), /* R7 == 328605 */
3901 			BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1),
3902 			BPF_EXIT_INSN(),
3903 			BPF_ALU64_REG(BPF_ADD, R8, R0),
3904 			BPF_ALU64_REG(BPF_ADD, R8, R1),
3905 			BPF_ALU64_REG(BPF_ADD, R8, R2),
3906 			BPF_ALU64_REG(BPF_ADD, R8, R3),
3907 			BPF_ALU64_REG(BPF_ADD, R8, R4),
3908 			BPF_ALU64_REG(BPF_ADD, R8, R5),
3909 			BPF_ALU64_REG(BPF_ADD, R8, R6),
3910 			BPF_ALU64_REG(BPF_ADD, R8, R7),
3911 			BPF_ALU64_REG(BPF_ADD, R8, R8),
3912 			BPF_ALU64_REG(BPF_ADD, R8, R9), /* R8 == 985799 */
3913 			BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1),
3914 			BPF_EXIT_INSN(),
3915 			BPF_ALU64_REG(BPF_ADD, R9, R0),
3916 			BPF_ALU64_REG(BPF_ADD, R9, R1),
3917 			BPF_ALU64_REG(BPF_ADD, R9, R2),
3918 			BPF_ALU64_REG(BPF_ADD, R9, R3),
3919 			BPF_ALU64_REG(BPF_ADD, R9, R4),
3920 			BPF_ALU64_REG(BPF_ADD, R9, R5),
3921 			BPF_ALU64_REG(BPF_ADD, R9, R6),
3922 			BPF_ALU64_REG(BPF_ADD, R9, R7),
3923 			BPF_ALU64_REG(BPF_ADD, R9, R8),
3924 			BPF_ALU64_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */
3925 			BPF_ALU64_REG(BPF_MOV, R0, R9),
3926 			BPF_EXIT_INSN(),
3927 		},
3928 		INTERNAL,
3929 		{ },
3930 		{ { 0, 2957380 } }
3931 	},
3932 	{
3933 		"INT: ADD 32-bit",
3934 		.u.insns_int = {
3935 			BPF_ALU32_IMM(BPF_MOV, R0, 20),
3936 			BPF_ALU32_IMM(BPF_MOV, R1, 1),
3937 			BPF_ALU32_IMM(BPF_MOV, R2, 2),
3938 			BPF_ALU32_IMM(BPF_MOV, R3, 3),
3939 			BPF_ALU32_IMM(BPF_MOV, R4, 4),
3940 			BPF_ALU32_IMM(BPF_MOV, R5, 5),
3941 			BPF_ALU32_IMM(BPF_MOV, R6, 6),
3942 			BPF_ALU32_IMM(BPF_MOV, R7, 7),
3943 			BPF_ALU32_IMM(BPF_MOV, R8, 8),
3944 			BPF_ALU32_IMM(BPF_MOV, R9, 9),
3945 			BPF_ALU64_IMM(BPF_ADD, R1, 10),
3946 			BPF_ALU64_IMM(BPF_ADD, R2, 10),
3947 			BPF_ALU64_IMM(BPF_ADD, R3, 10),
3948 			BPF_ALU64_IMM(BPF_ADD, R4, 10),
3949 			BPF_ALU64_IMM(BPF_ADD, R5, 10),
3950 			BPF_ALU64_IMM(BPF_ADD, R6, 10),
3951 			BPF_ALU64_IMM(BPF_ADD, R7, 10),
3952 			BPF_ALU64_IMM(BPF_ADD, R8, 10),
3953 			BPF_ALU64_IMM(BPF_ADD, R9, 10),
3954 			BPF_ALU32_REG(BPF_ADD, R0, R1),
3955 			BPF_ALU32_REG(BPF_ADD, R0, R2),
3956 			BPF_ALU32_REG(BPF_ADD, R0, R3),
3957 			BPF_ALU32_REG(BPF_ADD, R0, R4),
3958 			BPF_ALU32_REG(BPF_ADD, R0, R5),
3959 			BPF_ALU32_REG(BPF_ADD, R0, R6),
3960 			BPF_ALU32_REG(BPF_ADD, R0, R7),
3961 			BPF_ALU32_REG(BPF_ADD, R0, R8),
3962 			BPF_ALU32_REG(BPF_ADD, R0, R9), /* R0 == 155 */
3963 			BPF_JMP_IMM(BPF_JEQ, R0, 155, 1),
3964 			BPF_EXIT_INSN(),
3965 			BPF_ALU32_REG(BPF_ADD, R1, R0),
3966 			BPF_ALU32_REG(BPF_ADD, R1, R1),
3967 			BPF_ALU32_REG(BPF_ADD, R1, R2),
3968 			BPF_ALU32_REG(BPF_ADD, R1, R3),
3969 			BPF_ALU32_REG(BPF_ADD, R1, R4),
3970 			BPF_ALU32_REG(BPF_ADD, R1, R5),
3971 			BPF_ALU32_REG(BPF_ADD, R1, R6),
3972 			BPF_ALU32_REG(BPF_ADD, R1, R7),
3973 			BPF_ALU32_REG(BPF_ADD, R1, R8),
3974 			BPF_ALU32_REG(BPF_ADD, R1, R9), /* R1 == 456 */
3975 			BPF_JMP_IMM(BPF_JEQ, R1, 456, 1),
3976 			BPF_EXIT_INSN(),
3977 			BPF_ALU32_REG(BPF_ADD, R2, R0),
3978 			BPF_ALU32_REG(BPF_ADD, R2, R1),
3979 			BPF_ALU32_REG(BPF_ADD, R2, R2),
3980 			BPF_ALU32_REG(BPF_ADD, R2, R3),
3981 			BPF_ALU32_REG(BPF_ADD, R2, R4),
3982 			BPF_ALU32_REG(BPF_ADD, R2, R5),
3983 			BPF_ALU32_REG(BPF_ADD, R2, R6),
3984 			BPF_ALU32_REG(BPF_ADD, R2, R7),
3985 			BPF_ALU32_REG(BPF_ADD, R2, R8),
3986 			BPF_ALU32_REG(BPF_ADD, R2, R9), /* R2 == 1358 */
3987 			BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1),
3988 			BPF_EXIT_INSN(),
3989 			BPF_ALU32_REG(BPF_ADD, R3, R0),
3990 			BPF_ALU32_REG(BPF_ADD, R3, R1),
3991 			BPF_ALU32_REG(BPF_ADD, R3, R2),
3992 			BPF_ALU32_REG(BPF_ADD, R3, R3),
3993 			BPF_ALU32_REG(BPF_ADD, R3, R4),
3994 			BPF_ALU32_REG(BPF_ADD, R3, R5),
3995 			BPF_ALU32_REG(BPF_ADD, R3, R6),
3996 			BPF_ALU32_REG(BPF_ADD, R3, R7),
3997 			BPF_ALU32_REG(BPF_ADD, R3, R8),
3998 			BPF_ALU32_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
3999 			BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
4000 			BPF_EXIT_INSN(),
4001 			BPF_ALU32_REG(BPF_ADD, R4, R0),
4002 			BPF_ALU32_REG(BPF_ADD, R4, R1),
4003 			BPF_ALU32_REG(BPF_ADD, R4, R2),
4004 			BPF_ALU32_REG(BPF_ADD, R4, R3),
4005 			BPF_ALU32_REG(BPF_ADD, R4, R4),
4006 			BPF_ALU32_REG(BPF_ADD, R4, R5),
4007 			BPF_ALU32_REG(BPF_ADD, R4, R6),
4008 			BPF_ALU32_REG(BPF_ADD, R4, R7),
4009 			BPF_ALU32_REG(BPF_ADD, R4, R8),
4010 			BPF_ALU32_REG(BPF_ADD, R4, R9), /* R4 == 12177 */
4011 			BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1),
4012 			BPF_EXIT_INSN(),
4013 			BPF_ALU32_REG(BPF_ADD, R5, R0),
4014 			BPF_ALU32_REG(BPF_ADD, R5, R1),
4015 			BPF_ALU32_REG(BPF_ADD, R5, R2),
4016 			BPF_ALU32_REG(BPF_ADD, R5, R3),
4017 			BPF_ALU32_REG(BPF_ADD, R5, R4),
4018 			BPF_ALU32_REG(BPF_ADD, R5, R5),
4019 			BPF_ALU32_REG(BPF_ADD, R5, R6),
4020 			BPF_ALU32_REG(BPF_ADD, R5, R7),
4021 			BPF_ALU32_REG(BPF_ADD, R5, R8),
4022 			BPF_ALU32_REG(BPF_ADD, R5, R9), /* R5 == 36518 */
4023 			BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1),
4024 			BPF_EXIT_INSN(),
4025 			BPF_ALU32_REG(BPF_ADD, R6, R0),
4026 			BPF_ALU32_REG(BPF_ADD, R6, R1),
4027 			BPF_ALU32_REG(BPF_ADD, R6, R2),
4028 			BPF_ALU32_REG(BPF_ADD, R6, R3),
4029 			BPF_ALU32_REG(BPF_ADD, R6, R4),
4030 			BPF_ALU32_REG(BPF_ADD, R6, R5),
4031 			BPF_ALU32_REG(BPF_ADD, R6, R6),
4032 			BPF_ALU32_REG(BPF_ADD, R6, R7),
4033 			BPF_ALU32_REG(BPF_ADD, R6, R8),
4034 			BPF_ALU32_REG(BPF_ADD, R6, R9), /* R6 == 109540 */
4035 			BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1),
4036 			BPF_EXIT_INSN(),
4037 			BPF_ALU32_REG(BPF_ADD, R7, R0),
4038 			BPF_ALU32_REG(BPF_ADD, R7, R1),
4039 			BPF_ALU32_REG(BPF_ADD, R7, R2),
4040 			BPF_ALU32_REG(BPF_ADD, R7, R3),
4041 			BPF_ALU32_REG(BPF_ADD, R7, R4),
4042 			BPF_ALU32_REG(BPF_ADD, R7, R5),
4043 			BPF_ALU32_REG(BPF_ADD, R7, R6),
4044 			BPF_ALU32_REG(BPF_ADD, R7, R7),
4045 			BPF_ALU32_REG(BPF_ADD, R7, R8),
4046 			BPF_ALU32_REG(BPF_ADD, R7, R9), /* R7 == 328605 */
4047 			BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1),
4048 			BPF_EXIT_INSN(),
4049 			BPF_ALU32_REG(BPF_ADD, R8, R0),
4050 			BPF_ALU32_REG(BPF_ADD, R8, R1),
4051 			BPF_ALU32_REG(BPF_ADD, R8, R2),
4052 			BPF_ALU32_REG(BPF_ADD, R8, R3),
4053 			BPF_ALU32_REG(BPF_ADD, R8, R4),
4054 			BPF_ALU32_REG(BPF_ADD, R8, R5),
4055 			BPF_ALU32_REG(BPF_ADD, R8, R6),
4056 			BPF_ALU32_REG(BPF_ADD, R8, R7),
4057 			BPF_ALU32_REG(BPF_ADD, R8, R8),
4058 			BPF_ALU32_REG(BPF_ADD, R8, R9), /* R8 == 985799 */
4059 			BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1),
4060 			BPF_EXIT_INSN(),
4061 			BPF_ALU32_REG(BPF_ADD, R9, R0),
4062 			BPF_ALU32_REG(BPF_ADD, R9, R1),
4063 			BPF_ALU32_REG(BPF_ADD, R9, R2),
4064 			BPF_ALU32_REG(BPF_ADD, R9, R3),
4065 			BPF_ALU32_REG(BPF_ADD, R9, R4),
4066 			BPF_ALU32_REG(BPF_ADD, R9, R5),
4067 			BPF_ALU32_REG(BPF_ADD, R9, R6),
4068 			BPF_ALU32_REG(BPF_ADD, R9, R7),
4069 			BPF_ALU32_REG(BPF_ADD, R9, R8),
4070 			BPF_ALU32_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */
4071 			BPF_ALU32_REG(BPF_MOV, R0, R9),
4072 			BPF_EXIT_INSN(),
4073 		},
4074 		INTERNAL,
4075 		{ },
4076 		{ { 0, 2957380 } }
4077 	},
4078 	{	/* Mainly checking JIT here. */
4079 		"INT: SUB",
4080 		.u.insns_int = {
4081 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
4082 			BPF_ALU64_IMM(BPF_MOV, R1, 1),
4083 			BPF_ALU64_IMM(BPF_MOV, R2, 2),
4084 			BPF_ALU64_IMM(BPF_MOV, R3, 3),
4085 			BPF_ALU64_IMM(BPF_MOV, R4, 4),
4086 			BPF_ALU64_IMM(BPF_MOV, R5, 5),
4087 			BPF_ALU64_IMM(BPF_MOV, R6, 6),
4088 			BPF_ALU64_IMM(BPF_MOV, R7, 7),
4089 			BPF_ALU64_IMM(BPF_MOV, R8, 8),
4090 			BPF_ALU64_IMM(BPF_MOV, R9, 9),
4091 			BPF_ALU64_REG(BPF_SUB, R0, R0),
4092 			BPF_ALU64_REG(BPF_SUB, R0, R1),
4093 			BPF_ALU64_REG(BPF_SUB, R0, R2),
4094 			BPF_ALU64_REG(BPF_SUB, R0, R3),
4095 			BPF_ALU64_REG(BPF_SUB, R0, R4),
4096 			BPF_ALU64_REG(BPF_SUB, R0, R5),
4097 			BPF_ALU64_REG(BPF_SUB, R0, R6),
4098 			BPF_ALU64_REG(BPF_SUB, R0, R7),
4099 			BPF_ALU64_REG(BPF_SUB, R0, R8),
4100 			BPF_ALU64_REG(BPF_SUB, R0, R9),
4101 			BPF_ALU64_IMM(BPF_SUB, R0, 10),
4102 			BPF_JMP_IMM(BPF_JEQ, R0, -55, 1),
4103 			BPF_EXIT_INSN(),
4104 			BPF_ALU64_REG(BPF_SUB, R1, R0),
4105 			BPF_ALU64_REG(BPF_SUB, R1, R2),
4106 			BPF_ALU64_REG(BPF_SUB, R1, R3),
4107 			BPF_ALU64_REG(BPF_SUB, R1, R4),
4108 			BPF_ALU64_REG(BPF_SUB, R1, R5),
4109 			BPF_ALU64_REG(BPF_SUB, R1, R6),
4110 			BPF_ALU64_REG(BPF_SUB, R1, R7),
4111 			BPF_ALU64_REG(BPF_SUB, R1, R8),
4112 			BPF_ALU64_REG(BPF_SUB, R1, R9),
4113 			BPF_ALU64_IMM(BPF_SUB, R1, 10),
4114 			BPF_ALU64_REG(BPF_SUB, R2, R0),
4115 			BPF_ALU64_REG(BPF_SUB, R2, R1),
4116 			BPF_ALU64_REG(BPF_SUB, R2, R3),
4117 			BPF_ALU64_REG(BPF_SUB, R2, R4),
4118 			BPF_ALU64_REG(BPF_SUB, R2, R5),
4119 			BPF_ALU64_REG(BPF_SUB, R2, R6),
4120 			BPF_ALU64_REG(BPF_SUB, R2, R7),
4121 			BPF_ALU64_REG(BPF_SUB, R2, R8),
4122 			BPF_ALU64_REG(BPF_SUB, R2, R9),
4123 			BPF_ALU64_IMM(BPF_SUB, R2, 10),
4124 			BPF_ALU64_REG(BPF_SUB, R3, R0),
4125 			BPF_ALU64_REG(BPF_SUB, R3, R1),
4126 			BPF_ALU64_REG(BPF_SUB, R3, R2),
4127 			BPF_ALU64_REG(BPF_SUB, R3, R4),
4128 			BPF_ALU64_REG(BPF_SUB, R3, R5),
4129 			BPF_ALU64_REG(BPF_SUB, R3, R6),
4130 			BPF_ALU64_REG(BPF_SUB, R3, R7),
4131 			BPF_ALU64_REG(BPF_SUB, R3, R8),
4132 			BPF_ALU64_REG(BPF_SUB, R3, R9),
4133 			BPF_ALU64_IMM(BPF_SUB, R3, 10),
4134 			BPF_ALU64_REG(BPF_SUB, R4, R0),
4135 			BPF_ALU64_REG(BPF_SUB, R4, R1),
4136 			BPF_ALU64_REG(BPF_SUB, R4, R2),
4137 			BPF_ALU64_REG(BPF_SUB, R4, R3),
4138 			BPF_ALU64_REG(BPF_SUB, R4, R5),
4139 			BPF_ALU64_REG(BPF_SUB, R4, R6),
4140 			BPF_ALU64_REG(BPF_SUB, R4, R7),
4141 			BPF_ALU64_REG(BPF_SUB, R4, R8),
4142 			BPF_ALU64_REG(BPF_SUB, R4, R9),
4143 			BPF_ALU64_IMM(BPF_SUB, R4, 10),
4144 			BPF_ALU64_REG(BPF_SUB, R5, R0),
4145 			BPF_ALU64_REG(BPF_SUB, R5, R1),
4146 			BPF_ALU64_REG(BPF_SUB, R5, R2),
4147 			BPF_ALU64_REG(BPF_SUB, R5, R3),
4148 			BPF_ALU64_REG(BPF_SUB, R5, R4),
4149 			BPF_ALU64_REG(BPF_SUB, R5, R6),
4150 			BPF_ALU64_REG(BPF_SUB, R5, R7),
4151 			BPF_ALU64_REG(BPF_SUB, R5, R8),
4152 			BPF_ALU64_REG(BPF_SUB, R5, R9),
4153 			BPF_ALU64_IMM(BPF_SUB, R5, 10),
4154 			BPF_ALU64_REG(BPF_SUB, R6, R0),
4155 			BPF_ALU64_REG(BPF_SUB, R6, R1),
4156 			BPF_ALU64_REG(BPF_SUB, R6, R2),
4157 			BPF_ALU64_REG(BPF_SUB, R6, R3),
4158 			BPF_ALU64_REG(BPF_SUB, R6, R4),
4159 			BPF_ALU64_REG(BPF_SUB, R6, R5),
4160 			BPF_ALU64_REG(BPF_SUB, R6, R7),
4161 			BPF_ALU64_REG(BPF_SUB, R6, R8),
4162 			BPF_ALU64_REG(BPF_SUB, R6, R9),
4163 			BPF_ALU64_IMM(BPF_SUB, R6, 10),
4164 			BPF_ALU64_REG(BPF_SUB, R7, R0),
4165 			BPF_ALU64_REG(BPF_SUB, R7, R1),
4166 			BPF_ALU64_REG(BPF_SUB, R7, R2),
4167 			BPF_ALU64_REG(BPF_SUB, R7, R3),
4168 			BPF_ALU64_REG(BPF_SUB, R7, R4),
4169 			BPF_ALU64_REG(BPF_SUB, R7, R5),
4170 			BPF_ALU64_REG(BPF_SUB, R7, R6),
4171 			BPF_ALU64_REG(BPF_SUB, R7, R8),
4172 			BPF_ALU64_REG(BPF_SUB, R7, R9),
4173 			BPF_ALU64_IMM(BPF_SUB, R7, 10),
4174 			BPF_ALU64_REG(BPF_SUB, R8, R0),
4175 			BPF_ALU64_REG(BPF_SUB, R8, R1),
4176 			BPF_ALU64_REG(BPF_SUB, R8, R2),
4177 			BPF_ALU64_REG(BPF_SUB, R8, R3),
4178 			BPF_ALU64_REG(BPF_SUB, R8, R4),
4179 			BPF_ALU64_REG(BPF_SUB, R8, R5),
4180 			BPF_ALU64_REG(BPF_SUB, R8, R6),
4181 			BPF_ALU64_REG(BPF_SUB, R8, R7),
4182 			BPF_ALU64_REG(BPF_SUB, R8, R9),
4183 			BPF_ALU64_IMM(BPF_SUB, R8, 10),
4184 			BPF_ALU64_REG(BPF_SUB, R9, R0),
4185 			BPF_ALU64_REG(BPF_SUB, R9, R1),
4186 			BPF_ALU64_REG(BPF_SUB, R9, R2),
4187 			BPF_ALU64_REG(BPF_SUB, R9, R3),
4188 			BPF_ALU64_REG(BPF_SUB, R9, R4),
4189 			BPF_ALU64_REG(BPF_SUB, R9, R5),
4190 			BPF_ALU64_REG(BPF_SUB, R9, R6),
4191 			BPF_ALU64_REG(BPF_SUB, R9, R7),
4192 			BPF_ALU64_REG(BPF_SUB, R9, R8),
4193 			BPF_ALU64_IMM(BPF_SUB, R9, 10),
4194 			BPF_ALU64_IMM(BPF_SUB, R0, 10),
4195 			BPF_ALU64_IMM(BPF_NEG, R0, 0),
4196 			BPF_ALU64_REG(BPF_SUB, R0, R1),
4197 			BPF_ALU64_REG(BPF_SUB, R0, R2),
4198 			BPF_ALU64_REG(BPF_SUB, R0, R3),
4199 			BPF_ALU64_REG(BPF_SUB, R0, R4),
4200 			BPF_ALU64_REG(BPF_SUB, R0, R5),
4201 			BPF_ALU64_REG(BPF_SUB, R0, R6),
4202 			BPF_ALU64_REG(BPF_SUB, R0, R7),
4203 			BPF_ALU64_REG(BPF_SUB, R0, R8),
4204 			BPF_ALU64_REG(BPF_SUB, R0, R9),
4205 			BPF_EXIT_INSN(),
4206 		},
4207 		INTERNAL,
4208 		{ },
4209 		{ { 0, 11 } }
4210 	},
4211 	{	/* Mainly checking JIT here. */
4212 		"INT: XOR",
4213 		.u.insns_int = {
4214 			BPF_ALU64_REG(BPF_SUB, R0, R0),
4215 			BPF_ALU64_REG(BPF_XOR, R1, R1),
4216 			BPF_JMP_REG(BPF_JEQ, R0, R1, 1),
4217 			BPF_EXIT_INSN(),
4218 			BPF_ALU64_IMM(BPF_MOV, R0, 10),
4219 			BPF_ALU64_IMM(BPF_MOV, R1, -1),
4220 			BPF_ALU64_REG(BPF_SUB, R1, R1),
4221 			BPF_ALU64_REG(BPF_XOR, R2, R2),
4222 			BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
4223 			BPF_EXIT_INSN(),
4224 			BPF_ALU64_REG(BPF_SUB, R2, R2),
4225 			BPF_ALU64_REG(BPF_XOR, R3, R3),
4226 			BPF_ALU64_IMM(BPF_MOV, R0, 10),
4227 			BPF_ALU64_IMM(BPF_MOV, R1, -1),
4228 			BPF_JMP_REG(BPF_JEQ, R2, R3, 1),
4229 			BPF_EXIT_INSN(),
4230 			BPF_ALU64_REG(BPF_SUB, R3, R3),
4231 			BPF_ALU64_REG(BPF_XOR, R4, R4),
4232 			BPF_ALU64_IMM(BPF_MOV, R2, 1),
4233 			BPF_ALU64_IMM(BPF_MOV, R5, -1),
4234 			BPF_JMP_REG(BPF_JEQ, R3, R4, 1),
4235 			BPF_EXIT_INSN(),
4236 			BPF_ALU64_REG(BPF_SUB, R4, R4),
4237 			BPF_ALU64_REG(BPF_XOR, R5, R5),
4238 			BPF_ALU64_IMM(BPF_MOV, R3, 1),
4239 			BPF_ALU64_IMM(BPF_MOV, R7, -1),
4240 			BPF_JMP_REG(BPF_JEQ, R5, R4, 1),
4241 			BPF_EXIT_INSN(),
4242 			BPF_ALU64_IMM(BPF_MOV, R5, 1),
4243 			BPF_ALU64_REG(BPF_SUB, R5, R5),
4244 			BPF_ALU64_REG(BPF_XOR, R6, R6),
4245 			BPF_ALU64_IMM(BPF_MOV, R1, 1),
4246 			BPF_ALU64_IMM(BPF_MOV, R8, -1),
4247 			BPF_JMP_REG(BPF_JEQ, R5, R6, 1),
4248 			BPF_EXIT_INSN(),
4249 			BPF_ALU64_REG(BPF_SUB, R6, R6),
4250 			BPF_ALU64_REG(BPF_XOR, R7, R7),
4251 			BPF_JMP_REG(BPF_JEQ, R7, R6, 1),
4252 			BPF_EXIT_INSN(),
4253 			BPF_ALU64_REG(BPF_SUB, R7, R7),
4254 			BPF_ALU64_REG(BPF_XOR, R8, R8),
4255 			BPF_JMP_REG(BPF_JEQ, R7, R8, 1),
4256 			BPF_EXIT_INSN(),
4257 			BPF_ALU64_REG(BPF_SUB, R8, R8),
4258 			BPF_ALU64_REG(BPF_XOR, R9, R9),
4259 			BPF_JMP_REG(BPF_JEQ, R9, R8, 1),
4260 			BPF_EXIT_INSN(),
4261 			BPF_ALU64_REG(BPF_SUB, R9, R9),
4262 			BPF_ALU64_REG(BPF_XOR, R0, R0),
4263 			BPF_JMP_REG(BPF_JEQ, R9, R0, 1),
4264 			BPF_EXIT_INSN(),
4265 			BPF_ALU64_REG(BPF_SUB, R1, R1),
4266 			BPF_ALU64_REG(BPF_XOR, R0, R0),
4267 			BPF_JMP_REG(BPF_JEQ, R9, R0, 2),
4268 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
4269 			BPF_EXIT_INSN(),
4270 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
4271 			BPF_EXIT_INSN(),
4272 		},
4273 		INTERNAL,
4274 		{ },
4275 		{ { 0, 1 } }
4276 	},
4277 	{	/* Mainly checking JIT here. */
4278 		"INT: MUL",
4279 		.u.insns_int = {
4280 			BPF_ALU64_IMM(BPF_MOV, R0, 11),
4281 			BPF_ALU64_IMM(BPF_MOV, R1, 1),
4282 			BPF_ALU64_IMM(BPF_MOV, R2, 2),
4283 			BPF_ALU64_IMM(BPF_MOV, R3, 3),
4284 			BPF_ALU64_IMM(BPF_MOV, R4, 4),
4285 			BPF_ALU64_IMM(BPF_MOV, R5, 5),
4286 			BPF_ALU64_IMM(BPF_MOV, R6, 6),
4287 			BPF_ALU64_IMM(BPF_MOV, R7, 7),
4288 			BPF_ALU64_IMM(BPF_MOV, R8, 8),
4289 			BPF_ALU64_IMM(BPF_MOV, R9, 9),
4290 			BPF_ALU64_REG(BPF_MUL, R0, R0),
4291 			BPF_ALU64_REG(BPF_MUL, R0, R1),
4292 			BPF_ALU64_REG(BPF_MUL, R0, R2),
4293 			BPF_ALU64_REG(BPF_MUL, R0, R3),
4294 			BPF_ALU64_REG(BPF_MUL, R0, R4),
4295 			BPF_ALU64_REG(BPF_MUL, R0, R5),
4296 			BPF_ALU64_REG(BPF_MUL, R0, R6),
4297 			BPF_ALU64_REG(BPF_MUL, R0, R7),
4298 			BPF_ALU64_REG(BPF_MUL, R0, R8),
4299 			BPF_ALU64_REG(BPF_MUL, R0, R9),
4300 			BPF_ALU64_IMM(BPF_MUL, R0, 10),
4301 			BPF_JMP_IMM(BPF_JEQ, R0, 439084800, 1),
4302 			BPF_EXIT_INSN(),
4303 			BPF_ALU64_REG(BPF_MUL, R1, R0),
4304 			BPF_ALU64_REG(BPF_MUL, R1, R2),
4305 			BPF_ALU64_REG(BPF_MUL, R1, R3),
4306 			BPF_ALU64_REG(BPF_MUL, R1, R4),
4307 			BPF_ALU64_REG(BPF_MUL, R1, R5),
4308 			BPF_ALU64_REG(BPF_MUL, R1, R6),
4309 			BPF_ALU64_REG(BPF_MUL, R1, R7),
4310 			BPF_ALU64_REG(BPF_MUL, R1, R8),
4311 			BPF_ALU64_REG(BPF_MUL, R1, R9),
4312 			BPF_ALU64_IMM(BPF_MUL, R1, 10),
4313 			BPF_ALU64_REG(BPF_MOV, R2, R1),
4314 			BPF_ALU64_IMM(BPF_RSH, R2, 32),
4315 			BPF_JMP_IMM(BPF_JEQ, R2, 0x5a924, 1),
4316 			BPF_EXIT_INSN(),
4317 			BPF_ALU64_IMM(BPF_LSH, R1, 32),
4318 			BPF_ALU64_IMM(BPF_ARSH, R1, 32),
4319 			BPF_JMP_IMM(BPF_JEQ, R1, 0xebb90000, 1),
4320 			BPF_EXIT_INSN(),
4321 			BPF_ALU64_REG(BPF_MUL, R2, R0),
4322 			BPF_ALU64_REG(BPF_MUL, R2, R1),
4323 			BPF_ALU64_REG(BPF_MUL, R2, R3),
4324 			BPF_ALU64_REG(BPF_MUL, R2, R4),
4325 			BPF_ALU64_REG(BPF_MUL, R2, R5),
4326 			BPF_ALU64_REG(BPF_MUL, R2, R6),
4327 			BPF_ALU64_REG(BPF_MUL, R2, R7),
4328 			BPF_ALU64_REG(BPF_MUL, R2, R8),
4329 			BPF_ALU64_REG(BPF_MUL, R2, R9),
4330 			BPF_ALU64_IMM(BPF_MUL, R2, 10),
4331 			BPF_ALU64_IMM(BPF_RSH, R2, 32),
4332 			BPF_ALU64_REG(BPF_MOV, R0, R2),
4333 			BPF_EXIT_INSN(),
4334 		},
4335 		INTERNAL,
4336 		{ },
4337 		{ { 0, 0x35d97ef2 } }
4338 	},
4339 	{	/* Mainly checking JIT here. */
4340 		"MOV REG64",
4341 		.u.insns_int = {
4342 			BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
4343 			BPF_MOV64_REG(R1, R0),
4344 			BPF_MOV64_REG(R2, R1),
4345 			BPF_MOV64_REG(R3, R2),
4346 			BPF_MOV64_REG(R4, R3),
4347 			BPF_MOV64_REG(R5, R4),
4348 			BPF_MOV64_REG(R6, R5),
4349 			BPF_MOV64_REG(R7, R6),
4350 			BPF_MOV64_REG(R8, R7),
4351 			BPF_MOV64_REG(R9, R8),
4352 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
4353 			BPF_ALU64_IMM(BPF_MOV, R1, 0),
4354 			BPF_ALU64_IMM(BPF_MOV, R2, 0),
4355 			BPF_ALU64_IMM(BPF_MOV, R3, 0),
4356 			BPF_ALU64_IMM(BPF_MOV, R4, 0),
4357 			BPF_ALU64_IMM(BPF_MOV, R5, 0),
4358 			BPF_ALU64_IMM(BPF_MOV, R6, 0),
4359 			BPF_ALU64_IMM(BPF_MOV, R7, 0),
4360 			BPF_ALU64_IMM(BPF_MOV, R8, 0),
4361 			BPF_ALU64_IMM(BPF_MOV, R9, 0),
4362 			BPF_ALU64_REG(BPF_ADD, R0, R0),
4363 			BPF_ALU64_REG(BPF_ADD, R0, R1),
4364 			BPF_ALU64_REG(BPF_ADD, R0, R2),
4365 			BPF_ALU64_REG(BPF_ADD, R0, R3),
4366 			BPF_ALU64_REG(BPF_ADD, R0, R4),
4367 			BPF_ALU64_REG(BPF_ADD, R0, R5),
4368 			BPF_ALU64_REG(BPF_ADD, R0, R6),
4369 			BPF_ALU64_REG(BPF_ADD, R0, R7),
4370 			BPF_ALU64_REG(BPF_ADD, R0, R8),
4371 			BPF_ALU64_REG(BPF_ADD, R0, R9),
4372 			BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
4373 			BPF_EXIT_INSN(),
4374 		},
4375 		INTERNAL,
4376 		{ },
4377 		{ { 0, 0xfefe } }
4378 	},
4379 	{	/* Mainly checking JIT here. */
4380 		"MOV REG32",
4381 		.u.insns_int = {
4382 			BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
4383 			BPF_MOV64_REG(R1, R0),
4384 			BPF_MOV64_REG(R2, R1),
4385 			BPF_MOV64_REG(R3, R2),
4386 			BPF_MOV64_REG(R4, R3),
4387 			BPF_MOV64_REG(R5, R4),
4388 			BPF_MOV64_REG(R6, R5),
4389 			BPF_MOV64_REG(R7, R6),
4390 			BPF_MOV64_REG(R8, R7),
4391 			BPF_MOV64_REG(R9, R8),
4392 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
4393 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
4394 			BPF_ALU32_IMM(BPF_MOV, R2, 0),
4395 			BPF_ALU32_IMM(BPF_MOV, R3, 0),
4396 			BPF_ALU32_IMM(BPF_MOV, R4, 0),
4397 			BPF_ALU32_IMM(BPF_MOV, R5, 0),
4398 			BPF_ALU32_IMM(BPF_MOV, R6, 0),
4399 			BPF_ALU32_IMM(BPF_MOV, R7, 0),
4400 			BPF_ALU32_IMM(BPF_MOV, R8, 0),
4401 			BPF_ALU32_IMM(BPF_MOV, R9, 0),
4402 			BPF_ALU64_REG(BPF_ADD, R0, R0),
4403 			BPF_ALU64_REG(BPF_ADD, R0, R1),
4404 			BPF_ALU64_REG(BPF_ADD, R0, R2),
4405 			BPF_ALU64_REG(BPF_ADD, R0, R3),
4406 			BPF_ALU64_REG(BPF_ADD, R0, R4),
4407 			BPF_ALU64_REG(BPF_ADD, R0, R5),
4408 			BPF_ALU64_REG(BPF_ADD, R0, R6),
4409 			BPF_ALU64_REG(BPF_ADD, R0, R7),
4410 			BPF_ALU64_REG(BPF_ADD, R0, R8),
4411 			BPF_ALU64_REG(BPF_ADD, R0, R9),
4412 			BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
4413 			BPF_EXIT_INSN(),
4414 		},
4415 		INTERNAL,
4416 		{ },
4417 		{ { 0, 0xfefe } }
4418 	},
4419 	{	/* Mainly checking JIT here. */
4420 		"LD IMM64",
4421 		.u.insns_int = {
4422 			BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
4423 			BPF_MOV64_REG(R1, R0),
4424 			BPF_MOV64_REG(R2, R1),
4425 			BPF_MOV64_REG(R3, R2),
4426 			BPF_MOV64_REG(R4, R3),
4427 			BPF_MOV64_REG(R5, R4),
4428 			BPF_MOV64_REG(R6, R5),
4429 			BPF_MOV64_REG(R7, R6),
4430 			BPF_MOV64_REG(R8, R7),
4431 			BPF_MOV64_REG(R9, R8),
4432 			BPF_LD_IMM64(R0, 0x0LL),
4433 			BPF_LD_IMM64(R1, 0x0LL),
4434 			BPF_LD_IMM64(R2, 0x0LL),
4435 			BPF_LD_IMM64(R3, 0x0LL),
4436 			BPF_LD_IMM64(R4, 0x0LL),
4437 			BPF_LD_IMM64(R5, 0x0LL),
4438 			BPF_LD_IMM64(R6, 0x0LL),
4439 			BPF_LD_IMM64(R7, 0x0LL),
4440 			BPF_LD_IMM64(R8, 0x0LL),
4441 			BPF_LD_IMM64(R9, 0x0LL),
4442 			BPF_ALU64_REG(BPF_ADD, R0, R0),
4443 			BPF_ALU64_REG(BPF_ADD, R0, R1),
4444 			BPF_ALU64_REG(BPF_ADD, R0, R2),
4445 			BPF_ALU64_REG(BPF_ADD, R0, R3),
4446 			BPF_ALU64_REG(BPF_ADD, R0, R4),
4447 			BPF_ALU64_REG(BPF_ADD, R0, R5),
4448 			BPF_ALU64_REG(BPF_ADD, R0, R6),
4449 			BPF_ALU64_REG(BPF_ADD, R0, R7),
4450 			BPF_ALU64_REG(BPF_ADD, R0, R8),
4451 			BPF_ALU64_REG(BPF_ADD, R0, R9),
4452 			BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
4453 			BPF_EXIT_INSN(),
4454 		},
4455 		INTERNAL,
4456 		{ },
4457 		{ { 0, 0xfefe } }
4458 	},
4459 	{
4460 		"INT: ALU MIX",
4461 		.u.insns_int = {
4462 			BPF_ALU64_IMM(BPF_MOV, R0, 11),
4463 			BPF_ALU64_IMM(BPF_ADD, R0, -1),
4464 			BPF_ALU64_IMM(BPF_MOV, R2, 2),
4465 			BPF_ALU64_IMM(BPF_XOR, R2, 3),
4466 			BPF_ALU64_REG(BPF_DIV, R0, R2),
4467 			BPF_JMP_IMM(BPF_JEQ, R0, 10, 1),
4468 			BPF_EXIT_INSN(),
4469 			BPF_ALU64_IMM(BPF_MOD, R0, 3),
4470 			BPF_JMP_IMM(BPF_JEQ, R0, 1, 1),
4471 			BPF_EXIT_INSN(),
4472 			BPF_ALU64_IMM(BPF_MOV, R0, -1),
4473 			BPF_EXIT_INSN(),
4474 		},
4475 		INTERNAL,
4476 		{ },
4477 		{ { 0, -1 } }
4478 	},
4479 	{
4480 		"INT: shifts by register",
4481 		.u.insns_int = {
4482 			BPF_MOV64_IMM(R0, -1234),
4483 			BPF_MOV64_IMM(R1, 1),
4484 			BPF_ALU32_REG(BPF_RSH, R0, R1),
4485 			BPF_JMP_IMM(BPF_JEQ, R0, 0x7ffffd97, 1),
4486 			BPF_EXIT_INSN(),
4487 			BPF_MOV64_IMM(R2, 1),
4488 			BPF_ALU64_REG(BPF_LSH, R0, R2),
4489 			BPF_MOV32_IMM(R4, -1234),
4490 			BPF_JMP_REG(BPF_JEQ, R0, R4, 1),
4491 			BPF_EXIT_INSN(),
4492 			BPF_ALU64_IMM(BPF_AND, R4, 63),
4493 			BPF_ALU64_REG(BPF_LSH, R0, R4), /* R0 <= 46 */
4494 			BPF_MOV64_IMM(R3, 47),
4495 			BPF_ALU64_REG(BPF_ARSH, R0, R3),
4496 			BPF_JMP_IMM(BPF_JEQ, R0, -617, 1),
4497 			BPF_EXIT_INSN(),
4498 			BPF_MOV64_IMM(R2, 1),
4499 			BPF_ALU64_REG(BPF_LSH, R4, R2), /* R4 = 46 << 1 */
4500 			BPF_JMP_IMM(BPF_JEQ, R4, 92, 1),
4501 			BPF_EXIT_INSN(),
4502 			BPF_MOV64_IMM(R4, 4),
4503 			BPF_ALU64_REG(BPF_LSH, R4, R4), /* R4 = 4 << 4 */
4504 			BPF_JMP_IMM(BPF_JEQ, R4, 64, 1),
4505 			BPF_EXIT_INSN(),
4506 			BPF_MOV64_IMM(R4, 5),
4507 			BPF_ALU32_REG(BPF_LSH, R4, R4), /* R4 = 5 << 5 */
4508 			BPF_JMP_IMM(BPF_JEQ, R4, 160, 1),
4509 			BPF_EXIT_INSN(),
4510 			BPF_MOV64_IMM(R0, -1),
4511 			BPF_EXIT_INSN(),
4512 		},
4513 		INTERNAL,
4514 		{ },
4515 		{ { 0, -1 } }
4516 	},
4517 #ifdef CONFIG_32BIT
4518 	{
4519 		"INT: 32-bit context pointer word order and zero-extension",
4520 		.u.insns_int = {
4521 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
4522 			BPF_JMP32_IMM(BPF_JEQ, R1, 0, 3),
4523 			BPF_ALU64_IMM(BPF_RSH, R1, 32),
4524 			BPF_JMP32_IMM(BPF_JNE, R1, 0, 1),
4525 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
4526 			BPF_EXIT_INSN(),
4527 		},
4528 		INTERNAL,
4529 		{ },
4530 		{ { 0, 1 } }
4531 	},
4532 #endif
4533 	{
4534 		"check: missing ret",
4535 		.u.insns = {
4536 			BPF_STMT(BPF_LD | BPF_IMM, 1),
4537 		},
4538 		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4539 		{ },
4540 		{ },
4541 		.fill_helper = NULL,
4542 		.expected_errcode = -EINVAL,
4543 	},
4544 	{
4545 		"check: div_k_0",
4546 		.u.insns = {
4547 			BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0),
4548 			BPF_STMT(BPF_RET | BPF_K, 0)
4549 		},
4550 		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4551 		{ },
4552 		{ },
4553 		.fill_helper = NULL,
4554 		.expected_errcode = -EINVAL,
4555 	},
4556 	{
4557 		"check: unknown insn",
4558 		.u.insns = {
4559 			/* seccomp insn, rejected in socket filter */
4560 			BPF_STMT(BPF_LDX | BPF_W | BPF_ABS, 0),
4561 			BPF_STMT(BPF_RET | BPF_K, 0)
4562 		},
4563 		CLASSIC | FLAG_EXPECTED_FAIL,
4564 		{ },
4565 		{ },
4566 		.fill_helper = NULL,
4567 		.expected_errcode = -EINVAL,
4568 	},
4569 	{
4570 		"check: out of range spill/fill",
4571 		.u.insns = {
4572 			BPF_STMT(BPF_STX, 16),
4573 			BPF_STMT(BPF_RET | BPF_K, 0)
4574 		},
4575 		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4576 		{ },
4577 		{ },
4578 		.fill_helper = NULL,
4579 		.expected_errcode = -EINVAL,
4580 	},
4581 	{
4582 		"JUMPS + HOLES",
4583 		.u.insns = {
4584 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4585 			BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 15),
4586 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
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_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 3, 4),
4600 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4601 			BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 1, 2),
4602 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4603 			BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
4604 			BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
4605 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
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_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 2, 3),
4619 			BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 1, 2),
4620 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4621 			BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
4622 			BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
4623 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
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_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 2, 3),
4637 			BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 1, 2),
4638 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4639 			BPF_STMT(BPF_RET | BPF_A, 0),
4640 			BPF_STMT(BPF_RET | BPF_A, 0),
4641 		},
4642 		CLASSIC,
4643 		{ 0x00, 0x1b, 0x21, 0x3c, 0x9d, 0xf8,
4644 		  0x90, 0xe2, 0xba, 0x0a, 0x56, 0xb4,
4645 		  0x08, 0x00,
4646 		  0x45, 0x00, 0x00, 0x28, 0x00, 0x00,
4647 		  0x20, 0x00, 0x40, 0x11, 0x00, 0x00, /* IP header */
4648 		  0xc0, 0xa8, 0x33, 0x01,
4649 		  0xc0, 0xa8, 0x33, 0x02,
4650 		  0xbb, 0xb6,
4651 		  0xa9, 0xfa,
4652 		  0x00, 0x14, 0x00, 0x00,
4653 		  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
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 },
4661 		{ { 88, 0x001b } }
4662 	},
4663 	{
4664 		"check: RET X",
4665 		.u.insns = {
4666 			BPF_STMT(BPF_RET | BPF_X, 0),
4667 		},
4668 		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4669 		{ },
4670 		{ },
4671 		.fill_helper = NULL,
4672 		.expected_errcode = -EINVAL,
4673 	},
4674 	{
4675 		"check: LDX + RET X",
4676 		.u.insns = {
4677 			BPF_STMT(BPF_LDX | BPF_IMM, 42),
4678 			BPF_STMT(BPF_RET | BPF_X, 0),
4679 		},
4680 		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4681 		{ },
4682 		{ },
4683 		.fill_helper = NULL,
4684 		.expected_errcode = -EINVAL,
4685 	},
4686 	{	/* Mainly checking JIT here. */
4687 		"M[]: alt STX + LDX",
4688 		.u.insns = {
4689 			BPF_STMT(BPF_LDX | BPF_IMM, 100),
4690 			BPF_STMT(BPF_STX, 0),
4691 			BPF_STMT(BPF_LDX | BPF_MEM, 0),
4692 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4693 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4694 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4695 			BPF_STMT(BPF_STX, 1),
4696 			BPF_STMT(BPF_LDX | BPF_MEM, 1),
4697 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4698 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4699 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4700 			BPF_STMT(BPF_STX, 2),
4701 			BPF_STMT(BPF_LDX | BPF_MEM, 2),
4702 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4703 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4704 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4705 			BPF_STMT(BPF_STX, 3),
4706 			BPF_STMT(BPF_LDX | BPF_MEM, 3),
4707 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4708 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4709 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4710 			BPF_STMT(BPF_STX, 4),
4711 			BPF_STMT(BPF_LDX | BPF_MEM, 4),
4712 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4713 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4714 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4715 			BPF_STMT(BPF_STX, 5),
4716 			BPF_STMT(BPF_LDX | BPF_MEM, 5),
4717 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4718 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4719 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4720 			BPF_STMT(BPF_STX, 6),
4721 			BPF_STMT(BPF_LDX | BPF_MEM, 6),
4722 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4723 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4724 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4725 			BPF_STMT(BPF_STX, 7),
4726 			BPF_STMT(BPF_LDX | BPF_MEM, 7),
4727 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4728 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4729 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4730 			BPF_STMT(BPF_STX, 8),
4731 			BPF_STMT(BPF_LDX | BPF_MEM, 8),
4732 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4733 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4734 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4735 			BPF_STMT(BPF_STX, 9),
4736 			BPF_STMT(BPF_LDX | BPF_MEM, 9),
4737 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4738 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4739 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4740 			BPF_STMT(BPF_STX, 10),
4741 			BPF_STMT(BPF_LDX | BPF_MEM, 10),
4742 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4743 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4744 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4745 			BPF_STMT(BPF_STX, 11),
4746 			BPF_STMT(BPF_LDX | BPF_MEM, 11),
4747 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4748 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4749 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4750 			BPF_STMT(BPF_STX, 12),
4751 			BPF_STMT(BPF_LDX | BPF_MEM, 12),
4752 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4753 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4754 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4755 			BPF_STMT(BPF_STX, 13),
4756 			BPF_STMT(BPF_LDX | BPF_MEM, 13),
4757 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4758 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4759 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4760 			BPF_STMT(BPF_STX, 14),
4761 			BPF_STMT(BPF_LDX | BPF_MEM, 14),
4762 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4763 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4764 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4765 			BPF_STMT(BPF_STX, 15),
4766 			BPF_STMT(BPF_LDX | BPF_MEM, 15),
4767 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4768 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4769 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4770 			BPF_STMT(BPF_RET | BPF_A, 0),
4771 		},
4772 		CLASSIC | FLAG_NO_DATA,
4773 		{ },
4774 		{ { 0, 116 } },
4775 	},
4776 	{	/* Mainly checking JIT here. */
4777 		"M[]: full STX + full LDX",
4778 		.u.insns = {
4779 			BPF_STMT(BPF_LDX | BPF_IMM, 0xbadfeedb),
4780 			BPF_STMT(BPF_STX, 0),
4781 			BPF_STMT(BPF_LDX | BPF_IMM, 0xecabedae),
4782 			BPF_STMT(BPF_STX, 1),
4783 			BPF_STMT(BPF_LDX | BPF_IMM, 0xafccfeaf),
4784 			BPF_STMT(BPF_STX, 2),
4785 			BPF_STMT(BPF_LDX | BPF_IMM, 0xbffdcedc),
4786 			BPF_STMT(BPF_STX, 3),
4787 			BPF_STMT(BPF_LDX | BPF_IMM, 0xfbbbdccb),
4788 			BPF_STMT(BPF_STX, 4),
4789 			BPF_STMT(BPF_LDX | BPF_IMM, 0xfbabcbda),
4790 			BPF_STMT(BPF_STX, 5),
4791 			BPF_STMT(BPF_LDX | BPF_IMM, 0xaedecbdb),
4792 			BPF_STMT(BPF_STX, 6),
4793 			BPF_STMT(BPF_LDX | BPF_IMM, 0xadebbade),
4794 			BPF_STMT(BPF_STX, 7),
4795 			BPF_STMT(BPF_LDX | BPF_IMM, 0xfcfcfaec),
4796 			BPF_STMT(BPF_STX, 8),
4797 			BPF_STMT(BPF_LDX | BPF_IMM, 0xbcdddbdc),
4798 			BPF_STMT(BPF_STX, 9),
4799 			BPF_STMT(BPF_LDX | BPF_IMM, 0xfeefdfac),
4800 			BPF_STMT(BPF_STX, 10),
4801 			BPF_STMT(BPF_LDX | BPF_IMM, 0xcddcdeea),
4802 			BPF_STMT(BPF_STX, 11),
4803 			BPF_STMT(BPF_LDX | BPF_IMM, 0xaccfaebb),
4804 			BPF_STMT(BPF_STX, 12),
4805 			BPF_STMT(BPF_LDX | BPF_IMM, 0xbdcccdcf),
4806 			BPF_STMT(BPF_STX, 13),
4807 			BPF_STMT(BPF_LDX | BPF_IMM, 0xaaedecde),
4808 			BPF_STMT(BPF_STX, 14),
4809 			BPF_STMT(BPF_LDX | BPF_IMM, 0xfaeacdad),
4810 			BPF_STMT(BPF_STX, 15),
4811 			BPF_STMT(BPF_LDX | BPF_MEM, 0),
4812 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4813 			BPF_STMT(BPF_LDX | BPF_MEM, 1),
4814 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4815 			BPF_STMT(BPF_LDX | BPF_MEM, 2),
4816 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4817 			BPF_STMT(BPF_LDX | BPF_MEM, 3),
4818 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4819 			BPF_STMT(BPF_LDX | BPF_MEM, 4),
4820 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4821 			BPF_STMT(BPF_LDX | BPF_MEM, 5),
4822 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4823 			BPF_STMT(BPF_LDX | BPF_MEM, 6),
4824 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4825 			BPF_STMT(BPF_LDX | BPF_MEM, 7),
4826 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4827 			BPF_STMT(BPF_LDX | BPF_MEM, 8),
4828 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4829 			BPF_STMT(BPF_LDX | BPF_MEM, 9),
4830 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4831 			BPF_STMT(BPF_LDX | BPF_MEM, 10),
4832 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4833 			BPF_STMT(BPF_LDX | BPF_MEM, 11),
4834 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4835 			BPF_STMT(BPF_LDX | BPF_MEM, 12),
4836 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4837 			BPF_STMT(BPF_LDX | BPF_MEM, 13),
4838 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4839 			BPF_STMT(BPF_LDX | BPF_MEM, 14),
4840 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4841 			BPF_STMT(BPF_LDX | BPF_MEM, 15),
4842 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4843 			BPF_STMT(BPF_RET | BPF_A, 0),
4844 		},
4845 		CLASSIC | FLAG_NO_DATA,
4846 		{ },
4847 		{ { 0, 0x2a5a5e5 } },
4848 	},
4849 	{
4850 		"check: SKF_AD_MAX",
4851 		.u.insns = {
4852 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
4853 				 SKF_AD_OFF + SKF_AD_MAX),
4854 			BPF_STMT(BPF_RET | BPF_A, 0),
4855 		},
4856 		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4857 		{ },
4858 		{ },
4859 		.fill_helper = NULL,
4860 		.expected_errcode = -EINVAL,
4861 	},
4862 	{	/* Passes checker but fails during runtime. */
4863 		"LD [SKF_AD_OFF-1]",
4864 		.u.insns = {
4865 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
4866 				 SKF_AD_OFF - 1),
4867 			BPF_STMT(BPF_RET | BPF_K, 1),
4868 		},
4869 		CLASSIC,
4870 		{ },
4871 		{ { 1, 0 } },
4872 	},
4873 	{
4874 		"load 64-bit immediate",
4875 		.u.insns_int = {
4876 			BPF_LD_IMM64(R1, 0x567800001234LL),
4877 			BPF_MOV64_REG(R2, R1),
4878 			BPF_MOV64_REG(R3, R2),
4879 			BPF_ALU64_IMM(BPF_RSH, R2, 32),
4880 			BPF_ALU64_IMM(BPF_LSH, R3, 32),
4881 			BPF_ALU64_IMM(BPF_RSH, R3, 32),
4882 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
4883 			BPF_JMP_IMM(BPF_JEQ, R2, 0x5678, 1),
4884 			BPF_EXIT_INSN(),
4885 			BPF_JMP_IMM(BPF_JEQ, R3, 0x1234, 1),
4886 			BPF_EXIT_INSN(),
4887 			BPF_LD_IMM64(R0, 0x1ffffffffLL),
4888 			BPF_ALU64_IMM(BPF_RSH, R0, 32), /* R0 = 1 */
4889 			BPF_EXIT_INSN(),
4890 		},
4891 		INTERNAL,
4892 		{ },
4893 		{ { 0, 1 } }
4894 	},
4895 	/* BPF_ALU | BPF_MOV | BPF_X */
4896 	{
4897 		"ALU_MOV_X: dst = 2",
4898 		.u.insns_int = {
4899 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
4900 			BPF_ALU32_REG(BPF_MOV, R0, R1),
4901 			BPF_EXIT_INSN(),
4902 		},
4903 		INTERNAL,
4904 		{ },
4905 		{ { 0, 2 } },
4906 	},
4907 	{
4908 		"ALU_MOV_X: dst = 4294967295",
4909 		.u.insns_int = {
4910 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
4911 			BPF_ALU32_REG(BPF_MOV, R0, R1),
4912 			BPF_EXIT_INSN(),
4913 		},
4914 		INTERNAL,
4915 		{ },
4916 		{ { 0, 4294967295U } },
4917 	},
4918 	{
4919 		"ALU64_MOV_X: dst = 2",
4920 		.u.insns_int = {
4921 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
4922 			BPF_ALU64_REG(BPF_MOV, R0, R1),
4923 			BPF_EXIT_INSN(),
4924 		},
4925 		INTERNAL,
4926 		{ },
4927 		{ { 0, 2 } },
4928 	},
4929 	{
4930 		"ALU64_MOV_X: dst = 4294967295",
4931 		.u.insns_int = {
4932 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
4933 			BPF_ALU64_REG(BPF_MOV, R0, R1),
4934 			BPF_EXIT_INSN(),
4935 		},
4936 		INTERNAL,
4937 		{ },
4938 		{ { 0, 4294967295U } },
4939 	},
4940 	/* BPF_ALU | BPF_MOV | BPF_K */
4941 	{
4942 		"ALU_MOV_K: dst = 2",
4943 		.u.insns_int = {
4944 			BPF_ALU32_IMM(BPF_MOV, R0, 2),
4945 			BPF_EXIT_INSN(),
4946 		},
4947 		INTERNAL,
4948 		{ },
4949 		{ { 0, 2 } },
4950 	},
4951 	{
4952 		"ALU_MOV_K: dst = 4294967295",
4953 		.u.insns_int = {
4954 			BPF_ALU32_IMM(BPF_MOV, R0, 4294967295U),
4955 			BPF_EXIT_INSN(),
4956 		},
4957 		INTERNAL,
4958 		{ },
4959 		{ { 0, 4294967295U } },
4960 	},
4961 	{
4962 		"ALU_MOV_K: 0x0000ffffffff0000 = 0x00000000ffffffff",
4963 		.u.insns_int = {
4964 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
4965 			BPF_LD_IMM64(R3, 0x00000000ffffffffLL),
4966 			BPF_ALU32_IMM(BPF_MOV, R2, 0xffffffff),
4967 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4968 			BPF_MOV32_IMM(R0, 2),
4969 			BPF_EXIT_INSN(),
4970 			BPF_MOV32_IMM(R0, 1),
4971 			BPF_EXIT_INSN(),
4972 		},
4973 		INTERNAL,
4974 		{ },
4975 		{ { 0, 0x1 } },
4976 	},
4977 	{
4978 		"ALU_MOV_K: small negative",
4979 		.u.insns_int = {
4980 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
4981 			BPF_EXIT_INSN(),
4982 		},
4983 		INTERNAL,
4984 		{ },
4985 		{ { 0, -123 } }
4986 	},
4987 	{
4988 		"ALU_MOV_K: small negative zero extension",
4989 		.u.insns_int = {
4990 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
4991 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
4992 			BPF_EXIT_INSN(),
4993 		},
4994 		INTERNAL,
4995 		{ },
4996 		{ { 0, 0 } }
4997 	},
4998 	{
4999 		"ALU_MOV_K: large negative",
5000 		.u.insns_int = {
5001 			BPF_ALU32_IMM(BPF_MOV, R0, -123456789),
5002 			BPF_EXIT_INSN(),
5003 		},
5004 		INTERNAL,
5005 		{ },
5006 		{ { 0, -123456789 } }
5007 	},
5008 	{
5009 		"ALU_MOV_K: large negative zero extension",
5010 		.u.insns_int = {
5011 			BPF_ALU32_IMM(BPF_MOV, R0, -123456789),
5012 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
5013 			BPF_EXIT_INSN(),
5014 		},
5015 		INTERNAL,
5016 		{ },
5017 		{ { 0, 0 } }
5018 	},
5019 	{
5020 		"ALU64_MOV_K: dst = 2",
5021 		.u.insns_int = {
5022 			BPF_ALU64_IMM(BPF_MOV, R0, 2),
5023 			BPF_EXIT_INSN(),
5024 		},
5025 		INTERNAL,
5026 		{ },
5027 		{ { 0, 2 } },
5028 	},
5029 	{
5030 		"ALU64_MOV_K: dst = 2147483647",
5031 		.u.insns_int = {
5032 			BPF_ALU64_IMM(BPF_MOV, R0, 2147483647),
5033 			BPF_EXIT_INSN(),
5034 		},
5035 		INTERNAL,
5036 		{ },
5037 		{ { 0, 2147483647 } },
5038 	},
5039 	{
5040 		"ALU64_OR_K: dst = 0x0",
5041 		.u.insns_int = {
5042 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
5043 			BPF_LD_IMM64(R3, 0x0),
5044 			BPF_ALU64_IMM(BPF_MOV, R2, 0x0),
5045 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5046 			BPF_MOV32_IMM(R0, 2),
5047 			BPF_EXIT_INSN(),
5048 			BPF_MOV32_IMM(R0, 1),
5049 			BPF_EXIT_INSN(),
5050 		},
5051 		INTERNAL,
5052 		{ },
5053 		{ { 0, 0x1 } },
5054 	},
5055 	{
5056 		"ALU64_MOV_K: dst = -1",
5057 		.u.insns_int = {
5058 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
5059 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
5060 			BPF_ALU64_IMM(BPF_MOV, R2, 0xffffffff),
5061 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5062 			BPF_MOV32_IMM(R0, 2),
5063 			BPF_EXIT_INSN(),
5064 			BPF_MOV32_IMM(R0, 1),
5065 			BPF_EXIT_INSN(),
5066 		},
5067 		INTERNAL,
5068 		{ },
5069 		{ { 0, 0x1 } },
5070 	},
5071 	{
5072 		"ALU64_MOV_K: small negative",
5073 		.u.insns_int = {
5074 			BPF_ALU64_IMM(BPF_MOV, R0, -123),
5075 			BPF_EXIT_INSN(),
5076 		},
5077 		INTERNAL,
5078 		{ },
5079 		{ { 0, -123 } }
5080 	},
5081 	{
5082 		"ALU64_MOV_K: small negative sign extension",
5083 		.u.insns_int = {
5084 			BPF_ALU64_IMM(BPF_MOV, R0, -123),
5085 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
5086 			BPF_EXIT_INSN(),
5087 		},
5088 		INTERNAL,
5089 		{ },
5090 		{ { 0, 0xffffffff } }
5091 	},
5092 	{
5093 		"ALU64_MOV_K: large negative",
5094 		.u.insns_int = {
5095 			BPF_ALU64_IMM(BPF_MOV, R0, -123456789),
5096 			BPF_EXIT_INSN(),
5097 		},
5098 		INTERNAL,
5099 		{ },
5100 		{ { 0, -123456789 } }
5101 	},
5102 	{
5103 		"ALU64_MOV_K: large negative sign extension",
5104 		.u.insns_int = {
5105 			BPF_ALU64_IMM(BPF_MOV, R0, -123456789),
5106 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
5107 			BPF_EXIT_INSN(),
5108 		},
5109 		INTERNAL,
5110 		{ },
5111 		{ { 0, 0xffffffff } }
5112 	},
5113 	/* BPF_ALU | BPF_ADD | BPF_X */
5114 	{
5115 		"ALU_ADD_X: 1 + 2 = 3",
5116 		.u.insns_int = {
5117 			BPF_LD_IMM64(R0, 1),
5118 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
5119 			BPF_ALU32_REG(BPF_ADD, R0, R1),
5120 			BPF_EXIT_INSN(),
5121 		},
5122 		INTERNAL,
5123 		{ },
5124 		{ { 0, 3 } },
5125 	},
5126 	{
5127 		"ALU_ADD_X: 1 + 4294967294 = 4294967295",
5128 		.u.insns_int = {
5129 			BPF_LD_IMM64(R0, 1),
5130 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
5131 			BPF_ALU32_REG(BPF_ADD, R0, R1),
5132 			BPF_EXIT_INSN(),
5133 		},
5134 		INTERNAL,
5135 		{ },
5136 		{ { 0, 4294967295U } },
5137 	},
5138 	{
5139 		"ALU_ADD_X: 2 + 4294967294 = 0",
5140 		.u.insns_int = {
5141 			BPF_LD_IMM64(R0, 2),
5142 			BPF_LD_IMM64(R1, 4294967294U),
5143 			BPF_ALU32_REG(BPF_ADD, R0, R1),
5144 			BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
5145 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
5146 			BPF_EXIT_INSN(),
5147 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
5148 			BPF_EXIT_INSN(),
5149 		},
5150 		INTERNAL,
5151 		{ },
5152 		{ { 0, 1 } },
5153 	},
5154 	{
5155 		"ALU64_ADD_X: 1 + 2 = 3",
5156 		.u.insns_int = {
5157 			BPF_LD_IMM64(R0, 1),
5158 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
5159 			BPF_ALU64_REG(BPF_ADD, R0, R1),
5160 			BPF_EXIT_INSN(),
5161 		},
5162 		INTERNAL,
5163 		{ },
5164 		{ { 0, 3 } },
5165 	},
5166 	{
5167 		"ALU64_ADD_X: 1 + 4294967294 = 4294967295",
5168 		.u.insns_int = {
5169 			BPF_LD_IMM64(R0, 1),
5170 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
5171 			BPF_ALU64_REG(BPF_ADD, R0, R1),
5172 			BPF_EXIT_INSN(),
5173 		},
5174 		INTERNAL,
5175 		{ },
5176 		{ { 0, 4294967295U } },
5177 	},
5178 	{
5179 		"ALU64_ADD_X: 2 + 4294967294 = 4294967296",
5180 		.u.insns_int = {
5181 			BPF_LD_IMM64(R0, 2),
5182 			BPF_LD_IMM64(R1, 4294967294U),
5183 			BPF_LD_IMM64(R2, 4294967296ULL),
5184 			BPF_ALU64_REG(BPF_ADD, R0, R1),
5185 			BPF_JMP_REG(BPF_JEQ, R0, R2, 2),
5186 			BPF_MOV32_IMM(R0, 0),
5187 			BPF_EXIT_INSN(),
5188 			BPF_MOV32_IMM(R0, 1),
5189 			BPF_EXIT_INSN(),
5190 		},
5191 		INTERNAL,
5192 		{ },
5193 		{ { 0, 1 } },
5194 	},
5195 	/* BPF_ALU | BPF_ADD | BPF_K */
5196 	{
5197 		"ALU_ADD_K: 1 + 2 = 3",
5198 		.u.insns_int = {
5199 			BPF_LD_IMM64(R0, 1),
5200 			BPF_ALU32_IMM(BPF_ADD, R0, 2),
5201 			BPF_EXIT_INSN(),
5202 		},
5203 		INTERNAL,
5204 		{ },
5205 		{ { 0, 3 } },
5206 	},
5207 	{
5208 		"ALU_ADD_K: 3 + 0 = 3",
5209 		.u.insns_int = {
5210 			BPF_LD_IMM64(R0, 3),
5211 			BPF_ALU32_IMM(BPF_ADD, R0, 0),
5212 			BPF_EXIT_INSN(),
5213 		},
5214 		INTERNAL,
5215 		{ },
5216 		{ { 0, 3 } },
5217 	},
5218 	{
5219 		"ALU_ADD_K: 1 + 4294967294 = 4294967295",
5220 		.u.insns_int = {
5221 			BPF_LD_IMM64(R0, 1),
5222 			BPF_ALU32_IMM(BPF_ADD, R0, 4294967294U),
5223 			BPF_EXIT_INSN(),
5224 		},
5225 		INTERNAL,
5226 		{ },
5227 		{ { 0, 4294967295U } },
5228 	},
5229 	{
5230 		"ALU_ADD_K: 4294967294 + 2 = 0",
5231 		.u.insns_int = {
5232 			BPF_LD_IMM64(R0, 4294967294U),
5233 			BPF_ALU32_IMM(BPF_ADD, R0, 2),
5234 			BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
5235 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
5236 			BPF_EXIT_INSN(),
5237 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
5238 			BPF_EXIT_INSN(),
5239 		},
5240 		INTERNAL,
5241 		{ },
5242 		{ { 0, 1 } },
5243 	},
5244 	{
5245 		"ALU_ADD_K: 0 + (-1) = 0x00000000ffffffff",
5246 		.u.insns_int = {
5247 			BPF_LD_IMM64(R2, 0x0),
5248 			BPF_LD_IMM64(R3, 0x00000000ffffffff),
5249 			BPF_ALU32_IMM(BPF_ADD, R2, 0xffffffff),
5250 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5251 			BPF_MOV32_IMM(R0, 2),
5252 			BPF_EXIT_INSN(),
5253 			BPF_MOV32_IMM(R0, 1),
5254 			BPF_EXIT_INSN(),
5255 		},
5256 		INTERNAL,
5257 		{ },
5258 		{ { 0, 0x1 } },
5259 	},
5260 	{
5261 		"ALU_ADD_K: 0 + 0xffff = 0xffff",
5262 		.u.insns_int = {
5263 			BPF_LD_IMM64(R2, 0x0),
5264 			BPF_LD_IMM64(R3, 0xffff),
5265 			BPF_ALU32_IMM(BPF_ADD, R2, 0xffff),
5266 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5267 			BPF_MOV32_IMM(R0, 2),
5268 			BPF_EXIT_INSN(),
5269 			BPF_MOV32_IMM(R0, 1),
5270 			BPF_EXIT_INSN(),
5271 		},
5272 		INTERNAL,
5273 		{ },
5274 		{ { 0, 0x1 } },
5275 	},
5276 	{
5277 		"ALU_ADD_K: 0 + 0x7fffffff = 0x7fffffff",
5278 		.u.insns_int = {
5279 			BPF_LD_IMM64(R2, 0x0),
5280 			BPF_LD_IMM64(R3, 0x7fffffff),
5281 			BPF_ALU32_IMM(BPF_ADD, R2, 0x7fffffff),
5282 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5283 			BPF_MOV32_IMM(R0, 2),
5284 			BPF_EXIT_INSN(),
5285 			BPF_MOV32_IMM(R0, 1),
5286 			BPF_EXIT_INSN(),
5287 		},
5288 		INTERNAL,
5289 		{ },
5290 		{ { 0, 0x1 } },
5291 	},
5292 	{
5293 		"ALU_ADD_K: 0 + 0x80000000 = 0x80000000",
5294 		.u.insns_int = {
5295 			BPF_LD_IMM64(R2, 0x0),
5296 			BPF_LD_IMM64(R3, 0x80000000),
5297 			BPF_ALU32_IMM(BPF_ADD, R2, 0x80000000),
5298 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5299 			BPF_MOV32_IMM(R0, 2),
5300 			BPF_EXIT_INSN(),
5301 			BPF_MOV32_IMM(R0, 1),
5302 			BPF_EXIT_INSN(),
5303 		},
5304 		INTERNAL,
5305 		{ },
5306 		{ { 0, 0x1 } },
5307 	},
5308 	{
5309 		"ALU_ADD_K: 0 + 0x80008000 = 0x80008000",
5310 		.u.insns_int = {
5311 			BPF_LD_IMM64(R2, 0x0),
5312 			BPF_LD_IMM64(R3, 0x80008000),
5313 			BPF_ALU32_IMM(BPF_ADD, R2, 0x80008000),
5314 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5315 			BPF_MOV32_IMM(R0, 2),
5316 			BPF_EXIT_INSN(),
5317 			BPF_MOV32_IMM(R0, 1),
5318 			BPF_EXIT_INSN(),
5319 		},
5320 		INTERNAL,
5321 		{ },
5322 		{ { 0, 0x1 } },
5323 	},
5324 	{
5325 		"ALU64_ADD_K: 1 + 2 = 3",
5326 		.u.insns_int = {
5327 			BPF_LD_IMM64(R0, 1),
5328 			BPF_ALU64_IMM(BPF_ADD, R0, 2),
5329 			BPF_EXIT_INSN(),
5330 		},
5331 		INTERNAL,
5332 		{ },
5333 		{ { 0, 3 } },
5334 	},
5335 	{
5336 		"ALU64_ADD_K: 3 + 0 = 3",
5337 		.u.insns_int = {
5338 			BPF_LD_IMM64(R0, 3),
5339 			BPF_ALU64_IMM(BPF_ADD, R0, 0),
5340 			BPF_EXIT_INSN(),
5341 		},
5342 		INTERNAL,
5343 		{ },
5344 		{ { 0, 3 } },
5345 	},
5346 	{
5347 		"ALU64_ADD_K: 1 + 2147483646 = 2147483647",
5348 		.u.insns_int = {
5349 			BPF_LD_IMM64(R0, 1),
5350 			BPF_ALU64_IMM(BPF_ADD, R0, 2147483646),
5351 			BPF_EXIT_INSN(),
5352 		},
5353 		INTERNAL,
5354 		{ },
5355 		{ { 0, 2147483647 } },
5356 	},
5357 	{
5358 		"ALU64_ADD_K: 4294967294 + 2 = 4294967296",
5359 		.u.insns_int = {
5360 			BPF_LD_IMM64(R0, 4294967294U),
5361 			BPF_LD_IMM64(R1, 4294967296ULL),
5362 			BPF_ALU64_IMM(BPF_ADD, R0, 2),
5363 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
5364 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
5365 			BPF_EXIT_INSN(),
5366 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
5367 			BPF_EXIT_INSN(),
5368 		},
5369 		INTERNAL,
5370 		{ },
5371 		{ { 0, 1 } },
5372 	},
5373 	{
5374 		"ALU64_ADD_K: 2147483646 + -2147483647 = -1",
5375 		.u.insns_int = {
5376 			BPF_LD_IMM64(R0, 2147483646),
5377 			BPF_ALU64_IMM(BPF_ADD, R0, -2147483647),
5378 			BPF_EXIT_INSN(),
5379 		},
5380 		INTERNAL,
5381 		{ },
5382 		{ { 0, -1 } },
5383 	},
5384 	{
5385 		"ALU64_ADD_K: 1 + 0 = 1",
5386 		.u.insns_int = {
5387 			BPF_LD_IMM64(R2, 0x1),
5388 			BPF_LD_IMM64(R3, 0x1),
5389 			BPF_ALU64_IMM(BPF_ADD, R2, 0x0),
5390 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5391 			BPF_MOV32_IMM(R0, 2),
5392 			BPF_EXIT_INSN(),
5393 			BPF_MOV32_IMM(R0, 1),
5394 			BPF_EXIT_INSN(),
5395 		},
5396 		INTERNAL,
5397 		{ },
5398 		{ { 0, 0x1 } },
5399 	},
5400 	{
5401 		"ALU64_ADD_K: 0 + (-1) = 0xffffffffffffffff",
5402 		.u.insns_int = {
5403 			BPF_LD_IMM64(R2, 0x0),
5404 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
5405 			BPF_ALU64_IMM(BPF_ADD, R2, 0xffffffff),
5406 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5407 			BPF_MOV32_IMM(R0, 2),
5408 			BPF_EXIT_INSN(),
5409 			BPF_MOV32_IMM(R0, 1),
5410 			BPF_EXIT_INSN(),
5411 		},
5412 		INTERNAL,
5413 		{ },
5414 		{ { 0, 0x1 } },
5415 	},
5416 	{
5417 		"ALU64_ADD_K: 0 + 0xffff = 0xffff",
5418 		.u.insns_int = {
5419 			BPF_LD_IMM64(R2, 0x0),
5420 			BPF_LD_IMM64(R3, 0xffff),
5421 			BPF_ALU64_IMM(BPF_ADD, R2, 0xffff),
5422 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5423 			BPF_MOV32_IMM(R0, 2),
5424 			BPF_EXIT_INSN(),
5425 			BPF_MOV32_IMM(R0, 1),
5426 			BPF_EXIT_INSN(),
5427 		},
5428 		INTERNAL,
5429 		{ },
5430 		{ { 0, 0x1 } },
5431 	},
5432 	{
5433 		"ALU64_ADD_K: 0 + 0x7fffffff = 0x7fffffff",
5434 		.u.insns_int = {
5435 			BPF_LD_IMM64(R2, 0x0),
5436 			BPF_LD_IMM64(R3, 0x7fffffff),
5437 			BPF_ALU64_IMM(BPF_ADD, R2, 0x7fffffff),
5438 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5439 			BPF_MOV32_IMM(R0, 2),
5440 			BPF_EXIT_INSN(),
5441 			BPF_MOV32_IMM(R0, 1),
5442 			BPF_EXIT_INSN(),
5443 		},
5444 		INTERNAL,
5445 		{ },
5446 		{ { 0, 0x1 } },
5447 	},
5448 	{
5449 		"ALU64_ADD_K: 0 + 0x80000000 = 0xffffffff80000000",
5450 		.u.insns_int = {
5451 			BPF_LD_IMM64(R2, 0x0),
5452 			BPF_LD_IMM64(R3, 0xffffffff80000000LL),
5453 			BPF_ALU64_IMM(BPF_ADD, R2, 0x80000000),
5454 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5455 			BPF_MOV32_IMM(R0, 2),
5456 			BPF_EXIT_INSN(),
5457 			BPF_MOV32_IMM(R0, 1),
5458 			BPF_EXIT_INSN(),
5459 		},
5460 		INTERNAL,
5461 		{ },
5462 		{ { 0, 0x1 } },
5463 	},
5464 	{
5465 		"ALU_ADD_K: 0 + 0x80008000 = 0xffffffff80008000",
5466 		.u.insns_int = {
5467 			BPF_LD_IMM64(R2, 0x0),
5468 			BPF_LD_IMM64(R3, 0xffffffff80008000LL),
5469 			BPF_ALU64_IMM(BPF_ADD, R2, 0x80008000),
5470 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5471 			BPF_MOV32_IMM(R0, 2),
5472 			BPF_EXIT_INSN(),
5473 			BPF_MOV32_IMM(R0, 1),
5474 			BPF_EXIT_INSN(),
5475 		},
5476 		INTERNAL,
5477 		{ },
5478 		{ { 0, 0x1 } },
5479 	},
5480 	/* BPF_ALU | BPF_SUB | BPF_X */
5481 	{
5482 		"ALU_SUB_X: 3 - 1 = 2",
5483 		.u.insns_int = {
5484 			BPF_LD_IMM64(R0, 3),
5485 			BPF_ALU32_IMM(BPF_MOV, R1, 1),
5486 			BPF_ALU32_REG(BPF_SUB, R0, R1),
5487 			BPF_EXIT_INSN(),
5488 		},
5489 		INTERNAL,
5490 		{ },
5491 		{ { 0, 2 } },
5492 	},
5493 	{
5494 		"ALU_SUB_X: 4294967295 - 4294967294 = 1",
5495 		.u.insns_int = {
5496 			BPF_LD_IMM64(R0, 4294967295U),
5497 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
5498 			BPF_ALU32_REG(BPF_SUB, R0, R1),
5499 			BPF_EXIT_INSN(),
5500 		},
5501 		INTERNAL,
5502 		{ },
5503 		{ { 0, 1 } },
5504 	},
5505 	{
5506 		"ALU64_SUB_X: 3 - 1 = 2",
5507 		.u.insns_int = {
5508 			BPF_LD_IMM64(R0, 3),
5509 			BPF_ALU32_IMM(BPF_MOV, R1, 1),
5510 			BPF_ALU64_REG(BPF_SUB, R0, R1),
5511 			BPF_EXIT_INSN(),
5512 		},
5513 		INTERNAL,
5514 		{ },
5515 		{ { 0, 2 } },
5516 	},
5517 	{
5518 		"ALU64_SUB_X: 4294967295 - 4294967294 = 1",
5519 		.u.insns_int = {
5520 			BPF_LD_IMM64(R0, 4294967295U),
5521 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
5522 			BPF_ALU64_REG(BPF_SUB, R0, R1),
5523 			BPF_EXIT_INSN(),
5524 		},
5525 		INTERNAL,
5526 		{ },
5527 		{ { 0, 1 } },
5528 	},
5529 	/* BPF_ALU | BPF_SUB | BPF_K */
5530 	{
5531 		"ALU_SUB_K: 3 - 1 = 2",
5532 		.u.insns_int = {
5533 			BPF_LD_IMM64(R0, 3),
5534 			BPF_ALU32_IMM(BPF_SUB, R0, 1),
5535 			BPF_EXIT_INSN(),
5536 		},
5537 		INTERNAL,
5538 		{ },
5539 		{ { 0, 2 } },
5540 	},
5541 	{
5542 		"ALU_SUB_K: 3 - 0 = 3",
5543 		.u.insns_int = {
5544 			BPF_LD_IMM64(R0, 3),
5545 			BPF_ALU32_IMM(BPF_SUB, R0, 0),
5546 			BPF_EXIT_INSN(),
5547 		},
5548 		INTERNAL,
5549 		{ },
5550 		{ { 0, 3 } },
5551 	},
5552 	{
5553 		"ALU_SUB_K: 4294967295 - 4294967294 = 1",
5554 		.u.insns_int = {
5555 			BPF_LD_IMM64(R0, 4294967295U),
5556 			BPF_ALU32_IMM(BPF_SUB, R0, 4294967294U),
5557 			BPF_EXIT_INSN(),
5558 		},
5559 		INTERNAL,
5560 		{ },
5561 		{ { 0, 1 } },
5562 	},
5563 	{
5564 		"ALU64_SUB_K: 3 - 1 = 2",
5565 		.u.insns_int = {
5566 			BPF_LD_IMM64(R0, 3),
5567 			BPF_ALU64_IMM(BPF_SUB, R0, 1),
5568 			BPF_EXIT_INSN(),
5569 		},
5570 		INTERNAL,
5571 		{ },
5572 		{ { 0, 2 } },
5573 	},
5574 	{
5575 		"ALU64_SUB_K: 3 - 0 = 3",
5576 		.u.insns_int = {
5577 			BPF_LD_IMM64(R0, 3),
5578 			BPF_ALU64_IMM(BPF_SUB, R0, 0),
5579 			BPF_EXIT_INSN(),
5580 		},
5581 		INTERNAL,
5582 		{ },
5583 		{ { 0, 3 } },
5584 	},
5585 	{
5586 		"ALU64_SUB_K: 4294967294 - 4294967295 = -1",
5587 		.u.insns_int = {
5588 			BPF_LD_IMM64(R0, 4294967294U),
5589 			BPF_ALU64_IMM(BPF_SUB, R0, 4294967295U),
5590 			BPF_EXIT_INSN(),
5591 		},
5592 		INTERNAL,
5593 		{ },
5594 		{ { 0, -1 } },
5595 	},
5596 	{
5597 		"ALU64_ADD_K: 2147483646 - 2147483647 = -1",
5598 		.u.insns_int = {
5599 			BPF_LD_IMM64(R0, 2147483646),
5600 			BPF_ALU64_IMM(BPF_SUB, R0, 2147483647),
5601 			BPF_EXIT_INSN(),
5602 		},
5603 		INTERNAL,
5604 		{ },
5605 		{ { 0, -1 } },
5606 	},
5607 	/* BPF_ALU | BPF_MUL | BPF_X */
5608 	{
5609 		"ALU_MUL_X: 2 * 3 = 6",
5610 		.u.insns_int = {
5611 			BPF_LD_IMM64(R0, 2),
5612 			BPF_ALU32_IMM(BPF_MOV, R1, 3),
5613 			BPF_ALU32_REG(BPF_MUL, R0, R1),
5614 			BPF_EXIT_INSN(),
5615 		},
5616 		INTERNAL,
5617 		{ },
5618 		{ { 0, 6 } },
5619 	},
5620 	{
5621 		"ALU_MUL_X: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
5622 		.u.insns_int = {
5623 			BPF_LD_IMM64(R0, 2),
5624 			BPF_ALU32_IMM(BPF_MOV, R1, 0x7FFFFFF8),
5625 			BPF_ALU32_REG(BPF_MUL, R0, R1),
5626 			BPF_EXIT_INSN(),
5627 		},
5628 		INTERNAL,
5629 		{ },
5630 		{ { 0, 0xFFFFFFF0 } },
5631 	},
5632 	{
5633 		"ALU_MUL_X: -1 * -1 = 1",
5634 		.u.insns_int = {
5635 			BPF_LD_IMM64(R0, -1),
5636 			BPF_ALU32_IMM(BPF_MOV, R1, -1),
5637 			BPF_ALU32_REG(BPF_MUL, R0, R1),
5638 			BPF_EXIT_INSN(),
5639 		},
5640 		INTERNAL,
5641 		{ },
5642 		{ { 0, 1 } },
5643 	},
5644 	{
5645 		"ALU64_MUL_X: 2 * 3 = 6",
5646 		.u.insns_int = {
5647 			BPF_LD_IMM64(R0, 2),
5648 			BPF_ALU32_IMM(BPF_MOV, R1, 3),
5649 			BPF_ALU64_REG(BPF_MUL, R0, R1),
5650 			BPF_EXIT_INSN(),
5651 		},
5652 		INTERNAL,
5653 		{ },
5654 		{ { 0, 6 } },
5655 	},
5656 	{
5657 		"ALU64_MUL_X: 1 * 2147483647 = 2147483647",
5658 		.u.insns_int = {
5659 			BPF_LD_IMM64(R0, 1),
5660 			BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
5661 			BPF_ALU64_REG(BPF_MUL, R0, R1),
5662 			BPF_EXIT_INSN(),
5663 		},
5664 		INTERNAL,
5665 		{ },
5666 		{ { 0, 2147483647 } },
5667 	},
5668 	{
5669 		"ALU64_MUL_X: 64x64 multiply, low word",
5670 		.u.insns_int = {
5671 			BPF_LD_IMM64(R0, 0x0fedcba987654321LL),
5672 			BPF_LD_IMM64(R1, 0x123456789abcdef0LL),
5673 			BPF_ALU64_REG(BPF_MUL, R0, R1),
5674 			BPF_EXIT_INSN(),
5675 		},
5676 		INTERNAL,
5677 		{ },
5678 		{ { 0, 0xe5618cf0 } }
5679 	},
5680 	{
5681 		"ALU64_MUL_X: 64x64 multiply, high word",
5682 		.u.insns_int = {
5683 			BPF_LD_IMM64(R0, 0x0fedcba987654321LL),
5684 			BPF_LD_IMM64(R1, 0x123456789abcdef0LL),
5685 			BPF_ALU64_REG(BPF_MUL, R0, R1),
5686 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
5687 			BPF_EXIT_INSN(),
5688 		},
5689 		INTERNAL,
5690 		{ },
5691 		{ { 0, 0x2236d88f } }
5692 	},
5693 	/* BPF_ALU | BPF_MUL | BPF_K */
5694 	{
5695 		"ALU_MUL_K: 2 * 3 = 6",
5696 		.u.insns_int = {
5697 			BPF_LD_IMM64(R0, 2),
5698 			BPF_ALU32_IMM(BPF_MUL, R0, 3),
5699 			BPF_EXIT_INSN(),
5700 		},
5701 		INTERNAL,
5702 		{ },
5703 		{ { 0, 6 } },
5704 	},
5705 	{
5706 		"ALU_MUL_K: 3 * 1 = 3",
5707 		.u.insns_int = {
5708 			BPF_LD_IMM64(R0, 3),
5709 			BPF_ALU32_IMM(BPF_MUL, R0, 1),
5710 			BPF_EXIT_INSN(),
5711 		},
5712 		INTERNAL,
5713 		{ },
5714 		{ { 0, 3 } },
5715 	},
5716 	{
5717 		"ALU_MUL_K: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
5718 		.u.insns_int = {
5719 			BPF_LD_IMM64(R0, 2),
5720 			BPF_ALU32_IMM(BPF_MUL, R0, 0x7FFFFFF8),
5721 			BPF_EXIT_INSN(),
5722 		},
5723 		INTERNAL,
5724 		{ },
5725 		{ { 0, 0xFFFFFFF0 } },
5726 	},
5727 	{
5728 		"ALU_MUL_K: 1 * (-1) = 0x00000000ffffffff",
5729 		.u.insns_int = {
5730 			BPF_LD_IMM64(R2, 0x1),
5731 			BPF_LD_IMM64(R3, 0x00000000ffffffff),
5732 			BPF_ALU32_IMM(BPF_MUL, R2, 0xffffffff),
5733 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5734 			BPF_MOV32_IMM(R0, 2),
5735 			BPF_EXIT_INSN(),
5736 			BPF_MOV32_IMM(R0, 1),
5737 			BPF_EXIT_INSN(),
5738 		},
5739 		INTERNAL,
5740 		{ },
5741 		{ { 0, 0x1 } },
5742 	},
5743 	{
5744 		"ALU64_MUL_K: 2 * 3 = 6",
5745 		.u.insns_int = {
5746 			BPF_LD_IMM64(R0, 2),
5747 			BPF_ALU64_IMM(BPF_MUL, R0, 3),
5748 			BPF_EXIT_INSN(),
5749 		},
5750 		INTERNAL,
5751 		{ },
5752 		{ { 0, 6 } },
5753 	},
5754 	{
5755 		"ALU64_MUL_K: 3 * 1 = 3",
5756 		.u.insns_int = {
5757 			BPF_LD_IMM64(R0, 3),
5758 			BPF_ALU64_IMM(BPF_MUL, R0, 1),
5759 			BPF_EXIT_INSN(),
5760 		},
5761 		INTERNAL,
5762 		{ },
5763 		{ { 0, 3 } },
5764 	},
5765 	{
5766 		"ALU64_MUL_K: 1 * 2147483647 = 2147483647",
5767 		.u.insns_int = {
5768 			BPF_LD_IMM64(R0, 1),
5769 			BPF_ALU64_IMM(BPF_MUL, R0, 2147483647),
5770 			BPF_EXIT_INSN(),
5771 		},
5772 		INTERNAL,
5773 		{ },
5774 		{ { 0, 2147483647 } },
5775 	},
5776 	{
5777 		"ALU64_MUL_K: 1 * -2147483647 = -2147483647",
5778 		.u.insns_int = {
5779 			BPF_LD_IMM64(R0, 1),
5780 			BPF_ALU64_IMM(BPF_MUL, R0, -2147483647),
5781 			BPF_EXIT_INSN(),
5782 		},
5783 		INTERNAL,
5784 		{ },
5785 		{ { 0, -2147483647 } },
5786 	},
5787 	{
5788 		"ALU64_MUL_K: 1 * (-1) = 0xffffffffffffffff",
5789 		.u.insns_int = {
5790 			BPF_LD_IMM64(R2, 0x1),
5791 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
5792 			BPF_ALU64_IMM(BPF_MUL, R2, 0xffffffff),
5793 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5794 			BPF_MOV32_IMM(R0, 2),
5795 			BPF_EXIT_INSN(),
5796 			BPF_MOV32_IMM(R0, 1),
5797 			BPF_EXIT_INSN(),
5798 		},
5799 		INTERNAL,
5800 		{ },
5801 		{ { 0, 0x1 } },
5802 	},
5803 	{
5804 		"ALU64_MUL_K: 64x32 multiply, low word",
5805 		.u.insns_int = {
5806 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5807 			BPF_ALU64_IMM(BPF_MUL, R0, 0x12345678),
5808 			BPF_EXIT_INSN(),
5809 		},
5810 		INTERNAL,
5811 		{ },
5812 		{ { 0, 0xe242d208 } }
5813 	},
5814 	{
5815 		"ALU64_MUL_K: 64x32 multiply, high word",
5816 		.u.insns_int = {
5817 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5818 			BPF_ALU64_IMM(BPF_MUL, R0, 0x12345678),
5819 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
5820 			BPF_EXIT_INSN(),
5821 		},
5822 		INTERNAL,
5823 		{ },
5824 		{ { 0, 0xc28f5c28 } }
5825 	},
5826 	/* BPF_ALU | BPF_DIV | BPF_X */
5827 	{
5828 		"ALU_DIV_X: 6 / 2 = 3",
5829 		.u.insns_int = {
5830 			BPF_LD_IMM64(R0, 6),
5831 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
5832 			BPF_ALU32_REG(BPF_DIV, R0, R1),
5833 			BPF_EXIT_INSN(),
5834 		},
5835 		INTERNAL,
5836 		{ },
5837 		{ { 0, 3 } },
5838 	},
5839 	{
5840 		"ALU_DIV_X: 4294967295 / 4294967295 = 1",
5841 		.u.insns_int = {
5842 			BPF_LD_IMM64(R0, 4294967295U),
5843 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
5844 			BPF_ALU32_REG(BPF_DIV, R0, R1),
5845 			BPF_EXIT_INSN(),
5846 		},
5847 		INTERNAL,
5848 		{ },
5849 		{ { 0, 1 } },
5850 	},
5851 	{
5852 		"ALU64_DIV_X: 6 / 2 = 3",
5853 		.u.insns_int = {
5854 			BPF_LD_IMM64(R0, 6),
5855 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
5856 			BPF_ALU64_REG(BPF_DIV, R0, R1),
5857 			BPF_EXIT_INSN(),
5858 		},
5859 		INTERNAL,
5860 		{ },
5861 		{ { 0, 3 } },
5862 	},
5863 	{
5864 		"ALU64_DIV_X: 2147483647 / 2147483647 = 1",
5865 		.u.insns_int = {
5866 			BPF_LD_IMM64(R0, 2147483647),
5867 			BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
5868 			BPF_ALU64_REG(BPF_DIV, R0, R1),
5869 			BPF_EXIT_INSN(),
5870 		},
5871 		INTERNAL,
5872 		{ },
5873 		{ { 0, 1 } },
5874 	},
5875 	{
5876 		"ALU64_DIV_X: 0xffffffffffffffff / (-1) = 0x0000000000000001",
5877 		.u.insns_int = {
5878 			BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
5879 			BPF_LD_IMM64(R4, 0xffffffffffffffffLL),
5880 			BPF_LD_IMM64(R3, 0x0000000000000001LL),
5881 			BPF_ALU64_REG(BPF_DIV, R2, R4),
5882 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5883 			BPF_MOV32_IMM(R0, 2),
5884 			BPF_EXIT_INSN(),
5885 			BPF_MOV32_IMM(R0, 1),
5886 			BPF_EXIT_INSN(),
5887 		},
5888 		INTERNAL,
5889 		{ },
5890 		{ { 0, 0x1 } },
5891 	},
5892 	/* BPF_ALU | BPF_DIV | BPF_K */
5893 	{
5894 		"ALU_DIV_K: 6 / 2 = 3",
5895 		.u.insns_int = {
5896 			BPF_LD_IMM64(R0, 6),
5897 			BPF_ALU32_IMM(BPF_DIV, R0, 2),
5898 			BPF_EXIT_INSN(),
5899 		},
5900 		INTERNAL,
5901 		{ },
5902 		{ { 0, 3 } },
5903 	},
5904 	{
5905 		"ALU_DIV_K: 3 / 1 = 3",
5906 		.u.insns_int = {
5907 			BPF_LD_IMM64(R0, 3),
5908 			BPF_ALU32_IMM(BPF_DIV, R0, 1),
5909 			BPF_EXIT_INSN(),
5910 		},
5911 		INTERNAL,
5912 		{ },
5913 		{ { 0, 3 } },
5914 	},
5915 	{
5916 		"ALU_DIV_K: 4294967295 / 4294967295 = 1",
5917 		.u.insns_int = {
5918 			BPF_LD_IMM64(R0, 4294967295U),
5919 			BPF_ALU32_IMM(BPF_DIV, R0, 4294967295U),
5920 			BPF_EXIT_INSN(),
5921 		},
5922 		INTERNAL,
5923 		{ },
5924 		{ { 0, 1 } },
5925 	},
5926 	{
5927 		"ALU_DIV_K: 0xffffffffffffffff / (-1) = 0x1",
5928 		.u.insns_int = {
5929 			BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
5930 			BPF_LD_IMM64(R3, 0x1UL),
5931 			BPF_ALU32_IMM(BPF_DIV, R2, 0xffffffff),
5932 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5933 			BPF_MOV32_IMM(R0, 2),
5934 			BPF_EXIT_INSN(),
5935 			BPF_MOV32_IMM(R0, 1),
5936 			BPF_EXIT_INSN(),
5937 		},
5938 		INTERNAL,
5939 		{ },
5940 		{ { 0, 0x1 } },
5941 	},
5942 	{
5943 		"ALU64_DIV_K: 6 / 2 = 3",
5944 		.u.insns_int = {
5945 			BPF_LD_IMM64(R0, 6),
5946 			BPF_ALU64_IMM(BPF_DIV, R0, 2),
5947 			BPF_EXIT_INSN(),
5948 		},
5949 		INTERNAL,
5950 		{ },
5951 		{ { 0, 3 } },
5952 	},
5953 	{
5954 		"ALU64_DIV_K: 3 / 1 = 3",
5955 		.u.insns_int = {
5956 			BPF_LD_IMM64(R0, 3),
5957 			BPF_ALU64_IMM(BPF_DIV, R0, 1),
5958 			BPF_EXIT_INSN(),
5959 		},
5960 		INTERNAL,
5961 		{ },
5962 		{ { 0, 3 } },
5963 	},
5964 	{
5965 		"ALU64_DIV_K: 2147483647 / 2147483647 = 1",
5966 		.u.insns_int = {
5967 			BPF_LD_IMM64(R0, 2147483647),
5968 			BPF_ALU64_IMM(BPF_DIV, R0, 2147483647),
5969 			BPF_EXIT_INSN(),
5970 		},
5971 		INTERNAL,
5972 		{ },
5973 		{ { 0, 1 } },
5974 	},
5975 	{
5976 		"ALU64_DIV_K: 0xffffffffffffffff / (-1) = 0x0000000000000001",
5977 		.u.insns_int = {
5978 			BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
5979 			BPF_LD_IMM64(R3, 0x0000000000000001LL),
5980 			BPF_ALU64_IMM(BPF_DIV, R2, 0xffffffff),
5981 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5982 			BPF_MOV32_IMM(R0, 2),
5983 			BPF_EXIT_INSN(),
5984 			BPF_MOV32_IMM(R0, 1),
5985 			BPF_EXIT_INSN(),
5986 		},
5987 		INTERNAL,
5988 		{ },
5989 		{ { 0, 0x1 } },
5990 	},
5991 	/* BPF_ALU | BPF_MOD | BPF_X */
5992 	{
5993 		"ALU_MOD_X: 3 % 2 = 1",
5994 		.u.insns_int = {
5995 			BPF_LD_IMM64(R0, 3),
5996 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
5997 			BPF_ALU32_REG(BPF_MOD, R0, R1),
5998 			BPF_EXIT_INSN(),
5999 		},
6000 		INTERNAL,
6001 		{ },
6002 		{ { 0, 1 } },
6003 	},
6004 	{
6005 		"ALU_MOD_X: 4294967295 % 4294967293 = 2",
6006 		.u.insns_int = {
6007 			BPF_LD_IMM64(R0, 4294967295U),
6008 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967293U),
6009 			BPF_ALU32_REG(BPF_MOD, R0, R1),
6010 			BPF_EXIT_INSN(),
6011 		},
6012 		INTERNAL,
6013 		{ },
6014 		{ { 0, 2 } },
6015 	},
6016 	{
6017 		"ALU64_MOD_X: 3 % 2 = 1",
6018 		.u.insns_int = {
6019 			BPF_LD_IMM64(R0, 3),
6020 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
6021 			BPF_ALU64_REG(BPF_MOD, R0, R1),
6022 			BPF_EXIT_INSN(),
6023 		},
6024 		INTERNAL,
6025 		{ },
6026 		{ { 0, 1 } },
6027 	},
6028 	{
6029 		"ALU64_MOD_X: 2147483647 % 2147483645 = 2",
6030 		.u.insns_int = {
6031 			BPF_LD_IMM64(R0, 2147483647),
6032 			BPF_ALU32_IMM(BPF_MOV, R1, 2147483645),
6033 			BPF_ALU64_REG(BPF_MOD, R0, R1),
6034 			BPF_EXIT_INSN(),
6035 		},
6036 		INTERNAL,
6037 		{ },
6038 		{ { 0, 2 } },
6039 	},
6040 	/* BPF_ALU | BPF_MOD | BPF_K */
6041 	{
6042 		"ALU_MOD_K: 3 % 2 = 1",
6043 		.u.insns_int = {
6044 			BPF_LD_IMM64(R0, 3),
6045 			BPF_ALU32_IMM(BPF_MOD, R0, 2),
6046 			BPF_EXIT_INSN(),
6047 		},
6048 		INTERNAL,
6049 		{ },
6050 		{ { 0, 1 } },
6051 	},
6052 	{
6053 		"ALU_MOD_K: 3 % 1 = 0",
6054 		.u.insns_int = {
6055 			BPF_LD_IMM64(R0, 3),
6056 			BPF_ALU32_IMM(BPF_MOD, R0, 1),
6057 			BPF_EXIT_INSN(),
6058 		},
6059 		INTERNAL,
6060 		{ },
6061 		{ { 0, 0 } },
6062 	},
6063 	{
6064 		"ALU_MOD_K: 4294967295 % 4294967293 = 2",
6065 		.u.insns_int = {
6066 			BPF_LD_IMM64(R0, 4294967295U),
6067 			BPF_ALU32_IMM(BPF_MOD, R0, 4294967293U),
6068 			BPF_EXIT_INSN(),
6069 		},
6070 		INTERNAL,
6071 		{ },
6072 		{ { 0, 2 } },
6073 	},
6074 	{
6075 		"ALU64_MOD_K: 3 % 2 = 1",
6076 		.u.insns_int = {
6077 			BPF_LD_IMM64(R0, 3),
6078 			BPF_ALU64_IMM(BPF_MOD, R0, 2),
6079 			BPF_EXIT_INSN(),
6080 		},
6081 		INTERNAL,
6082 		{ },
6083 		{ { 0, 1 } },
6084 	},
6085 	{
6086 		"ALU64_MOD_K: 3 % 1 = 0",
6087 		.u.insns_int = {
6088 			BPF_LD_IMM64(R0, 3),
6089 			BPF_ALU64_IMM(BPF_MOD, R0, 1),
6090 			BPF_EXIT_INSN(),
6091 		},
6092 		INTERNAL,
6093 		{ },
6094 		{ { 0, 0 } },
6095 	},
6096 	{
6097 		"ALU64_MOD_K: 2147483647 % 2147483645 = 2",
6098 		.u.insns_int = {
6099 			BPF_LD_IMM64(R0, 2147483647),
6100 			BPF_ALU64_IMM(BPF_MOD, R0, 2147483645),
6101 			BPF_EXIT_INSN(),
6102 		},
6103 		INTERNAL,
6104 		{ },
6105 		{ { 0, 2 } },
6106 	},
6107 	/* BPF_ALU | BPF_AND | BPF_X */
6108 	{
6109 		"ALU_AND_X: 3 & 2 = 2",
6110 		.u.insns_int = {
6111 			BPF_LD_IMM64(R0, 3),
6112 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
6113 			BPF_ALU32_REG(BPF_AND, R0, R1),
6114 			BPF_EXIT_INSN(),
6115 		},
6116 		INTERNAL,
6117 		{ },
6118 		{ { 0, 2 } },
6119 	},
6120 	{
6121 		"ALU_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
6122 		.u.insns_int = {
6123 			BPF_LD_IMM64(R0, 0xffffffff),
6124 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6125 			BPF_ALU32_REG(BPF_AND, R0, R1),
6126 			BPF_EXIT_INSN(),
6127 		},
6128 		INTERNAL,
6129 		{ },
6130 		{ { 0, 0xffffffff } },
6131 	},
6132 	{
6133 		"ALU64_AND_X: 3 & 2 = 2",
6134 		.u.insns_int = {
6135 			BPF_LD_IMM64(R0, 3),
6136 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
6137 			BPF_ALU64_REG(BPF_AND, R0, R1),
6138 			BPF_EXIT_INSN(),
6139 		},
6140 		INTERNAL,
6141 		{ },
6142 		{ { 0, 2 } },
6143 	},
6144 	{
6145 		"ALU64_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
6146 		.u.insns_int = {
6147 			BPF_LD_IMM64(R0, 0xffffffff),
6148 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6149 			BPF_ALU64_REG(BPF_AND, R0, R1),
6150 			BPF_EXIT_INSN(),
6151 		},
6152 		INTERNAL,
6153 		{ },
6154 		{ { 0, 0xffffffff } },
6155 	},
6156 	/* BPF_ALU | BPF_AND | BPF_K */
6157 	{
6158 		"ALU_AND_K: 3 & 2 = 2",
6159 		.u.insns_int = {
6160 			BPF_LD_IMM64(R0, 3),
6161 			BPF_ALU32_IMM(BPF_AND, R0, 2),
6162 			BPF_EXIT_INSN(),
6163 		},
6164 		INTERNAL,
6165 		{ },
6166 		{ { 0, 2 } },
6167 	},
6168 	{
6169 		"ALU_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
6170 		.u.insns_int = {
6171 			BPF_LD_IMM64(R0, 0xffffffff),
6172 			BPF_ALU32_IMM(BPF_AND, R0, 0xffffffff),
6173 			BPF_EXIT_INSN(),
6174 		},
6175 		INTERNAL,
6176 		{ },
6177 		{ { 0, 0xffffffff } },
6178 	},
6179 	{
6180 		"ALU_AND_K: Small immediate",
6181 		.u.insns_int = {
6182 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
6183 			BPF_ALU32_IMM(BPF_AND, R0, 15),
6184 			BPF_EXIT_INSN(),
6185 		},
6186 		INTERNAL,
6187 		{ },
6188 		{ { 0, 4 } }
6189 	},
6190 	{
6191 		"ALU_AND_K: Large immediate",
6192 		.u.insns_int = {
6193 			BPF_ALU32_IMM(BPF_MOV, R0, 0xf1f2f3f4),
6194 			BPF_ALU32_IMM(BPF_AND, R0, 0xafbfcfdf),
6195 			BPF_EXIT_INSN(),
6196 		},
6197 		INTERNAL,
6198 		{ },
6199 		{ { 0, 0xa1b2c3d4 } }
6200 	},
6201 	{
6202 		"ALU_AND_K: Zero extension",
6203 		.u.insns_int = {
6204 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6205 			BPF_LD_IMM64(R1, 0x0000000080a0c0e0LL),
6206 			BPF_ALU32_IMM(BPF_AND, R0, 0xf0f0f0f0),
6207 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6208 			BPF_MOV32_IMM(R0, 2),
6209 			BPF_EXIT_INSN(),
6210 			BPF_MOV32_IMM(R0, 1),
6211 			BPF_EXIT_INSN(),
6212 		},
6213 		INTERNAL,
6214 		{ },
6215 		{ { 0, 1 } }
6216 	},
6217 	{
6218 		"ALU64_AND_K: 3 & 2 = 2",
6219 		.u.insns_int = {
6220 			BPF_LD_IMM64(R0, 3),
6221 			BPF_ALU64_IMM(BPF_AND, R0, 2),
6222 			BPF_EXIT_INSN(),
6223 		},
6224 		INTERNAL,
6225 		{ },
6226 		{ { 0, 2 } },
6227 	},
6228 	{
6229 		"ALU64_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
6230 		.u.insns_int = {
6231 			BPF_LD_IMM64(R0, 0xffffffff),
6232 			BPF_ALU64_IMM(BPF_AND, R0, 0xffffffff),
6233 			BPF_EXIT_INSN(),
6234 		},
6235 		INTERNAL,
6236 		{ },
6237 		{ { 0, 0xffffffff } },
6238 	},
6239 	{
6240 		"ALU64_AND_K: 0x0000ffffffff0000 & 0x0 = 0x0000000000000000",
6241 		.u.insns_int = {
6242 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6243 			BPF_LD_IMM64(R3, 0x0000000000000000LL),
6244 			BPF_ALU64_IMM(BPF_AND, R2, 0x0),
6245 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6246 			BPF_MOV32_IMM(R0, 2),
6247 			BPF_EXIT_INSN(),
6248 			BPF_MOV32_IMM(R0, 1),
6249 			BPF_EXIT_INSN(),
6250 		},
6251 		INTERNAL,
6252 		{ },
6253 		{ { 0, 0x1 } },
6254 	},
6255 	{
6256 		"ALU64_AND_K: 0x0000ffffffff0000 & -1 = 0x0000ffffffff0000",
6257 		.u.insns_int = {
6258 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6259 			BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
6260 			BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
6261 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6262 			BPF_MOV32_IMM(R0, 2),
6263 			BPF_EXIT_INSN(),
6264 			BPF_MOV32_IMM(R0, 1),
6265 			BPF_EXIT_INSN(),
6266 		},
6267 		INTERNAL,
6268 		{ },
6269 		{ { 0, 0x1 } },
6270 	},
6271 	{
6272 		"ALU64_AND_K: 0xffffffffffffffff & -1 = 0xffffffffffffffff",
6273 		.u.insns_int = {
6274 			BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
6275 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
6276 			BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
6277 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6278 			BPF_MOV32_IMM(R0, 2),
6279 			BPF_EXIT_INSN(),
6280 			BPF_MOV32_IMM(R0, 1),
6281 			BPF_EXIT_INSN(),
6282 		},
6283 		INTERNAL,
6284 		{ },
6285 		{ { 0, 0x1 } },
6286 	},
6287 	{
6288 		"ALU64_AND_K: Sign extension 1",
6289 		.u.insns_int = {
6290 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6291 			BPF_LD_IMM64(R1, 0x00000000090b0d0fLL),
6292 			BPF_ALU64_IMM(BPF_AND, R0, 0x0f0f0f0f),
6293 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6294 			BPF_MOV32_IMM(R0, 2),
6295 			BPF_EXIT_INSN(),
6296 			BPF_MOV32_IMM(R0, 1),
6297 			BPF_EXIT_INSN(),
6298 		},
6299 		INTERNAL,
6300 		{ },
6301 		{ { 0, 1 } }
6302 	},
6303 	{
6304 		"ALU64_AND_K: Sign extension 2",
6305 		.u.insns_int = {
6306 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6307 			BPF_LD_IMM64(R1, 0x0123456780a0c0e0LL),
6308 			BPF_ALU64_IMM(BPF_AND, R0, 0xf0f0f0f0),
6309 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6310 			BPF_MOV32_IMM(R0, 2),
6311 			BPF_EXIT_INSN(),
6312 			BPF_MOV32_IMM(R0, 1),
6313 			BPF_EXIT_INSN(),
6314 		},
6315 		INTERNAL,
6316 		{ },
6317 		{ { 0, 1 } }
6318 	},
6319 	/* BPF_ALU | BPF_OR | BPF_X */
6320 	{
6321 		"ALU_OR_X: 1 | 2 = 3",
6322 		.u.insns_int = {
6323 			BPF_LD_IMM64(R0, 1),
6324 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
6325 			BPF_ALU32_REG(BPF_OR, R0, R1),
6326 			BPF_EXIT_INSN(),
6327 		},
6328 		INTERNAL,
6329 		{ },
6330 		{ { 0, 3 } },
6331 	},
6332 	{
6333 		"ALU_OR_X: 0x0 | 0xffffffff = 0xffffffff",
6334 		.u.insns_int = {
6335 			BPF_LD_IMM64(R0, 0),
6336 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6337 			BPF_ALU32_REG(BPF_OR, R0, R1),
6338 			BPF_EXIT_INSN(),
6339 		},
6340 		INTERNAL,
6341 		{ },
6342 		{ { 0, 0xffffffff } },
6343 	},
6344 	{
6345 		"ALU64_OR_X: 1 | 2 = 3",
6346 		.u.insns_int = {
6347 			BPF_LD_IMM64(R0, 1),
6348 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
6349 			BPF_ALU64_REG(BPF_OR, R0, R1),
6350 			BPF_EXIT_INSN(),
6351 		},
6352 		INTERNAL,
6353 		{ },
6354 		{ { 0, 3 } },
6355 	},
6356 	{
6357 		"ALU64_OR_X: 0 | 0xffffffff = 0xffffffff",
6358 		.u.insns_int = {
6359 			BPF_LD_IMM64(R0, 0),
6360 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6361 			BPF_ALU64_REG(BPF_OR, R0, R1),
6362 			BPF_EXIT_INSN(),
6363 		},
6364 		INTERNAL,
6365 		{ },
6366 		{ { 0, 0xffffffff } },
6367 	},
6368 	/* BPF_ALU | BPF_OR | BPF_K */
6369 	{
6370 		"ALU_OR_K: 1 | 2 = 3",
6371 		.u.insns_int = {
6372 			BPF_LD_IMM64(R0, 1),
6373 			BPF_ALU32_IMM(BPF_OR, R0, 2),
6374 			BPF_EXIT_INSN(),
6375 		},
6376 		INTERNAL,
6377 		{ },
6378 		{ { 0, 3 } },
6379 	},
6380 	{
6381 		"ALU_OR_K: 0 & 0xffffffff = 0xffffffff",
6382 		.u.insns_int = {
6383 			BPF_LD_IMM64(R0, 0),
6384 			BPF_ALU32_IMM(BPF_OR, R0, 0xffffffff),
6385 			BPF_EXIT_INSN(),
6386 		},
6387 		INTERNAL,
6388 		{ },
6389 		{ { 0, 0xffffffff } },
6390 	},
6391 	{
6392 		"ALU_OR_K: Small immediate",
6393 		.u.insns_int = {
6394 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
6395 			BPF_ALU32_IMM(BPF_OR, R0, 1),
6396 			BPF_EXIT_INSN(),
6397 		},
6398 		INTERNAL,
6399 		{ },
6400 		{ { 0, 0x01020305 } }
6401 	},
6402 	{
6403 		"ALU_OR_K: Large immediate",
6404 		.u.insns_int = {
6405 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
6406 			BPF_ALU32_IMM(BPF_OR, R0, 0xa0b0c0d0),
6407 			BPF_EXIT_INSN(),
6408 		},
6409 		INTERNAL,
6410 		{ },
6411 		{ { 0, 0xa1b2c3d4 } }
6412 	},
6413 	{
6414 		"ALU_OR_K: Zero extension",
6415 		.u.insns_int = {
6416 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6417 			BPF_LD_IMM64(R1, 0x00000000f9fbfdffLL),
6418 			BPF_ALU32_IMM(BPF_OR, R0, 0xf0f0f0f0),
6419 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6420 			BPF_MOV32_IMM(R0, 2),
6421 			BPF_EXIT_INSN(),
6422 			BPF_MOV32_IMM(R0, 1),
6423 			BPF_EXIT_INSN(),
6424 		},
6425 		INTERNAL,
6426 		{ },
6427 		{ { 0, 1 } }
6428 	},
6429 	{
6430 		"ALU64_OR_K: 1 | 2 = 3",
6431 		.u.insns_int = {
6432 			BPF_LD_IMM64(R0, 1),
6433 			BPF_ALU64_IMM(BPF_OR, R0, 2),
6434 			BPF_EXIT_INSN(),
6435 		},
6436 		INTERNAL,
6437 		{ },
6438 		{ { 0, 3 } },
6439 	},
6440 	{
6441 		"ALU64_OR_K: 0 & 0xffffffff = 0xffffffff",
6442 		.u.insns_int = {
6443 			BPF_LD_IMM64(R0, 0),
6444 			BPF_ALU64_IMM(BPF_OR, R0, 0xffffffff),
6445 			BPF_EXIT_INSN(),
6446 		},
6447 		INTERNAL,
6448 		{ },
6449 		{ { 0, 0xffffffff } },
6450 	},
6451 	{
6452 		"ALU64_OR_K: 0x0000ffffffff0000 | 0x0 = 0x0000ffffffff0000",
6453 		.u.insns_int = {
6454 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6455 			BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
6456 			BPF_ALU64_IMM(BPF_OR, R2, 0x0),
6457 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6458 			BPF_MOV32_IMM(R0, 2),
6459 			BPF_EXIT_INSN(),
6460 			BPF_MOV32_IMM(R0, 1),
6461 			BPF_EXIT_INSN(),
6462 		},
6463 		INTERNAL,
6464 		{ },
6465 		{ { 0, 0x1 } },
6466 	},
6467 	{
6468 		"ALU64_OR_K: 0x0000ffffffff0000 | -1 = 0xffffffffffffffff",
6469 		.u.insns_int = {
6470 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6471 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
6472 			BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
6473 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6474 			BPF_MOV32_IMM(R0, 2),
6475 			BPF_EXIT_INSN(),
6476 			BPF_MOV32_IMM(R0, 1),
6477 			BPF_EXIT_INSN(),
6478 		},
6479 		INTERNAL,
6480 		{ },
6481 		{ { 0, 0x1 } },
6482 	},
6483 	{
6484 		"ALU64_OR_K: 0x000000000000000 | -1 = 0xffffffffffffffff",
6485 		.u.insns_int = {
6486 			BPF_LD_IMM64(R2, 0x0000000000000000LL),
6487 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
6488 			BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
6489 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6490 			BPF_MOV32_IMM(R0, 2),
6491 			BPF_EXIT_INSN(),
6492 			BPF_MOV32_IMM(R0, 1),
6493 			BPF_EXIT_INSN(),
6494 		},
6495 		INTERNAL,
6496 		{ },
6497 		{ { 0, 0x1 } },
6498 	},
6499 	{
6500 		"ALU64_OR_K: Sign extension 1",
6501 		.u.insns_int = {
6502 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6503 			BPF_LD_IMM64(R1, 0x012345678fafcfefLL),
6504 			BPF_ALU64_IMM(BPF_OR, R0, 0x0f0f0f0f),
6505 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6506 			BPF_MOV32_IMM(R0, 2),
6507 			BPF_EXIT_INSN(),
6508 			BPF_MOV32_IMM(R0, 1),
6509 			BPF_EXIT_INSN(),
6510 		},
6511 		INTERNAL,
6512 		{ },
6513 		{ { 0, 1 } }
6514 	},
6515 	{
6516 		"ALU64_OR_K: Sign extension 2",
6517 		.u.insns_int = {
6518 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6519 			BPF_LD_IMM64(R1, 0xfffffffff9fbfdffLL),
6520 			BPF_ALU64_IMM(BPF_OR, R0, 0xf0f0f0f0),
6521 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6522 			BPF_MOV32_IMM(R0, 2),
6523 			BPF_EXIT_INSN(),
6524 			BPF_MOV32_IMM(R0, 1),
6525 			BPF_EXIT_INSN(),
6526 		},
6527 		INTERNAL,
6528 		{ },
6529 		{ { 0, 1 } }
6530 	},
6531 	/* BPF_ALU | BPF_XOR | BPF_X */
6532 	{
6533 		"ALU_XOR_X: 5 ^ 6 = 3",
6534 		.u.insns_int = {
6535 			BPF_LD_IMM64(R0, 5),
6536 			BPF_ALU32_IMM(BPF_MOV, R1, 6),
6537 			BPF_ALU32_REG(BPF_XOR, R0, R1),
6538 			BPF_EXIT_INSN(),
6539 		},
6540 		INTERNAL,
6541 		{ },
6542 		{ { 0, 3 } },
6543 	},
6544 	{
6545 		"ALU_XOR_X: 0x1 ^ 0xffffffff = 0xfffffffe",
6546 		.u.insns_int = {
6547 			BPF_LD_IMM64(R0, 1),
6548 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6549 			BPF_ALU32_REG(BPF_XOR, R0, R1),
6550 			BPF_EXIT_INSN(),
6551 		},
6552 		INTERNAL,
6553 		{ },
6554 		{ { 0, 0xfffffffe } },
6555 	},
6556 	{
6557 		"ALU64_XOR_X: 5 ^ 6 = 3",
6558 		.u.insns_int = {
6559 			BPF_LD_IMM64(R0, 5),
6560 			BPF_ALU32_IMM(BPF_MOV, R1, 6),
6561 			BPF_ALU64_REG(BPF_XOR, R0, R1),
6562 			BPF_EXIT_INSN(),
6563 		},
6564 		INTERNAL,
6565 		{ },
6566 		{ { 0, 3 } },
6567 	},
6568 	{
6569 		"ALU64_XOR_X: 1 ^ 0xffffffff = 0xfffffffe",
6570 		.u.insns_int = {
6571 			BPF_LD_IMM64(R0, 1),
6572 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6573 			BPF_ALU64_REG(BPF_XOR, R0, R1),
6574 			BPF_EXIT_INSN(),
6575 		},
6576 		INTERNAL,
6577 		{ },
6578 		{ { 0, 0xfffffffe } },
6579 	},
6580 	/* BPF_ALU | BPF_XOR | BPF_K */
6581 	{
6582 		"ALU_XOR_K: 5 ^ 6 = 3",
6583 		.u.insns_int = {
6584 			BPF_LD_IMM64(R0, 5),
6585 			BPF_ALU32_IMM(BPF_XOR, R0, 6),
6586 			BPF_EXIT_INSN(),
6587 		},
6588 		INTERNAL,
6589 		{ },
6590 		{ { 0, 3 } },
6591 	},
6592 	{
6593 		"ALU_XOR_K: 1 ^ 0xffffffff = 0xfffffffe",
6594 		.u.insns_int = {
6595 			BPF_LD_IMM64(R0, 1),
6596 			BPF_ALU32_IMM(BPF_XOR, R0, 0xffffffff),
6597 			BPF_EXIT_INSN(),
6598 		},
6599 		INTERNAL,
6600 		{ },
6601 		{ { 0, 0xfffffffe } },
6602 	},
6603 	{
6604 		"ALU_XOR_K: Small immediate",
6605 		.u.insns_int = {
6606 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
6607 			BPF_ALU32_IMM(BPF_XOR, R0, 15),
6608 			BPF_EXIT_INSN(),
6609 		},
6610 		INTERNAL,
6611 		{ },
6612 		{ { 0, 0x0102030b } }
6613 	},
6614 	{
6615 		"ALU_XOR_K: Large immediate",
6616 		.u.insns_int = {
6617 			BPF_ALU32_IMM(BPF_MOV, R0, 0xf1f2f3f4),
6618 			BPF_ALU32_IMM(BPF_XOR, R0, 0xafbfcfdf),
6619 			BPF_EXIT_INSN(),
6620 		},
6621 		INTERNAL,
6622 		{ },
6623 		{ { 0, 0x5e4d3c2b } }
6624 	},
6625 	{
6626 		"ALU_XOR_K: Zero extension",
6627 		.u.insns_int = {
6628 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6629 			BPF_LD_IMM64(R1, 0x00000000795b3d1fLL),
6630 			BPF_ALU32_IMM(BPF_XOR, R0, 0xf0f0f0f0),
6631 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6632 			BPF_MOV32_IMM(R0, 2),
6633 			BPF_EXIT_INSN(),
6634 			BPF_MOV32_IMM(R0, 1),
6635 			BPF_EXIT_INSN(),
6636 		},
6637 		INTERNAL,
6638 		{ },
6639 		{ { 0, 1 } }
6640 	},
6641 	{
6642 		"ALU64_XOR_K: 5 ^ 6 = 3",
6643 		.u.insns_int = {
6644 			BPF_LD_IMM64(R0, 5),
6645 			BPF_ALU64_IMM(BPF_XOR, R0, 6),
6646 			BPF_EXIT_INSN(),
6647 		},
6648 		INTERNAL,
6649 		{ },
6650 		{ { 0, 3 } },
6651 	},
6652 	{
6653 		"ALU64_XOR_K: 1 ^ 0xffffffff = 0xfffffffe",
6654 		.u.insns_int = {
6655 			BPF_LD_IMM64(R0, 1),
6656 			BPF_ALU64_IMM(BPF_XOR, R0, 0xffffffff),
6657 			BPF_EXIT_INSN(),
6658 		},
6659 		INTERNAL,
6660 		{ },
6661 		{ { 0, 0xfffffffe } },
6662 	},
6663 	{
6664 		"ALU64_XOR_K: 0x0000ffffffff0000 ^ 0x0 = 0x0000ffffffff0000",
6665 		.u.insns_int = {
6666 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6667 			BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
6668 			BPF_ALU64_IMM(BPF_XOR, R2, 0x0),
6669 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6670 			BPF_MOV32_IMM(R0, 2),
6671 			BPF_EXIT_INSN(),
6672 			BPF_MOV32_IMM(R0, 1),
6673 			BPF_EXIT_INSN(),
6674 		},
6675 		INTERNAL,
6676 		{ },
6677 		{ { 0, 0x1 } },
6678 	},
6679 	{
6680 		"ALU64_XOR_K: 0x0000ffffffff0000 ^ -1 = 0xffff00000000ffff",
6681 		.u.insns_int = {
6682 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6683 			BPF_LD_IMM64(R3, 0xffff00000000ffffLL),
6684 			BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
6685 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6686 			BPF_MOV32_IMM(R0, 2),
6687 			BPF_EXIT_INSN(),
6688 			BPF_MOV32_IMM(R0, 1),
6689 			BPF_EXIT_INSN(),
6690 		},
6691 		INTERNAL,
6692 		{ },
6693 		{ { 0, 0x1 } },
6694 	},
6695 	{
6696 		"ALU64_XOR_K: 0x000000000000000 ^ -1 = 0xffffffffffffffff",
6697 		.u.insns_int = {
6698 			BPF_LD_IMM64(R2, 0x0000000000000000LL),
6699 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
6700 			BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
6701 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6702 			BPF_MOV32_IMM(R0, 2),
6703 			BPF_EXIT_INSN(),
6704 			BPF_MOV32_IMM(R0, 1),
6705 			BPF_EXIT_INSN(),
6706 		},
6707 		INTERNAL,
6708 		{ },
6709 		{ { 0, 0x1 } },
6710 	},
6711 	{
6712 		"ALU64_XOR_K: Sign extension 1",
6713 		.u.insns_int = {
6714 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6715 			BPF_LD_IMM64(R1, 0x0123456786a4c2e0LL),
6716 			BPF_ALU64_IMM(BPF_XOR, R0, 0x0f0f0f0f),
6717 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6718 			BPF_MOV32_IMM(R0, 2),
6719 			BPF_EXIT_INSN(),
6720 			BPF_MOV32_IMM(R0, 1),
6721 			BPF_EXIT_INSN(),
6722 		},
6723 		INTERNAL,
6724 		{ },
6725 		{ { 0, 1 } }
6726 	},
6727 	{
6728 		"ALU64_XOR_K: Sign extension 2",
6729 		.u.insns_int = {
6730 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6731 			BPF_LD_IMM64(R1, 0xfedcba98795b3d1fLL),
6732 			BPF_ALU64_IMM(BPF_XOR, R0, 0xf0f0f0f0),
6733 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6734 			BPF_MOV32_IMM(R0, 2),
6735 			BPF_EXIT_INSN(),
6736 			BPF_MOV32_IMM(R0, 1),
6737 			BPF_EXIT_INSN(),
6738 		},
6739 		INTERNAL,
6740 		{ },
6741 		{ { 0, 1 } }
6742 	},
6743 	/* BPF_ALU | BPF_LSH | BPF_X */
6744 	{
6745 		"ALU_LSH_X: 1 << 1 = 2",
6746 		.u.insns_int = {
6747 			BPF_LD_IMM64(R0, 1),
6748 			BPF_ALU32_IMM(BPF_MOV, R1, 1),
6749 			BPF_ALU32_REG(BPF_LSH, R0, R1),
6750 			BPF_EXIT_INSN(),
6751 		},
6752 		INTERNAL,
6753 		{ },
6754 		{ { 0, 2 } },
6755 	},
6756 	{
6757 		"ALU_LSH_X: 1 << 31 = 0x80000000",
6758 		.u.insns_int = {
6759 			BPF_LD_IMM64(R0, 1),
6760 			BPF_ALU32_IMM(BPF_MOV, R1, 31),
6761 			BPF_ALU32_REG(BPF_LSH, R0, R1),
6762 			BPF_EXIT_INSN(),
6763 		},
6764 		INTERNAL,
6765 		{ },
6766 		{ { 0, 0x80000000 } },
6767 	},
6768 	{
6769 		"ALU_LSH_X: 0x12345678 << 12 = 0x45678000",
6770 		.u.insns_int = {
6771 			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
6772 			BPF_ALU32_IMM(BPF_MOV, R1, 12),
6773 			BPF_ALU32_REG(BPF_LSH, R0, R1),
6774 			BPF_EXIT_INSN(),
6775 		},
6776 		INTERNAL,
6777 		{ },
6778 		{ { 0, 0x45678000 } }
6779 	},
6780 	{
6781 		"ALU64_LSH_X: 1 << 1 = 2",
6782 		.u.insns_int = {
6783 			BPF_LD_IMM64(R0, 1),
6784 			BPF_ALU32_IMM(BPF_MOV, R1, 1),
6785 			BPF_ALU64_REG(BPF_LSH, R0, R1),
6786 			BPF_EXIT_INSN(),
6787 		},
6788 		INTERNAL,
6789 		{ },
6790 		{ { 0, 2 } },
6791 	},
6792 	{
6793 		"ALU64_LSH_X: 1 << 31 = 0x80000000",
6794 		.u.insns_int = {
6795 			BPF_LD_IMM64(R0, 1),
6796 			BPF_ALU32_IMM(BPF_MOV, R1, 31),
6797 			BPF_ALU64_REG(BPF_LSH, R0, R1),
6798 			BPF_EXIT_INSN(),
6799 		},
6800 		INTERNAL,
6801 		{ },
6802 		{ { 0, 0x80000000 } },
6803 	},
6804 	{
6805 		"ALU64_LSH_X: Shift < 32, low word",
6806 		.u.insns_int = {
6807 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6808 			BPF_ALU32_IMM(BPF_MOV, R1, 12),
6809 			BPF_ALU64_REG(BPF_LSH, R0, R1),
6810 			BPF_EXIT_INSN(),
6811 		},
6812 		INTERNAL,
6813 		{ },
6814 		{ { 0, 0xbcdef000 } }
6815 	},
6816 	{
6817 		"ALU64_LSH_X: Shift < 32, high word",
6818 		.u.insns_int = {
6819 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6820 			BPF_ALU32_IMM(BPF_MOV, R1, 12),
6821 			BPF_ALU64_REG(BPF_LSH, R0, R1),
6822 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6823 			BPF_EXIT_INSN(),
6824 		},
6825 		INTERNAL,
6826 		{ },
6827 		{ { 0, 0x3456789a } }
6828 	},
6829 	{
6830 		"ALU64_LSH_X: Shift > 32, low word",
6831 		.u.insns_int = {
6832 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6833 			BPF_ALU32_IMM(BPF_MOV, R1, 36),
6834 			BPF_ALU64_REG(BPF_LSH, R0, R1),
6835 			BPF_EXIT_INSN(),
6836 		},
6837 		INTERNAL,
6838 		{ },
6839 		{ { 0, 0 } }
6840 	},
6841 	{
6842 		"ALU64_LSH_X: Shift > 32, high word",
6843 		.u.insns_int = {
6844 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6845 			BPF_ALU32_IMM(BPF_MOV, R1, 36),
6846 			BPF_ALU64_REG(BPF_LSH, R0, R1),
6847 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6848 			BPF_EXIT_INSN(),
6849 		},
6850 		INTERNAL,
6851 		{ },
6852 		{ { 0, 0x9abcdef0 } }
6853 	},
6854 	{
6855 		"ALU64_LSH_X: Shift == 32, low word",
6856 		.u.insns_int = {
6857 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6858 			BPF_ALU32_IMM(BPF_MOV, R1, 32),
6859 			BPF_ALU64_REG(BPF_LSH, R0, R1),
6860 			BPF_EXIT_INSN(),
6861 		},
6862 		INTERNAL,
6863 		{ },
6864 		{ { 0, 0 } }
6865 	},
6866 	{
6867 		"ALU64_LSH_X: Shift == 32, high word",
6868 		.u.insns_int = {
6869 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6870 			BPF_ALU32_IMM(BPF_MOV, R1, 32),
6871 			BPF_ALU64_REG(BPF_LSH, R0, R1),
6872 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6873 			BPF_EXIT_INSN(),
6874 		},
6875 		INTERNAL,
6876 		{ },
6877 		{ { 0, 0x89abcdef } }
6878 	},
6879 	{
6880 		"ALU64_LSH_X: Zero shift, low word",
6881 		.u.insns_int = {
6882 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6883 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
6884 			BPF_ALU64_REG(BPF_LSH, R0, R1),
6885 			BPF_EXIT_INSN(),
6886 		},
6887 		INTERNAL,
6888 		{ },
6889 		{ { 0, 0x89abcdef } }
6890 	},
6891 	{
6892 		"ALU64_LSH_X: Zero shift, high word",
6893 		.u.insns_int = {
6894 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6895 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
6896 			BPF_ALU64_REG(BPF_LSH, R0, R1),
6897 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6898 			BPF_EXIT_INSN(),
6899 		},
6900 		INTERNAL,
6901 		{ },
6902 		{ { 0, 0x01234567 } }
6903 	},
6904 	/* BPF_ALU | BPF_LSH | BPF_K */
6905 	{
6906 		"ALU_LSH_K: 1 << 1 = 2",
6907 		.u.insns_int = {
6908 			BPF_LD_IMM64(R0, 1),
6909 			BPF_ALU32_IMM(BPF_LSH, R0, 1),
6910 			BPF_EXIT_INSN(),
6911 		},
6912 		INTERNAL,
6913 		{ },
6914 		{ { 0, 2 } },
6915 	},
6916 	{
6917 		"ALU_LSH_K: 1 << 31 = 0x80000000",
6918 		.u.insns_int = {
6919 			BPF_LD_IMM64(R0, 1),
6920 			BPF_ALU32_IMM(BPF_LSH, R0, 31),
6921 			BPF_EXIT_INSN(),
6922 		},
6923 		INTERNAL,
6924 		{ },
6925 		{ { 0, 0x80000000 } },
6926 	},
6927 	{
6928 		"ALU_LSH_K: 0x12345678 << 12 = 0x45678000",
6929 		.u.insns_int = {
6930 			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
6931 			BPF_ALU32_IMM(BPF_LSH, R0, 12),
6932 			BPF_EXIT_INSN(),
6933 		},
6934 		INTERNAL,
6935 		{ },
6936 		{ { 0, 0x45678000 } }
6937 	},
6938 	{
6939 		"ALU_LSH_K: 0x12345678 << 0 = 0x12345678",
6940 		.u.insns_int = {
6941 			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
6942 			BPF_ALU32_IMM(BPF_LSH, R0, 0),
6943 			BPF_EXIT_INSN(),
6944 		},
6945 		INTERNAL,
6946 		{ },
6947 		{ { 0, 0x12345678 } }
6948 	},
6949 	{
6950 		"ALU64_LSH_K: 1 << 1 = 2",
6951 		.u.insns_int = {
6952 			BPF_LD_IMM64(R0, 1),
6953 			BPF_ALU64_IMM(BPF_LSH, R0, 1),
6954 			BPF_EXIT_INSN(),
6955 		},
6956 		INTERNAL,
6957 		{ },
6958 		{ { 0, 2 } },
6959 	},
6960 	{
6961 		"ALU64_LSH_K: 1 << 31 = 0x80000000",
6962 		.u.insns_int = {
6963 			BPF_LD_IMM64(R0, 1),
6964 			BPF_ALU64_IMM(BPF_LSH, R0, 31),
6965 			BPF_EXIT_INSN(),
6966 		},
6967 		INTERNAL,
6968 		{ },
6969 		{ { 0, 0x80000000 } },
6970 	},
6971 	{
6972 		"ALU64_LSH_K: Shift < 32, low word",
6973 		.u.insns_int = {
6974 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6975 			BPF_ALU64_IMM(BPF_LSH, R0, 12),
6976 			BPF_EXIT_INSN(),
6977 		},
6978 		INTERNAL,
6979 		{ },
6980 		{ { 0, 0xbcdef000 } }
6981 	},
6982 	{
6983 		"ALU64_LSH_K: Shift < 32, high word",
6984 		.u.insns_int = {
6985 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6986 			BPF_ALU64_IMM(BPF_LSH, R0, 12),
6987 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6988 			BPF_EXIT_INSN(),
6989 		},
6990 		INTERNAL,
6991 		{ },
6992 		{ { 0, 0x3456789a } }
6993 	},
6994 	{
6995 		"ALU64_LSH_K: Shift > 32, low word",
6996 		.u.insns_int = {
6997 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6998 			BPF_ALU64_IMM(BPF_LSH, R0, 36),
6999 			BPF_EXIT_INSN(),
7000 		},
7001 		INTERNAL,
7002 		{ },
7003 		{ { 0, 0 } }
7004 	},
7005 	{
7006 		"ALU64_LSH_K: Shift > 32, high word",
7007 		.u.insns_int = {
7008 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7009 			BPF_ALU64_IMM(BPF_LSH, R0, 36),
7010 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7011 			BPF_EXIT_INSN(),
7012 		},
7013 		INTERNAL,
7014 		{ },
7015 		{ { 0, 0x9abcdef0 } }
7016 	},
7017 	{
7018 		"ALU64_LSH_K: Shift == 32, low word",
7019 		.u.insns_int = {
7020 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7021 			BPF_ALU64_IMM(BPF_LSH, R0, 32),
7022 			BPF_EXIT_INSN(),
7023 		},
7024 		INTERNAL,
7025 		{ },
7026 		{ { 0, 0 } }
7027 	},
7028 	{
7029 		"ALU64_LSH_K: Shift == 32, high word",
7030 		.u.insns_int = {
7031 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7032 			BPF_ALU64_IMM(BPF_LSH, R0, 32),
7033 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7034 			BPF_EXIT_INSN(),
7035 		},
7036 		INTERNAL,
7037 		{ },
7038 		{ { 0, 0x89abcdef } }
7039 	},
7040 	{
7041 		"ALU64_LSH_K: Zero shift",
7042 		.u.insns_int = {
7043 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7044 			BPF_ALU64_IMM(BPF_LSH, R0, 0),
7045 			BPF_EXIT_INSN(),
7046 		},
7047 		INTERNAL,
7048 		{ },
7049 		{ { 0, 0x89abcdef } }
7050 	},
7051 	/* BPF_ALU | BPF_RSH | BPF_X */
7052 	{
7053 		"ALU_RSH_X: 2 >> 1 = 1",
7054 		.u.insns_int = {
7055 			BPF_LD_IMM64(R0, 2),
7056 			BPF_ALU32_IMM(BPF_MOV, R1, 1),
7057 			BPF_ALU32_REG(BPF_RSH, R0, R1),
7058 			BPF_EXIT_INSN(),
7059 		},
7060 		INTERNAL,
7061 		{ },
7062 		{ { 0, 1 } },
7063 	},
7064 	{
7065 		"ALU_RSH_X: 0x80000000 >> 31 = 1",
7066 		.u.insns_int = {
7067 			BPF_LD_IMM64(R0, 0x80000000),
7068 			BPF_ALU32_IMM(BPF_MOV, R1, 31),
7069 			BPF_ALU32_REG(BPF_RSH, R0, R1),
7070 			BPF_EXIT_INSN(),
7071 		},
7072 		INTERNAL,
7073 		{ },
7074 		{ { 0, 1 } },
7075 	},
7076 	{
7077 		"ALU_RSH_X: 0x12345678 >> 20 = 0x123",
7078 		.u.insns_int = {
7079 			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
7080 			BPF_ALU32_IMM(BPF_MOV, R1, 20),
7081 			BPF_ALU32_REG(BPF_RSH, R0, R1),
7082 			BPF_EXIT_INSN(),
7083 		},
7084 		INTERNAL,
7085 		{ },
7086 		{ { 0, 0x123 } }
7087 	},
7088 	{
7089 		"ALU64_RSH_X: 2 >> 1 = 1",
7090 		.u.insns_int = {
7091 			BPF_LD_IMM64(R0, 2),
7092 			BPF_ALU32_IMM(BPF_MOV, R1, 1),
7093 			BPF_ALU64_REG(BPF_RSH, R0, R1),
7094 			BPF_EXIT_INSN(),
7095 		},
7096 		INTERNAL,
7097 		{ },
7098 		{ { 0, 1 } },
7099 	},
7100 	{
7101 		"ALU64_RSH_X: 0x80000000 >> 31 = 1",
7102 		.u.insns_int = {
7103 			BPF_LD_IMM64(R0, 0x80000000),
7104 			BPF_ALU32_IMM(BPF_MOV, R1, 31),
7105 			BPF_ALU64_REG(BPF_RSH, R0, R1),
7106 			BPF_EXIT_INSN(),
7107 		},
7108 		INTERNAL,
7109 		{ },
7110 		{ { 0, 1 } },
7111 	},
7112 	{
7113 		"ALU64_RSH_X: Shift < 32, low word",
7114 		.u.insns_int = {
7115 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7116 			BPF_ALU32_IMM(BPF_MOV, R1, 12),
7117 			BPF_ALU64_REG(BPF_RSH, R0, R1),
7118 			BPF_EXIT_INSN(),
7119 		},
7120 		INTERNAL,
7121 		{ },
7122 		{ { 0, 0x56789abc } }
7123 	},
7124 	{
7125 		"ALU64_RSH_X: Shift < 32, high word",
7126 		.u.insns_int = {
7127 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7128 			BPF_ALU32_IMM(BPF_MOV, R1, 12),
7129 			BPF_ALU64_REG(BPF_RSH, R0, R1),
7130 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7131 			BPF_EXIT_INSN(),
7132 		},
7133 		INTERNAL,
7134 		{ },
7135 		{ { 0, 0x00081234 } }
7136 	},
7137 	{
7138 		"ALU64_RSH_X: Shift > 32, low word",
7139 		.u.insns_int = {
7140 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7141 			BPF_ALU32_IMM(BPF_MOV, R1, 36),
7142 			BPF_ALU64_REG(BPF_RSH, R0, R1),
7143 			BPF_EXIT_INSN(),
7144 		},
7145 		INTERNAL,
7146 		{ },
7147 		{ { 0, 0x08123456 } }
7148 	},
7149 	{
7150 		"ALU64_RSH_X: Shift > 32, high word",
7151 		.u.insns_int = {
7152 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7153 			BPF_ALU32_IMM(BPF_MOV, R1, 36),
7154 			BPF_ALU64_REG(BPF_RSH, R0, R1),
7155 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7156 			BPF_EXIT_INSN(),
7157 		},
7158 		INTERNAL,
7159 		{ },
7160 		{ { 0, 0 } }
7161 	},
7162 	{
7163 		"ALU64_RSH_X: Shift == 32, low word",
7164 		.u.insns_int = {
7165 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7166 			BPF_ALU32_IMM(BPF_MOV, R1, 32),
7167 			BPF_ALU64_REG(BPF_RSH, R0, R1),
7168 			BPF_EXIT_INSN(),
7169 		},
7170 		INTERNAL,
7171 		{ },
7172 		{ { 0, 0x81234567 } }
7173 	},
7174 	{
7175 		"ALU64_RSH_X: Shift == 32, high word",
7176 		.u.insns_int = {
7177 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7178 			BPF_ALU32_IMM(BPF_MOV, R1, 32),
7179 			BPF_ALU64_REG(BPF_RSH, R0, R1),
7180 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7181 			BPF_EXIT_INSN(),
7182 		},
7183 		INTERNAL,
7184 		{ },
7185 		{ { 0, 0 } }
7186 	},
7187 	{
7188 		"ALU64_RSH_X: Zero shift, low word",
7189 		.u.insns_int = {
7190 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7191 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
7192 			BPF_ALU64_REG(BPF_RSH, R0, R1),
7193 			BPF_EXIT_INSN(),
7194 		},
7195 		INTERNAL,
7196 		{ },
7197 		{ { 0, 0x89abcdef } }
7198 	},
7199 	{
7200 		"ALU64_RSH_X: Zero shift, high word",
7201 		.u.insns_int = {
7202 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7203 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
7204 			BPF_ALU64_REG(BPF_RSH, R0, R1),
7205 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7206 			BPF_EXIT_INSN(),
7207 		},
7208 		INTERNAL,
7209 		{ },
7210 		{ { 0, 0x81234567 } }
7211 	},
7212 	/* BPF_ALU | BPF_RSH | BPF_K */
7213 	{
7214 		"ALU_RSH_K: 2 >> 1 = 1",
7215 		.u.insns_int = {
7216 			BPF_LD_IMM64(R0, 2),
7217 			BPF_ALU32_IMM(BPF_RSH, R0, 1),
7218 			BPF_EXIT_INSN(),
7219 		},
7220 		INTERNAL,
7221 		{ },
7222 		{ { 0, 1 } },
7223 	},
7224 	{
7225 		"ALU_RSH_K: 0x80000000 >> 31 = 1",
7226 		.u.insns_int = {
7227 			BPF_LD_IMM64(R0, 0x80000000),
7228 			BPF_ALU32_IMM(BPF_RSH, R0, 31),
7229 			BPF_EXIT_INSN(),
7230 		},
7231 		INTERNAL,
7232 		{ },
7233 		{ { 0, 1 } },
7234 	},
7235 	{
7236 		"ALU_RSH_K: 0x12345678 >> 20 = 0x123",
7237 		.u.insns_int = {
7238 			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
7239 			BPF_ALU32_IMM(BPF_RSH, R0, 20),
7240 			BPF_EXIT_INSN(),
7241 		},
7242 		INTERNAL,
7243 		{ },
7244 		{ { 0, 0x123 } }
7245 	},
7246 	{
7247 		"ALU_RSH_K: 0x12345678 >> 0 = 0x12345678",
7248 		.u.insns_int = {
7249 			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
7250 			BPF_ALU32_IMM(BPF_RSH, R0, 0),
7251 			BPF_EXIT_INSN(),
7252 		},
7253 		INTERNAL,
7254 		{ },
7255 		{ { 0, 0x12345678 } }
7256 	},
7257 	{
7258 		"ALU64_RSH_K: 2 >> 1 = 1",
7259 		.u.insns_int = {
7260 			BPF_LD_IMM64(R0, 2),
7261 			BPF_ALU64_IMM(BPF_RSH, R0, 1),
7262 			BPF_EXIT_INSN(),
7263 		},
7264 		INTERNAL,
7265 		{ },
7266 		{ { 0, 1 } },
7267 	},
7268 	{
7269 		"ALU64_RSH_K: 0x80000000 >> 31 = 1",
7270 		.u.insns_int = {
7271 			BPF_LD_IMM64(R0, 0x80000000),
7272 			BPF_ALU64_IMM(BPF_RSH, R0, 31),
7273 			BPF_EXIT_INSN(),
7274 		},
7275 		INTERNAL,
7276 		{ },
7277 		{ { 0, 1 } },
7278 	},
7279 	{
7280 		"ALU64_RSH_K: Shift < 32, low word",
7281 		.u.insns_int = {
7282 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7283 			BPF_ALU64_IMM(BPF_RSH, R0, 12),
7284 			BPF_EXIT_INSN(),
7285 		},
7286 		INTERNAL,
7287 		{ },
7288 		{ { 0, 0x56789abc } }
7289 	},
7290 	{
7291 		"ALU64_RSH_K: Shift < 32, high word",
7292 		.u.insns_int = {
7293 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7294 			BPF_ALU64_IMM(BPF_RSH, R0, 12),
7295 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7296 			BPF_EXIT_INSN(),
7297 		},
7298 		INTERNAL,
7299 		{ },
7300 		{ { 0, 0x00081234 } }
7301 	},
7302 	{
7303 		"ALU64_RSH_K: Shift > 32, low word",
7304 		.u.insns_int = {
7305 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7306 			BPF_ALU64_IMM(BPF_RSH, R0, 36),
7307 			BPF_EXIT_INSN(),
7308 		},
7309 		INTERNAL,
7310 		{ },
7311 		{ { 0, 0x08123456 } }
7312 	},
7313 	{
7314 		"ALU64_RSH_K: Shift > 32, high word",
7315 		.u.insns_int = {
7316 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7317 			BPF_ALU64_IMM(BPF_RSH, R0, 36),
7318 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7319 			BPF_EXIT_INSN(),
7320 		},
7321 		INTERNAL,
7322 		{ },
7323 		{ { 0, 0 } }
7324 	},
7325 	{
7326 		"ALU64_RSH_K: Shift == 32, low word",
7327 		.u.insns_int = {
7328 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7329 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7330 			BPF_EXIT_INSN(),
7331 		},
7332 		INTERNAL,
7333 		{ },
7334 		{ { 0, 0x81234567 } }
7335 	},
7336 	{
7337 		"ALU64_RSH_K: Shift == 32, high word",
7338 		.u.insns_int = {
7339 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7340 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7341 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7342 			BPF_EXIT_INSN(),
7343 		},
7344 		INTERNAL,
7345 		{ },
7346 		{ { 0, 0 } }
7347 	},
7348 	{
7349 		"ALU64_RSH_K: Zero shift",
7350 		.u.insns_int = {
7351 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7352 			BPF_ALU64_IMM(BPF_RSH, R0, 0),
7353 			BPF_EXIT_INSN(),
7354 		},
7355 		INTERNAL,
7356 		{ },
7357 		{ { 0, 0x89abcdef } }
7358 	},
7359 	/* BPF_ALU | BPF_ARSH | BPF_X */
7360 	{
7361 		"ALU32_ARSH_X: -1234 >> 7 = -10",
7362 		.u.insns_int = {
7363 			BPF_ALU32_IMM(BPF_MOV, R0, -1234),
7364 			BPF_ALU32_IMM(BPF_MOV, R1, 7),
7365 			BPF_ALU32_REG(BPF_ARSH, R0, R1),
7366 			BPF_EXIT_INSN(),
7367 		},
7368 		INTERNAL,
7369 		{ },
7370 		{ { 0, -10 } }
7371 	},
7372 	{
7373 		"ALU64_ARSH_X: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
7374 		.u.insns_int = {
7375 			BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
7376 			BPF_ALU32_IMM(BPF_MOV, R1, 40),
7377 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
7378 			BPF_EXIT_INSN(),
7379 		},
7380 		INTERNAL,
7381 		{ },
7382 		{ { 0, 0xffff00ff } },
7383 	},
7384 	{
7385 		"ALU64_ARSH_X: Shift < 32, low word",
7386 		.u.insns_int = {
7387 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7388 			BPF_ALU32_IMM(BPF_MOV, R1, 12),
7389 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
7390 			BPF_EXIT_INSN(),
7391 		},
7392 		INTERNAL,
7393 		{ },
7394 		{ { 0, 0x56789abc } }
7395 	},
7396 	{
7397 		"ALU64_ARSH_X: Shift < 32, high word",
7398 		.u.insns_int = {
7399 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7400 			BPF_ALU32_IMM(BPF_MOV, R1, 12),
7401 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
7402 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7403 			BPF_EXIT_INSN(),
7404 		},
7405 		INTERNAL,
7406 		{ },
7407 		{ { 0, 0xfff81234 } }
7408 	},
7409 	{
7410 		"ALU64_ARSH_X: Shift > 32, low word",
7411 		.u.insns_int = {
7412 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7413 			BPF_ALU32_IMM(BPF_MOV, R1, 36),
7414 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
7415 			BPF_EXIT_INSN(),
7416 		},
7417 		INTERNAL,
7418 		{ },
7419 		{ { 0, 0xf8123456 } }
7420 	},
7421 	{
7422 		"ALU64_ARSH_X: Shift > 32, high word",
7423 		.u.insns_int = {
7424 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7425 			BPF_ALU32_IMM(BPF_MOV, R1, 36),
7426 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
7427 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7428 			BPF_EXIT_INSN(),
7429 		},
7430 		INTERNAL,
7431 		{ },
7432 		{ { 0, -1 } }
7433 	},
7434 	{
7435 		"ALU64_ARSH_X: Shift == 32, low word",
7436 		.u.insns_int = {
7437 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7438 			BPF_ALU32_IMM(BPF_MOV, R1, 32),
7439 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
7440 			BPF_EXIT_INSN(),
7441 		},
7442 		INTERNAL,
7443 		{ },
7444 		{ { 0, 0x81234567 } }
7445 	},
7446 	{
7447 		"ALU64_ARSH_X: Shift == 32, high word",
7448 		.u.insns_int = {
7449 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7450 			BPF_ALU32_IMM(BPF_MOV, R1, 32),
7451 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
7452 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7453 			BPF_EXIT_INSN(),
7454 		},
7455 		INTERNAL,
7456 		{ },
7457 		{ { 0, -1 } }
7458 	},
7459 	{
7460 		"ALU64_ARSH_X: Zero shift, low word",
7461 		.u.insns_int = {
7462 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7463 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
7464 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
7465 			BPF_EXIT_INSN(),
7466 		},
7467 		INTERNAL,
7468 		{ },
7469 		{ { 0, 0x89abcdef } }
7470 	},
7471 	{
7472 		"ALU64_ARSH_X: Zero shift, high word",
7473 		.u.insns_int = {
7474 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7475 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
7476 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
7477 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7478 			BPF_EXIT_INSN(),
7479 		},
7480 		INTERNAL,
7481 		{ },
7482 		{ { 0, 0x81234567 } }
7483 	},
7484 	/* BPF_ALU | BPF_ARSH | BPF_K */
7485 	{
7486 		"ALU32_ARSH_K: -1234 >> 7 = -10",
7487 		.u.insns_int = {
7488 			BPF_ALU32_IMM(BPF_MOV, R0, -1234),
7489 			BPF_ALU32_IMM(BPF_ARSH, R0, 7),
7490 			BPF_EXIT_INSN(),
7491 		},
7492 		INTERNAL,
7493 		{ },
7494 		{ { 0, -10 } }
7495 	},
7496 	{
7497 		"ALU32_ARSH_K: -1234 >> 0 = -1234",
7498 		.u.insns_int = {
7499 			BPF_ALU32_IMM(BPF_MOV, R0, -1234),
7500 			BPF_ALU32_IMM(BPF_ARSH, R0, 0),
7501 			BPF_EXIT_INSN(),
7502 		},
7503 		INTERNAL,
7504 		{ },
7505 		{ { 0, -1234 } }
7506 	},
7507 	{
7508 		"ALU64_ARSH_K: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
7509 		.u.insns_int = {
7510 			BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
7511 			BPF_ALU64_IMM(BPF_ARSH, R0, 40),
7512 			BPF_EXIT_INSN(),
7513 		},
7514 		INTERNAL,
7515 		{ },
7516 		{ { 0, 0xffff00ff } },
7517 	},
7518 	{
7519 		"ALU64_ARSH_K: Shift < 32, low word",
7520 		.u.insns_int = {
7521 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7522 			BPF_ALU64_IMM(BPF_RSH, R0, 12),
7523 			BPF_EXIT_INSN(),
7524 		},
7525 		INTERNAL,
7526 		{ },
7527 		{ { 0, 0x56789abc } }
7528 	},
7529 	{
7530 		"ALU64_ARSH_K: Shift < 32, high word",
7531 		.u.insns_int = {
7532 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7533 			BPF_ALU64_IMM(BPF_ARSH, R0, 12),
7534 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7535 			BPF_EXIT_INSN(),
7536 		},
7537 		INTERNAL,
7538 		{ },
7539 		{ { 0, 0xfff81234 } }
7540 	},
7541 	{
7542 		"ALU64_ARSH_K: Shift > 32, low word",
7543 		.u.insns_int = {
7544 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7545 			BPF_ALU64_IMM(BPF_ARSH, R0, 36),
7546 			BPF_EXIT_INSN(),
7547 		},
7548 		INTERNAL,
7549 		{ },
7550 		{ { 0, 0xf8123456 } }
7551 	},
7552 	{
7553 		"ALU64_ARSH_K: Shift > 32, high word",
7554 		.u.insns_int = {
7555 			BPF_LD_IMM64(R0, 0xf123456789abcdefLL),
7556 			BPF_ALU64_IMM(BPF_ARSH, R0, 36),
7557 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7558 			BPF_EXIT_INSN(),
7559 		},
7560 		INTERNAL,
7561 		{ },
7562 		{ { 0, -1 } }
7563 	},
7564 	{
7565 		"ALU64_ARSH_K: Shift == 32, low word",
7566 		.u.insns_int = {
7567 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7568 			BPF_ALU64_IMM(BPF_ARSH, R0, 32),
7569 			BPF_EXIT_INSN(),
7570 		},
7571 		INTERNAL,
7572 		{ },
7573 		{ { 0, 0x81234567 } }
7574 	},
7575 	{
7576 		"ALU64_ARSH_K: Shift == 32, high word",
7577 		.u.insns_int = {
7578 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7579 			BPF_ALU64_IMM(BPF_ARSH, R0, 32),
7580 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7581 			BPF_EXIT_INSN(),
7582 		},
7583 		INTERNAL,
7584 		{ },
7585 		{ { 0, -1 } }
7586 	},
7587 	{
7588 		"ALU64_ARSH_K: Zero shift",
7589 		.u.insns_int = {
7590 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7591 			BPF_ALU64_IMM(BPF_ARSH, R0, 0),
7592 			BPF_EXIT_INSN(),
7593 		},
7594 		INTERNAL,
7595 		{ },
7596 		{ { 0, 0x89abcdef } }
7597 	},
7598 	/* BPF_ALU | BPF_NEG */
7599 	{
7600 		"ALU_NEG: -(3) = -3",
7601 		.u.insns_int = {
7602 			BPF_ALU32_IMM(BPF_MOV, R0, 3),
7603 			BPF_ALU32_IMM(BPF_NEG, R0, 0),
7604 			BPF_EXIT_INSN(),
7605 		},
7606 		INTERNAL,
7607 		{ },
7608 		{ { 0, -3 } },
7609 	},
7610 	{
7611 		"ALU_NEG: -(-3) = 3",
7612 		.u.insns_int = {
7613 			BPF_ALU32_IMM(BPF_MOV, R0, -3),
7614 			BPF_ALU32_IMM(BPF_NEG, R0, 0),
7615 			BPF_EXIT_INSN(),
7616 		},
7617 		INTERNAL,
7618 		{ },
7619 		{ { 0, 3 } },
7620 	},
7621 	{
7622 		"ALU64_NEG: -(3) = -3",
7623 		.u.insns_int = {
7624 			BPF_LD_IMM64(R0, 3),
7625 			BPF_ALU64_IMM(BPF_NEG, R0, 0),
7626 			BPF_EXIT_INSN(),
7627 		},
7628 		INTERNAL,
7629 		{ },
7630 		{ { 0, -3 } },
7631 	},
7632 	{
7633 		"ALU64_NEG: -(-3) = 3",
7634 		.u.insns_int = {
7635 			BPF_LD_IMM64(R0, -3),
7636 			BPF_ALU64_IMM(BPF_NEG, R0, 0),
7637 			BPF_EXIT_INSN(),
7638 		},
7639 		INTERNAL,
7640 		{ },
7641 		{ { 0, 3 } },
7642 	},
7643 	/* BPF_ALU | BPF_END | BPF_FROM_BE */
7644 	{
7645 		"ALU_END_FROM_BE 16: 0x0123456789abcdef -> 0xcdef",
7646 		.u.insns_int = {
7647 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7648 			BPF_ENDIAN(BPF_FROM_BE, R0, 16),
7649 			BPF_EXIT_INSN(),
7650 		},
7651 		INTERNAL,
7652 		{ },
7653 		{ { 0,  cpu_to_be16(0xcdef) } },
7654 	},
7655 	{
7656 		"ALU_END_FROM_BE 32: 0x0123456789abcdef -> 0x89abcdef",
7657 		.u.insns_int = {
7658 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7659 			BPF_ENDIAN(BPF_FROM_BE, R0, 32),
7660 			BPF_ALU64_REG(BPF_MOV, R1, R0),
7661 			BPF_ALU64_IMM(BPF_RSH, R1, 32),
7662 			BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
7663 			BPF_EXIT_INSN(),
7664 		},
7665 		INTERNAL,
7666 		{ },
7667 		{ { 0, cpu_to_be32(0x89abcdef) } },
7668 	},
7669 	{
7670 		"ALU_END_FROM_BE 64: 0x0123456789abcdef -> 0x89abcdef",
7671 		.u.insns_int = {
7672 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7673 			BPF_ENDIAN(BPF_FROM_BE, R0, 64),
7674 			BPF_EXIT_INSN(),
7675 		},
7676 		INTERNAL,
7677 		{ },
7678 		{ { 0, (u32) cpu_to_be64(0x0123456789abcdefLL) } },
7679 	},
7680 	{
7681 		"ALU_END_FROM_BE 64: 0x0123456789abcdef >> 32 -> 0x01234567",
7682 		.u.insns_int = {
7683 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7684 			BPF_ENDIAN(BPF_FROM_BE, R0, 64),
7685 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7686 			BPF_EXIT_INSN(),
7687 		},
7688 		INTERNAL,
7689 		{ },
7690 		{ { 0, (u32) (cpu_to_be64(0x0123456789abcdefLL) >> 32) } },
7691 	},
7692 	/* BPF_ALU | BPF_END | BPF_FROM_BE, reversed */
7693 	{
7694 		"ALU_END_FROM_BE 16: 0xfedcba9876543210 -> 0x3210",
7695 		.u.insns_int = {
7696 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7697 			BPF_ENDIAN(BPF_FROM_BE, R0, 16),
7698 			BPF_EXIT_INSN(),
7699 		},
7700 		INTERNAL,
7701 		{ },
7702 		{ { 0,  cpu_to_be16(0x3210) } },
7703 	},
7704 	{
7705 		"ALU_END_FROM_BE 32: 0xfedcba9876543210 -> 0x76543210",
7706 		.u.insns_int = {
7707 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7708 			BPF_ENDIAN(BPF_FROM_BE, R0, 32),
7709 			BPF_ALU64_REG(BPF_MOV, R1, R0),
7710 			BPF_ALU64_IMM(BPF_RSH, R1, 32),
7711 			BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
7712 			BPF_EXIT_INSN(),
7713 		},
7714 		INTERNAL,
7715 		{ },
7716 		{ { 0, cpu_to_be32(0x76543210) } },
7717 	},
7718 	{
7719 		"ALU_END_FROM_BE 64: 0xfedcba9876543210 -> 0x76543210",
7720 		.u.insns_int = {
7721 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7722 			BPF_ENDIAN(BPF_FROM_BE, R0, 64),
7723 			BPF_EXIT_INSN(),
7724 		},
7725 		INTERNAL,
7726 		{ },
7727 		{ { 0, (u32) cpu_to_be64(0xfedcba9876543210ULL) } },
7728 	},
7729 	{
7730 		"ALU_END_FROM_BE 64: 0xfedcba9876543210 >> 32 -> 0xfedcba98",
7731 		.u.insns_int = {
7732 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7733 			BPF_ENDIAN(BPF_FROM_BE, R0, 64),
7734 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7735 			BPF_EXIT_INSN(),
7736 		},
7737 		INTERNAL,
7738 		{ },
7739 		{ { 0, (u32) (cpu_to_be64(0xfedcba9876543210ULL) >> 32) } },
7740 	},
7741 	/* BPF_ALU | BPF_END | BPF_FROM_LE */
7742 	{
7743 		"ALU_END_FROM_LE 16: 0x0123456789abcdef -> 0xefcd",
7744 		.u.insns_int = {
7745 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7746 			BPF_ENDIAN(BPF_FROM_LE, R0, 16),
7747 			BPF_EXIT_INSN(),
7748 		},
7749 		INTERNAL,
7750 		{ },
7751 		{ { 0, cpu_to_le16(0xcdef) } },
7752 	},
7753 	{
7754 		"ALU_END_FROM_LE 32: 0x0123456789abcdef -> 0xefcdab89",
7755 		.u.insns_int = {
7756 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7757 			BPF_ENDIAN(BPF_FROM_LE, R0, 32),
7758 			BPF_ALU64_REG(BPF_MOV, R1, R0),
7759 			BPF_ALU64_IMM(BPF_RSH, R1, 32),
7760 			BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
7761 			BPF_EXIT_INSN(),
7762 		},
7763 		INTERNAL,
7764 		{ },
7765 		{ { 0, cpu_to_le32(0x89abcdef) } },
7766 	},
7767 	{
7768 		"ALU_END_FROM_LE 64: 0x0123456789abcdef -> 0x67452301",
7769 		.u.insns_int = {
7770 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7771 			BPF_ENDIAN(BPF_FROM_LE, R0, 64),
7772 			BPF_EXIT_INSN(),
7773 		},
7774 		INTERNAL,
7775 		{ },
7776 		{ { 0, (u32) cpu_to_le64(0x0123456789abcdefLL) } },
7777 	},
7778 	{
7779 		"ALU_END_FROM_LE 64: 0x0123456789abcdef >> 32 -> 0xefcdab89",
7780 		.u.insns_int = {
7781 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7782 			BPF_ENDIAN(BPF_FROM_LE, R0, 64),
7783 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7784 			BPF_EXIT_INSN(),
7785 		},
7786 		INTERNAL,
7787 		{ },
7788 		{ { 0, (u32) (cpu_to_le64(0x0123456789abcdefLL) >> 32) } },
7789 	},
7790 	/* BPF_ALU | BPF_END | BPF_FROM_LE, reversed */
7791 	{
7792 		"ALU_END_FROM_LE 16: 0xfedcba9876543210 -> 0x1032",
7793 		.u.insns_int = {
7794 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7795 			BPF_ENDIAN(BPF_FROM_LE, R0, 16),
7796 			BPF_EXIT_INSN(),
7797 		},
7798 		INTERNAL,
7799 		{ },
7800 		{ { 0,  cpu_to_le16(0x3210) } },
7801 	},
7802 	{
7803 		"ALU_END_FROM_LE 32: 0xfedcba9876543210 -> 0x10325476",
7804 		.u.insns_int = {
7805 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7806 			BPF_ENDIAN(BPF_FROM_LE, R0, 32),
7807 			BPF_ALU64_REG(BPF_MOV, R1, R0),
7808 			BPF_ALU64_IMM(BPF_RSH, R1, 32),
7809 			BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
7810 			BPF_EXIT_INSN(),
7811 		},
7812 		INTERNAL,
7813 		{ },
7814 		{ { 0, cpu_to_le32(0x76543210) } },
7815 	},
7816 	{
7817 		"ALU_END_FROM_LE 64: 0xfedcba9876543210 -> 0x10325476",
7818 		.u.insns_int = {
7819 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7820 			BPF_ENDIAN(BPF_FROM_LE, R0, 64),
7821 			BPF_EXIT_INSN(),
7822 		},
7823 		INTERNAL,
7824 		{ },
7825 		{ { 0, (u32) cpu_to_le64(0xfedcba9876543210ULL) } },
7826 	},
7827 	{
7828 		"ALU_END_FROM_LE 64: 0xfedcba9876543210 >> 32 -> 0x98badcfe",
7829 		.u.insns_int = {
7830 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7831 			BPF_ENDIAN(BPF_FROM_LE, R0, 64),
7832 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7833 			BPF_EXIT_INSN(),
7834 		},
7835 		INTERNAL,
7836 		{ },
7837 		{ { 0, (u32) (cpu_to_le64(0xfedcba9876543210ULL) >> 32) } },
7838 	},
7839 	/* BPF_LDX_MEM B/H/W/DW */
7840 	{
7841 		"BPF_LDX_MEM | BPF_B",
7842 		.u.insns_int = {
7843 			BPF_LD_IMM64(R1, 0x0102030405060708ULL),
7844 			BPF_LD_IMM64(R2, 0x0000000000000008ULL),
7845 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
7846 #ifdef __BIG_ENDIAN
7847 			BPF_LDX_MEM(BPF_B, R0, R10, -1),
7848 #else
7849 			BPF_LDX_MEM(BPF_B, R0, R10, -8),
7850 #endif
7851 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
7852 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7853 			BPF_EXIT_INSN(),
7854 		},
7855 		INTERNAL,
7856 		{ },
7857 		{ { 0, 0 } },
7858 		.stack_depth = 8,
7859 	},
7860 	{
7861 		"BPF_LDX_MEM | BPF_B, MSB set",
7862 		.u.insns_int = {
7863 			BPF_LD_IMM64(R1, 0x8182838485868788ULL),
7864 			BPF_LD_IMM64(R2, 0x0000000000000088ULL),
7865 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
7866 #ifdef __BIG_ENDIAN
7867 			BPF_LDX_MEM(BPF_B, R0, R10, -1),
7868 #else
7869 			BPF_LDX_MEM(BPF_B, R0, R10, -8),
7870 #endif
7871 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
7872 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7873 			BPF_EXIT_INSN(),
7874 		},
7875 		INTERNAL,
7876 		{ },
7877 		{ { 0, 0 } },
7878 		.stack_depth = 8,
7879 	},
7880 	{
7881 		"BPF_LDX_MEM | BPF_H",
7882 		.u.insns_int = {
7883 			BPF_LD_IMM64(R1, 0x0102030405060708ULL),
7884 			BPF_LD_IMM64(R2, 0x0000000000000708ULL),
7885 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
7886 #ifdef __BIG_ENDIAN
7887 			BPF_LDX_MEM(BPF_H, R0, R10, -2),
7888 #else
7889 			BPF_LDX_MEM(BPF_H, R0, R10, -8),
7890 #endif
7891 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
7892 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7893 			BPF_EXIT_INSN(),
7894 		},
7895 		INTERNAL,
7896 		{ },
7897 		{ { 0, 0 } },
7898 		.stack_depth = 8,
7899 	},
7900 	{
7901 		"BPF_LDX_MEM | BPF_H, MSB set",
7902 		.u.insns_int = {
7903 			BPF_LD_IMM64(R1, 0x8182838485868788ULL),
7904 			BPF_LD_IMM64(R2, 0x0000000000008788ULL),
7905 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
7906 #ifdef __BIG_ENDIAN
7907 			BPF_LDX_MEM(BPF_H, R0, R10, -2),
7908 #else
7909 			BPF_LDX_MEM(BPF_H, R0, R10, -8),
7910 #endif
7911 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
7912 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7913 			BPF_EXIT_INSN(),
7914 		},
7915 		INTERNAL,
7916 		{ },
7917 		{ { 0, 0 } },
7918 		.stack_depth = 8,
7919 	},
7920 	{
7921 		"BPF_LDX_MEM | BPF_W",
7922 		.u.insns_int = {
7923 			BPF_LD_IMM64(R1, 0x0102030405060708ULL),
7924 			BPF_LD_IMM64(R2, 0x0000000005060708ULL),
7925 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
7926 #ifdef __BIG_ENDIAN
7927 			BPF_LDX_MEM(BPF_W, R0, R10, -4),
7928 #else
7929 			BPF_LDX_MEM(BPF_W, R0, R10, -8),
7930 #endif
7931 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
7932 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7933 			BPF_EXIT_INSN(),
7934 		},
7935 		INTERNAL,
7936 		{ },
7937 		{ { 0, 0 } },
7938 		.stack_depth = 8,
7939 	},
7940 	{
7941 		"BPF_LDX_MEM | BPF_W, MSB set",
7942 		.u.insns_int = {
7943 			BPF_LD_IMM64(R1, 0x8182838485868788ULL),
7944 			BPF_LD_IMM64(R2, 0x0000000085868788ULL),
7945 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
7946 #ifdef __BIG_ENDIAN
7947 			BPF_LDX_MEM(BPF_W, R0, R10, -4),
7948 #else
7949 			BPF_LDX_MEM(BPF_W, R0, R10, -8),
7950 #endif
7951 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
7952 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7953 			BPF_EXIT_INSN(),
7954 		},
7955 		INTERNAL,
7956 		{ },
7957 		{ { 0, 0 } },
7958 		.stack_depth = 8,
7959 	},
7960 	/* BPF_STX_MEM B/H/W/DW */
7961 	{
7962 		"BPF_STX_MEM | BPF_B",
7963 		.u.insns_int = {
7964 			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
7965 			BPF_LD_IMM64(R2, 0x0102030405060708ULL),
7966 			BPF_LD_IMM64(R3, 0x8090a0b0c0d0e008ULL),
7967 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
7968 #ifdef __BIG_ENDIAN
7969 			BPF_STX_MEM(BPF_B, R10, R2, -1),
7970 #else
7971 			BPF_STX_MEM(BPF_B, R10, R2, -8),
7972 #endif
7973 			BPF_LDX_MEM(BPF_DW, R0, R10, -8),
7974 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
7975 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7976 			BPF_EXIT_INSN(),
7977 		},
7978 		INTERNAL,
7979 		{ },
7980 		{ { 0, 0 } },
7981 		.stack_depth = 8,
7982 	},
7983 	{
7984 		"BPF_STX_MEM | BPF_B, MSB set",
7985 		.u.insns_int = {
7986 			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
7987 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
7988 			BPF_LD_IMM64(R3, 0x8090a0b0c0d0e088ULL),
7989 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
7990 #ifdef __BIG_ENDIAN
7991 			BPF_STX_MEM(BPF_B, R10, R2, -1),
7992 #else
7993 			BPF_STX_MEM(BPF_B, R10, R2, -8),
7994 #endif
7995 			BPF_LDX_MEM(BPF_DW, R0, R10, -8),
7996 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
7997 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7998 			BPF_EXIT_INSN(),
7999 		},
8000 		INTERNAL,
8001 		{ },
8002 		{ { 0, 0 } },
8003 		.stack_depth = 8,
8004 	},
8005 	{
8006 		"BPF_STX_MEM | BPF_H",
8007 		.u.insns_int = {
8008 			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8009 			BPF_LD_IMM64(R2, 0x0102030405060708ULL),
8010 			BPF_LD_IMM64(R3, 0x8090a0b0c0d00708ULL),
8011 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
8012 #ifdef __BIG_ENDIAN
8013 			BPF_STX_MEM(BPF_H, R10, R2, -2),
8014 #else
8015 			BPF_STX_MEM(BPF_H, R10, R2, -8),
8016 #endif
8017 			BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8018 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8019 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8020 			BPF_EXIT_INSN(),
8021 		},
8022 		INTERNAL,
8023 		{ },
8024 		{ { 0, 0 } },
8025 		.stack_depth = 8,
8026 	},
8027 	{
8028 		"BPF_STX_MEM | BPF_H, MSB set",
8029 		.u.insns_int = {
8030 			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8031 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8032 			BPF_LD_IMM64(R3, 0x8090a0b0c0d08788ULL),
8033 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
8034 #ifdef __BIG_ENDIAN
8035 			BPF_STX_MEM(BPF_H, R10, R2, -2),
8036 #else
8037 			BPF_STX_MEM(BPF_H, R10, R2, -8),
8038 #endif
8039 			BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8040 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8041 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8042 			BPF_EXIT_INSN(),
8043 		},
8044 		INTERNAL,
8045 		{ },
8046 		{ { 0, 0 } },
8047 		.stack_depth = 8,
8048 	},
8049 	{
8050 		"BPF_STX_MEM | BPF_W",
8051 		.u.insns_int = {
8052 			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8053 			BPF_LD_IMM64(R2, 0x0102030405060708ULL),
8054 			BPF_LD_IMM64(R3, 0x8090a0b005060708ULL),
8055 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
8056 #ifdef __BIG_ENDIAN
8057 			BPF_STX_MEM(BPF_W, R10, R2, -4),
8058 #else
8059 			BPF_STX_MEM(BPF_W, R10, R2, -8),
8060 #endif
8061 			BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8062 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8063 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8064 			BPF_EXIT_INSN(),
8065 		},
8066 		INTERNAL,
8067 		{ },
8068 		{ { 0, 0 } },
8069 		.stack_depth = 8,
8070 	},
8071 	{
8072 		"BPF_STX_MEM | BPF_W, MSB set",
8073 		.u.insns_int = {
8074 			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8075 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8076 			BPF_LD_IMM64(R3, 0x8090a0b085868788ULL),
8077 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
8078 #ifdef __BIG_ENDIAN
8079 			BPF_STX_MEM(BPF_W, R10, R2, -4),
8080 #else
8081 			BPF_STX_MEM(BPF_W, R10, R2, -8),
8082 #endif
8083 			BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8084 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8085 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8086 			BPF_EXIT_INSN(),
8087 		},
8088 		INTERNAL,
8089 		{ },
8090 		{ { 0, 0 } },
8091 		.stack_depth = 8,
8092 	},
8093 	/* BPF_ST(X) | BPF_MEM | BPF_B/H/W/DW */
8094 	{
8095 		"ST_MEM_B: Store/Load byte: max negative",
8096 		.u.insns_int = {
8097 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8098 			BPF_ST_MEM(BPF_B, R10, -40, 0xff),
8099 			BPF_LDX_MEM(BPF_B, R0, R10, -40),
8100 			BPF_EXIT_INSN(),
8101 		},
8102 		INTERNAL,
8103 		{ },
8104 		{ { 0, 0xff } },
8105 		.stack_depth = 40,
8106 	},
8107 	{
8108 		"ST_MEM_B: Store/Load byte: max positive",
8109 		.u.insns_int = {
8110 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8111 			BPF_ST_MEM(BPF_H, R10, -40, 0x7f),
8112 			BPF_LDX_MEM(BPF_H, R0, R10, -40),
8113 			BPF_EXIT_INSN(),
8114 		},
8115 		INTERNAL,
8116 		{ },
8117 		{ { 0, 0x7f } },
8118 		.stack_depth = 40,
8119 	},
8120 	{
8121 		"STX_MEM_B: Store/Load byte: max negative",
8122 		.u.insns_int = {
8123 			BPF_LD_IMM64(R0, 0),
8124 			BPF_LD_IMM64(R1, 0xffLL),
8125 			BPF_STX_MEM(BPF_B, R10, R1, -40),
8126 			BPF_LDX_MEM(BPF_B, R0, R10, -40),
8127 			BPF_EXIT_INSN(),
8128 		},
8129 		INTERNAL,
8130 		{ },
8131 		{ { 0, 0xff } },
8132 		.stack_depth = 40,
8133 	},
8134 	{
8135 		"ST_MEM_H: Store/Load half word: max negative",
8136 		.u.insns_int = {
8137 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8138 			BPF_ST_MEM(BPF_H, R10, -40, 0xffff),
8139 			BPF_LDX_MEM(BPF_H, R0, R10, -40),
8140 			BPF_EXIT_INSN(),
8141 		},
8142 		INTERNAL,
8143 		{ },
8144 		{ { 0, 0xffff } },
8145 		.stack_depth = 40,
8146 	},
8147 	{
8148 		"ST_MEM_H: Store/Load half word: max positive",
8149 		.u.insns_int = {
8150 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8151 			BPF_ST_MEM(BPF_H, R10, -40, 0x7fff),
8152 			BPF_LDX_MEM(BPF_H, R0, R10, -40),
8153 			BPF_EXIT_INSN(),
8154 		},
8155 		INTERNAL,
8156 		{ },
8157 		{ { 0, 0x7fff } },
8158 		.stack_depth = 40,
8159 	},
8160 	{
8161 		"STX_MEM_H: Store/Load half word: max negative",
8162 		.u.insns_int = {
8163 			BPF_LD_IMM64(R0, 0),
8164 			BPF_LD_IMM64(R1, 0xffffLL),
8165 			BPF_STX_MEM(BPF_H, R10, R1, -40),
8166 			BPF_LDX_MEM(BPF_H, R0, R10, -40),
8167 			BPF_EXIT_INSN(),
8168 		},
8169 		INTERNAL,
8170 		{ },
8171 		{ { 0, 0xffff } },
8172 		.stack_depth = 40,
8173 	},
8174 	{
8175 		"ST_MEM_W: Store/Load word: max negative",
8176 		.u.insns_int = {
8177 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8178 			BPF_ST_MEM(BPF_W, R10, -40, 0xffffffff),
8179 			BPF_LDX_MEM(BPF_W, R0, R10, -40),
8180 			BPF_EXIT_INSN(),
8181 		},
8182 		INTERNAL,
8183 		{ },
8184 		{ { 0, 0xffffffff } },
8185 		.stack_depth = 40,
8186 	},
8187 	{
8188 		"ST_MEM_W: Store/Load word: max positive",
8189 		.u.insns_int = {
8190 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8191 			BPF_ST_MEM(BPF_W, R10, -40, 0x7fffffff),
8192 			BPF_LDX_MEM(BPF_W, R0, R10, -40),
8193 			BPF_EXIT_INSN(),
8194 		},
8195 		INTERNAL,
8196 		{ },
8197 		{ { 0, 0x7fffffff } },
8198 		.stack_depth = 40,
8199 	},
8200 	{
8201 		"STX_MEM_W: Store/Load word: max negative",
8202 		.u.insns_int = {
8203 			BPF_LD_IMM64(R0, 0),
8204 			BPF_LD_IMM64(R1, 0xffffffffLL),
8205 			BPF_STX_MEM(BPF_W, R10, R1, -40),
8206 			BPF_LDX_MEM(BPF_W, R0, R10, -40),
8207 			BPF_EXIT_INSN(),
8208 		},
8209 		INTERNAL,
8210 		{ },
8211 		{ { 0, 0xffffffff } },
8212 		.stack_depth = 40,
8213 	},
8214 	{
8215 		"ST_MEM_DW: Store/Load double word: max negative",
8216 		.u.insns_int = {
8217 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8218 			BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
8219 			BPF_LDX_MEM(BPF_DW, R0, R10, -40),
8220 			BPF_EXIT_INSN(),
8221 		},
8222 		INTERNAL,
8223 		{ },
8224 		{ { 0, 0xffffffff } },
8225 		.stack_depth = 40,
8226 	},
8227 	{
8228 		"ST_MEM_DW: Store/Load double word: max negative 2",
8229 		.u.insns_int = {
8230 			BPF_LD_IMM64(R2, 0xffff00000000ffffLL),
8231 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
8232 			BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
8233 			BPF_LDX_MEM(BPF_DW, R2, R10, -40),
8234 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
8235 			BPF_MOV32_IMM(R0, 2),
8236 			BPF_EXIT_INSN(),
8237 			BPF_MOV32_IMM(R0, 1),
8238 			BPF_EXIT_INSN(),
8239 		},
8240 		INTERNAL,
8241 		{ },
8242 		{ { 0, 0x1 } },
8243 		.stack_depth = 40,
8244 	},
8245 	{
8246 		"ST_MEM_DW: Store/Load double word: max positive",
8247 		.u.insns_int = {
8248 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8249 			BPF_ST_MEM(BPF_DW, R10, -40, 0x7fffffff),
8250 			BPF_LDX_MEM(BPF_DW, R0, R10, -40),
8251 			BPF_EXIT_INSN(),
8252 		},
8253 		INTERNAL,
8254 		{ },
8255 		{ { 0, 0x7fffffff } },
8256 		.stack_depth = 40,
8257 	},
8258 	{
8259 		"STX_MEM_DW: Store/Load double word: max negative",
8260 		.u.insns_int = {
8261 			BPF_LD_IMM64(R0, 0),
8262 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
8263 			BPF_STX_MEM(BPF_DW, R10, R1, -40),
8264 			BPF_LDX_MEM(BPF_DW, R0, R10, -40),
8265 			BPF_EXIT_INSN(),
8266 		},
8267 		INTERNAL,
8268 		{ },
8269 		{ { 0, 0xffffffff } },
8270 		.stack_depth = 40,
8271 	},
8272 	{
8273 		"STX_MEM_DW: Store double word: first word in memory",
8274 		.u.insns_int = {
8275 			BPF_LD_IMM64(R0, 0),
8276 			BPF_LD_IMM64(R1, 0x0123456789abcdefLL),
8277 			BPF_STX_MEM(BPF_DW, R10, R1, -40),
8278 			BPF_LDX_MEM(BPF_W, R0, R10, -40),
8279 			BPF_EXIT_INSN(),
8280 		},
8281 		INTERNAL,
8282 		{ },
8283 #ifdef __BIG_ENDIAN
8284 		{ { 0, 0x01234567 } },
8285 #else
8286 		{ { 0, 0x89abcdef } },
8287 #endif
8288 		.stack_depth = 40,
8289 	},
8290 	{
8291 		"STX_MEM_DW: Store double word: second word in memory",
8292 		.u.insns_int = {
8293 			BPF_LD_IMM64(R0, 0),
8294 			BPF_LD_IMM64(R1, 0x0123456789abcdefLL),
8295 			BPF_STX_MEM(BPF_DW, R10, R1, -40),
8296 			BPF_LDX_MEM(BPF_W, R0, R10, -36),
8297 			BPF_EXIT_INSN(),
8298 		},
8299 		INTERNAL,
8300 		{ },
8301 #ifdef __BIG_ENDIAN
8302 		{ { 0, 0x89abcdef } },
8303 #else
8304 		{ { 0, 0x01234567 } },
8305 #endif
8306 		.stack_depth = 40,
8307 	},
8308 	/* BPF_STX | BPF_ATOMIC | BPF_W/DW */
8309 	{
8310 		"STX_XADD_W: X + 1 + 1 + 1 + ...",
8311 		{ },
8312 		INTERNAL,
8313 		{ },
8314 		{ { 0, 4134 } },
8315 		.fill_helper = bpf_fill_stxw,
8316 	},
8317 	{
8318 		"STX_XADD_DW: X + 1 + 1 + 1 + ...",
8319 		{ },
8320 		INTERNAL,
8321 		{ },
8322 		{ { 0, 4134 } },
8323 		.fill_helper = bpf_fill_stxdw,
8324 	},
8325 	/*
8326 	 * Exhaustive tests of atomic operation variants.
8327 	 * Individual tests are expanded from template macros for all
8328 	 * combinations of ALU operation, word size and fetching.
8329 	 */
8330 #define BPF_ATOMIC_POISON(width) ((width) == BPF_W ? (0xbaadf00dULL << 32) : 0)
8331 
8332 #define BPF_ATOMIC_OP_TEST1(width, op, logic, old, update, result)	\
8333 {									\
8334 	"BPF_ATOMIC | " #width ", " #op ": Test: "			\
8335 		#old " " #logic " " #update " = " #result,		\
8336 	.u.insns_int = {						\
8337 		BPF_LD_IMM64(R5, (update) | BPF_ATOMIC_POISON(width)),	\
8338 		BPF_ST_MEM(width, R10, -40, old),			\
8339 		BPF_ATOMIC_OP(width, op, R10, R5, -40),			\
8340 		BPF_LDX_MEM(width, R0, R10, -40),			\
8341 		BPF_ALU64_REG(BPF_MOV, R1, R0),				\
8342 		BPF_ALU64_IMM(BPF_RSH, R1, 32),				\
8343 		BPF_ALU64_REG(BPF_OR, R0, R1),				\
8344 		BPF_EXIT_INSN(),					\
8345 	},								\
8346 	INTERNAL,							\
8347 	{ },								\
8348 	{ { 0, result } },						\
8349 	.stack_depth = 40,						\
8350 }
8351 #define BPF_ATOMIC_OP_TEST2(width, op, logic, old, update, result)	\
8352 {									\
8353 	"BPF_ATOMIC | " #width ", " #op ": Test side effects, r10: "	\
8354 		#old " " #logic " " #update " = " #result,		\
8355 	.u.insns_int = {						\
8356 		BPF_ALU64_REG(BPF_MOV, R1, R10),			\
8357 		BPF_LD_IMM64(R0, (update) | BPF_ATOMIC_POISON(width)),	\
8358 		BPF_ST_MEM(BPF_W, R10, -40, old),			\
8359 		BPF_ATOMIC_OP(width, op, R10, R0, -40),			\
8360 		BPF_ALU64_REG(BPF_MOV, R0, R10),			\
8361 		BPF_ALU64_REG(BPF_SUB, R0, R1),				\
8362 		BPF_ALU64_REG(BPF_MOV, R1, R0),				\
8363 		BPF_ALU64_IMM(BPF_RSH, R1, 32),				\
8364 		BPF_ALU64_REG(BPF_OR, R0, R1),				\
8365 		BPF_EXIT_INSN(),					\
8366 	},								\
8367 	INTERNAL,							\
8368 	{ },								\
8369 	{ { 0, 0 } },							\
8370 	.stack_depth = 40,						\
8371 }
8372 #define BPF_ATOMIC_OP_TEST3(width, op, logic, old, update, result)	\
8373 {									\
8374 	"BPF_ATOMIC | " #width ", " #op ": Test side effects, r0: "	\
8375 		#old " " #logic " " #update " = " #result,		\
8376 	.u.insns_int = {						\
8377 		BPF_ALU64_REG(BPF_MOV, R0, R10),			\
8378 		BPF_LD_IMM64(R1, (update) | BPF_ATOMIC_POISON(width)),	\
8379 		BPF_ST_MEM(width, R10, -40, old),			\
8380 		BPF_ATOMIC_OP(width, op, R10, R1, -40),			\
8381 		BPF_ALU64_REG(BPF_SUB, R0, R10),			\
8382 		BPF_ALU64_REG(BPF_MOV, R1, R0),				\
8383 		BPF_ALU64_IMM(BPF_RSH, R1, 32),				\
8384 		BPF_ALU64_REG(BPF_OR, R0, R1),				\
8385 		BPF_EXIT_INSN(),					\
8386 	},								\
8387 	INTERNAL,                                                       \
8388 	{ },                                                            \
8389 	{ { 0, 0 } },                                                   \
8390 	.stack_depth = 40,                                              \
8391 }
8392 #define BPF_ATOMIC_OP_TEST4(width, op, logic, old, update, result)	\
8393 {									\
8394 	"BPF_ATOMIC | " #width ", " #op ": Test fetch: "		\
8395 		#old " " #logic " " #update " = " #result,		\
8396 	.u.insns_int = {						\
8397 		BPF_LD_IMM64(R3, (update) | BPF_ATOMIC_POISON(width)),	\
8398 		BPF_ST_MEM(width, R10, -40, old),			\
8399 		BPF_ATOMIC_OP(width, op, R10, R3, -40),			\
8400 		BPF_ALU32_REG(BPF_MOV, R0, R3),                         \
8401 		BPF_EXIT_INSN(),					\
8402 	},								\
8403 	INTERNAL,                                                       \
8404 	{ },                                                            \
8405 	{ { 0, (op) & BPF_FETCH ? old : update } },			\
8406 	.stack_depth = 40,                                              \
8407 }
8408 	/* BPF_ATOMIC | BPF_W: BPF_ADD */
8409 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
8410 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
8411 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
8412 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
8413 	/* BPF_ATOMIC | BPF_W: BPF_ADD | BPF_FETCH */
8414 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
8415 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
8416 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
8417 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
8418 	/* BPF_ATOMIC | BPF_DW: BPF_ADD */
8419 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
8420 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
8421 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
8422 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
8423 	/* BPF_ATOMIC | BPF_DW: BPF_ADD | BPF_FETCH */
8424 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
8425 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
8426 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
8427 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
8428 	/* BPF_ATOMIC | BPF_W: BPF_AND */
8429 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
8430 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
8431 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
8432 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
8433 	/* BPF_ATOMIC | BPF_W: BPF_AND | BPF_FETCH */
8434 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
8435 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
8436 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
8437 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
8438 	/* BPF_ATOMIC | BPF_DW: BPF_AND */
8439 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
8440 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
8441 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
8442 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
8443 	/* BPF_ATOMIC | BPF_DW: BPF_AND | BPF_FETCH */
8444 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
8445 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
8446 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
8447 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
8448 	/* BPF_ATOMIC | BPF_W: BPF_OR */
8449 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
8450 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
8451 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
8452 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
8453 	/* BPF_ATOMIC | BPF_W: BPF_OR | BPF_FETCH */
8454 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
8455 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
8456 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
8457 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
8458 	/* BPF_ATOMIC | BPF_DW: BPF_OR */
8459 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
8460 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
8461 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
8462 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
8463 	/* BPF_ATOMIC | BPF_DW: BPF_OR | BPF_FETCH */
8464 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
8465 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
8466 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
8467 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
8468 	/* BPF_ATOMIC | BPF_W: BPF_XOR */
8469 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
8470 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
8471 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
8472 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
8473 	/* BPF_ATOMIC | BPF_W: BPF_XOR | BPF_FETCH */
8474 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
8475 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
8476 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
8477 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
8478 	/* BPF_ATOMIC | BPF_DW: BPF_XOR */
8479 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
8480 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
8481 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
8482 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
8483 	/* BPF_ATOMIC | BPF_DW: BPF_XOR | BPF_FETCH */
8484 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
8485 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
8486 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
8487 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
8488 	/* BPF_ATOMIC | BPF_W: BPF_XCHG */
8489 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
8490 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
8491 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
8492 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
8493 	/* BPF_ATOMIC | BPF_DW: BPF_XCHG */
8494 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
8495 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
8496 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
8497 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
8498 #undef BPF_ATOMIC_POISON
8499 #undef BPF_ATOMIC_OP_TEST1
8500 #undef BPF_ATOMIC_OP_TEST2
8501 #undef BPF_ATOMIC_OP_TEST3
8502 #undef BPF_ATOMIC_OP_TEST4
8503 	/* BPF_ATOMIC | BPF_W, BPF_CMPXCHG */
8504 	{
8505 		"BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test successful return",
8506 		.u.insns_int = {
8507 			BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
8508 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
8509 			BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
8510 			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
8511 			BPF_EXIT_INSN(),
8512 		},
8513 		INTERNAL,
8514 		{ },
8515 		{ { 0, 0x01234567 } },
8516 		.stack_depth = 40,
8517 	},
8518 	{
8519 		"BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test successful store",
8520 		.u.insns_int = {
8521 			BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
8522 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
8523 			BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
8524 			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
8525 			BPF_LDX_MEM(BPF_W, R0, R10, -40),
8526 			BPF_EXIT_INSN(),
8527 		},
8528 		INTERNAL,
8529 		{ },
8530 		{ { 0, 0x89abcdef } },
8531 		.stack_depth = 40,
8532 	},
8533 	{
8534 		"BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test failure return",
8535 		.u.insns_int = {
8536 			BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
8537 			BPF_ALU32_IMM(BPF_MOV, R0, 0x76543210),
8538 			BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
8539 			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
8540 			BPF_EXIT_INSN(),
8541 		},
8542 		INTERNAL,
8543 		{ },
8544 		{ { 0, 0x01234567 } },
8545 		.stack_depth = 40,
8546 	},
8547 	{
8548 		"BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test failure store",
8549 		.u.insns_int = {
8550 			BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
8551 			BPF_ALU32_IMM(BPF_MOV, R0, 0x76543210),
8552 			BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
8553 			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
8554 			BPF_LDX_MEM(BPF_W, R0, R10, -40),
8555 			BPF_EXIT_INSN(),
8556 		},
8557 		INTERNAL,
8558 		{ },
8559 		{ { 0, 0x01234567 } },
8560 		.stack_depth = 40,
8561 	},
8562 	{
8563 		"BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test side effects",
8564 		.u.insns_int = {
8565 			BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
8566 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
8567 			BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
8568 			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
8569 			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
8570 			BPF_ALU32_REG(BPF_MOV, R0, R3),
8571 			BPF_EXIT_INSN(),
8572 		},
8573 		INTERNAL,
8574 		{ },
8575 		{ { 0, 0x89abcdef } },
8576 		.stack_depth = 40,
8577 	},
8578 	/* BPF_ATOMIC | BPF_DW, BPF_CMPXCHG */
8579 	{
8580 		"BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test successful return",
8581 		.u.insns_int = {
8582 			BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
8583 			BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
8584 			BPF_ALU64_REG(BPF_MOV, R0, R1),
8585 			BPF_STX_MEM(BPF_DW, R10, R1, -40),
8586 			BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
8587 			BPF_JMP_REG(BPF_JNE, R0, R1, 1),
8588 			BPF_ALU64_REG(BPF_SUB, R0, R1),
8589 			BPF_EXIT_INSN(),
8590 		},
8591 		INTERNAL,
8592 		{ },
8593 		{ { 0, 0 } },
8594 		.stack_depth = 40,
8595 	},
8596 	{
8597 		"BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test successful store",
8598 		.u.insns_int = {
8599 			BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
8600 			BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
8601 			BPF_ALU64_REG(BPF_MOV, R0, R1),
8602 			BPF_STX_MEM(BPF_DW, R10, R0, -40),
8603 			BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
8604 			BPF_LDX_MEM(BPF_DW, R0, R10, -40),
8605 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8606 			BPF_ALU64_REG(BPF_SUB, R0, R2),
8607 			BPF_EXIT_INSN(),
8608 		},
8609 		INTERNAL,
8610 		{ },
8611 		{ { 0, 0 } },
8612 		.stack_depth = 40,
8613 	},
8614 	{
8615 		"BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test failure return",
8616 		.u.insns_int = {
8617 			BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
8618 			BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
8619 			BPF_ALU64_REG(BPF_MOV, R0, R1),
8620 			BPF_ALU64_IMM(BPF_ADD, R0, 1),
8621 			BPF_STX_MEM(BPF_DW, R10, R1, -40),
8622 			BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
8623 			BPF_JMP_REG(BPF_JNE, R0, R1, 1),
8624 			BPF_ALU64_REG(BPF_SUB, R0, R1),
8625 			BPF_EXIT_INSN(),
8626 		},
8627 		INTERNAL,
8628 		{ },
8629 		{ { 0, 0 } },
8630 		.stack_depth = 40,
8631 	},
8632 	{
8633 		"BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test failure store",
8634 		.u.insns_int = {
8635 			BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
8636 			BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
8637 			BPF_ALU64_REG(BPF_MOV, R0, R1),
8638 			BPF_ALU64_IMM(BPF_ADD, R0, 1),
8639 			BPF_STX_MEM(BPF_DW, R10, R1, -40),
8640 			BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
8641 			BPF_LDX_MEM(BPF_DW, R0, R10, -40),
8642 			BPF_JMP_REG(BPF_JNE, R0, R1, 1),
8643 			BPF_ALU64_REG(BPF_SUB, R0, R1),
8644 			BPF_EXIT_INSN(),
8645 		},
8646 		INTERNAL,
8647 		{ },
8648 		{ { 0, 0 } },
8649 		.stack_depth = 40,
8650 	},
8651 	{
8652 		"BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test side effects",
8653 		.u.insns_int = {
8654 			BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
8655 			BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
8656 			BPF_ALU64_REG(BPF_MOV, R0, R1),
8657 			BPF_STX_MEM(BPF_DW, R10, R1, -40),
8658 			BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
8659 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
8660 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8661 			BPF_ALU64_REG(BPF_SUB, R0, R2),
8662 			BPF_EXIT_INSN(),
8663 		},
8664 		INTERNAL,
8665 		{ },
8666 		{ { 0, 0 } },
8667 		.stack_depth = 40,
8668 	},
8669 	/* BPF_JMP32 | BPF_JEQ | BPF_K */
8670 	{
8671 		"JMP32_JEQ_K: Small immediate",
8672 		.u.insns_int = {
8673 			BPF_ALU32_IMM(BPF_MOV, R0, 123),
8674 			BPF_JMP32_IMM(BPF_JEQ, R0, 321, 1),
8675 			BPF_JMP32_IMM(BPF_JEQ, R0, 123, 1),
8676 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8677 			BPF_EXIT_INSN(),
8678 		},
8679 		INTERNAL,
8680 		{ },
8681 		{ { 0, 123 } }
8682 	},
8683 	{
8684 		"JMP32_JEQ_K: Large immediate",
8685 		.u.insns_int = {
8686 			BPF_ALU32_IMM(BPF_MOV, R0, 12345678),
8687 			BPF_JMP32_IMM(BPF_JEQ, R0, 12345678 & 0xffff, 1),
8688 			BPF_JMP32_IMM(BPF_JEQ, R0, 12345678, 1),
8689 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8690 			BPF_EXIT_INSN(),
8691 		},
8692 		INTERNAL,
8693 		{ },
8694 		{ { 0, 12345678 } }
8695 	},
8696 	{
8697 		"JMP32_JEQ_K: negative immediate",
8698 		.u.insns_int = {
8699 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
8700 			BPF_JMP32_IMM(BPF_JEQ, R0,  123, 1),
8701 			BPF_JMP32_IMM(BPF_JEQ, R0, -123, 1),
8702 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8703 			BPF_EXIT_INSN(),
8704 		},
8705 		INTERNAL,
8706 		{ },
8707 		{ { 0, -123 } }
8708 	},
8709 	/* BPF_JMP32 | BPF_JEQ | BPF_X */
8710 	{
8711 		"JMP32_JEQ_X",
8712 		.u.insns_int = {
8713 			BPF_ALU32_IMM(BPF_MOV, R0, 1234),
8714 			BPF_ALU32_IMM(BPF_MOV, R1, 4321),
8715 			BPF_JMP32_REG(BPF_JEQ, R0, R1, 2),
8716 			BPF_ALU32_IMM(BPF_MOV, R1, 1234),
8717 			BPF_JMP32_REG(BPF_JEQ, R0, R1, 1),
8718 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8719 			BPF_EXIT_INSN(),
8720 		},
8721 		INTERNAL,
8722 		{ },
8723 		{ { 0, 1234 } }
8724 	},
8725 	/* BPF_JMP32 | BPF_JNE | BPF_K */
8726 	{
8727 		"JMP32_JNE_K: Small immediate",
8728 		.u.insns_int = {
8729 			BPF_ALU32_IMM(BPF_MOV, R0, 123),
8730 			BPF_JMP32_IMM(BPF_JNE, R0, 123, 1),
8731 			BPF_JMP32_IMM(BPF_JNE, R0, 321, 1),
8732 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8733 			BPF_EXIT_INSN(),
8734 		},
8735 		INTERNAL,
8736 		{ },
8737 		{ { 0, 123 } }
8738 	},
8739 	{
8740 		"JMP32_JNE_K: Large immediate",
8741 		.u.insns_int = {
8742 			BPF_ALU32_IMM(BPF_MOV, R0, 12345678),
8743 			BPF_JMP32_IMM(BPF_JNE, R0, 12345678, 1),
8744 			BPF_JMP32_IMM(BPF_JNE, R0, 12345678 & 0xffff, 1),
8745 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8746 			BPF_EXIT_INSN(),
8747 		},
8748 		INTERNAL,
8749 		{ },
8750 		{ { 0, 12345678 } }
8751 	},
8752 	{
8753 		"JMP32_JNE_K: negative immediate",
8754 		.u.insns_int = {
8755 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
8756 			BPF_JMP32_IMM(BPF_JNE, R0, -123, 1),
8757 			BPF_JMP32_IMM(BPF_JNE, R0,  123, 1),
8758 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8759 			BPF_EXIT_INSN(),
8760 		},
8761 		INTERNAL,
8762 		{ },
8763 		{ { 0, -123 } }
8764 	},
8765 	/* BPF_JMP32 | BPF_JNE | BPF_X */
8766 	{
8767 		"JMP32_JNE_X",
8768 		.u.insns_int = {
8769 			BPF_ALU32_IMM(BPF_MOV, R0, 1234),
8770 			BPF_ALU32_IMM(BPF_MOV, R1, 1234),
8771 			BPF_JMP32_REG(BPF_JNE, R0, R1, 2),
8772 			BPF_ALU32_IMM(BPF_MOV, R1, 4321),
8773 			BPF_JMP32_REG(BPF_JNE, R0, R1, 1),
8774 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8775 			BPF_EXIT_INSN(),
8776 		},
8777 		INTERNAL,
8778 		{ },
8779 		{ { 0, 1234 } }
8780 	},
8781 	/* BPF_JMP32 | BPF_JSET | BPF_K */
8782 	{
8783 		"JMP32_JSET_K: Small immediate",
8784 		.u.insns_int = {
8785 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8786 			BPF_JMP32_IMM(BPF_JSET, R0, 2, 1),
8787 			BPF_JMP32_IMM(BPF_JSET, R0, 3, 1),
8788 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8789 			BPF_EXIT_INSN(),
8790 		},
8791 		INTERNAL,
8792 		{ },
8793 		{ { 0, 1 } }
8794 	},
8795 	{
8796 		"JMP32_JSET_K: Large immediate",
8797 		.u.insns_int = {
8798 			BPF_ALU32_IMM(BPF_MOV, R0, 0x40000000),
8799 			BPF_JMP32_IMM(BPF_JSET, R0, 0x3fffffff, 1),
8800 			BPF_JMP32_IMM(BPF_JSET, R0, 0x60000000, 1),
8801 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8802 			BPF_EXIT_INSN(),
8803 		},
8804 		INTERNAL,
8805 		{ },
8806 		{ { 0, 0x40000000 } }
8807 	},
8808 	{
8809 		"JMP32_JSET_K: negative immediate",
8810 		.u.insns_int = {
8811 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
8812 			BPF_JMP32_IMM(BPF_JSET, R0, -1, 1),
8813 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8814 			BPF_EXIT_INSN(),
8815 		},
8816 		INTERNAL,
8817 		{ },
8818 		{ { 0, -123 } }
8819 	},
8820 	/* BPF_JMP32 | BPF_JSET | BPF_X */
8821 	{
8822 		"JMP32_JSET_X",
8823 		.u.insns_int = {
8824 			BPF_ALU32_IMM(BPF_MOV, R0, 8),
8825 			BPF_ALU32_IMM(BPF_MOV, R1, 7),
8826 			BPF_JMP32_REG(BPF_JSET, R0, R1, 2),
8827 			BPF_ALU32_IMM(BPF_MOV, R1, 8 | 2),
8828 			BPF_JMP32_REG(BPF_JNE, R0, R1, 1),
8829 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8830 			BPF_EXIT_INSN(),
8831 		},
8832 		INTERNAL,
8833 		{ },
8834 		{ { 0, 8 } }
8835 	},
8836 	/* BPF_JMP32 | BPF_JGT | BPF_K */
8837 	{
8838 		"JMP32_JGT_K: Small immediate",
8839 		.u.insns_int = {
8840 			BPF_ALU32_IMM(BPF_MOV, R0, 123),
8841 			BPF_JMP32_IMM(BPF_JGT, R0, 123, 1),
8842 			BPF_JMP32_IMM(BPF_JGT, R0, 122, 1),
8843 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8844 			BPF_EXIT_INSN(),
8845 		},
8846 		INTERNAL,
8847 		{ },
8848 		{ { 0, 123 } }
8849 	},
8850 	{
8851 		"JMP32_JGT_K: Large immediate",
8852 		.u.insns_int = {
8853 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
8854 			BPF_JMP32_IMM(BPF_JGT, R0, 0xffffffff, 1),
8855 			BPF_JMP32_IMM(BPF_JGT, R0, 0xfffffffd, 1),
8856 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8857 			BPF_EXIT_INSN(),
8858 		},
8859 		INTERNAL,
8860 		{ },
8861 		{ { 0, 0xfffffffe } }
8862 	},
8863 	/* BPF_JMP32 | BPF_JGT | BPF_X */
8864 	{
8865 		"JMP32_JGT_X",
8866 		.u.insns_int = {
8867 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
8868 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
8869 			BPF_JMP32_REG(BPF_JGT, R0, R1, 2),
8870 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
8871 			BPF_JMP32_REG(BPF_JGT, R0, R1, 1),
8872 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8873 			BPF_EXIT_INSN(),
8874 		},
8875 		INTERNAL,
8876 		{ },
8877 		{ { 0, 0xfffffffe } }
8878 	},
8879 	/* BPF_JMP32 | BPF_JGE | BPF_K */
8880 	{
8881 		"JMP32_JGE_K: Small immediate",
8882 		.u.insns_int = {
8883 			BPF_ALU32_IMM(BPF_MOV, R0, 123),
8884 			BPF_JMP32_IMM(BPF_JGE, R0, 124, 1),
8885 			BPF_JMP32_IMM(BPF_JGE, R0, 123, 1),
8886 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8887 			BPF_EXIT_INSN(),
8888 		},
8889 		INTERNAL,
8890 		{ },
8891 		{ { 0, 123 } }
8892 	},
8893 	{
8894 		"JMP32_JGE_K: Large immediate",
8895 		.u.insns_int = {
8896 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
8897 			BPF_JMP32_IMM(BPF_JGE, R0, 0xffffffff, 1),
8898 			BPF_JMP32_IMM(BPF_JGE, R0, 0xfffffffe, 1),
8899 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8900 			BPF_EXIT_INSN(),
8901 		},
8902 		INTERNAL,
8903 		{ },
8904 		{ { 0, 0xfffffffe } }
8905 	},
8906 	/* BPF_JMP32 | BPF_JGE | BPF_X */
8907 	{
8908 		"JMP32_JGE_X",
8909 		.u.insns_int = {
8910 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
8911 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
8912 			BPF_JMP32_REG(BPF_JGE, R0, R1, 2),
8913 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffe),
8914 			BPF_JMP32_REG(BPF_JGE, R0, R1, 1),
8915 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8916 			BPF_EXIT_INSN(),
8917 		},
8918 		INTERNAL,
8919 		{ },
8920 		{ { 0, 0xfffffffe } }
8921 	},
8922 	/* BPF_JMP32 | BPF_JLT | BPF_K */
8923 	{
8924 		"JMP32_JLT_K: Small immediate",
8925 		.u.insns_int = {
8926 			BPF_ALU32_IMM(BPF_MOV, R0, 123),
8927 			BPF_JMP32_IMM(BPF_JLT, R0, 123, 1),
8928 			BPF_JMP32_IMM(BPF_JLT, R0, 124, 1),
8929 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8930 			BPF_EXIT_INSN(),
8931 		},
8932 		INTERNAL,
8933 		{ },
8934 		{ { 0, 123 } }
8935 	},
8936 	{
8937 		"JMP32_JLT_K: Large immediate",
8938 		.u.insns_int = {
8939 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
8940 			BPF_JMP32_IMM(BPF_JLT, R0, 0xfffffffd, 1),
8941 			BPF_JMP32_IMM(BPF_JLT, R0, 0xffffffff, 1),
8942 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8943 			BPF_EXIT_INSN(),
8944 		},
8945 		INTERNAL,
8946 		{ },
8947 		{ { 0, 0xfffffffe } }
8948 	},
8949 	/* BPF_JMP32 | BPF_JLT | BPF_X */
8950 	{
8951 		"JMP32_JLT_X",
8952 		.u.insns_int = {
8953 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
8954 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
8955 			BPF_JMP32_REG(BPF_JLT, R0, R1, 2),
8956 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
8957 			BPF_JMP32_REG(BPF_JLT, R0, R1, 1),
8958 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8959 			BPF_EXIT_INSN(),
8960 		},
8961 		INTERNAL,
8962 		{ },
8963 		{ { 0, 0xfffffffe } }
8964 	},
8965 	/* BPF_JMP32 | BPF_JLE | BPF_K */
8966 	{
8967 		"JMP32_JLE_K: Small immediate",
8968 		.u.insns_int = {
8969 			BPF_ALU32_IMM(BPF_MOV, R0, 123),
8970 			BPF_JMP32_IMM(BPF_JLE, R0, 122, 1),
8971 			BPF_JMP32_IMM(BPF_JLE, R0, 123, 1),
8972 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8973 			BPF_EXIT_INSN(),
8974 		},
8975 		INTERNAL,
8976 		{ },
8977 		{ { 0, 123 } }
8978 	},
8979 	{
8980 		"JMP32_JLE_K: Large immediate",
8981 		.u.insns_int = {
8982 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
8983 			BPF_JMP32_IMM(BPF_JLE, R0, 0xfffffffd, 1),
8984 			BPF_JMP32_IMM(BPF_JLE, R0, 0xfffffffe, 1),
8985 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8986 			BPF_EXIT_INSN(),
8987 		},
8988 		INTERNAL,
8989 		{ },
8990 		{ { 0, 0xfffffffe } }
8991 	},
8992 	/* BPF_JMP32 | BPF_JLE | BPF_X */
8993 	{
8994 		"JMP32_JLE_X",
8995 		.u.insns_int = {
8996 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
8997 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
8998 			BPF_JMP32_REG(BPF_JLE, R0, R1, 2),
8999 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffe),
9000 			BPF_JMP32_REG(BPF_JLE, R0, R1, 1),
9001 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9002 			BPF_EXIT_INSN(),
9003 		},
9004 		INTERNAL,
9005 		{ },
9006 		{ { 0, 0xfffffffe } }
9007 	},
9008 	/* BPF_JMP32 | BPF_JSGT | BPF_K */
9009 	{
9010 		"JMP32_JSGT_K: Small immediate",
9011 		.u.insns_int = {
9012 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
9013 			BPF_JMP32_IMM(BPF_JSGT, R0, -123, 1),
9014 			BPF_JMP32_IMM(BPF_JSGT, R0, -124, 1),
9015 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9016 			BPF_EXIT_INSN(),
9017 		},
9018 		INTERNAL,
9019 		{ },
9020 		{ { 0, -123 } }
9021 	},
9022 	{
9023 		"JMP32_JSGT_K: Large immediate",
9024 		.u.insns_int = {
9025 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9026 			BPF_JMP32_IMM(BPF_JSGT, R0, -12345678, 1),
9027 			BPF_JMP32_IMM(BPF_JSGT, R0, -12345679, 1),
9028 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9029 			BPF_EXIT_INSN(),
9030 		},
9031 		INTERNAL,
9032 		{ },
9033 		{ { 0, -12345678 } }
9034 	},
9035 	/* BPF_JMP32 | BPF_JSGT | BPF_X */
9036 	{
9037 		"JMP32_JSGT_X",
9038 		.u.insns_int = {
9039 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9040 			BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
9041 			BPF_JMP32_REG(BPF_JSGT, R0, R1, 2),
9042 			BPF_ALU32_IMM(BPF_MOV, R1, -12345679),
9043 			BPF_JMP32_REG(BPF_JSGT, R0, R1, 1),
9044 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9045 			BPF_EXIT_INSN(),
9046 		},
9047 		INTERNAL,
9048 		{ },
9049 		{ { 0, -12345678 } }
9050 	},
9051 	/* BPF_JMP32 | BPF_JSGE | BPF_K */
9052 	{
9053 		"JMP32_JSGE_K: Small immediate",
9054 		.u.insns_int = {
9055 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
9056 			BPF_JMP32_IMM(BPF_JSGE, R0, -122, 1),
9057 			BPF_JMP32_IMM(BPF_JSGE, R0, -123, 1),
9058 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9059 			BPF_EXIT_INSN(),
9060 		},
9061 		INTERNAL,
9062 		{ },
9063 		{ { 0, -123 } }
9064 	},
9065 	{
9066 		"JMP32_JSGE_K: Large immediate",
9067 		.u.insns_int = {
9068 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9069 			BPF_JMP32_IMM(BPF_JSGE, R0, -12345677, 1),
9070 			BPF_JMP32_IMM(BPF_JSGE, R0, -12345678, 1),
9071 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9072 			BPF_EXIT_INSN(),
9073 		},
9074 		INTERNAL,
9075 		{ },
9076 		{ { 0, -12345678 } }
9077 	},
9078 	/* BPF_JMP32 | BPF_JSGE | BPF_X */
9079 	{
9080 		"JMP32_JSGE_X",
9081 		.u.insns_int = {
9082 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9083 			BPF_ALU32_IMM(BPF_MOV, R1, -12345677),
9084 			BPF_JMP32_REG(BPF_JSGE, R0, R1, 2),
9085 			BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
9086 			BPF_JMP32_REG(BPF_JSGE, R0, R1, 1),
9087 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9088 			BPF_EXIT_INSN(),
9089 		},
9090 		INTERNAL,
9091 		{ },
9092 		{ { 0, -12345678 } }
9093 	},
9094 	/* BPF_JMP32 | BPF_JSLT | BPF_K */
9095 	{
9096 		"JMP32_JSLT_K: Small immediate",
9097 		.u.insns_int = {
9098 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
9099 			BPF_JMP32_IMM(BPF_JSLT, R0, -123, 1),
9100 			BPF_JMP32_IMM(BPF_JSLT, R0, -122, 1),
9101 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9102 			BPF_EXIT_INSN(),
9103 		},
9104 		INTERNAL,
9105 		{ },
9106 		{ { 0, -123 } }
9107 	},
9108 	{
9109 		"JMP32_JSLT_K: Large immediate",
9110 		.u.insns_int = {
9111 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9112 			BPF_JMP32_IMM(BPF_JSLT, R0, -12345678, 1),
9113 			BPF_JMP32_IMM(BPF_JSLT, R0, -12345677, 1),
9114 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9115 			BPF_EXIT_INSN(),
9116 		},
9117 		INTERNAL,
9118 		{ },
9119 		{ { 0, -12345678 } }
9120 	},
9121 	/* BPF_JMP32 | BPF_JSLT | BPF_X */
9122 	{
9123 		"JMP32_JSLT_X",
9124 		.u.insns_int = {
9125 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9126 			BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
9127 			BPF_JMP32_REG(BPF_JSLT, R0, R1, 2),
9128 			BPF_ALU32_IMM(BPF_MOV, R1, -12345677),
9129 			BPF_JMP32_REG(BPF_JSLT, R0, R1, 1),
9130 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9131 			BPF_EXIT_INSN(),
9132 		},
9133 		INTERNAL,
9134 		{ },
9135 		{ { 0, -12345678 } }
9136 	},
9137 	/* BPF_JMP32 | BPF_JSLE | BPF_K */
9138 	{
9139 		"JMP32_JSLE_K: Small immediate",
9140 		.u.insns_int = {
9141 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
9142 			BPF_JMP32_IMM(BPF_JSLE, R0, -124, 1),
9143 			BPF_JMP32_IMM(BPF_JSLE, R0, -123, 1),
9144 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9145 			BPF_EXIT_INSN(),
9146 		},
9147 		INTERNAL,
9148 		{ },
9149 		{ { 0, -123 } }
9150 	},
9151 	{
9152 		"JMP32_JSLE_K: Large immediate",
9153 		.u.insns_int = {
9154 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9155 			BPF_JMP32_IMM(BPF_JSLE, R0, -12345679, 1),
9156 			BPF_JMP32_IMM(BPF_JSLE, R0, -12345678, 1),
9157 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9158 			BPF_EXIT_INSN(),
9159 		},
9160 		INTERNAL,
9161 		{ },
9162 		{ { 0, -12345678 } }
9163 	},
9164 	/* BPF_JMP32 | BPF_JSLE | BPF_K */
9165 	{
9166 		"JMP32_JSLE_X",
9167 		.u.insns_int = {
9168 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9169 			BPF_ALU32_IMM(BPF_MOV, R1, -12345679),
9170 			BPF_JMP32_REG(BPF_JSLE, R0, R1, 2),
9171 			BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
9172 			BPF_JMP32_REG(BPF_JSLE, R0, R1, 1),
9173 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9174 			BPF_EXIT_INSN(),
9175 		},
9176 		INTERNAL,
9177 		{ },
9178 		{ { 0, -12345678 } }
9179 	},
9180 	/* BPF_JMP | BPF_EXIT */
9181 	{
9182 		"JMP_EXIT",
9183 		.u.insns_int = {
9184 			BPF_ALU32_IMM(BPF_MOV, R0, 0x4711),
9185 			BPF_EXIT_INSN(),
9186 			BPF_ALU32_IMM(BPF_MOV, R0, 0x4712),
9187 		},
9188 		INTERNAL,
9189 		{ },
9190 		{ { 0, 0x4711 } },
9191 	},
9192 	/* BPF_JMP | BPF_JA */
9193 	{
9194 		"JMP_JA: Unconditional jump: if (true) return 1",
9195 		.u.insns_int = {
9196 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9197 			BPF_JMP_IMM(BPF_JA, 0, 0, 1),
9198 			BPF_EXIT_INSN(),
9199 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9200 			BPF_EXIT_INSN(),
9201 		},
9202 		INTERNAL,
9203 		{ },
9204 		{ { 0, 1 } },
9205 	},
9206 	/* BPF_JMP | BPF_JSLT | BPF_K */
9207 	{
9208 		"JMP_JSLT_K: Signed jump: if (-2 < -1) return 1",
9209 		.u.insns_int = {
9210 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9211 			BPF_LD_IMM64(R1, 0xfffffffffffffffeLL),
9212 			BPF_JMP_IMM(BPF_JSLT, R1, -1, 1),
9213 			BPF_EXIT_INSN(),
9214 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9215 			BPF_EXIT_INSN(),
9216 		},
9217 		INTERNAL,
9218 		{ },
9219 		{ { 0, 1 } },
9220 	},
9221 	{
9222 		"JMP_JSLT_K: Signed jump: if (-1 < -1) return 0",
9223 		.u.insns_int = {
9224 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9225 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9226 			BPF_JMP_IMM(BPF_JSLT, R1, -1, 1),
9227 			BPF_EXIT_INSN(),
9228 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9229 			BPF_EXIT_INSN(),
9230 		},
9231 		INTERNAL,
9232 		{ },
9233 		{ { 0, 1 } },
9234 	},
9235 	/* BPF_JMP | BPF_JSGT | BPF_K */
9236 	{
9237 		"JMP_JSGT_K: Signed jump: if (-1 > -2) return 1",
9238 		.u.insns_int = {
9239 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9240 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9241 			BPF_JMP_IMM(BPF_JSGT, R1, -2, 1),
9242 			BPF_EXIT_INSN(),
9243 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9244 			BPF_EXIT_INSN(),
9245 		},
9246 		INTERNAL,
9247 		{ },
9248 		{ { 0, 1 } },
9249 	},
9250 	{
9251 		"JMP_JSGT_K: Signed jump: if (-1 > -1) return 0",
9252 		.u.insns_int = {
9253 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9254 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9255 			BPF_JMP_IMM(BPF_JSGT, R1, -1, 1),
9256 			BPF_EXIT_INSN(),
9257 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9258 			BPF_EXIT_INSN(),
9259 		},
9260 		INTERNAL,
9261 		{ },
9262 		{ { 0, 1 } },
9263 	},
9264 	/* BPF_JMP | BPF_JSLE | BPF_K */
9265 	{
9266 		"JMP_JSLE_K: Signed jump: if (-2 <= -1) return 1",
9267 		.u.insns_int = {
9268 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9269 			BPF_LD_IMM64(R1, 0xfffffffffffffffeLL),
9270 			BPF_JMP_IMM(BPF_JSLE, R1, -1, 1),
9271 			BPF_EXIT_INSN(),
9272 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9273 			BPF_EXIT_INSN(),
9274 		},
9275 		INTERNAL,
9276 		{ },
9277 		{ { 0, 1 } },
9278 	},
9279 	{
9280 		"JMP_JSLE_K: Signed jump: if (-1 <= -1) return 1",
9281 		.u.insns_int = {
9282 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9283 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9284 			BPF_JMP_IMM(BPF_JSLE, R1, -1, 1),
9285 			BPF_EXIT_INSN(),
9286 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9287 			BPF_EXIT_INSN(),
9288 		},
9289 		INTERNAL,
9290 		{ },
9291 		{ { 0, 1 } },
9292 	},
9293 	{
9294 		"JMP_JSLE_K: Signed jump: value walk 1",
9295 		.u.insns_int = {
9296 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9297 			BPF_LD_IMM64(R1, 3),
9298 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 6),
9299 			BPF_ALU64_IMM(BPF_SUB, R1, 1),
9300 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 4),
9301 			BPF_ALU64_IMM(BPF_SUB, R1, 1),
9302 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 2),
9303 			BPF_ALU64_IMM(BPF_SUB, R1, 1),
9304 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 1),
9305 			BPF_EXIT_INSN(),		/* bad exit */
9306 			BPF_ALU32_IMM(BPF_MOV, R0, 1),	/* good exit */
9307 			BPF_EXIT_INSN(),
9308 		},
9309 		INTERNAL,
9310 		{ },
9311 		{ { 0, 1 } },
9312 	},
9313 	{
9314 		"JMP_JSLE_K: Signed jump: value walk 2",
9315 		.u.insns_int = {
9316 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9317 			BPF_LD_IMM64(R1, 3),
9318 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 4),
9319 			BPF_ALU64_IMM(BPF_SUB, R1, 2),
9320 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 2),
9321 			BPF_ALU64_IMM(BPF_SUB, R1, 2),
9322 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 1),
9323 			BPF_EXIT_INSN(),		/* bad exit */
9324 			BPF_ALU32_IMM(BPF_MOV, R0, 1),	/* good exit */
9325 			BPF_EXIT_INSN(),
9326 		},
9327 		INTERNAL,
9328 		{ },
9329 		{ { 0, 1 } },
9330 	},
9331 	/* BPF_JMP | BPF_JSGE | BPF_K */
9332 	{
9333 		"JMP_JSGE_K: Signed jump: if (-1 >= -2) return 1",
9334 		.u.insns_int = {
9335 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9336 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9337 			BPF_JMP_IMM(BPF_JSGE, R1, -2, 1),
9338 			BPF_EXIT_INSN(),
9339 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9340 			BPF_EXIT_INSN(),
9341 		},
9342 		INTERNAL,
9343 		{ },
9344 		{ { 0, 1 } },
9345 	},
9346 	{
9347 		"JMP_JSGE_K: Signed jump: if (-1 >= -1) return 1",
9348 		.u.insns_int = {
9349 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9350 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9351 			BPF_JMP_IMM(BPF_JSGE, R1, -1, 1),
9352 			BPF_EXIT_INSN(),
9353 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9354 			BPF_EXIT_INSN(),
9355 		},
9356 		INTERNAL,
9357 		{ },
9358 		{ { 0, 1 } },
9359 	},
9360 	{
9361 		"JMP_JSGE_K: Signed jump: value walk 1",
9362 		.u.insns_int = {
9363 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9364 			BPF_LD_IMM64(R1, -3),
9365 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 6),
9366 			BPF_ALU64_IMM(BPF_ADD, R1, 1),
9367 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 4),
9368 			BPF_ALU64_IMM(BPF_ADD, R1, 1),
9369 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 2),
9370 			BPF_ALU64_IMM(BPF_ADD, R1, 1),
9371 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 1),
9372 			BPF_EXIT_INSN(),		/* bad exit */
9373 			BPF_ALU32_IMM(BPF_MOV, R0, 1),	/* good exit */
9374 			BPF_EXIT_INSN(),
9375 		},
9376 		INTERNAL,
9377 		{ },
9378 		{ { 0, 1 } },
9379 	},
9380 	{
9381 		"JMP_JSGE_K: Signed jump: value walk 2",
9382 		.u.insns_int = {
9383 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9384 			BPF_LD_IMM64(R1, -3),
9385 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 4),
9386 			BPF_ALU64_IMM(BPF_ADD, R1, 2),
9387 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 2),
9388 			BPF_ALU64_IMM(BPF_ADD, R1, 2),
9389 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 1),
9390 			BPF_EXIT_INSN(),		/* bad exit */
9391 			BPF_ALU32_IMM(BPF_MOV, R0, 1),	/* good exit */
9392 			BPF_EXIT_INSN(),
9393 		},
9394 		INTERNAL,
9395 		{ },
9396 		{ { 0, 1 } },
9397 	},
9398 	/* BPF_JMP | BPF_JGT | BPF_K */
9399 	{
9400 		"JMP_JGT_K: if (3 > 2) return 1",
9401 		.u.insns_int = {
9402 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9403 			BPF_LD_IMM64(R1, 3),
9404 			BPF_JMP_IMM(BPF_JGT, R1, 2, 1),
9405 			BPF_EXIT_INSN(),
9406 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9407 			BPF_EXIT_INSN(),
9408 		},
9409 		INTERNAL,
9410 		{ },
9411 		{ { 0, 1 } },
9412 	},
9413 	{
9414 		"JMP_JGT_K: Unsigned jump: if (-1 > 1) return 1",
9415 		.u.insns_int = {
9416 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9417 			BPF_LD_IMM64(R1, -1),
9418 			BPF_JMP_IMM(BPF_JGT, R1, 1, 1),
9419 			BPF_EXIT_INSN(),
9420 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9421 			BPF_EXIT_INSN(),
9422 		},
9423 		INTERNAL,
9424 		{ },
9425 		{ { 0, 1 } },
9426 	},
9427 	/* BPF_JMP | BPF_JLT | BPF_K */
9428 	{
9429 		"JMP_JLT_K: if (2 < 3) return 1",
9430 		.u.insns_int = {
9431 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9432 			BPF_LD_IMM64(R1, 2),
9433 			BPF_JMP_IMM(BPF_JLT, R1, 3, 1),
9434 			BPF_EXIT_INSN(),
9435 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9436 			BPF_EXIT_INSN(),
9437 		},
9438 		INTERNAL,
9439 		{ },
9440 		{ { 0, 1 } },
9441 	},
9442 	{
9443 		"JMP_JGT_K: Unsigned jump: if (1 < -1) return 1",
9444 		.u.insns_int = {
9445 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9446 			BPF_LD_IMM64(R1, 1),
9447 			BPF_JMP_IMM(BPF_JLT, R1, -1, 1),
9448 			BPF_EXIT_INSN(),
9449 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9450 			BPF_EXIT_INSN(),
9451 		},
9452 		INTERNAL,
9453 		{ },
9454 		{ { 0, 1 } },
9455 	},
9456 	/* BPF_JMP | BPF_JGE | BPF_K */
9457 	{
9458 		"JMP_JGE_K: if (3 >= 2) return 1",
9459 		.u.insns_int = {
9460 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9461 			BPF_LD_IMM64(R1, 3),
9462 			BPF_JMP_IMM(BPF_JGE, R1, 2, 1),
9463 			BPF_EXIT_INSN(),
9464 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9465 			BPF_EXIT_INSN(),
9466 		},
9467 		INTERNAL,
9468 		{ },
9469 		{ { 0, 1 } },
9470 	},
9471 	/* BPF_JMP | BPF_JLE | BPF_K */
9472 	{
9473 		"JMP_JLE_K: if (2 <= 3) return 1",
9474 		.u.insns_int = {
9475 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9476 			BPF_LD_IMM64(R1, 2),
9477 			BPF_JMP_IMM(BPF_JLE, R1, 3, 1),
9478 			BPF_EXIT_INSN(),
9479 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9480 			BPF_EXIT_INSN(),
9481 		},
9482 		INTERNAL,
9483 		{ },
9484 		{ { 0, 1 } },
9485 	},
9486 	/* BPF_JMP | BPF_JGT | BPF_K jump backwards */
9487 	{
9488 		"JMP_JGT_K: if (3 > 2) return 1 (jump backwards)",
9489 		.u.insns_int = {
9490 			BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
9491 			BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */
9492 			BPF_EXIT_INSN(),
9493 			BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
9494 			BPF_LD_IMM64(R1, 3), /* note: this takes 2 insns */
9495 			BPF_JMP_IMM(BPF_JGT, R1, 2, -6), /* goto out */
9496 			BPF_EXIT_INSN(),
9497 		},
9498 		INTERNAL,
9499 		{ },
9500 		{ { 0, 1 } },
9501 	},
9502 	{
9503 		"JMP_JGE_K: if (3 >= 3) return 1",
9504 		.u.insns_int = {
9505 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9506 			BPF_LD_IMM64(R1, 3),
9507 			BPF_JMP_IMM(BPF_JGE, R1, 3, 1),
9508 			BPF_EXIT_INSN(),
9509 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9510 			BPF_EXIT_INSN(),
9511 		},
9512 		INTERNAL,
9513 		{ },
9514 		{ { 0, 1 } },
9515 	},
9516 	/* BPF_JMP | BPF_JLT | BPF_K jump backwards */
9517 	{
9518 		"JMP_JGT_K: if (2 < 3) return 1 (jump backwards)",
9519 		.u.insns_int = {
9520 			BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
9521 			BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */
9522 			BPF_EXIT_INSN(),
9523 			BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
9524 			BPF_LD_IMM64(R1, 2), /* note: this takes 2 insns */
9525 			BPF_JMP_IMM(BPF_JLT, R1, 3, -6), /* goto out */
9526 			BPF_EXIT_INSN(),
9527 		},
9528 		INTERNAL,
9529 		{ },
9530 		{ { 0, 1 } },
9531 	},
9532 	{
9533 		"JMP_JLE_K: if (3 <= 3) return 1",
9534 		.u.insns_int = {
9535 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9536 			BPF_LD_IMM64(R1, 3),
9537 			BPF_JMP_IMM(BPF_JLE, R1, 3, 1),
9538 			BPF_EXIT_INSN(),
9539 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9540 			BPF_EXIT_INSN(),
9541 		},
9542 		INTERNAL,
9543 		{ },
9544 		{ { 0, 1 } },
9545 	},
9546 	/* BPF_JMP | BPF_JNE | BPF_K */
9547 	{
9548 		"JMP_JNE_K: if (3 != 2) return 1",
9549 		.u.insns_int = {
9550 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9551 			BPF_LD_IMM64(R1, 3),
9552 			BPF_JMP_IMM(BPF_JNE, R1, 2, 1),
9553 			BPF_EXIT_INSN(),
9554 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9555 			BPF_EXIT_INSN(),
9556 		},
9557 		INTERNAL,
9558 		{ },
9559 		{ { 0, 1 } },
9560 	},
9561 	/* BPF_JMP | BPF_JEQ | BPF_K */
9562 	{
9563 		"JMP_JEQ_K: if (3 == 3) return 1",
9564 		.u.insns_int = {
9565 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9566 			BPF_LD_IMM64(R1, 3),
9567 			BPF_JMP_IMM(BPF_JEQ, R1, 3, 1),
9568 			BPF_EXIT_INSN(),
9569 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9570 			BPF_EXIT_INSN(),
9571 		},
9572 		INTERNAL,
9573 		{ },
9574 		{ { 0, 1 } },
9575 	},
9576 	/* BPF_JMP | BPF_JSET | BPF_K */
9577 	{
9578 		"JMP_JSET_K: if (0x3 & 0x2) return 1",
9579 		.u.insns_int = {
9580 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9581 			BPF_LD_IMM64(R1, 3),
9582 			BPF_JMP_IMM(BPF_JSET, R1, 2, 1),
9583 			BPF_EXIT_INSN(),
9584 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9585 			BPF_EXIT_INSN(),
9586 		},
9587 		INTERNAL,
9588 		{ },
9589 		{ { 0, 1 } },
9590 	},
9591 	{
9592 		"JMP_JSET_K: if (0x3 & 0xffffffff) return 1",
9593 		.u.insns_int = {
9594 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9595 			BPF_LD_IMM64(R1, 3),
9596 			BPF_JMP_IMM(BPF_JSET, R1, 0xffffffff, 1),
9597 			BPF_EXIT_INSN(),
9598 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9599 			BPF_EXIT_INSN(),
9600 		},
9601 		INTERNAL,
9602 		{ },
9603 		{ { 0, 1 } },
9604 	},
9605 	/* BPF_JMP | BPF_JSGT | BPF_X */
9606 	{
9607 		"JMP_JSGT_X: Signed jump: if (-1 > -2) return 1",
9608 		.u.insns_int = {
9609 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9610 			BPF_LD_IMM64(R1, -1),
9611 			BPF_LD_IMM64(R2, -2),
9612 			BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
9613 			BPF_EXIT_INSN(),
9614 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9615 			BPF_EXIT_INSN(),
9616 		},
9617 		INTERNAL,
9618 		{ },
9619 		{ { 0, 1 } },
9620 	},
9621 	{
9622 		"JMP_JSGT_X: Signed jump: if (-1 > -1) return 0",
9623 		.u.insns_int = {
9624 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9625 			BPF_LD_IMM64(R1, -1),
9626 			BPF_LD_IMM64(R2, -1),
9627 			BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
9628 			BPF_EXIT_INSN(),
9629 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9630 			BPF_EXIT_INSN(),
9631 		},
9632 		INTERNAL,
9633 		{ },
9634 		{ { 0, 1 } },
9635 	},
9636 	/* BPF_JMP | BPF_JSLT | BPF_X */
9637 	{
9638 		"JMP_JSLT_X: Signed jump: if (-2 < -1) return 1",
9639 		.u.insns_int = {
9640 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9641 			BPF_LD_IMM64(R1, -1),
9642 			BPF_LD_IMM64(R2, -2),
9643 			BPF_JMP_REG(BPF_JSLT, R2, R1, 1),
9644 			BPF_EXIT_INSN(),
9645 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9646 			BPF_EXIT_INSN(),
9647 		},
9648 		INTERNAL,
9649 		{ },
9650 		{ { 0, 1 } },
9651 	},
9652 	{
9653 		"JMP_JSLT_X: Signed jump: if (-1 < -1) return 0",
9654 		.u.insns_int = {
9655 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9656 			BPF_LD_IMM64(R1, -1),
9657 			BPF_LD_IMM64(R2, -1),
9658 			BPF_JMP_REG(BPF_JSLT, R1, R2, 1),
9659 			BPF_EXIT_INSN(),
9660 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9661 			BPF_EXIT_INSN(),
9662 		},
9663 		INTERNAL,
9664 		{ },
9665 		{ { 0, 1 } },
9666 	},
9667 	/* BPF_JMP | BPF_JSGE | BPF_X */
9668 	{
9669 		"JMP_JSGE_X: Signed jump: if (-1 >= -2) return 1",
9670 		.u.insns_int = {
9671 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9672 			BPF_LD_IMM64(R1, -1),
9673 			BPF_LD_IMM64(R2, -2),
9674 			BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
9675 			BPF_EXIT_INSN(),
9676 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9677 			BPF_EXIT_INSN(),
9678 		},
9679 		INTERNAL,
9680 		{ },
9681 		{ { 0, 1 } },
9682 	},
9683 	{
9684 		"JMP_JSGE_X: Signed jump: if (-1 >= -1) return 1",
9685 		.u.insns_int = {
9686 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9687 			BPF_LD_IMM64(R1, -1),
9688 			BPF_LD_IMM64(R2, -1),
9689 			BPF_JMP_REG(BPF_JSGE, R1, R2, 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_JSLE | BPF_X */
9699 	{
9700 		"JMP_JSLE_X: Signed jump: if (-2 <= -1) return 1",
9701 		.u.insns_int = {
9702 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9703 			BPF_LD_IMM64(R1, -1),
9704 			BPF_LD_IMM64(R2, -2),
9705 			BPF_JMP_REG(BPF_JSLE, R2, R1, 1),
9706 			BPF_EXIT_INSN(),
9707 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9708 			BPF_EXIT_INSN(),
9709 		},
9710 		INTERNAL,
9711 		{ },
9712 		{ { 0, 1 } },
9713 	},
9714 	{
9715 		"JMP_JSLE_X: Signed jump: if (-1 <= -1) return 1",
9716 		.u.insns_int = {
9717 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9718 			BPF_LD_IMM64(R1, -1),
9719 			BPF_LD_IMM64(R2, -1),
9720 			BPF_JMP_REG(BPF_JSLE, R1, R2, 1),
9721 			BPF_EXIT_INSN(),
9722 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9723 			BPF_EXIT_INSN(),
9724 		},
9725 		INTERNAL,
9726 		{ },
9727 		{ { 0, 1 } },
9728 	},
9729 	/* BPF_JMP | BPF_JGT | BPF_X */
9730 	{
9731 		"JMP_JGT_X: if (3 > 2) return 1",
9732 		.u.insns_int = {
9733 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9734 			BPF_LD_IMM64(R1, 3),
9735 			BPF_LD_IMM64(R2, 2),
9736 			BPF_JMP_REG(BPF_JGT, R1, R2, 1),
9737 			BPF_EXIT_INSN(),
9738 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9739 			BPF_EXIT_INSN(),
9740 		},
9741 		INTERNAL,
9742 		{ },
9743 		{ { 0, 1 } },
9744 	},
9745 	{
9746 		"JMP_JGT_X: Unsigned jump: if (-1 > 1) return 1",
9747 		.u.insns_int = {
9748 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9749 			BPF_LD_IMM64(R1, -1),
9750 			BPF_LD_IMM64(R2, 1),
9751 			BPF_JMP_REG(BPF_JGT, R1, R2, 1),
9752 			BPF_EXIT_INSN(),
9753 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9754 			BPF_EXIT_INSN(),
9755 		},
9756 		INTERNAL,
9757 		{ },
9758 		{ { 0, 1 } },
9759 	},
9760 	/* BPF_JMP | BPF_JLT | BPF_X */
9761 	{
9762 		"JMP_JLT_X: if (2 < 3) return 1",
9763 		.u.insns_int = {
9764 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9765 			BPF_LD_IMM64(R1, 3),
9766 			BPF_LD_IMM64(R2, 2),
9767 			BPF_JMP_REG(BPF_JLT, R2, R1, 1),
9768 			BPF_EXIT_INSN(),
9769 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9770 			BPF_EXIT_INSN(),
9771 		},
9772 		INTERNAL,
9773 		{ },
9774 		{ { 0, 1 } },
9775 	},
9776 	{
9777 		"JMP_JLT_X: Unsigned jump: if (1 < -1) return 1",
9778 		.u.insns_int = {
9779 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9780 			BPF_LD_IMM64(R1, -1),
9781 			BPF_LD_IMM64(R2, 1),
9782 			BPF_JMP_REG(BPF_JLT, R2, R1, 1),
9783 			BPF_EXIT_INSN(),
9784 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9785 			BPF_EXIT_INSN(),
9786 		},
9787 		INTERNAL,
9788 		{ },
9789 		{ { 0, 1 } },
9790 	},
9791 	/* BPF_JMP | BPF_JGE | BPF_X */
9792 	{
9793 		"JMP_JGE_X: if (3 >= 2) return 1",
9794 		.u.insns_int = {
9795 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9796 			BPF_LD_IMM64(R1, 3),
9797 			BPF_LD_IMM64(R2, 2),
9798 			BPF_JMP_REG(BPF_JGE, R1, R2, 1),
9799 			BPF_EXIT_INSN(),
9800 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9801 			BPF_EXIT_INSN(),
9802 		},
9803 		INTERNAL,
9804 		{ },
9805 		{ { 0, 1 } },
9806 	},
9807 	{
9808 		"JMP_JGE_X: if (3 >= 3) return 1",
9809 		.u.insns_int = {
9810 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9811 			BPF_LD_IMM64(R1, 3),
9812 			BPF_LD_IMM64(R2, 3),
9813 			BPF_JMP_REG(BPF_JGE, R1, R2, 1),
9814 			BPF_EXIT_INSN(),
9815 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9816 			BPF_EXIT_INSN(),
9817 		},
9818 		INTERNAL,
9819 		{ },
9820 		{ { 0, 1 } },
9821 	},
9822 	/* BPF_JMP | BPF_JLE | BPF_X */
9823 	{
9824 		"JMP_JLE_X: if (2 <= 3) return 1",
9825 		.u.insns_int = {
9826 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9827 			BPF_LD_IMM64(R1, 3),
9828 			BPF_LD_IMM64(R2, 2),
9829 			BPF_JMP_REG(BPF_JLE, R2, R1, 1),
9830 			BPF_EXIT_INSN(),
9831 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9832 			BPF_EXIT_INSN(),
9833 		},
9834 		INTERNAL,
9835 		{ },
9836 		{ { 0, 1 } },
9837 	},
9838 	{
9839 		"JMP_JLE_X: if (3 <= 3) return 1",
9840 		.u.insns_int = {
9841 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9842 			BPF_LD_IMM64(R1, 3),
9843 			BPF_LD_IMM64(R2, 3),
9844 			BPF_JMP_REG(BPF_JLE, R1, R2, 1),
9845 			BPF_EXIT_INSN(),
9846 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9847 			BPF_EXIT_INSN(),
9848 		},
9849 		INTERNAL,
9850 		{ },
9851 		{ { 0, 1 } },
9852 	},
9853 	{
9854 		/* Mainly testing JIT + imm64 here. */
9855 		"JMP_JGE_X: ldimm64 test 1",
9856 		.u.insns_int = {
9857 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9858 			BPF_LD_IMM64(R1, 3),
9859 			BPF_LD_IMM64(R2, 2),
9860 			BPF_JMP_REG(BPF_JGE, R1, R2, 2),
9861 			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
9862 			BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
9863 			BPF_EXIT_INSN(),
9864 		},
9865 		INTERNAL,
9866 		{ },
9867 		{ { 0, 0xeeeeeeeeU } },
9868 	},
9869 	{
9870 		"JMP_JGE_X: ldimm64 test 2",
9871 		.u.insns_int = {
9872 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9873 			BPF_LD_IMM64(R1, 3),
9874 			BPF_LD_IMM64(R2, 2),
9875 			BPF_JMP_REG(BPF_JGE, R1, R2, 0),
9876 			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
9877 			BPF_EXIT_INSN(),
9878 		},
9879 		INTERNAL,
9880 		{ },
9881 		{ { 0, 0xffffffffU } },
9882 	},
9883 	{
9884 		"JMP_JGE_X: ldimm64 test 3",
9885 		.u.insns_int = {
9886 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9887 			BPF_LD_IMM64(R1, 3),
9888 			BPF_LD_IMM64(R2, 2),
9889 			BPF_JMP_REG(BPF_JGE, R1, R2, 4),
9890 			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
9891 			BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
9892 			BPF_EXIT_INSN(),
9893 		},
9894 		INTERNAL,
9895 		{ },
9896 		{ { 0, 1 } },
9897 	},
9898 	{
9899 		"JMP_JLE_X: ldimm64 test 1",
9900 		.u.insns_int = {
9901 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9902 			BPF_LD_IMM64(R1, 3),
9903 			BPF_LD_IMM64(R2, 2),
9904 			BPF_JMP_REG(BPF_JLE, R2, R1, 2),
9905 			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
9906 			BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
9907 			BPF_EXIT_INSN(),
9908 		},
9909 		INTERNAL,
9910 		{ },
9911 		{ { 0, 0xeeeeeeeeU } },
9912 	},
9913 	{
9914 		"JMP_JLE_X: ldimm64 test 2",
9915 		.u.insns_int = {
9916 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9917 			BPF_LD_IMM64(R1, 3),
9918 			BPF_LD_IMM64(R2, 2),
9919 			BPF_JMP_REG(BPF_JLE, R2, R1, 0),
9920 			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
9921 			BPF_EXIT_INSN(),
9922 		},
9923 		INTERNAL,
9924 		{ },
9925 		{ { 0, 0xffffffffU } },
9926 	},
9927 	{
9928 		"JMP_JLE_X: ldimm64 test 3",
9929 		.u.insns_int = {
9930 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9931 			BPF_LD_IMM64(R1, 3),
9932 			BPF_LD_IMM64(R2, 2),
9933 			BPF_JMP_REG(BPF_JLE, R2, R1, 4),
9934 			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
9935 			BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
9936 			BPF_EXIT_INSN(),
9937 		},
9938 		INTERNAL,
9939 		{ },
9940 		{ { 0, 1 } },
9941 	},
9942 	/* BPF_JMP | BPF_JNE | BPF_X */
9943 	{
9944 		"JMP_JNE_X: if (3 != 2) return 1",
9945 		.u.insns_int = {
9946 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9947 			BPF_LD_IMM64(R1, 3),
9948 			BPF_LD_IMM64(R2, 2),
9949 			BPF_JMP_REG(BPF_JNE, R1, R2, 1),
9950 			BPF_EXIT_INSN(),
9951 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9952 			BPF_EXIT_INSN(),
9953 		},
9954 		INTERNAL,
9955 		{ },
9956 		{ { 0, 1 } },
9957 	},
9958 	/* BPF_JMP | BPF_JEQ | BPF_X */
9959 	{
9960 		"JMP_JEQ_X: if (3 == 3) return 1",
9961 		.u.insns_int = {
9962 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9963 			BPF_LD_IMM64(R1, 3),
9964 			BPF_LD_IMM64(R2, 3),
9965 			BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
9966 			BPF_EXIT_INSN(),
9967 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9968 			BPF_EXIT_INSN(),
9969 		},
9970 		INTERNAL,
9971 		{ },
9972 		{ { 0, 1 } },
9973 	},
9974 	/* BPF_JMP | BPF_JSET | BPF_X */
9975 	{
9976 		"JMP_JSET_X: if (0x3 & 0x2) return 1",
9977 		.u.insns_int = {
9978 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9979 			BPF_LD_IMM64(R1, 3),
9980 			BPF_LD_IMM64(R2, 2),
9981 			BPF_JMP_REG(BPF_JSET, R1, R2, 1),
9982 			BPF_EXIT_INSN(),
9983 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9984 			BPF_EXIT_INSN(),
9985 		},
9986 		INTERNAL,
9987 		{ },
9988 		{ { 0, 1 } },
9989 	},
9990 	{
9991 		"JMP_JSET_X: if (0x3 & 0xffffffff) return 1",
9992 		.u.insns_int = {
9993 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9994 			BPF_LD_IMM64(R1, 3),
9995 			BPF_LD_IMM64(R2, 0xffffffff),
9996 			BPF_JMP_REG(BPF_JSET, R1, R2, 1),
9997 			BPF_EXIT_INSN(),
9998 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9999 			BPF_EXIT_INSN(),
10000 		},
10001 		INTERNAL,
10002 		{ },
10003 		{ { 0, 1 } },
10004 	},
10005 	{
10006 		"JMP_JA: Jump, gap, jump, ...",
10007 		{ },
10008 		CLASSIC | FLAG_NO_DATA,
10009 		{ },
10010 		{ { 0, 0xababcbac } },
10011 		.fill_helper = bpf_fill_ja,
10012 	},
10013 	{	/* Mainly checking JIT here. */
10014 		"BPF_MAXINSNS: Maximum possible literals",
10015 		{ },
10016 		CLASSIC | FLAG_NO_DATA,
10017 		{ },
10018 		{ { 0, 0xffffffff } },
10019 		.fill_helper = bpf_fill_maxinsns1,
10020 	},
10021 	{	/* Mainly checking JIT here. */
10022 		"BPF_MAXINSNS: Single literal",
10023 		{ },
10024 		CLASSIC | FLAG_NO_DATA,
10025 		{ },
10026 		{ { 0, 0xfefefefe } },
10027 		.fill_helper = bpf_fill_maxinsns2,
10028 	},
10029 	{	/* Mainly checking JIT here. */
10030 		"BPF_MAXINSNS: Run/add until end",
10031 		{ },
10032 		CLASSIC | FLAG_NO_DATA,
10033 		{ },
10034 		{ { 0, 0x947bf368 } },
10035 		.fill_helper = bpf_fill_maxinsns3,
10036 	},
10037 	{
10038 		"BPF_MAXINSNS: Too many instructions",
10039 		{ },
10040 		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
10041 		{ },
10042 		{ },
10043 		.fill_helper = bpf_fill_maxinsns4,
10044 		.expected_errcode = -EINVAL,
10045 	},
10046 	{	/* Mainly checking JIT here. */
10047 		"BPF_MAXINSNS: Very long jump",
10048 		{ },
10049 		CLASSIC | FLAG_NO_DATA,
10050 		{ },
10051 		{ { 0, 0xabababab } },
10052 		.fill_helper = bpf_fill_maxinsns5,
10053 	},
10054 	{	/* Mainly checking JIT here. */
10055 		"BPF_MAXINSNS: Ctx heavy transformations",
10056 		{ },
10057 		CLASSIC,
10058 		{ },
10059 		{
10060 			{  1, SKB_VLAN_PRESENT },
10061 			{ 10, SKB_VLAN_PRESENT }
10062 		},
10063 		.fill_helper = bpf_fill_maxinsns6,
10064 	},
10065 	{	/* Mainly checking JIT here. */
10066 		"BPF_MAXINSNS: Call heavy transformations",
10067 		{ },
10068 		CLASSIC | FLAG_NO_DATA,
10069 		{ },
10070 		{ { 1, 0 }, { 10, 0 } },
10071 		.fill_helper = bpf_fill_maxinsns7,
10072 	},
10073 	{	/* Mainly checking JIT here. */
10074 		"BPF_MAXINSNS: Jump heavy test",
10075 		{ },
10076 		CLASSIC | FLAG_NO_DATA,
10077 		{ },
10078 		{ { 0, 0xffffffff } },
10079 		.fill_helper = bpf_fill_maxinsns8,
10080 	},
10081 	{	/* Mainly checking JIT here. */
10082 		"BPF_MAXINSNS: Very long jump backwards",
10083 		{ },
10084 		INTERNAL | FLAG_NO_DATA,
10085 		{ },
10086 		{ { 0, 0xcbababab } },
10087 		.fill_helper = bpf_fill_maxinsns9,
10088 	},
10089 	{	/* Mainly checking JIT here. */
10090 		"BPF_MAXINSNS: Edge hopping nuthouse",
10091 		{ },
10092 		INTERNAL | FLAG_NO_DATA,
10093 		{ },
10094 		{ { 0, 0xabababac } },
10095 		.fill_helper = bpf_fill_maxinsns10,
10096 	},
10097 	{
10098 		"BPF_MAXINSNS: Jump, gap, jump, ...",
10099 		{ },
10100 		CLASSIC | FLAG_NO_DATA,
10101 		{ },
10102 		{ { 0, 0xababcbac } },
10103 		.fill_helper = bpf_fill_maxinsns11,
10104 	},
10105 	{
10106 		"BPF_MAXINSNS: jump over MSH",
10107 		{ },
10108 		CLASSIC | FLAG_EXPECTED_FAIL,
10109 		{ 0xfa, 0xfb, 0xfc, 0xfd, },
10110 		{ { 4, 0xabababab } },
10111 		.fill_helper = bpf_fill_maxinsns12,
10112 		.expected_errcode = -EINVAL,
10113 	},
10114 	{
10115 		"BPF_MAXINSNS: exec all MSH",
10116 		{ },
10117 		CLASSIC,
10118 		{ 0xfa, 0xfb, 0xfc, 0xfd, },
10119 		{ { 4, 0xababab83 } },
10120 		.fill_helper = bpf_fill_maxinsns13,
10121 	},
10122 	{
10123 		"BPF_MAXINSNS: ld_abs+get_processor_id",
10124 		{ },
10125 		CLASSIC,
10126 		{ },
10127 		{ { 1, 0xbee } },
10128 		.fill_helper = bpf_fill_ld_abs_get_processor_id,
10129 	},
10130 	/*
10131 	 * LD_IND / LD_ABS on fragmented SKBs
10132 	 */
10133 	{
10134 		"LD_IND byte frag",
10135 		.u.insns = {
10136 			BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
10137 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x0),
10138 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10139 		},
10140 		CLASSIC | FLAG_SKB_FRAG,
10141 		{ },
10142 		{ {0x40, 0x42} },
10143 		.frag_data = {
10144 			0x42, 0x00, 0x00, 0x00,
10145 			0x43, 0x44, 0x00, 0x00,
10146 			0x21, 0x07, 0x19, 0x83,
10147 		},
10148 	},
10149 	{
10150 		"LD_IND halfword frag",
10151 		.u.insns = {
10152 			BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
10153 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x4),
10154 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10155 		},
10156 		CLASSIC | FLAG_SKB_FRAG,
10157 		{ },
10158 		{ {0x40, 0x4344} },
10159 		.frag_data = {
10160 			0x42, 0x00, 0x00, 0x00,
10161 			0x43, 0x44, 0x00, 0x00,
10162 			0x21, 0x07, 0x19, 0x83,
10163 		},
10164 	},
10165 	{
10166 		"LD_IND word frag",
10167 		.u.insns = {
10168 			BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
10169 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x8),
10170 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10171 		},
10172 		CLASSIC | FLAG_SKB_FRAG,
10173 		{ },
10174 		{ {0x40, 0x21071983} },
10175 		.frag_data = {
10176 			0x42, 0x00, 0x00, 0x00,
10177 			0x43, 0x44, 0x00, 0x00,
10178 			0x21, 0x07, 0x19, 0x83,
10179 		},
10180 	},
10181 	{
10182 		"LD_IND halfword mixed head/frag",
10183 		.u.insns = {
10184 			BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
10185 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
10186 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10187 		},
10188 		CLASSIC | FLAG_SKB_FRAG,
10189 		{ [0x3e] = 0x25, [0x3f] = 0x05, },
10190 		{ {0x40, 0x0519} },
10191 		.frag_data = { 0x19, 0x82 },
10192 	},
10193 	{
10194 		"LD_IND word mixed head/frag",
10195 		.u.insns = {
10196 			BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
10197 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
10198 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10199 		},
10200 		CLASSIC | FLAG_SKB_FRAG,
10201 		{ [0x3e] = 0x25, [0x3f] = 0x05, },
10202 		{ {0x40, 0x25051982} },
10203 		.frag_data = { 0x19, 0x82 },
10204 	},
10205 	{
10206 		"LD_ABS byte frag",
10207 		.u.insns = {
10208 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x40),
10209 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10210 		},
10211 		CLASSIC | FLAG_SKB_FRAG,
10212 		{ },
10213 		{ {0x40, 0x42} },
10214 		.frag_data = {
10215 			0x42, 0x00, 0x00, 0x00,
10216 			0x43, 0x44, 0x00, 0x00,
10217 			0x21, 0x07, 0x19, 0x83,
10218 		},
10219 	},
10220 	{
10221 		"LD_ABS halfword frag",
10222 		.u.insns = {
10223 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x44),
10224 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10225 		},
10226 		CLASSIC | FLAG_SKB_FRAG,
10227 		{ },
10228 		{ {0x40, 0x4344} },
10229 		.frag_data = {
10230 			0x42, 0x00, 0x00, 0x00,
10231 			0x43, 0x44, 0x00, 0x00,
10232 			0x21, 0x07, 0x19, 0x83,
10233 		},
10234 	},
10235 	{
10236 		"LD_ABS word frag",
10237 		.u.insns = {
10238 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x48),
10239 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10240 		},
10241 		CLASSIC | FLAG_SKB_FRAG,
10242 		{ },
10243 		{ {0x40, 0x21071983} },
10244 		.frag_data = {
10245 			0x42, 0x00, 0x00, 0x00,
10246 			0x43, 0x44, 0x00, 0x00,
10247 			0x21, 0x07, 0x19, 0x83,
10248 		},
10249 	},
10250 	{
10251 		"LD_ABS halfword mixed head/frag",
10252 		.u.insns = {
10253 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f),
10254 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10255 		},
10256 		CLASSIC | FLAG_SKB_FRAG,
10257 		{ [0x3e] = 0x25, [0x3f] = 0x05, },
10258 		{ {0x40, 0x0519} },
10259 		.frag_data = { 0x19, 0x82 },
10260 	},
10261 	{
10262 		"LD_ABS word mixed head/frag",
10263 		.u.insns = {
10264 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3e),
10265 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10266 		},
10267 		CLASSIC | FLAG_SKB_FRAG,
10268 		{ [0x3e] = 0x25, [0x3f] = 0x05, },
10269 		{ {0x40, 0x25051982} },
10270 		.frag_data = { 0x19, 0x82 },
10271 	},
10272 	/*
10273 	 * LD_IND / LD_ABS on non fragmented SKBs
10274 	 */
10275 	{
10276 		/*
10277 		 * this tests that the JIT/interpreter correctly resets X
10278 		 * before using it in an LD_IND instruction.
10279 		 */
10280 		"LD_IND byte default X",
10281 		.u.insns = {
10282 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
10283 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10284 		},
10285 		CLASSIC,
10286 		{ [0x1] = 0x42 },
10287 		{ {0x40, 0x42 } },
10288 	},
10289 	{
10290 		"LD_IND byte positive offset",
10291 		.u.insns = {
10292 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10293 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
10294 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10295 		},
10296 		CLASSIC,
10297 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10298 		{ {0x40, 0x82 } },
10299 	},
10300 	{
10301 		"LD_IND byte negative offset",
10302 		.u.insns = {
10303 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10304 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x1),
10305 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10306 		},
10307 		CLASSIC,
10308 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10309 		{ {0x40, 0x05 } },
10310 	},
10311 	{
10312 		"LD_IND byte positive offset, all ff",
10313 		.u.insns = {
10314 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10315 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
10316 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10317 		},
10318 		CLASSIC,
10319 		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
10320 		{ {0x40, 0xff } },
10321 	},
10322 	{
10323 		"LD_IND byte positive offset, out of bounds",
10324 		.u.insns = {
10325 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10326 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
10327 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10328 		},
10329 		CLASSIC,
10330 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10331 		{ {0x3f, 0 }, },
10332 	},
10333 	{
10334 		"LD_IND byte negative offset, out of bounds",
10335 		.u.insns = {
10336 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10337 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x3f),
10338 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10339 		},
10340 		CLASSIC,
10341 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10342 		{ {0x3f, 0 } },
10343 	},
10344 	{
10345 		"LD_IND byte negative offset, multiple calls",
10346 		.u.insns = {
10347 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3b),
10348 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 1),
10349 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 2),
10350 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 3),
10351 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 4),
10352 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10353 		},
10354 		CLASSIC,
10355 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10356 		{ {0x40, 0x82 }, },
10357 	},
10358 	{
10359 		"LD_IND halfword positive offset",
10360 		.u.insns = {
10361 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
10362 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x2),
10363 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10364 		},
10365 		CLASSIC,
10366 		{
10367 			[0x1c] = 0xaa, [0x1d] = 0x55,
10368 			[0x1e] = 0xbb, [0x1f] = 0x66,
10369 			[0x20] = 0xcc, [0x21] = 0x77,
10370 			[0x22] = 0xdd, [0x23] = 0x88,
10371 		},
10372 		{ {0x40, 0xdd88 } },
10373 	},
10374 	{
10375 		"LD_IND halfword negative offset",
10376 		.u.insns = {
10377 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
10378 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x2),
10379 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10380 		},
10381 		CLASSIC,
10382 		{
10383 			[0x1c] = 0xaa, [0x1d] = 0x55,
10384 			[0x1e] = 0xbb, [0x1f] = 0x66,
10385 			[0x20] = 0xcc, [0x21] = 0x77,
10386 			[0x22] = 0xdd, [0x23] = 0x88,
10387 		},
10388 		{ {0x40, 0xbb66 } },
10389 	},
10390 	{
10391 		"LD_IND halfword unaligned",
10392 		.u.insns = {
10393 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
10394 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
10395 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10396 		},
10397 		CLASSIC,
10398 		{
10399 			[0x1c] = 0xaa, [0x1d] = 0x55,
10400 			[0x1e] = 0xbb, [0x1f] = 0x66,
10401 			[0x20] = 0xcc, [0x21] = 0x77,
10402 			[0x22] = 0xdd, [0x23] = 0x88,
10403 		},
10404 		{ {0x40, 0x66cc } },
10405 	},
10406 	{
10407 		"LD_IND halfword positive offset, all ff",
10408 		.u.insns = {
10409 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3d),
10410 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1),
10411 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10412 		},
10413 		CLASSIC,
10414 		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
10415 		{ {0x40, 0xffff } },
10416 	},
10417 	{
10418 		"LD_IND halfword positive offset, out of bounds",
10419 		.u.insns = {
10420 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10421 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1),
10422 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10423 		},
10424 		CLASSIC,
10425 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10426 		{ {0x3f, 0 }, },
10427 	},
10428 	{
10429 		"LD_IND halfword negative offset, out of bounds",
10430 		.u.insns = {
10431 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10432 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x3f),
10433 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10434 		},
10435 		CLASSIC,
10436 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10437 		{ {0x3f, 0 } },
10438 	},
10439 	{
10440 		"LD_IND word positive offset",
10441 		.u.insns = {
10442 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
10443 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x4),
10444 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10445 		},
10446 		CLASSIC,
10447 		{
10448 			[0x1c] = 0xaa, [0x1d] = 0x55,
10449 			[0x1e] = 0xbb, [0x1f] = 0x66,
10450 			[0x20] = 0xcc, [0x21] = 0x77,
10451 			[0x22] = 0xdd, [0x23] = 0x88,
10452 			[0x24] = 0xee, [0x25] = 0x99,
10453 			[0x26] = 0xff, [0x27] = 0xaa,
10454 		},
10455 		{ {0x40, 0xee99ffaa } },
10456 	},
10457 	{
10458 		"LD_IND word negative offset",
10459 		.u.insns = {
10460 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
10461 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x4),
10462 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10463 		},
10464 		CLASSIC,
10465 		{
10466 			[0x1c] = 0xaa, [0x1d] = 0x55,
10467 			[0x1e] = 0xbb, [0x1f] = 0x66,
10468 			[0x20] = 0xcc, [0x21] = 0x77,
10469 			[0x22] = 0xdd, [0x23] = 0x88,
10470 			[0x24] = 0xee, [0x25] = 0x99,
10471 			[0x26] = 0xff, [0x27] = 0xaa,
10472 		},
10473 		{ {0x40, 0xaa55bb66 } },
10474 	},
10475 	{
10476 		"LD_IND word unaligned (addr & 3 == 2)",
10477 		.u.insns = {
10478 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
10479 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
10480 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10481 		},
10482 		CLASSIC,
10483 		{
10484 			[0x1c] = 0xaa, [0x1d] = 0x55,
10485 			[0x1e] = 0xbb, [0x1f] = 0x66,
10486 			[0x20] = 0xcc, [0x21] = 0x77,
10487 			[0x22] = 0xdd, [0x23] = 0x88,
10488 			[0x24] = 0xee, [0x25] = 0x99,
10489 			[0x26] = 0xff, [0x27] = 0xaa,
10490 		},
10491 		{ {0x40, 0xbb66cc77 } },
10492 	},
10493 	{
10494 		"LD_IND word unaligned (addr & 3 == 1)",
10495 		.u.insns = {
10496 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
10497 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3),
10498 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10499 		},
10500 		CLASSIC,
10501 		{
10502 			[0x1c] = 0xaa, [0x1d] = 0x55,
10503 			[0x1e] = 0xbb, [0x1f] = 0x66,
10504 			[0x20] = 0xcc, [0x21] = 0x77,
10505 			[0x22] = 0xdd, [0x23] = 0x88,
10506 			[0x24] = 0xee, [0x25] = 0x99,
10507 			[0x26] = 0xff, [0x27] = 0xaa,
10508 		},
10509 		{ {0x40, 0x55bb66cc } },
10510 	},
10511 	{
10512 		"LD_IND word unaligned (addr & 3 == 3)",
10513 		.u.insns = {
10514 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
10515 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x1),
10516 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10517 		},
10518 		CLASSIC,
10519 		{
10520 			[0x1c] = 0xaa, [0x1d] = 0x55,
10521 			[0x1e] = 0xbb, [0x1f] = 0x66,
10522 			[0x20] = 0xcc, [0x21] = 0x77,
10523 			[0x22] = 0xdd, [0x23] = 0x88,
10524 			[0x24] = 0xee, [0x25] = 0x99,
10525 			[0x26] = 0xff, [0x27] = 0xaa,
10526 		},
10527 		{ {0x40, 0x66cc77dd } },
10528 	},
10529 	{
10530 		"LD_IND word positive offset, all ff",
10531 		.u.insns = {
10532 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3b),
10533 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1),
10534 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10535 		},
10536 		CLASSIC,
10537 		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
10538 		{ {0x40, 0xffffffff } },
10539 	},
10540 	{
10541 		"LD_IND word positive offset, out of bounds",
10542 		.u.insns = {
10543 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10544 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1),
10545 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10546 		},
10547 		CLASSIC,
10548 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10549 		{ {0x3f, 0 }, },
10550 	},
10551 	{
10552 		"LD_IND word negative offset, out of bounds",
10553 		.u.insns = {
10554 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10555 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3f),
10556 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10557 		},
10558 		CLASSIC,
10559 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10560 		{ {0x3f, 0 } },
10561 	},
10562 	{
10563 		"LD_ABS byte",
10564 		.u.insns = {
10565 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x20),
10566 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10567 		},
10568 		CLASSIC,
10569 		{
10570 			[0x1c] = 0xaa, [0x1d] = 0x55,
10571 			[0x1e] = 0xbb, [0x1f] = 0x66,
10572 			[0x20] = 0xcc, [0x21] = 0x77,
10573 			[0x22] = 0xdd, [0x23] = 0x88,
10574 			[0x24] = 0xee, [0x25] = 0x99,
10575 			[0x26] = 0xff, [0x27] = 0xaa,
10576 		},
10577 		{ {0x40, 0xcc } },
10578 	},
10579 	{
10580 		"LD_ABS byte positive offset, all ff",
10581 		.u.insns = {
10582 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f),
10583 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10584 		},
10585 		CLASSIC,
10586 		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
10587 		{ {0x40, 0xff } },
10588 	},
10589 	{
10590 		"LD_ABS byte positive offset, out of bounds",
10591 		.u.insns = {
10592 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f),
10593 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10594 		},
10595 		CLASSIC,
10596 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10597 		{ {0x3f, 0 }, },
10598 	},
10599 	{
10600 		"LD_ABS byte negative offset, out of bounds load",
10601 		.u.insns = {
10602 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, -1),
10603 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10604 		},
10605 		CLASSIC | FLAG_EXPECTED_FAIL,
10606 		.expected_errcode = -EINVAL,
10607 	},
10608 	{
10609 		"LD_ABS byte negative offset, in bounds",
10610 		.u.insns = {
10611 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
10612 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10613 		},
10614 		CLASSIC,
10615 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10616 		{ {0x40, 0x82 }, },
10617 	},
10618 	{
10619 		"LD_ABS byte negative offset, out of bounds",
10620 		.u.insns = {
10621 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
10622 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10623 		},
10624 		CLASSIC,
10625 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10626 		{ {0x3f, 0 }, },
10627 	},
10628 	{
10629 		"LD_ABS byte negative offset, multiple calls",
10630 		.u.insns = {
10631 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3c),
10632 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3d),
10633 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3e),
10634 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
10635 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10636 		},
10637 		CLASSIC,
10638 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10639 		{ {0x40, 0x82 }, },
10640 	},
10641 	{
10642 		"LD_ABS halfword",
10643 		.u.insns = {
10644 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x22),
10645 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10646 		},
10647 		CLASSIC,
10648 		{
10649 			[0x1c] = 0xaa, [0x1d] = 0x55,
10650 			[0x1e] = 0xbb, [0x1f] = 0x66,
10651 			[0x20] = 0xcc, [0x21] = 0x77,
10652 			[0x22] = 0xdd, [0x23] = 0x88,
10653 			[0x24] = 0xee, [0x25] = 0x99,
10654 			[0x26] = 0xff, [0x27] = 0xaa,
10655 		},
10656 		{ {0x40, 0xdd88 } },
10657 	},
10658 	{
10659 		"LD_ABS halfword unaligned",
10660 		.u.insns = {
10661 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x25),
10662 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10663 		},
10664 		CLASSIC,
10665 		{
10666 			[0x1c] = 0xaa, [0x1d] = 0x55,
10667 			[0x1e] = 0xbb, [0x1f] = 0x66,
10668 			[0x20] = 0xcc, [0x21] = 0x77,
10669 			[0x22] = 0xdd, [0x23] = 0x88,
10670 			[0x24] = 0xee, [0x25] = 0x99,
10671 			[0x26] = 0xff, [0x27] = 0xaa,
10672 		},
10673 		{ {0x40, 0x99ff } },
10674 	},
10675 	{
10676 		"LD_ABS halfword positive offset, all ff",
10677 		.u.insns = {
10678 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3e),
10679 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10680 		},
10681 		CLASSIC,
10682 		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
10683 		{ {0x40, 0xffff } },
10684 	},
10685 	{
10686 		"LD_ABS halfword positive offset, out of bounds",
10687 		.u.insns = {
10688 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f),
10689 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10690 		},
10691 		CLASSIC,
10692 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10693 		{ {0x3f, 0 }, },
10694 	},
10695 	{
10696 		"LD_ABS halfword negative offset, out of bounds load",
10697 		.u.insns = {
10698 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, -1),
10699 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10700 		},
10701 		CLASSIC | FLAG_EXPECTED_FAIL,
10702 		.expected_errcode = -EINVAL,
10703 	},
10704 	{
10705 		"LD_ABS halfword negative offset, in bounds",
10706 		.u.insns = {
10707 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e),
10708 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10709 		},
10710 		CLASSIC,
10711 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10712 		{ {0x40, 0x1982 }, },
10713 	},
10714 	{
10715 		"LD_ABS halfword negative offset, out of bounds",
10716 		.u.insns = {
10717 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e),
10718 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10719 		},
10720 		CLASSIC,
10721 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10722 		{ {0x3f, 0 }, },
10723 	},
10724 	{
10725 		"LD_ABS word",
10726 		.u.insns = {
10727 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x1c),
10728 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10729 		},
10730 		CLASSIC,
10731 		{
10732 			[0x1c] = 0xaa, [0x1d] = 0x55,
10733 			[0x1e] = 0xbb, [0x1f] = 0x66,
10734 			[0x20] = 0xcc, [0x21] = 0x77,
10735 			[0x22] = 0xdd, [0x23] = 0x88,
10736 			[0x24] = 0xee, [0x25] = 0x99,
10737 			[0x26] = 0xff, [0x27] = 0xaa,
10738 		},
10739 		{ {0x40, 0xaa55bb66 } },
10740 	},
10741 	{
10742 		"LD_ABS word unaligned (addr & 3 == 2)",
10743 		.u.insns = {
10744 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x22),
10745 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10746 		},
10747 		CLASSIC,
10748 		{
10749 			[0x1c] = 0xaa, [0x1d] = 0x55,
10750 			[0x1e] = 0xbb, [0x1f] = 0x66,
10751 			[0x20] = 0xcc, [0x21] = 0x77,
10752 			[0x22] = 0xdd, [0x23] = 0x88,
10753 			[0x24] = 0xee, [0x25] = 0x99,
10754 			[0x26] = 0xff, [0x27] = 0xaa,
10755 		},
10756 		{ {0x40, 0xdd88ee99 } },
10757 	},
10758 	{
10759 		"LD_ABS word unaligned (addr & 3 == 1)",
10760 		.u.insns = {
10761 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x21),
10762 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10763 		},
10764 		CLASSIC,
10765 		{
10766 			[0x1c] = 0xaa, [0x1d] = 0x55,
10767 			[0x1e] = 0xbb, [0x1f] = 0x66,
10768 			[0x20] = 0xcc, [0x21] = 0x77,
10769 			[0x22] = 0xdd, [0x23] = 0x88,
10770 			[0x24] = 0xee, [0x25] = 0x99,
10771 			[0x26] = 0xff, [0x27] = 0xaa,
10772 		},
10773 		{ {0x40, 0x77dd88ee } },
10774 	},
10775 	{
10776 		"LD_ABS word unaligned (addr & 3 == 3)",
10777 		.u.insns = {
10778 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x23),
10779 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10780 		},
10781 		CLASSIC,
10782 		{
10783 			[0x1c] = 0xaa, [0x1d] = 0x55,
10784 			[0x1e] = 0xbb, [0x1f] = 0x66,
10785 			[0x20] = 0xcc, [0x21] = 0x77,
10786 			[0x22] = 0xdd, [0x23] = 0x88,
10787 			[0x24] = 0xee, [0x25] = 0x99,
10788 			[0x26] = 0xff, [0x27] = 0xaa,
10789 		},
10790 		{ {0x40, 0x88ee99ff } },
10791 	},
10792 	{
10793 		"LD_ABS word positive offset, all ff",
10794 		.u.insns = {
10795 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3c),
10796 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10797 		},
10798 		CLASSIC,
10799 		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
10800 		{ {0x40, 0xffffffff } },
10801 	},
10802 	{
10803 		"LD_ABS word positive offset, out of bounds",
10804 		.u.insns = {
10805 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3f),
10806 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10807 		},
10808 		CLASSIC,
10809 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10810 		{ {0x3f, 0 }, },
10811 	},
10812 	{
10813 		"LD_ABS word negative offset, out of bounds load",
10814 		.u.insns = {
10815 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, -1),
10816 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10817 		},
10818 		CLASSIC | FLAG_EXPECTED_FAIL,
10819 		.expected_errcode = -EINVAL,
10820 	},
10821 	{
10822 		"LD_ABS word negative offset, in bounds",
10823 		.u.insns = {
10824 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c),
10825 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10826 		},
10827 		CLASSIC,
10828 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10829 		{ {0x40, 0x25051982 }, },
10830 	},
10831 	{
10832 		"LD_ABS word negative offset, out of bounds",
10833 		.u.insns = {
10834 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c),
10835 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10836 		},
10837 		CLASSIC,
10838 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10839 		{ {0x3f, 0 }, },
10840 	},
10841 	{
10842 		"LDX_MSH standalone, preserved A",
10843 		.u.insns = {
10844 			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
10845 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
10846 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10847 		},
10848 		CLASSIC,
10849 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10850 		{ {0x40, 0xffeebbaa }, },
10851 	},
10852 	{
10853 		"LDX_MSH standalone, preserved A 2",
10854 		.u.insns = {
10855 			BPF_STMT(BPF_LD | BPF_IMM, 0x175e9d63),
10856 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
10857 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3d),
10858 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e),
10859 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3f),
10860 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10861 		},
10862 		CLASSIC,
10863 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10864 		{ {0x40, 0x175e9d63 }, },
10865 	},
10866 	{
10867 		"LDX_MSH standalone, test result 1",
10868 		.u.insns = {
10869 			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
10870 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
10871 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
10872 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10873 		},
10874 		CLASSIC,
10875 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10876 		{ {0x40, 0x14 }, },
10877 	},
10878 	{
10879 		"LDX_MSH standalone, test result 2",
10880 		.u.insns = {
10881 			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
10882 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e),
10883 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
10884 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10885 		},
10886 		CLASSIC,
10887 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10888 		{ {0x40, 0x24 }, },
10889 	},
10890 	{
10891 		"LDX_MSH standalone, negative offset",
10892 		.u.insns = {
10893 			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
10894 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, -1),
10895 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
10896 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10897 		},
10898 		CLASSIC,
10899 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10900 		{ {0x40, 0 }, },
10901 	},
10902 	{
10903 		"LDX_MSH standalone, negative offset 2",
10904 		.u.insns = {
10905 			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
10906 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, SKF_LL_OFF + 0x3e),
10907 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
10908 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10909 		},
10910 		CLASSIC,
10911 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10912 		{ {0x40, 0x24 }, },
10913 	},
10914 	{
10915 		"LDX_MSH standalone, out of bounds",
10916 		.u.insns = {
10917 			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
10918 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x40),
10919 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
10920 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10921 		},
10922 		CLASSIC,
10923 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10924 		{ {0x40, 0 }, },
10925 	},
10926 	/*
10927 	 * verify that the interpreter or JIT correctly sets A and X
10928 	 * to 0.
10929 	 */
10930 	{
10931 		"ADD default X",
10932 		.u.insns = {
10933 			/*
10934 			 * A = 0x42
10935 			 * A = A + X
10936 			 * ret A
10937 			 */
10938 			BPF_STMT(BPF_LD | BPF_IMM, 0x42),
10939 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
10940 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10941 		},
10942 		CLASSIC | FLAG_NO_DATA,
10943 		{},
10944 		{ {0x1, 0x42 } },
10945 	},
10946 	{
10947 		"ADD default A",
10948 		.u.insns = {
10949 			/*
10950 			 * A = A + 0x42
10951 			 * ret A
10952 			 */
10953 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0x42),
10954 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10955 		},
10956 		CLASSIC | FLAG_NO_DATA,
10957 		{},
10958 		{ {0x1, 0x42 } },
10959 	},
10960 	{
10961 		"SUB default X",
10962 		.u.insns = {
10963 			/*
10964 			 * A = 0x66
10965 			 * A = A - X
10966 			 * ret A
10967 			 */
10968 			BPF_STMT(BPF_LD | BPF_IMM, 0x66),
10969 			BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
10970 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10971 		},
10972 		CLASSIC | FLAG_NO_DATA,
10973 		{},
10974 		{ {0x1, 0x66 } },
10975 	},
10976 	{
10977 		"SUB default A",
10978 		.u.insns = {
10979 			/*
10980 			 * A = A - -0x66
10981 			 * ret A
10982 			 */
10983 			BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, -0x66),
10984 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10985 		},
10986 		CLASSIC | FLAG_NO_DATA,
10987 		{},
10988 		{ {0x1, 0x66 } },
10989 	},
10990 	{
10991 		"MUL default X",
10992 		.u.insns = {
10993 			/*
10994 			 * A = 0x42
10995 			 * A = A * X
10996 			 * ret A
10997 			 */
10998 			BPF_STMT(BPF_LD | BPF_IMM, 0x42),
10999 			BPF_STMT(BPF_ALU | BPF_MUL | BPF_X, 0),
11000 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11001 		},
11002 		CLASSIC | FLAG_NO_DATA,
11003 		{},
11004 		{ {0x1, 0x0 } },
11005 	},
11006 	{
11007 		"MUL default A",
11008 		.u.insns = {
11009 			/*
11010 			 * A = A * 0x66
11011 			 * ret A
11012 			 */
11013 			BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 0x66),
11014 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11015 		},
11016 		CLASSIC | FLAG_NO_DATA,
11017 		{},
11018 		{ {0x1, 0x0 } },
11019 	},
11020 	{
11021 		"DIV default X",
11022 		.u.insns = {
11023 			/*
11024 			 * A = 0x42
11025 			 * A = A / X ; this halt the filter execution if X is 0
11026 			 * ret 0x42
11027 			 */
11028 			BPF_STMT(BPF_LD | BPF_IMM, 0x42),
11029 			BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
11030 			BPF_STMT(BPF_RET | BPF_K, 0x42),
11031 		},
11032 		CLASSIC | FLAG_NO_DATA,
11033 		{},
11034 		{ {0x1, 0x0 } },
11035 	},
11036 	{
11037 		"DIV default A",
11038 		.u.insns = {
11039 			/*
11040 			 * A = A / 1
11041 			 * ret A
11042 			 */
11043 			BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x1),
11044 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11045 		},
11046 		CLASSIC | FLAG_NO_DATA,
11047 		{},
11048 		{ {0x1, 0x0 } },
11049 	},
11050 	{
11051 		"MOD default X",
11052 		.u.insns = {
11053 			/*
11054 			 * A = 0x42
11055 			 * A = A mod X ; this halt the filter execution if X is 0
11056 			 * ret 0x42
11057 			 */
11058 			BPF_STMT(BPF_LD | BPF_IMM, 0x42),
11059 			BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
11060 			BPF_STMT(BPF_RET | BPF_K, 0x42),
11061 		},
11062 		CLASSIC | FLAG_NO_DATA,
11063 		{},
11064 		{ {0x1, 0x0 } },
11065 	},
11066 	{
11067 		"MOD default A",
11068 		.u.insns = {
11069 			/*
11070 			 * A = A mod 1
11071 			 * ret A
11072 			 */
11073 			BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x1),
11074 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11075 		},
11076 		CLASSIC | FLAG_NO_DATA,
11077 		{},
11078 		{ {0x1, 0x0 } },
11079 	},
11080 	{
11081 		"JMP EQ default A",
11082 		.u.insns = {
11083 			/*
11084 			 * cmp A, 0x0, 0, 1
11085 			 * ret 0x42
11086 			 * ret 0x66
11087 			 */
11088 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0, 0, 1),
11089 			BPF_STMT(BPF_RET | BPF_K, 0x42),
11090 			BPF_STMT(BPF_RET | BPF_K, 0x66),
11091 		},
11092 		CLASSIC | FLAG_NO_DATA,
11093 		{},
11094 		{ {0x1, 0x42 } },
11095 	},
11096 	{
11097 		"JMP EQ default X",
11098 		.u.insns = {
11099 			/*
11100 			 * A = 0x0
11101 			 * cmp A, X, 0, 1
11102 			 * ret 0x42
11103 			 * ret 0x66
11104 			 */
11105 			BPF_STMT(BPF_LD | BPF_IMM, 0x0),
11106 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0x0, 0, 1),
11107 			BPF_STMT(BPF_RET | BPF_K, 0x42),
11108 			BPF_STMT(BPF_RET | BPF_K, 0x66),
11109 		},
11110 		CLASSIC | FLAG_NO_DATA,
11111 		{},
11112 		{ {0x1, 0x42 } },
11113 	},
11114 	/* Checking interpreter vs JIT wrt signed extended imms. */
11115 	{
11116 		"JNE signed compare, test 1",
11117 		.u.insns_int = {
11118 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
11119 			BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
11120 			BPF_MOV64_REG(R2, R1),
11121 			BPF_ALU64_REG(BPF_AND, R2, R3),
11122 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
11123 			BPF_JMP_IMM(BPF_JNE, R2, -17104896, 1),
11124 			BPF_ALU32_IMM(BPF_MOV, R0, 2),
11125 			BPF_EXIT_INSN(),
11126 		},
11127 		INTERNAL,
11128 		{ },
11129 		{ { 0, 1 } },
11130 	},
11131 	{
11132 		"JNE signed compare, test 2",
11133 		.u.insns_int = {
11134 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
11135 			BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
11136 			BPF_MOV64_REG(R2, R1),
11137 			BPF_ALU64_REG(BPF_AND, R2, R3),
11138 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
11139 			BPF_JMP_IMM(BPF_JNE, R2, 0xfefb0000, 1),
11140 			BPF_ALU32_IMM(BPF_MOV, R0, 2),
11141 			BPF_EXIT_INSN(),
11142 		},
11143 		INTERNAL,
11144 		{ },
11145 		{ { 0, 1 } },
11146 	},
11147 	{
11148 		"JNE signed compare, test 3",
11149 		.u.insns_int = {
11150 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
11151 			BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
11152 			BPF_ALU32_IMM(BPF_MOV, R4, 0xfefb0000),
11153 			BPF_MOV64_REG(R2, R1),
11154 			BPF_ALU64_REG(BPF_AND, R2, R3),
11155 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
11156 			BPF_JMP_REG(BPF_JNE, R2, R4, 1),
11157 			BPF_ALU32_IMM(BPF_MOV, R0, 2),
11158 			BPF_EXIT_INSN(),
11159 		},
11160 		INTERNAL,
11161 		{ },
11162 		{ { 0, 2 } },
11163 	},
11164 	{
11165 		"JNE signed compare, test 4",
11166 		.u.insns_int = {
11167 			BPF_LD_IMM64(R1, -17104896),
11168 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
11169 			BPF_JMP_IMM(BPF_JNE, R1, -17104896, 1),
11170 			BPF_ALU32_IMM(BPF_MOV, R0, 2),
11171 			BPF_EXIT_INSN(),
11172 		},
11173 		INTERNAL,
11174 		{ },
11175 		{ { 0, 2 } },
11176 	},
11177 	{
11178 		"JNE signed compare, test 5",
11179 		.u.insns_int = {
11180 			BPF_LD_IMM64(R1, 0xfefb0000),
11181 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
11182 			BPF_JMP_IMM(BPF_JNE, R1, 0xfefb0000, 1),
11183 			BPF_ALU32_IMM(BPF_MOV, R0, 2),
11184 			BPF_EXIT_INSN(),
11185 		},
11186 		INTERNAL,
11187 		{ },
11188 		{ { 0, 1 } },
11189 	},
11190 	{
11191 		"JNE signed compare, test 6",
11192 		.u.insns_int = {
11193 			BPF_LD_IMM64(R1, 0x7efb0000),
11194 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
11195 			BPF_JMP_IMM(BPF_JNE, R1, 0x7efb0000, 1),
11196 			BPF_ALU32_IMM(BPF_MOV, R0, 2),
11197 			BPF_EXIT_INSN(),
11198 		},
11199 		INTERNAL,
11200 		{ },
11201 		{ { 0, 2 } },
11202 	},
11203 	{
11204 		"JNE signed compare, test 7",
11205 		.u.insns = {
11206 			BPF_STMT(BPF_LD | BPF_IMM, 0xffff0000),
11207 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
11208 			BPF_STMT(BPF_LD | BPF_IMM, 0xfefbbc12),
11209 			BPF_STMT(BPF_ALU | BPF_AND | BPF_X, 0),
11210 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0xfefb0000, 1, 0),
11211 			BPF_STMT(BPF_RET | BPF_K, 1),
11212 			BPF_STMT(BPF_RET | BPF_K, 2),
11213 		},
11214 		CLASSIC | FLAG_NO_DATA,
11215 		{},
11216 		{ { 0, 2 } },
11217 	},
11218 	/* BPF_LDX_MEM with operand aliasing */
11219 	{
11220 		"LDX_MEM_B: operand register aliasing",
11221 		.u.insns_int = {
11222 			BPF_ST_MEM(BPF_B, R10, -8, 123),
11223 			BPF_MOV64_REG(R0, R10),
11224 			BPF_LDX_MEM(BPF_B, R0, R0, -8),
11225 			BPF_EXIT_INSN(),
11226 		},
11227 		INTERNAL,
11228 		{ },
11229 		{ { 0, 123 } },
11230 		.stack_depth = 8,
11231 	},
11232 	{
11233 		"LDX_MEM_H: operand register aliasing",
11234 		.u.insns_int = {
11235 			BPF_ST_MEM(BPF_H, R10, -8, 12345),
11236 			BPF_MOV64_REG(R0, R10),
11237 			BPF_LDX_MEM(BPF_H, R0, R0, -8),
11238 			BPF_EXIT_INSN(),
11239 		},
11240 		INTERNAL,
11241 		{ },
11242 		{ { 0, 12345 } },
11243 		.stack_depth = 8,
11244 	},
11245 	{
11246 		"LDX_MEM_W: operand register aliasing",
11247 		.u.insns_int = {
11248 			BPF_ST_MEM(BPF_W, R10, -8, 123456789),
11249 			BPF_MOV64_REG(R0, R10),
11250 			BPF_LDX_MEM(BPF_W, R0, R0, -8),
11251 			BPF_EXIT_INSN(),
11252 		},
11253 		INTERNAL,
11254 		{ },
11255 		{ { 0, 123456789 } },
11256 		.stack_depth = 8,
11257 	},
11258 	{
11259 		"LDX_MEM_DW: operand register aliasing",
11260 		.u.insns_int = {
11261 			BPF_LD_IMM64(R1, 0x123456789abcdefULL),
11262 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
11263 			BPF_MOV64_REG(R0, R10),
11264 			BPF_LDX_MEM(BPF_DW, R0, R0, -8),
11265 			BPF_ALU64_REG(BPF_SUB, R0, R1),
11266 			BPF_MOV64_REG(R1, R0),
11267 			BPF_ALU64_IMM(BPF_RSH, R1, 32),
11268 			BPF_ALU64_REG(BPF_OR, R0, R1),
11269 			BPF_EXIT_INSN(),
11270 		},
11271 		INTERNAL,
11272 		{ },
11273 		{ { 0, 0 } },
11274 		.stack_depth = 8,
11275 	},
11276 	/*
11277 	 * Register (non-)clobbering tests for the case where a JIT implements
11278 	 * complex ALU or ATOMIC operations via function calls. If so, the
11279 	 * function call must be transparent to the eBPF registers. The JIT
11280 	 * must therefore save and restore relevant registers across the call.
11281 	 * The following tests check that the eBPF registers retain their
11282 	 * values after such an operation. Mainly intended for complex ALU
11283 	 * and atomic operation, but we run it for all. You never know...
11284 	 *
11285 	 * Note that each operations should be tested twice with different
11286 	 * destinations, to check preservation for all registers.
11287 	 */
11288 #define BPF_TEST_CLOBBER_ALU(alu, op, dst, src)			\
11289 	{							\
11290 		#alu "_" #op " to " #dst ": no clobbering",	\
11291 		.u.insns_int = {				\
11292 			BPF_ALU64_IMM(BPF_MOV, R0, R0),		\
11293 			BPF_ALU64_IMM(BPF_MOV, R1, R1),		\
11294 			BPF_ALU64_IMM(BPF_MOV, R2, R2),		\
11295 			BPF_ALU64_IMM(BPF_MOV, R3, R3),		\
11296 			BPF_ALU64_IMM(BPF_MOV, R4, R4),		\
11297 			BPF_ALU64_IMM(BPF_MOV, R5, R5),		\
11298 			BPF_ALU64_IMM(BPF_MOV, R6, R6),		\
11299 			BPF_ALU64_IMM(BPF_MOV, R7, R7),		\
11300 			BPF_ALU64_IMM(BPF_MOV, R8, R8),		\
11301 			BPF_ALU64_IMM(BPF_MOV, R9, R9),		\
11302 			BPF_##alu(BPF_ ##op, dst, src),		\
11303 			BPF_ALU32_IMM(BPF_MOV, dst, dst),	\
11304 			BPF_JMP_IMM(BPF_JNE, R0, R0, 10),	\
11305 			BPF_JMP_IMM(BPF_JNE, R1, R1, 9),	\
11306 			BPF_JMP_IMM(BPF_JNE, R2, R2, 8),	\
11307 			BPF_JMP_IMM(BPF_JNE, R3, R3, 7),	\
11308 			BPF_JMP_IMM(BPF_JNE, R4, R4, 6),	\
11309 			BPF_JMP_IMM(BPF_JNE, R5, R5, 5),	\
11310 			BPF_JMP_IMM(BPF_JNE, R6, R6, 4),	\
11311 			BPF_JMP_IMM(BPF_JNE, R7, R7, 3),	\
11312 			BPF_JMP_IMM(BPF_JNE, R8, R8, 2),	\
11313 			BPF_JMP_IMM(BPF_JNE, R9, R9, 1),	\
11314 			BPF_ALU64_IMM(BPF_MOV, R0, 1),		\
11315 			BPF_EXIT_INSN(),			\
11316 		},						\
11317 		INTERNAL,					\
11318 		{ },						\
11319 		{ { 0, 1 } }					\
11320 	}
11321 	/* ALU64 operations, register clobbering */
11322 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, AND, R8, 123456789),
11323 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, AND, R9, 123456789),
11324 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, OR, R8, 123456789),
11325 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, OR, R9, 123456789),
11326 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, XOR, R8, 123456789),
11327 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, XOR, R9, 123456789),
11328 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, LSH, R8, 12),
11329 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, LSH, R9, 12),
11330 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, RSH, R8, 12),
11331 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, RSH, R9, 12),
11332 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, ARSH, R8, 12),
11333 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, ARSH, R9, 12),
11334 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, ADD, R8, 123456789),
11335 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, ADD, R9, 123456789),
11336 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, SUB, R8, 123456789),
11337 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, SUB, R9, 123456789),
11338 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, MUL, R8, 123456789),
11339 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, MUL, R9, 123456789),
11340 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, DIV, R8, 123456789),
11341 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, DIV, R9, 123456789),
11342 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, MOD, R8, 123456789),
11343 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, MOD, R9, 123456789),
11344 	/* ALU32 immediate operations, register clobbering */
11345 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, AND, R8, 123456789),
11346 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, AND, R9, 123456789),
11347 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, OR, R8, 123456789),
11348 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, OR, R9, 123456789),
11349 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, XOR, R8, 123456789),
11350 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, XOR, R9, 123456789),
11351 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, LSH, R8, 12),
11352 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, LSH, R9, 12),
11353 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, RSH, R8, 12),
11354 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, RSH, R9, 12),
11355 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, ARSH, R8, 12),
11356 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, ARSH, R9, 12),
11357 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, ADD, R8, 123456789),
11358 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, ADD, R9, 123456789),
11359 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, SUB, R8, 123456789),
11360 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, SUB, R9, 123456789),
11361 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, MUL, R8, 123456789),
11362 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, MUL, R9, 123456789),
11363 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, DIV, R8, 123456789),
11364 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, DIV, R9, 123456789),
11365 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, MOD, R8, 123456789),
11366 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, MOD, R9, 123456789),
11367 	/* ALU64 register operations, register clobbering */
11368 	BPF_TEST_CLOBBER_ALU(ALU64_REG, AND, R8, R1),
11369 	BPF_TEST_CLOBBER_ALU(ALU64_REG, AND, R9, R1),
11370 	BPF_TEST_CLOBBER_ALU(ALU64_REG, OR, R8, R1),
11371 	BPF_TEST_CLOBBER_ALU(ALU64_REG, OR, R9, R1),
11372 	BPF_TEST_CLOBBER_ALU(ALU64_REG, XOR, R8, R1),
11373 	BPF_TEST_CLOBBER_ALU(ALU64_REG, XOR, R9, R1),
11374 	BPF_TEST_CLOBBER_ALU(ALU64_REG, LSH, R8, R1),
11375 	BPF_TEST_CLOBBER_ALU(ALU64_REG, LSH, R9, R1),
11376 	BPF_TEST_CLOBBER_ALU(ALU64_REG, RSH, R8, R1),
11377 	BPF_TEST_CLOBBER_ALU(ALU64_REG, RSH, R9, R1),
11378 	BPF_TEST_CLOBBER_ALU(ALU64_REG, ARSH, R8, R1),
11379 	BPF_TEST_CLOBBER_ALU(ALU64_REG, ARSH, R9, R1),
11380 	BPF_TEST_CLOBBER_ALU(ALU64_REG, ADD, R8, R1),
11381 	BPF_TEST_CLOBBER_ALU(ALU64_REG, ADD, R9, R1),
11382 	BPF_TEST_CLOBBER_ALU(ALU64_REG, SUB, R8, R1),
11383 	BPF_TEST_CLOBBER_ALU(ALU64_REG, SUB, R9, R1),
11384 	BPF_TEST_CLOBBER_ALU(ALU64_REG, MUL, R8, R1),
11385 	BPF_TEST_CLOBBER_ALU(ALU64_REG, MUL, R9, R1),
11386 	BPF_TEST_CLOBBER_ALU(ALU64_REG, DIV, R8, R1),
11387 	BPF_TEST_CLOBBER_ALU(ALU64_REG, DIV, R9, R1),
11388 	BPF_TEST_CLOBBER_ALU(ALU64_REG, MOD, R8, R1),
11389 	BPF_TEST_CLOBBER_ALU(ALU64_REG, MOD, R9, R1),
11390 	/* ALU32 register operations, register clobbering */
11391 	BPF_TEST_CLOBBER_ALU(ALU32_REG, AND, R8, R1),
11392 	BPF_TEST_CLOBBER_ALU(ALU32_REG, AND, R9, R1),
11393 	BPF_TEST_CLOBBER_ALU(ALU32_REG, OR, R8, R1),
11394 	BPF_TEST_CLOBBER_ALU(ALU32_REG, OR, R9, R1),
11395 	BPF_TEST_CLOBBER_ALU(ALU32_REG, XOR, R8, R1),
11396 	BPF_TEST_CLOBBER_ALU(ALU32_REG, XOR, R9, R1),
11397 	BPF_TEST_CLOBBER_ALU(ALU32_REG, LSH, R8, R1),
11398 	BPF_TEST_CLOBBER_ALU(ALU32_REG, LSH, R9, R1),
11399 	BPF_TEST_CLOBBER_ALU(ALU32_REG, RSH, R8, R1),
11400 	BPF_TEST_CLOBBER_ALU(ALU32_REG, RSH, R9, R1),
11401 	BPF_TEST_CLOBBER_ALU(ALU32_REG, ARSH, R8, R1),
11402 	BPF_TEST_CLOBBER_ALU(ALU32_REG, ARSH, R9, R1),
11403 	BPF_TEST_CLOBBER_ALU(ALU32_REG, ADD, R8, R1),
11404 	BPF_TEST_CLOBBER_ALU(ALU32_REG, ADD, R9, R1),
11405 	BPF_TEST_CLOBBER_ALU(ALU32_REG, SUB, R8, R1),
11406 	BPF_TEST_CLOBBER_ALU(ALU32_REG, SUB, R9, R1),
11407 	BPF_TEST_CLOBBER_ALU(ALU32_REG, MUL, R8, R1),
11408 	BPF_TEST_CLOBBER_ALU(ALU32_REG, MUL, R9, R1),
11409 	BPF_TEST_CLOBBER_ALU(ALU32_REG, DIV, R8, R1),
11410 	BPF_TEST_CLOBBER_ALU(ALU32_REG, DIV, R9, R1),
11411 	BPF_TEST_CLOBBER_ALU(ALU32_REG, MOD, R8, R1),
11412 	BPF_TEST_CLOBBER_ALU(ALU32_REG, MOD, R9, R1),
11413 #undef BPF_TEST_CLOBBER_ALU
11414 #define BPF_TEST_CLOBBER_ATOMIC(width, op)			\
11415 	{							\
11416 		"Atomic_" #width " " #op ": no clobbering",	\
11417 		.u.insns_int = {				\
11418 			BPF_ALU64_IMM(BPF_MOV, R0, 0),		\
11419 			BPF_ALU64_IMM(BPF_MOV, R1, 1),		\
11420 			BPF_ALU64_IMM(BPF_MOV, R2, 2),		\
11421 			BPF_ALU64_IMM(BPF_MOV, R3, 3),		\
11422 			BPF_ALU64_IMM(BPF_MOV, R4, 4),		\
11423 			BPF_ALU64_IMM(BPF_MOV, R5, 5),		\
11424 			BPF_ALU64_IMM(BPF_MOV, R6, 6),		\
11425 			BPF_ALU64_IMM(BPF_MOV, R7, 7),		\
11426 			BPF_ALU64_IMM(BPF_MOV, R8, 8),		\
11427 			BPF_ALU64_IMM(BPF_MOV, R9, 9),		\
11428 			BPF_ST_MEM(width, R10, -8,		\
11429 				   (op) == BPF_CMPXCHG ? 0 :	\
11430 				   (op) & BPF_FETCH ? 1 : 0),	\
11431 			BPF_ATOMIC_OP(width, op, R10, R1, -8),	\
11432 			BPF_JMP_IMM(BPF_JNE, R0, 0, 10),	\
11433 			BPF_JMP_IMM(BPF_JNE, R1, 1, 9),		\
11434 			BPF_JMP_IMM(BPF_JNE, R2, 2, 8),		\
11435 			BPF_JMP_IMM(BPF_JNE, R3, 3, 7),		\
11436 			BPF_JMP_IMM(BPF_JNE, R4, 4, 6),		\
11437 			BPF_JMP_IMM(BPF_JNE, R5, 5, 5),		\
11438 			BPF_JMP_IMM(BPF_JNE, R6, 6, 4),		\
11439 			BPF_JMP_IMM(BPF_JNE, R7, 7, 3),		\
11440 			BPF_JMP_IMM(BPF_JNE, R8, 8, 2),		\
11441 			BPF_JMP_IMM(BPF_JNE, R9, 9, 1),		\
11442 			BPF_ALU64_IMM(BPF_MOV, R0, 1),		\
11443 			BPF_EXIT_INSN(),			\
11444 		},						\
11445 		INTERNAL,					\
11446 		{ },						\
11447 		{ { 0, 1 } },					\
11448 		.stack_depth = 8,				\
11449 	}
11450 	/* 64-bit atomic operations, register clobbering */
11451 	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_ADD),
11452 	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_AND),
11453 	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_OR),
11454 	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_XOR),
11455 	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_ADD | BPF_FETCH),
11456 	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_AND | BPF_FETCH),
11457 	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_OR | BPF_FETCH),
11458 	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_XOR | BPF_FETCH),
11459 	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_XCHG),
11460 	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_CMPXCHG),
11461 	/* 32-bit atomic operations, register clobbering */
11462 	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_ADD),
11463 	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_AND),
11464 	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_OR),
11465 	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_XOR),
11466 	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_ADD | BPF_FETCH),
11467 	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_AND | BPF_FETCH),
11468 	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_OR | BPF_FETCH),
11469 	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_XOR | BPF_FETCH),
11470 	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_XCHG),
11471 	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_CMPXCHG),
11472 #undef BPF_TEST_CLOBBER_ATOMIC
11473 	/* Checking that ALU32 src is not zero extended in place */
11474 #define BPF_ALU32_SRC_ZEXT(op)					\
11475 	{							\
11476 		"ALU32_" #op "_X: src preserved in zext",	\
11477 		.u.insns_int = {				\
11478 			BPF_LD_IMM64(R1, 0x0123456789acbdefULL),\
11479 			BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),\
11480 			BPF_ALU64_REG(BPF_MOV, R0, R1),		\
11481 			BPF_ALU32_REG(BPF_##op, R2, R1),	\
11482 			BPF_ALU64_REG(BPF_SUB, R0, R1),		\
11483 			BPF_ALU64_REG(BPF_MOV, R1, R0),		\
11484 			BPF_ALU64_IMM(BPF_RSH, R1, 32),		\
11485 			BPF_ALU64_REG(BPF_OR, R0, R1),		\
11486 			BPF_EXIT_INSN(),			\
11487 		},						\
11488 		INTERNAL,					\
11489 		{ },						\
11490 		{ { 0, 0 } },					\
11491 	}
11492 	BPF_ALU32_SRC_ZEXT(MOV),
11493 	BPF_ALU32_SRC_ZEXT(AND),
11494 	BPF_ALU32_SRC_ZEXT(OR),
11495 	BPF_ALU32_SRC_ZEXT(XOR),
11496 	BPF_ALU32_SRC_ZEXT(ADD),
11497 	BPF_ALU32_SRC_ZEXT(SUB),
11498 	BPF_ALU32_SRC_ZEXT(MUL),
11499 	BPF_ALU32_SRC_ZEXT(DIV),
11500 	BPF_ALU32_SRC_ZEXT(MOD),
11501 #undef BPF_ALU32_SRC_ZEXT
11502 	/* Checking that ATOMIC32 src is not zero extended in place */
11503 #define BPF_ATOMIC32_SRC_ZEXT(op)					\
11504 	{								\
11505 		"ATOMIC_W_" #op ": src preserved in zext",		\
11506 		.u.insns_int = {					\
11507 			BPF_LD_IMM64(R0, 0x0123456789acbdefULL),	\
11508 			BPF_ALU64_REG(BPF_MOV, R1, R0),			\
11509 			BPF_ST_MEM(BPF_W, R10, -4, 0),			\
11510 			BPF_ATOMIC_OP(BPF_W, BPF_##op, R10, R1, -4),	\
11511 			BPF_ALU64_REG(BPF_SUB, R0, R1),			\
11512 			BPF_ALU64_REG(BPF_MOV, R1, R0),			\
11513 			BPF_ALU64_IMM(BPF_RSH, R1, 32),			\
11514 			BPF_ALU64_REG(BPF_OR, R0, R1),			\
11515 			BPF_EXIT_INSN(),				\
11516 		},							\
11517 		INTERNAL,						\
11518 		{ },							\
11519 		{ { 0, 0 } },						\
11520 		.stack_depth = 8,					\
11521 	}
11522 	BPF_ATOMIC32_SRC_ZEXT(ADD),
11523 	BPF_ATOMIC32_SRC_ZEXT(AND),
11524 	BPF_ATOMIC32_SRC_ZEXT(OR),
11525 	BPF_ATOMIC32_SRC_ZEXT(XOR),
11526 #undef BPF_ATOMIC32_SRC_ZEXT
11527 	/* Checking that CMPXCHG32 src is not zero extended in place */
11528 	{
11529 		"ATOMIC_W_CMPXCHG: src preserved in zext",
11530 		.u.insns_int = {
11531 			BPF_LD_IMM64(R1, 0x0123456789acbdefULL),
11532 			BPF_ALU64_REG(BPF_MOV, R2, R1),
11533 			BPF_ALU64_REG(BPF_MOV, R0, 0),
11534 			BPF_ST_MEM(BPF_W, R10, -4, 0),
11535 			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R1, -4),
11536 			BPF_ALU64_REG(BPF_SUB, R1, R2),
11537 			BPF_ALU64_REG(BPF_MOV, R2, R1),
11538 			BPF_ALU64_IMM(BPF_RSH, R2, 32),
11539 			BPF_ALU64_REG(BPF_OR, R1, R2),
11540 			BPF_ALU64_REG(BPF_MOV, R0, R1),
11541 			BPF_EXIT_INSN(),
11542 		},
11543 		INTERNAL,
11544 		{ },
11545 		{ { 0, 0 } },
11546 		.stack_depth = 8,
11547 	},
11548 	/* Checking that JMP32 immediate src is not zero extended in place */
11549 #define BPF_JMP32_IMM_ZEXT(op)					\
11550 	{							\
11551 		"JMP32_" #op "_K: operand preserved in zext",	\
11552 		.u.insns_int = {				\
11553 			BPF_LD_IMM64(R0, 0x0123456789acbdefULL),\
11554 			BPF_ALU64_REG(BPF_MOV, R1, R0),		\
11555 			BPF_JMP32_IMM(BPF_##op, R0, 1234, 1),	\
11556 			BPF_JMP_A(0), /* Nop */			\
11557 			BPF_ALU64_REG(BPF_SUB, R0, R1),		\
11558 			BPF_ALU64_REG(BPF_MOV, R1, R0),		\
11559 			BPF_ALU64_IMM(BPF_RSH, R1, 32),		\
11560 			BPF_ALU64_REG(BPF_OR, R0, R1),		\
11561 			BPF_EXIT_INSN(),			\
11562 		},						\
11563 		INTERNAL,					\
11564 		{ },						\
11565 		{ { 0, 0 } },					\
11566 	}
11567 	BPF_JMP32_IMM_ZEXT(JEQ),
11568 	BPF_JMP32_IMM_ZEXT(JNE),
11569 	BPF_JMP32_IMM_ZEXT(JSET),
11570 	BPF_JMP32_IMM_ZEXT(JGT),
11571 	BPF_JMP32_IMM_ZEXT(JGE),
11572 	BPF_JMP32_IMM_ZEXT(JLT),
11573 	BPF_JMP32_IMM_ZEXT(JLE),
11574 	BPF_JMP32_IMM_ZEXT(JSGT),
11575 	BPF_JMP32_IMM_ZEXT(JSGE),
11576 	BPF_JMP32_IMM_ZEXT(JSGT),
11577 	BPF_JMP32_IMM_ZEXT(JSLT),
11578 	BPF_JMP32_IMM_ZEXT(JSLE),
11579 #undef BPF_JMP2_IMM_ZEXT
11580 	/* Checking that JMP32 dst & src are not zero extended in place */
11581 #define BPF_JMP32_REG_ZEXT(op)					\
11582 	{							\
11583 		"JMP32_" #op "_X: operands preserved in zext",	\
11584 		.u.insns_int = {				\
11585 			BPF_LD_IMM64(R0, 0x0123456789acbdefULL),\
11586 			BPF_LD_IMM64(R1, 0xfedcba9876543210ULL),\
11587 			BPF_ALU64_REG(BPF_MOV, R2, R0),		\
11588 			BPF_ALU64_REG(BPF_MOV, R3, R1),		\
11589 			BPF_JMP32_IMM(BPF_##op, R0, R1, 1),	\
11590 			BPF_JMP_A(0), /* Nop */			\
11591 			BPF_ALU64_REG(BPF_SUB, R0, R2),		\
11592 			BPF_ALU64_REG(BPF_SUB, R1, R3),		\
11593 			BPF_ALU64_REG(BPF_OR, R0, R1),		\
11594 			BPF_ALU64_REG(BPF_MOV, R1, R0),		\
11595 			BPF_ALU64_IMM(BPF_RSH, R1, 32),		\
11596 			BPF_ALU64_REG(BPF_OR, R0, R1),		\
11597 			BPF_EXIT_INSN(),			\
11598 		},						\
11599 		INTERNAL,					\
11600 		{ },						\
11601 		{ { 0, 0 } },					\
11602 	}
11603 	BPF_JMP32_REG_ZEXT(JEQ),
11604 	BPF_JMP32_REG_ZEXT(JNE),
11605 	BPF_JMP32_REG_ZEXT(JSET),
11606 	BPF_JMP32_REG_ZEXT(JGT),
11607 	BPF_JMP32_REG_ZEXT(JGE),
11608 	BPF_JMP32_REG_ZEXT(JLT),
11609 	BPF_JMP32_REG_ZEXT(JLE),
11610 	BPF_JMP32_REG_ZEXT(JSGT),
11611 	BPF_JMP32_REG_ZEXT(JSGE),
11612 	BPF_JMP32_REG_ZEXT(JSGT),
11613 	BPF_JMP32_REG_ZEXT(JSLT),
11614 	BPF_JMP32_REG_ZEXT(JSLE),
11615 #undef BPF_JMP2_REG_ZEXT
11616 	/* ALU64 K register combinations */
11617 	{
11618 		"ALU64_MOV_K: registers",
11619 		{ },
11620 		INTERNAL,
11621 		{ },
11622 		{ { 0, 1 } },
11623 		.fill_helper = bpf_fill_alu64_mov_imm_regs,
11624 	},
11625 	{
11626 		"ALU64_AND_K: registers",
11627 		{ },
11628 		INTERNAL,
11629 		{ },
11630 		{ { 0, 1 } },
11631 		.fill_helper = bpf_fill_alu64_and_imm_regs,
11632 	},
11633 	{
11634 		"ALU64_OR_K: registers",
11635 		{ },
11636 		INTERNAL,
11637 		{ },
11638 		{ { 0, 1 } },
11639 		.fill_helper = bpf_fill_alu64_or_imm_regs,
11640 	},
11641 	{
11642 		"ALU64_XOR_K: registers",
11643 		{ },
11644 		INTERNAL,
11645 		{ },
11646 		{ { 0, 1 } },
11647 		.fill_helper = bpf_fill_alu64_xor_imm_regs,
11648 	},
11649 	{
11650 		"ALU64_LSH_K: registers",
11651 		{ },
11652 		INTERNAL,
11653 		{ },
11654 		{ { 0, 1 } },
11655 		.fill_helper = bpf_fill_alu64_lsh_imm_regs,
11656 	},
11657 	{
11658 		"ALU64_RSH_K: registers",
11659 		{ },
11660 		INTERNAL,
11661 		{ },
11662 		{ { 0, 1 } },
11663 		.fill_helper = bpf_fill_alu64_rsh_imm_regs,
11664 	},
11665 	{
11666 		"ALU64_ARSH_K: registers",
11667 		{ },
11668 		INTERNAL,
11669 		{ },
11670 		{ { 0, 1 } },
11671 		.fill_helper = bpf_fill_alu64_arsh_imm_regs,
11672 	},
11673 	{
11674 		"ALU64_ADD_K: registers",
11675 		{ },
11676 		INTERNAL,
11677 		{ },
11678 		{ { 0, 1 } },
11679 		.fill_helper = bpf_fill_alu64_add_imm_regs,
11680 	},
11681 	{
11682 		"ALU64_SUB_K: registers",
11683 		{ },
11684 		INTERNAL,
11685 		{ },
11686 		{ { 0, 1 } },
11687 		.fill_helper = bpf_fill_alu64_sub_imm_regs,
11688 	},
11689 	{
11690 		"ALU64_MUL_K: registers",
11691 		{ },
11692 		INTERNAL,
11693 		{ },
11694 		{ { 0, 1 } },
11695 		.fill_helper = bpf_fill_alu64_mul_imm_regs,
11696 	},
11697 	{
11698 		"ALU64_DIV_K: registers",
11699 		{ },
11700 		INTERNAL,
11701 		{ },
11702 		{ { 0, 1 } },
11703 		.fill_helper = bpf_fill_alu64_div_imm_regs,
11704 	},
11705 	{
11706 		"ALU64_MOD_K: registers",
11707 		{ },
11708 		INTERNAL,
11709 		{ },
11710 		{ { 0, 1 } },
11711 		.fill_helper = bpf_fill_alu64_mod_imm_regs,
11712 	},
11713 	/* ALU32 K registers */
11714 	{
11715 		"ALU32_MOV_K: registers",
11716 		{ },
11717 		INTERNAL,
11718 		{ },
11719 		{ { 0, 1 } },
11720 		.fill_helper = bpf_fill_alu32_mov_imm_regs,
11721 	},
11722 	{
11723 		"ALU32_AND_K: registers",
11724 		{ },
11725 		INTERNAL,
11726 		{ },
11727 		{ { 0, 1 } },
11728 		.fill_helper = bpf_fill_alu32_and_imm_regs,
11729 	},
11730 	{
11731 		"ALU32_OR_K: registers",
11732 		{ },
11733 		INTERNAL,
11734 		{ },
11735 		{ { 0, 1 } },
11736 		.fill_helper = bpf_fill_alu32_or_imm_regs,
11737 	},
11738 	{
11739 		"ALU32_XOR_K: registers",
11740 		{ },
11741 		INTERNAL,
11742 		{ },
11743 		{ { 0, 1 } },
11744 		.fill_helper = bpf_fill_alu32_xor_imm_regs,
11745 	},
11746 	{
11747 		"ALU32_LSH_K: registers",
11748 		{ },
11749 		INTERNAL,
11750 		{ },
11751 		{ { 0, 1 } },
11752 		.fill_helper = bpf_fill_alu32_lsh_imm_regs,
11753 	},
11754 	{
11755 		"ALU32_RSH_K: registers",
11756 		{ },
11757 		INTERNAL,
11758 		{ },
11759 		{ { 0, 1 } },
11760 		.fill_helper = bpf_fill_alu32_rsh_imm_regs,
11761 	},
11762 	{
11763 		"ALU32_ARSH_K: registers",
11764 		{ },
11765 		INTERNAL,
11766 		{ },
11767 		{ { 0, 1 } },
11768 		.fill_helper = bpf_fill_alu32_arsh_imm_regs,
11769 	},
11770 	{
11771 		"ALU32_ADD_K: registers",
11772 		{ },
11773 		INTERNAL,
11774 		{ },
11775 		{ { 0, 1 } },
11776 		.fill_helper = bpf_fill_alu32_add_imm_regs,
11777 	},
11778 	{
11779 		"ALU32_SUB_K: registers",
11780 		{ },
11781 		INTERNAL,
11782 		{ },
11783 		{ { 0, 1 } },
11784 		.fill_helper = bpf_fill_alu32_sub_imm_regs,
11785 	},
11786 	{
11787 		"ALU32_MUL_K: registers",
11788 		{ },
11789 		INTERNAL,
11790 		{ },
11791 		{ { 0, 1 } },
11792 		.fill_helper = bpf_fill_alu32_mul_imm_regs,
11793 	},
11794 	{
11795 		"ALU32_DIV_K: registers",
11796 		{ },
11797 		INTERNAL,
11798 		{ },
11799 		{ { 0, 1 } },
11800 		.fill_helper = bpf_fill_alu32_div_imm_regs,
11801 	},
11802 	{
11803 		"ALU32_MOD_K: registers",
11804 		{ },
11805 		INTERNAL,
11806 		{ },
11807 		{ { 0, 1 } },
11808 		.fill_helper = bpf_fill_alu32_mod_imm_regs,
11809 	},
11810 	/* ALU64 X register combinations */
11811 	{
11812 		"ALU64_MOV_X: register combinations",
11813 		{ },
11814 		INTERNAL,
11815 		{ },
11816 		{ { 0, 1 } },
11817 		.fill_helper = bpf_fill_alu64_mov_reg_pairs,
11818 	},
11819 	{
11820 		"ALU64_AND_X: register combinations",
11821 		{ },
11822 		INTERNAL,
11823 		{ },
11824 		{ { 0, 1 } },
11825 		.fill_helper = bpf_fill_alu64_and_reg_pairs,
11826 	},
11827 	{
11828 		"ALU64_OR_X: register combinations",
11829 		{ },
11830 		INTERNAL,
11831 		{ },
11832 		{ { 0, 1 } },
11833 		.fill_helper = bpf_fill_alu64_or_reg_pairs,
11834 	},
11835 	{
11836 		"ALU64_XOR_X: register combinations",
11837 		{ },
11838 		INTERNAL,
11839 		{ },
11840 		{ { 0, 1 } },
11841 		.fill_helper = bpf_fill_alu64_xor_reg_pairs,
11842 	},
11843 	{
11844 		"ALU64_LSH_X: register combinations",
11845 		{ },
11846 		INTERNAL,
11847 		{ },
11848 		{ { 0, 1 } },
11849 		.fill_helper = bpf_fill_alu64_lsh_reg_pairs,
11850 	},
11851 	{
11852 		"ALU64_RSH_X: register combinations",
11853 		{ },
11854 		INTERNAL,
11855 		{ },
11856 		{ { 0, 1 } },
11857 		.fill_helper = bpf_fill_alu64_rsh_reg_pairs,
11858 	},
11859 	{
11860 		"ALU64_ARSH_X: register combinations",
11861 		{ },
11862 		INTERNAL,
11863 		{ },
11864 		{ { 0, 1 } },
11865 		.fill_helper = bpf_fill_alu64_arsh_reg_pairs,
11866 	},
11867 	{
11868 		"ALU64_ADD_X: register combinations",
11869 		{ },
11870 		INTERNAL,
11871 		{ },
11872 		{ { 0, 1 } },
11873 		.fill_helper = bpf_fill_alu64_add_reg_pairs,
11874 	},
11875 	{
11876 		"ALU64_SUB_X: register combinations",
11877 		{ },
11878 		INTERNAL,
11879 		{ },
11880 		{ { 0, 1 } },
11881 		.fill_helper = bpf_fill_alu64_sub_reg_pairs,
11882 	},
11883 	{
11884 		"ALU64_MUL_X: register combinations",
11885 		{ },
11886 		INTERNAL,
11887 		{ },
11888 		{ { 0, 1 } },
11889 		.fill_helper = bpf_fill_alu64_mul_reg_pairs,
11890 	},
11891 	{
11892 		"ALU64_DIV_X: register combinations",
11893 		{ },
11894 		INTERNAL,
11895 		{ },
11896 		{ { 0, 1 } },
11897 		.fill_helper = bpf_fill_alu64_div_reg_pairs,
11898 	},
11899 	{
11900 		"ALU64_MOD_X: register combinations",
11901 		{ },
11902 		INTERNAL,
11903 		{ },
11904 		{ { 0, 1 } },
11905 		.fill_helper = bpf_fill_alu64_mod_reg_pairs,
11906 	},
11907 	/* ALU32 X register combinations */
11908 	{
11909 		"ALU32_MOV_X: register combinations",
11910 		{ },
11911 		INTERNAL,
11912 		{ },
11913 		{ { 0, 1 } },
11914 		.fill_helper = bpf_fill_alu32_mov_reg_pairs,
11915 	},
11916 	{
11917 		"ALU32_AND_X: register combinations",
11918 		{ },
11919 		INTERNAL,
11920 		{ },
11921 		{ { 0, 1 } },
11922 		.fill_helper = bpf_fill_alu32_and_reg_pairs,
11923 	},
11924 	{
11925 		"ALU32_OR_X: register combinations",
11926 		{ },
11927 		INTERNAL,
11928 		{ },
11929 		{ { 0, 1 } },
11930 		.fill_helper = bpf_fill_alu32_or_reg_pairs,
11931 	},
11932 	{
11933 		"ALU32_XOR_X: register combinations",
11934 		{ },
11935 		INTERNAL,
11936 		{ },
11937 		{ { 0, 1 } },
11938 		.fill_helper = bpf_fill_alu32_xor_reg_pairs,
11939 	},
11940 	{
11941 		"ALU32_LSH_X: register combinations",
11942 		{ },
11943 		INTERNAL,
11944 		{ },
11945 		{ { 0, 1 } },
11946 		.fill_helper = bpf_fill_alu32_lsh_reg_pairs,
11947 	},
11948 	{
11949 		"ALU32_RSH_X: register combinations",
11950 		{ },
11951 		INTERNAL,
11952 		{ },
11953 		{ { 0, 1 } },
11954 		.fill_helper = bpf_fill_alu32_rsh_reg_pairs,
11955 	},
11956 	{
11957 		"ALU32_ARSH_X: register combinations",
11958 		{ },
11959 		INTERNAL,
11960 		{ },
11961 		{ { 0, 1 } },
11962 		.fill_helper = bpf_fill_alu32_arsh_reg_pairs,
11963 	},
11964 	{
11965 		"ALU32_ADD_X: register combinations",
11966 		{ },
11967 		INTERNAL,
11968 		{ },
11969 		{ { 0, 1 } },
11970 		.fill_helper = bpf_fill_alu32_add_reg_pairs,
11971 	},
11972 	{
11973 		"ALU32_SUB_X: register combinations",
11974 		{ },
11975 		INTERNAL,
11976 		{ },
11977 		{ { 0, 1 } },
11978 		.fill_helper = bpf_fill_alu32_sub_reg_pairs,
11979 	},
11980 	{
11981 		"ALU32_MUL_X: register combinations",
11982 		{ },
11983 		INTERNAL,
11984 		{ },
11985 		{ { 0, 1 } },
11986 		.fill_helper = bpf_fill_alu32_mul_reg_pairs,
11987 	},
11988 	{
11989 		"ALU32_DIV_X: register combinations",
11990 		{ },
11991 		INTERNAL,
11992 		{ },
11993 		{ { 0, 1 } },
11994 		.fill_helper = bpf_fill_alu32_div_reg_pairs,
11995 	},
11996 	{
11997 		"ALU32_MOD_X register combinations",
11998 		{ },
11999 		INTERNAL,
12000 		{ },
12001 		{ { 0, 1 } },
12002 		.fill_helper = bpf_fill_alu32_mod_reg_pairs,
12003 	},
12004 	/* Exhaustive test of ALU64 shift operations */
12005 	{
12006 		"ALU64_LSH_K: all shift values",
12007 		{ },
12008 		INTERNAL | FLAG_NO_DATA,
12009 		{ },
12010 		{ { 0, 1 } },
12011 		.fill_helper = bpf_fill_alu64_lsh_imm,
12012 	},
12013 	{
12014 		"ALU64_RSH_K: all shift values",
12015 		{ },
12016 		INTERNAL | FLAG_NO_DATA,
12017 		{ },
12018 		{ { 0, 1 } },
12019 		.fill_helper = bpf_fill_alu64_rsh_imm,
12020 	},
12021 	{
12022 		"ALU64_ARSH_K: all shift values",
12023 		{ },
12024 		INTERNAL | FLAG_NO_DATA,
12025 		{ },
12026 		{ { 0, 1 } },
12027 		.fill_helper = bpf_fill_alu64_arsh_imm,
12028 	},
12029 	{
12030 		"ALU64_LSH_X: all shift values",
12031 		{ },
12032 		INTERNAL | FLAG_NO_DATA,
12033 		{ },
12034 		{ { 0, 1 } },
12035 		.fill_helper = bpf_fill_alu64_lsh_reg,
12036 	},
12037 	{
12038 		"ALU64_RSH_X: all shift values",
12039 		{ },
12040 		INTERNAL | FLAG_NO_DATA,
12041 		{ },
12042 		{ { 0, 1 } },
12043 		.fill_helper = bpf_fill_alu64_rsh_reg,
12044 	},
12045 	{
12046 		"ALU64_ARSH_X: all shift values",
12047 		{ },
12048 		INTERNAL | FLAG_NO_DATA,
12049 		{ },
12050 		{ { 0, 1 } },
12051 		.fill_helper = bpf_fill_alu64_arsh_reg,
12052 	},
12053 	/* Exhaustive test of ALU32 shift operations */
12054 	{
12055 		"ALU32_LSH_K: all shift values",
12056 		{ },
12057 		INTERNAL | FLAG_NO_DATA,
12058 		{ },
12059 		{ { 0, 1 } },
12060 		.fill_helper = bpf_fill_alu32_lsh_imm,
12061 	},
12062 	{
12063 		"ALU32_RSH_K: all shift values",
12064 		{ },
12065 		INTERNAL | FLAG_NO_DATA,
12066 		{ },
12067 		{ { 0, 1 } },
12068 		.fill_helper = bpf_fill_alu32_rsh_imm,
12069 	},
12070 	{
12071 		"ALU32_ARSH_K: all shift values",
12072 		{ },
12073 		INTERNAL | FLAG_NO_DATA,
12074 		{ },
12075 		{ { 0, 1 } },
12076 		.fill_helper = bpf_fill_alu32_arsh_imm,
12077 	},
12078 	{
12079 		"ALU32_LSH_X: all shift values",
12080 		{ },
12081 		INTERNAL | FLAG_NO_DATA,
12082 		{ },
12083 		{ { 0, 1 } },
12084 		.fill_helper = bpf_fill_alu32_lsh_reg,
12085 	},
12086 	{
12087 		"ALU32_RSH_X: all shift values",
12088 		{ },
12089 		INTERNAL | FLAG_NO_DATA,
12090 		{ },
12091 		{ { 0, 1 } },
12092 		.fill_helper = bpf_fill_alu32_rsh_reg,
12093 	},
12094 	{
12095 		"ALU32_ARSH_X: all shift values",
12096 		{ },
12097 		INTERNAL | FLAG_NO_DATA,
12098 		{ },
12099 		{ { 0, 1 } },
12100 		.fill_helper = bpf_fill_alu32_arsh_reg,
12101 	},
12102 	/*
12103 	 * Exhaustive test of ALU64 shift operations when
12104 	 * source and destination register are the same.
12105 	 */
12106 	{
12107 		"ALU64_LSH_X: all shift values with the same register",
12108 		{ },
12109 		INTERNAL | FLAG_NO_DATA,
12110 		{ },
12111 		{ { 0, 1 } },
12112 		.fill_helper = bpf_fill_alu64_lsh_same_reg,
12113 	},
12114 	{
12115 		"ALU64_RSH_X: all shift values with the same register",
12116 		{ },
12117 		INTERNAL | FLAG_NO_DATA,
12118 		{ },
12119 		{ { 0, 1 } },
12120 		.fill_helper = bpf_fill_alu64_rsh_same_reg,
12121 	},
12122 	{
12123 		"ALU64_ARSH_X: all shift values with the same register",
12124 		{ },
12125 		INTERNAL | FLAG_NO_DATA,
12126 		{ },
12127 		{ { 0, 1 } },
12128 		.fill_helper = bpf_fill_alu64_arsh_same_reg,
12129 	},
12130 	/*
12131 	 * Exhaustive test of ALU32 shift operations when
12132 	 * source and destination register are the same.
12133 	 */
12134 	{
12135 		"ALU32_LSH_X: all shift values with the same register",
12136 		{ },
12137 		INTERNAL | FLAG_NO_DATA,
12138 		{ },
12139 		{ { 0, 1 } },
12140 		.fill_helper = bpf_fill_alu32_lsh_same_reg,
12141 	},
12142 	{
12143 		"ALU32_RSH_X: all shift values with the same register",
12144 		{ },
12145 		INTERNAL | FLAG_NO_DATA,
12146 		{ },
12147 		{ { 0, 1 } },
12148 		.fill_helper = bpf_fill_alu32_rsh_same_reg,
12149 	},
12150 	{
12151 		"ALU32_ARSH_X: all shift values with the same register",
12152 		{ },
12153 		INTERNAL | FLAG_NO_DATA,
12154 		{ },
12155 		{ { 0, 1 } },
12156 		.fill_helper = bpf_fill_alu32_arsh_same_reg,
12157 	},
12158 	/* ALU64 immediate magnitudes */
12159 	{
12160 		"ALU64_MOV_K: all immediate value magnitudes",
12161 		{ },
12162 		INTERNAL | FLAG_NO_DATA,
12163 		{ },
12164 		{ { 0, 1 } },
12165 		.fill_helper = bpf_fill_alu64_mov_imm,
12166 		.nr_testruns = NR_PATTERN_RUNS,
12167 	},
12168 	{
12169 		"ALU64_AND_K: all immediate value magnitudes",
12170 		{ },
12171 		INTERNAL | FLAG_NO_DATA,
12172 		{ },
12173 		{ { 0, 1 } },
12174 		.fill_helper = bpf_fill_alu64_and_imm,
12175 		.nr_testruns = NR_PATTERN_RUNS,
12176 	},
12177 	{
12178 		"ALU64_OR_K: all immediate value magnitudes",
12179 		{ },
12180 		INTERNAL | FLAG_NO_DATA,
12181 		{ },
12182 		{ { 0, 1 } },
12183 		.fill_helper = bpf_fill_alu64_or_imm,
12184 		.nr_testruns = NR_PATTERN_RUNS,
12185 	},
12186 	{
12187 		"ALU64_XOR_K: all immediate value magnitudes",
12188 		{ },
12189 		INTERNAL | FLAG_NO_DATA,
12190 		{ },
12191 		{ { 0, 1 } },
12192 		.fill_helper = bpf_fill_alu64_xor_imm,
12193 		.nr_testruns = NR_PATTERN_RUNS,
12194 	},
12195 	{
12196 		"ALU64_ADD_K: all immediate value magnitudes",
12197 		{ },
12198 		INTERNAL | FLAG_NO_DATA,
12199 		{ },
12200 		{ { 0, 1 } },
12201 		.fill_helper = bpf_fill_alu64_add_imm,
12202 		.nr_testruns = NR_PATTERN_RUNS,
12203 	},
12204 	{
12205 		"ALU64_SUB_K: all immediate value magnitudes",
12206 		{ },
12207 		INTERNAL | FLAG_NO_DATA,
12208 		{ },
12209 		{ { 0, 1 } },
12210 		.fill_helper = bpf_fill_alu64_sub_imm,
12211 		.nr_testruns = NR_PATTERN_RUNS,
12212 	},
12213 	{
12214 		"ALU64_MUL_K: all immediate value magnitudes",
12215 		{ },
12216 		INTERNAL | FLAG_NO_DATA,
12217 		{ },
12218 		{ { 0, 1 } },
12219 		.fill_helper = bpf_fill_alu64_mul_imm,
12220 		.nr_testruns = NR_PATTERN_RUNS,
12221 	},
12222 	{
12223 		"ALU64_DIV_K: all immediate value magnitudes",
12224 		{ },
12225 		INTERNAL | FLAG_NO_DATA,
12226 		{ },
12227 		{ { 0, 1 } },
12228 		.fill_helper = bpf_fill_alu64_div_imm,
12229 		.nr_testruns = NR_PATTERN_RUNS,
12230 	},
12231 	{
12232 		"ALU64_MOD_K: all immediate value magnitudes",
12233 		{ },
12234 		INTERNAL | FLAG_NO_DATA,
12235 		{ },
12236 		{ { 0, 1 } },
12237 		.fill_helper = bpf_fill_alu64_mod_imm,
12238 		.nr_testruns = NR_PATTERN_RUNS,
12239 	},
12240 	/* ALU32 immediate magnitudes */
12241 	{
12242 		"ALU32_MOV_K: all immediate value magnitudes",
12243 		{ },
12244 		INTERNAL | FLAG_NO_DATA,
12245 		{ },
12246 		{ { 0, 1 } },
12247 		.fill_helper = bpf_fill_alu32_mov_imm,
12248 		.nr_testruns = NR_PATTERN_RUNS,
12249 	},
12250 	{
12251 		"ALU32_AND_K: all immediate value magnitudes",
12252 		{ },
12253 		INTERNAL | FLAG_NO_DATA,
12254 		{ },
12255 		{ { 0, 1 } },
12256 		.fill_helper = bpf_fill_alu32_and_imm,
12257 		.nr_testruns = NR_PATTERN_RUNS,
12258 	},
12259 	{
12260 		"ALU32_OR_K: all immediate value magnitudes",
12261 		{ },
12262 		INTERNAL | FLAG_NO_DATA,
12263 		{ },
12264 		{ { 0, 1 } },
12265 		.fill_helper = bpf_fill_alu32_or_imm,
12266 		.nr_testruns = NR_PATTERN_RUNS,
12267 	},
12268 	{
12269 		"ALU32_XOR_K: all immediate value magnitudes",
12270 		{ },
12271 		INTERNAL | FLAG_NO_DATA,
12272 		{ },
12273 		{ { 0, 1 } },
12274 		.fill_helper = bpf_fill_alu32_xor_imm,
12275 		.nr_testruns = NR_PATTERN_RUNS,
12276 	},
12277 	{
12278 		"ALU32_ADD_K: all immediate value magnitudes",
12279 		{ },
12280 		INTERNAL | FLAG_NO_DATA,
12281 		{ },
12282 		{ { 0, 1 } },
12283 		.fill_helper = bpf_fill_alu32_add_imm,
12284 		.nr_testruns = NR_PATTERN_RUNS,
12285 	},
12286 	{
12287 		"ALU32_SUB_K: all immediate value magnitudes",
12288 		{ },
12289 		INTERNAL | FLAG_NO_DATA,
12290 		{ },
12291 		{ { 0, 1 } },
12292 		.fill_helper = bpf_fill_alu32_sub_imm,
12293 		.nr_testruns = NR_PATTERN_RUNS,
12294 	},
12295 	{
12296 		"ALU32_MUL_K: all immediate value magnitudes",
12297 		{ },
12298 		INTERNAL | FLAG_NO_DATA,
12299 		{ },
12300 		{ { 0, 1 } },
12301 		.fill_helper = bpf_fill_alu32_mul_imm,
12302 		.nr_testruns = NR_PATTERN_RUNS,
12303 	},
12304 	{
12305 		"ALU32_DIV_K: all immediate value magnitudes",
12306 		{ },
12307 		INTERNAL | FLAG_NO_DATA,
12308 		{ },
12309 		{ { 0, 1 } },
12310 		.fill_helper = bpf_fill_alu32_div_imm,
12311 		.nr_testruns = NR_PATTERN_RUNS,
12312 	},
12313 	{
12314 		"ALU32_MOD_K: all immediate value magnitudes",
12315 		{ },
12316 		INTERNAL | FLAG_NO_DATA,
12317 		{ },
12318 		{ { 0, 1 } },
12319 		.fill_helper = bpf_fill_alu32_mod_imm,
12320 		.nr_testruns = NR_PATTERN_RUNS,
12321 	},
12322 	/* ALU64 register magnitudes */
12323 	{
12324 		"ALU64_MOV_X: all register value magnitudes",
12325 		{ },
12326 		INTERNAL | FLAG_NO_DATA,
12327 		{ },
12328 		{ { 0, 1 } },
12329 		.fill_helper = bpf_fill_alu64_mov_reg,
12330 		.nr_testruns = NR_PATTERN_RUNS,
12331 	},
12332 	{
12333 		"ALU64_AND_X: all register value magnitudes",
12334 		{ },
12335 		INTERNAL | FLAG_NO_DATA,
12336 		{ },
12337 		{ { 0, 1 } },
12338 		.fill_helper = bpf_fill_alu64_and_reg,
12339 		.nr_testruns = NR_PATTERN_RUNS,
12340 	},
12341 	{
12342 		"ALU64_OR_X: all register value magnitudes",
12343 		{ },
12344 		INTERNAL | FLAG_NO_DATA,
12345 		{ },
12346 		{ { 0, 1 } },
12347 		.fill_helper = bpf_fill_alu64_or_reg,
12348 		.nr_testruns = NR_PATTERN_RUNS,
12349 	},
12350 	{
12351 		"ALU64_XOR_X: all register value magnitudes",
12352 		{ },
12353 		INTERNAL | FLAG_NO_DATA,
12354 		{ },
12355 		{ { 0, 1 } },
12356 		.fill_helper = bpf_fill_alu64_xor_reg,
12357 		.nr_testruns = NR_PATTERN_RUNS,
12358 	},
12359 	{
12360 		"ALU64_ADD_X: all register value magnitudes",
12361 		{ },
12362 		INTERNAL | FLAG_NO_DATA,
12363 		{ },
12364 		{ { 0, 1 } },
12365 		.fill_helper = bpf_fill_alu64_add_reg,
12366 		.nr_testruns = NR_PATTERN_RUNS,
12367 	},
12368 	{
12369 		"ALU64_SUB_X: all register value magnitudes",
12370 		{ },
12371 		INTERNAL | FLAG_NO_DATA,
12372 		{ },
12373 		{ { 0, 1 } },
12374 		.fill_helper = bpf_fill_alu64_sub_reg,
12375 		.nr_testruns = NR_PATTERN_RUNS,
12376 	},
12377 	{
12378 		"ALU64_MUL_X: all register value magnitudes",
12379 		{ },
12380 		INTERNAL | FLAG_NO_DATA,
12381 		{ },
12382 		{ { 0, 1 } },
12383 		.fill_helper = bpf_fill_alu64_mul_reg,
12384 		.nr_testruns = NR_PATTERN_RUNS,
12385 	},
12386 	{
12387 		"ALU64_DIV_X: all register value magnitudes",
12388 		{ },
12389 		INTERNAL | FLAG_NO_DATA,
12390 		{ },
12391 		{ { 0, 1 } },
12392 		.fill_helper = bpf_fill_alu64_div_reg,
12393 		.nr_testruns = NR_PATTERN_RUNS,
12394 	},
12395 	{
12396 		"ALU64_MOD_X: all register value magnitudes",
12397 		{ },
12398 		INTERNAL | FLAG_NO_DATA,
12399 		{ },
12400 		{ { 0, 1 } },
12401 		.fill_helper = bpf_fill_alu64_mod_reg,
12402 		.nr_testruns = NR_PATTERN_RUNS,
12403 	},
12404 	/* ALU32 register magnitudes */
12405 	{
12406 		"ALU32_MOV_X: all register value magnitudes",
12407 		{ },
12408 		INTERNAL | FLAG_NO_DATA,
12409 		{ },
12410 		{ { 0, 1 } },
12411 		.fill_helper = bpf_fill_alu32_mov_reg,
12412 		.nr_testruns = NR_PATTERN_RUNS,
12413 	},
12414 	{
12415 		"ALU32_AND_X: all register value magnitudes",
12416 		{ },
12417 		INTERNAL | FLAG_NO_DATA,
12418 		{ },
12419 		{ { 0, 1 } },
12420 		.fill_helper = bpf_fill_alu32_and_reg,
12421 		.nr_testruns = NR_PATTERN_RUNS,
12422 	},
12423 	{
12424 		"ALU32_OR_X: all register value magnitudes",
12425 		{ },
12426 		INTERNAL | FLAG_NO_DATA,
12427 		{ },
12428 		{ { 0, 1 } },
12429 		.fill_helper = bpf_fill_alu32_or_reg,
12430 		.nr_testruns = NR_PATTERN_RUNS,
12431 	},
12432 	{
12433 		"ALU32_XOR_X: all register value magnitudes",
12434 		{ },
12435 		INTERNAL | FLAG_NO_DATA,
12436 		{ },
12437 		{ { 0, 1 } },
12438 		.fill_helper = bpf_fill_alu32_xor_reg,
12439 		.nr_testruns = NR_PATTERN_RUNS,
12440 	},
12441 	{
12442 		"ALU32_ADD_X: all register value magnitudes",
12443 		{ },
12444 		INTERNAL | FLAG_NO_DATA,
12445 		{ },
12446 		{ { 0, 1 } },
12447 		.fill_helper = bpf_fill_alu32_add_reg,
12448 		.nr_testruns = NR_PATTERN_RUNS,
12449 	},
12450 	{
12451 		"ALU32_SUB_X: all register value magnitudes",
12452 		{ },
12453 		INTERNAL | FLAG_NO_DATA,
12454 		{ },
12455 		{ { 0, 1 } },
12456 		.fill_helper = bpf_fill_alu32_sub_reg,
12457 		.nr_testruns = NR_PATTERN_RUNS,
12458 	},
12459 	{
12460 		"ALU32_MUL_X: all register value magnitudes",
12461 		{ },
12462 		INTERNAL | FLAG_NO_DATA,
12463 		{ },
12464 		{ { 0, 1 } },
12465 		.fill_helper = bpf_fill_alu32_mul_reg,
12466 		.nr_testruns = NR_PATTERN_RUNS,
12467 	},
12468 	{
12469 		"ALU32_DIV_X: all register value magnitudes",
12470 		{ },
12471 		INTERNAL | FLAG_NO_DATA,
12472 		{ },
12473 		{ { 0, 1 } },
12474 		.fill_helper = bpf_fill_alu32_div_reg,
12475 		.nr_testruns = NR_PATTERN_RUNS,
12476 	},
12477 	{
12478 		"ALU32_MOD_X: all register value magnitudes",
12479 		{ },
12480 		INTERNAL | FLAG_NO_DATA,
12481 		{ },
12482 		{ { 0, 1 } },
12483 		.fill_helper = bpf_fill_alu32_mod_reg,
12484 		.nr_testruns = NR_PATTERN_RUNS,
12485 	},
12486 	/* LD_IMM64 immediate magnitudes and byte patterns */
12487 	{
12488 		"LD_IMM64: all immediate value magnitudes",
12489 		{ },
12490 		INTERNAL | FLAG_NO_DATA,
12491 		{ },
12492 		{ { 0, 1 } },
12493 		.fill_helper = bpf_fill_ld_imm64_magn,
12494 	},
12495 	{
12496 		"LD_IMM64: checker byte patterns",
12497 		{ },
12498 		INTERNAL | FLAG_NO_DATA,
12499 		{ },
12500 		{ { 0, 1 } },
12501 		.fill_helper = bpf_fill_ld_imm64_checker,
12502 	},
12503 	{
12504 		"LD_IMM64: random positive and zero byte patterns",
12505 		{ },
12506 		INTERNAL | FLAG_NO_DATA,
12507 		{ },
12508 		{ { 0, 1 } },
12509 		.fill_helper = bpf_fill_ld_imm64_pos_zero,
12510 	},
12511 	{
12512 		"LD_IMM64: random negative and zero byte patterns",
12513 		{ },
12514 		INTERNAL | FLAG_NO_DATA,
12515 		{ },
12516 		{ { 0, 1 } },
12517 		.fill_helper = bpf_fill_ld_imm64_neg_zero,
12518 	},
12519 	{
12520 		"LD_IMM64: random positive and negative byte patterns",
12521 		{ },
12522 		INTERNAL | FLAG_NO_DATA,
12523 		{ },
12524 		{ { 0, 1 } },
12525 		.fill_helper = bpf_fill_ld_imm64_pos_neg,
12526 	},
12527 	/* 64-bit ATOMIC register combinations */
12528 	{
12529 		"ATOMIC_DW_ADD: register combinations",
12530 		{ },
12531 		INTERNAL,
12532 		{ },
12533 		{ { 0, 1 } },
12534 		.fill_helper = bpf_fill_atomic64_add_reg_pairs,
12535 		.stack_depth = 8,
12536 	},
12537 	{
12538 		"ATOMIC_DW_AND: register combinations",
12539 		{ },
12540 		INTERNAL,
12541 		{ },
12542 		{ { 0, 1 } },
12543 		.fill_helper = bpf_fill_atomic64_and_reg_pairs,
12544 		.stack_depth = 8,
12545 	},
12546 	{
12547 		"ATOMIC_DW_OR: register combinations",
12548 		{ },
12549 		INTERNAL,
12550 		{ },
12551 		{ { 0, 1 } },
12552 		.fill_helper = bpf_fill_atomic64_or_reg_pairs,
12553 		.stack_depth = 8,
12554 	},
12555 	{
12556 		"ATOMIC_DW_XOR: register combinations",
12557 		{ },
12558 		INTERNAL,
12559 		{ },
12560 		{ { 0, 1 } },
12561 		.fill_helper = bpf_fill_atomic64_xor_reg_pairs,
12562 		.stack_depth = 8,
12563 	},
12564 	{
12565 		"ATOMIC_DW_ADD_FETCH: register combinations",
12566 		{ },
12567 		INTERNAL,
12568 		{ },
12569 		{ { 0, 1 } },
12570 		.fill_helper = bpf_fill_atomic64_add_fetch_reg_pairs,
12571 		.stack_depth = 8,
12572 	},
12573 	{
12574 		"ATOMIC_DW_AND_FETCH: register combinations",
12575 		{ },
12576 		INTERNAL,
12577 		{ },
12578 		{ { 0, 1 } },
12579 		.fill_helper = bpf_fill_atomic64_and_fetch_reg_pairs,
12580 		.stack_depth = 8,
12581 	},
12582 	{
12583 		"ATOMIC_DW_OR_FETCH: register combinations",
12584 		{ },
12585 		INTERNAL,
12586 		{ },
12587 		{ { 0, 1 } },
12588 		.fill_helper = bpf_fill_atomic64_or_fetch_reg_pairs,
12589 		.stack_depth = 8,
12590 	},
12591 	{
12592 		"ATOMIC_DW_XOR_FETCH: register combinations",
12593 		{ },
12594 		INTERNAL,
12595 		{ },
12596 		{ { 0, 1 } },
12597 		.fill_helper = bpf_fill_atomic64_xor_fetch_reg_pairs,
12598 		.stack_depth = 8,
12599 	},
12600 	{
12601 		"ATOMIC_DW_XCHG: register combinations",
12602 		{ },
12603 		INTERNAL,
12604 		{ },
12605 		{ { 0, 1 } },
12606 		.fill_helper = bpf_fill_atomic64_xchg_reg_pairs,
12607 		.stack_depth = 8,
12608 	},
12609 	{
12610 		"ATOMIC_DW_CMPXCHG: register combinations",
12611 		{ },
12612 		INTERNAL,
12613 		{ },
12614 		{ { 0, 1 } },
12615 		.fill_helper = bpf_fill_atomic64_cmpxchg_reg_pairs,
12616 		.stack_depth = 8,
12617 	},
12618 	/* 32-bit ATOMIC register combinations */
12619 	{
12620 		"ATOMIC_W_ADD: register combinations",
12621 		{ },
12622 		INTERNAL,
12623 		{ },
12624 		{ { 0, 1 } },
12625 		.fill_helper = bpf_fill_atomic32_add_reg_pairs,
12626 		.stack_depth = 8,
12627 	},
12628 	{
12629 		"ATOMIC_W_AND: register combinations",
12630 		{ },
12631 		INTERNAL,
12632 		{ },
12633 		{ { 0, 1 } },
12634 		.fill_helper = bpf_fill_atomic32_and_reg_pairs,
12635 		.stack_depth = 8,
12636 	},
12637 	{
12638 		"ATOMIC_W_OR: register combinations",
12639 		{ },
12640 		INTERNAL,
12641 		{ },
12642 		{ { 0, 1 } },
12643 		.fill_helper = bpf_fill_atomic32_or_reg_pairs,
12644 		.stack_depth = 8,
12645 	},
12646 	{
12647 		"ATOMIC_W_XOR: register combinations",
12648 		{ },
12649 		INTERNAL,
12650 		{ },
12651 		{ { 0, 1 } },
12652 		.fill_helper = bpf_fill_atomic32_xor_reg_pairs,
12653 		.stack_depth = 8,
12654 	},
12655 	{
12656 		"ATOMIC_W_ADD_FETCH: register combinations",
12657 		{ },
12658 		INTERNAL,
12659 		{ },
12660 		{ { 0, 1 } },
12661 		.fill_helper = bpf_fill_atomic32_add_fetch_reg_pairs,
12662 		.stack_depth = 8,
12663 	},
12664 	{
12665 		"ATOMIC_W_AND_FETCH: register combinations",
12666 		{ },
12667 		INTERNAL,
12668 		{ },
12669 		{ { 0, 1 } },
12670 		.fill_helper = bpf_fill_atomic32_and_fetch_reg_pairs,
12671 		.stack_depth = 8,
12672 	},
12673 	{
12674 		"ATOMIC_W_OR_FETCH: register combinations",
12675 		{ },
12676 		INTERNAL,
12677 		{ },
12678 		{ { 0, 1 } },
12679 		.fill_helper = bpf_fill_atomic32_or_fetch_reg_pairs,
12680 		.stack_depth = 8,
12681 	},
12682 	{
12683 		"ATOMIC_W_XOR_FETCH: register combinations",
12684 		{ },
12685 		INTERNAL,
12686 		{ },
12687 		{ { 0, 1 } },
12688 		.fill_helper = bpf_fill_atomic32_xor_fetch_reg_pairs,
12689 		.stack_depth = 8,
12690 	},
12691 	{
12692 		"ATOMIC_W_XCHG: register combinations",
12693 		{ },
12694 		INTERNAL,
12695 		{ },
12696 		{ { 0, 1 } },
12697 		.fill_helper = bpf_fill_atomic32_xchg_reg_pairs,
12698 		.stack_depth = 8,
12699 	},
12700 	{
12701 		"ATOMIC_W_CMPXCHG: register combinations",
12702 		{ },
12703 		INTERNAL,
12704 		{ },
12705 		{ { 0, 1 } },
12706 		.fill_helper = bpf_fill_atomic32_cmpxchg_reg_pairs,
12707 		.stack_depth = 8,
12708 	},
12709 	/* 64-bit ATOMIC magnitudes */
12710 	{
12711 		"ATOMIC_DW_ADD: all operand magnitudes",
12712 		{ },
12713 		INTERNAL | FLAG_NO_DATA,
12714 		{ },
12715 		{ { 0, 1 } },
12716 		.fill_helper = bpf_fill_atomic64_add,
12717 		.stack_depth = 8,
12718 		.nr_testruns = NR_PATTERN_RUNS,
12719 	},
12720 	{
12721 		"ATOMIC_DW_AND: all operand magnitudes",
12722 		{ },
12723 		INTERNAL | FLAG_NO_DATA,
12724 		{ },
12725 		{ { 0, 1 } },
12726 		.fill_helper = bpf_fill_atomic64_and,
12727 		.stack_depth = 8,
12728 		.nr_testruns = NR_PATTERN_RUNS,
12729 	},
12730 	{
12731 		"ATOMIC_DW_OR: all operand magnitudes",
12732 		{ },
12733 		INTERNAL | FLAG_NO_DATA,
12734 		{ },
12735 		{ { 0, 1 } },
12736 		.fill_helper = bpf_fill_atomic64_or,
12737 		.stack_depth = 8,
12738 		.nr_testruns = NR_PATTERN_RUNS,
12739 	},
12740 	{
12741 		"ATOMIC_DW_XOR: all operand magnitudes",
12742 		{ },
12743 		INTERNAL | FLAG_NO_DATA,
12744 		{ },
12745 		{ { 0, 1 } },
12746 		.fill_helper = bpf_fill_atomic64_xor,
12747 		.stack_depth = 8,
12748 		.nr_testruns = NR_PATTERN_RUNS,
12749 	},
12750 	{
12751 		"ATOMIC_DW_ADD_FETCH: all operand magnitudes",
12752 		{ },
12753 		INTERNAL | FLAG_NO_DATA,
12754 		{ },
12755 		{ { 0, 1 } },
12756 		.fill_helper = bpf_fill_atomic64_add_fetch,
12757 		.stack_depth = 8,
12758 		.nr_testruns = NR_PATTERN_RUNS,
12759 	},
12760 	{
12761 		"ATOMIC_DW_AND_FETCH: all operand magnitudes",
12762 		{ },
12763 		INTERNAL | FLAG_NO_DATA,
12764 		{ },
12765 		{ { 0, 1 } },
12766 		.fill_helper = bpf_fill_atomic64_and_fetch,
12767 		.stack_depth = 8,
12768 		.nr_testruns = NR_PATTERN_RUNS,
12769 	},
12770 	{
12771 		"ATOMIC_DW_OR_FETCH: all operand magnitudes",
12772 		{ },
12773 		INTERNAL | FLAG_NO_DATA,
12774 		{ },
12775 		{ { 0, 1 } },
12776 		.fill_helper = bpf_fill_atomic64_or_fetch,
12777 		.stack_depth = 8,
12778 		.nr_testruns = NR_PATTERN_RUNS,
12779 	},
12780 	{
12781 		"ATOMIC_DW_XOR_FETCH: all operand magnitudes",
12782 		{ },
12783 		INTERNAL | FLAG_NO_DATA,
12784 		{ },
12785 		{ { 0, 1 } },
12786 		.fill_helper = bpf_fill_atomic64_xor_fetch,
12787 		.stack_depth = 8,
12788 		.nr_testruns = NR_PATTERN_RUNS,
12789 	},
12790 	{
12791 		"ATOMIC_DW_XCHG: all operand magnitudes",
12792 		{ },
12793 		INTERNAL | FLAG_NO_DATA,
12794 		{ },
12795 		{ { 0, 1 } },
12796 		.fill_helper = bpf_fill_atomic64_xchg,
12797 		.stack_depth = 8,
12798 		.nr_testruns = NR_PATTERN_RUNS,
12799 	},
12800 	{
12801 		"ATOMIC_DW_CMPXCHG: all operand magnitudes",
12802 		{ },
12803 		INTERNAL | FLAG_NO_DATA,
12804 		{ },
12805 		{ { 0, 1 } },
12806 		.fill_helper = bpf_fill_cmpxchg64,
12807 		.stack_depth = 8,
12808 		.nr_testruns = NR_PATTERN_RUNS,
12809 	},
12810 	/* 64-bit atomic magnitudes */
12811 	{
12812 		"ATOMIC_W_ADD: all operand magnitudes",
12813 		{ },
12814 		INTERNAL | FLAG_NO_DATA,
12815 		{ },
12816 		{ { 0, 1 } },
12817 		.fill_helper = bpf_fill_atomic32_add,
12818 		.stack_depth = 8,
12819 		.nr_testruns = NR_PATTERN_RUNS,
12820 	},
12821 	{
12822 		"ATOMIC_W_AND: all operand magnitudes",
12823 		{ },
12824 		INTERNAL | FLAG_NO_DATA,
12825 		{ },
12826 		{ { 0, 1 } },
12827 		.fill_helper = bpf_fill_atomic32_and,
12828 		.stack_depth = 8,
12829 		.nr_testruns = NR_PATTERN_RUNS,
12830 	},
12831 	{
12832 		"ATOMIC_W_OR: all operand magnitudes",
12833 		{ },
12834 		INTERNAL | FLAG_NO_DATA,
12835 		{ },
12836 		{ { 0, 1 } },
12837 		.fill_helper = bpf_fill_atomic32_or,
12838 		.stack_depth = 8,
12839 		.nr_testruns = NR_PATTERN_RUNS,
12840 	},
12841 	{
12842 		"ATOMIC_W_XOR: all operand magnitudes",
12843 		{ },
12844 		INTERNAL | FLAG_NO_DATA,
12845 		{ },
12846 		{ { 0, 1 } },
12847 		.fill_helper = bpf_fill_atomic32_xor,
12848 		.stack_depth = 8,
12849 		.nr_testruns = NR_PATTERN_RUNS,
12850 	},
12851 	{
12852 		"ATOMIC_W_ADD_FETCH: all operand magnitudes",
12853 		{ },
12854 		INTERNAL | FLAG_NO_DATA,
12855 		{ },
12856 		{ { 0, 1 } },
12857 		.fill_helper = bpf_fill_atomic32_add_fetch,
12858 		.stack_depth = 8,
12859 		.nr_testruns = NR_PATTERN_RUNS,
12860 	},
12861 	{
12862 		"ATOMIC_W_AND_FETCH: all operand magnitudes",
12863 		{ },
12864 		INTERNAL | FLAG_NO_DATA,
12865 		{ },
12866 		{ { 0, 1 } },
12867 		.fill_helper = bpf_fill_atomic32_and_fetch,
12868 		.stack_depth = 8,
12869 		.nr_testruns = NR_PATTERN_RUNS,
12870 	},
12871 	{
12872 		"ATOMIC_W_OR_FETCH: all operand magnitudes",
12873 		{ },
12874 		INTERNAL | FLAG_NO_DATA,
12875 		{ },
12876 		{ { 0, 1 } },
12877 		.fill_helper = bpf_fill_atomic32_or_fetch,
12878 		.stack_depth = 8,
12879 		.nr_testruns = NR_PATTERN_RUNS,
12880 	},
12881 	{
12882 		"ATOMIC_W_XOR_FETCH: all operand magnitudes",
12883 		{ },
12884 		INTERNAL | FLAG_NO_DATA,
12885 		{ },
12886 		{ { 0, 1 } },
12887 		.fill_helper = bpf_fill_atomic32_xor_fetch,
12888 		.stack_depth = 8,
12889 		.nr_testruns = NR_PATTERN_RUNS,
12890 	},
12891 	{
12892 		"ATOMIC_W_XCHG: all operand magnitudes",
12893 		{ },
12894 		INTERNAL | FLAG_NO_DATA,
12895 		{ },
12896 		{ { 0, 1 } },
12897 		.fill_helper = bpf_fill_atomic32_xchg,
12898 		.stack_depth = 8,
12899 		.nr_testruns = NR_PATTERN_RUNS,
12900 	},
12901 	{
12902 		"ATOMIC_W_CMPXCHG: all operand magnitudes",
12903 		{ },
12904 		INTERNAL | FLAG_NO_DATA,
12905 		{ },
12906 		{ { 0, 1 } },
12907 		.fill_helper = bpf_fill_cmpxchg32,
12908 		.stack_depth = 8,
12909 		.nr_testruns = NR_PATTERN_RUNS,
12910 	},
12911 	/* JMP immediate magnitudes */
12912 	{
12913 		"JMP_JSET_K: all immediate value magnitudes",
12914 		{ },
12915 		INTERNAL | FLAG_NO_DATA,
12916 		{ },
12917 		{ { 0, 1 } },
12918 		.fill_helper = bpf_fill_jmp_jset_imm,
12919 		.nr_testruns = NR_PATTERN_RUNS,
12920 	},
12921 	{
12922 		"JMP_JEQ_K: all immediate value magnitudes",
12923 		{ },
12924 		INTERNAL | FLAG_NO_DATA,
12925 		{ },
12926 		{ { 0, 1 } },
12927 		.fill_helper = bpf_fill_jmp_jeq_imm,
12928 		.nr_testruns = NR_PATTERN_RUNS,
12929 	},
12930 	{
12931 		"JMP_JNE_K: all immediate value magnitudes",
12932 		{ },
12933 		INTERNAL | FLAG_NO_DATA,
12934 		{ },
12935 		{ { 0, 1 } },
12936 		.fill_helper = bpf_fill_jmp_jne_imm,
12937 		.nr_testruns = NR_PATTERN_RUNS,
12938 	},
12939 	{
12940 		"JMP_JGT_K: all immediate value magnitudes",
12941 		{ },
12942 		INTERNAL | FLAG_NO_DATA,
12943 		{ },
12944 		{ { 0, 1 } },
12945 		.fill_helper = bpf_fill_jmp_jgt_imm,
12946 		.nr_testruns = NR_PATTERN_RUNS,
12947 	},
12948 	{
12949 		"JMP_JGE_K: all immediate value magnitudes",
12950 		{ },
12951 		INTERNAL | FLAG_NO_DATA,
12952 		{ },
12953 		{ { 0, 1 } },
12954 		.fill_helper = bpf_fill_jmp_jge_imm,
12955 		.nr_testruns = NR_PATTERN_RUNS,
12956 	},
12957 	{
12958 		"JMP_JLT_K: all immediate value magnitudes",
12959 		{ },
12960 		INTERNAL | FLAG_NO_DATA,
12961 		{ },
12962 		{ { 0, 1 } },
12963 		.fill_helper = bpf_fill_jmp_jlt_imm,
12964 		.nr_testruns = NR_PATTERN_RUNS,
12965 	},
12966 	{
12967 		"JMP_JLE_K: all immediate value magnitudes",
12968 		{ },
12969 		INTERNAL | FLAG_NO_DATA,
12970 		{ },
12971 		{ { 0, 1 } },
12972 		.fill_helper = bpf_fill_jmp_jle_imm,
12973 		.nr_testruns = NR_PATTERN_RUNS,
12974 	},
12975 	{
12976 		"JMP_JSGT_K: all immediate value magnitudes",
12977 		{ },
12978 		INTERNAL | FLAG_NO_DATA,
12979 		{ },
12980 		{ { 0, 1 } },
12981 		.fill_helper = bpf_fill_jmp_jsgt_imm,
12982 		.nr_testruns = NR_PATTERN_RUNS,
12983 	},
12984 	{
12985 		"JMP_JSGE_K: all immediate value magnitudes",
12986 		{ },
12987 		INTERNAL | FLAG_NO_DATA,
12988 		{ },
12989 		{ { 0, 1 } },
12990 		.fill_helper = bpf_fill_jmp_jsge_imm,
12991 		.nr_testruns = NR_PATTERN_RUNS,
12992 	},
12993 	{
12994 		"JMP_JSLT_K: all immediate value magnitudes",
12995 		{ },
12996 		INTERNAL | FLAG_NO_DATA,
12997 		{ },
12998 		{ { 0, 1 } },
12999 		.fill_helper = bpf_fill_jmp_jslt_imm,
13000 		.nr_testruns = NR_PATTERN_RUNS,
13001 	},
13002 	{
13003 		"JMP_JSLE_K: all immediate value magnitudes",
13004 		{ },
13005 		INTERNAL | FLAG_NO_DATA,
13006 		{ },
13007 		{ { 0, 1 } },
13008 		.fill_helper = bpf_fill_jmp_jsle_imm,
13009 		.nr_testruns = NR_PATTERN_RUNS,
13010 	},
13011 	/* JMP register magnitudes */
13012 	{
13013 		"JMP_JSET_X: all register value magnitudes",
13014 		{ },
13015 		INTERNAL | FLAG_NO_DATA,
13016 		{ },
13017 		{ { 0, 1 } },
13018 		.fill_helper = bpf_fill_jmp_jset_reg,
13019 		.nr_testruns = NR_PATTERN_RUNS,
13020 	},
13021 	{
13022 		"JMP_JEQ_X: all register value magnitudes",
13023 		{ },
13024 		INTERNAL | FLAG_NO_DATA,
13025 		{ },
13026 		{ { 0, 1 } },
13027 		.fill_helper = bpf_fill_jmp_jeq_reg,
13028 		.nr_testruns = NR_PATTERN_RUNS,
13029 	},
13030 	{
13031 		"JMP_JNE_X: all register value magnitudes",
13032 		{ },
13033 		INTERNAL | FLAG_NO_DATA,
13034 		{ },
13035 		{ { 0, 1 } },
13036 		.fill_helper = bpf_fill_jmp_jne_reg,
13037 		.nr_testruns = NR_PATTERN_RUNS,
13038 	},
13039 	{
13040 		"JMP_JGT_X: all register value magnitudes",
13041 		{ },
13042 		INTERNAL | FLAG_NO_DATA,
13043 		{ },
13044 		{ { 0, 1 } },
13045 		.fill_helper = bpf_fill_jmp_jgt_reg,
13046 		.nr_testruns = NR_PATTERN_RUNS,
13047 	},
13048 	{
13049 		"JMP_JGE_X: all register value magnitudes",
13050 		{ },
13051 		INTERNAL | FLAG_NO_DATA,
13052 		{ },
13053 		{ { 0, 1 } },
13054 		.fill_helper = bpf_fill_jmp_jge_reg,
13055 		.nr_testruns = NR_PATTERN_RUNS,
13056 	},
13057 	{
13058 		"JMP_JLT_X: all register value magnitudes",
13059 		{ },
13060 		INTERNAL | FLAG_NO_DATA,
13061 		{ },
13062 		{ { 0, 1 } },
13063 		.fill_helper = bpf_fill_jmp_jlt_reg,
13064 		.nr_testruns = NR_PATTERN_RUNS,
13065 	},
13066 	{
13067 		"JMP_JLE_X: all register value magnitudes",
13068 		{ },
13069 		INTERNAL | FLAG_NO_DATA,
13070 		{ },
13071 		{ { 0, 1 } },
13072 		.fill_helper = bpf_fill_jmp_jle_reg,
13073 		.nr_testruns = NR_PATTERN_RUNS,
13074 	},
13075 	{
13076 		"JMP_JSGT_X: all register value magnitudes",
13077 		{ },
13078 		INTERNAL | FLAG_NO_DATA,
13079 		{ },
13080 		{ { 0, 1 } },
13081 		.fill_helper = bpf_fill_jmp_jsgt_reg,
13082 		.nr_testruns = NR_PATTERN_RUNS,
13083 	},
13084 	{
13085 		"JMP_JSGE_X: all register value magnitudes",
13086 		{ },
13087 		INTERNAL | FLAG_NO_DATA,
13088 		{ },
13089 		{ { 0, 1 } },
13090 		.fill_helper = bpf_fill_jmp_jsge_reg,
13091 		.nr_testruns = NR_PATTERN_RUNS,
13092 	},
13093 	{
13094 		"JMP_JSLT_X: all register value magnitudes",
13095 		{ },
13096 		INTERNAL | FLAG_NO_DATA,
13097 		{ },
13098 		{ { 0, 1 } },
13099 		.fill_helper = bpf_fill_jmp_jslt_reg,
13100 		.nr_testruns = NR_PATTERN_RUNS,
13101 	},
13102 	{
13103 		"JMP_JSLE_X: all register value magnitudes",
13104 		{ },
13105 		INTERNAL | FLAG_NO_DATA,
13106 		{ },
13107 		{ { 0, 1 } },
13108 		.fill_helper = bpf_fill_jmp_jsle_reg,
13109 		.nr_testruns = NR_PATTERN_RUNS,
13110 	},
13111 	/* JMP32 immediate magnitudes */
13112 	{
13113 		"JMP32_JSET_K: all immediate value magnitudes",
13114 		{ },
13115 		INTERNAL | FLAG_NO_DATA,
13116 		{ },
13117 		{ { 0, 1 } },
13118 		.fill_helper = bpf_fill_jmp32_jset_imm,
13119 		.nr_testruns = NR_PATTERN_RUNS,
13120 	},
13121 	{
13122 		"JMP32_JEQ_K: all immediate value magnitudes",
13123 		{ },
13124 		INTERNAL | FLAG_NO_DATA,
13125 		{ },
13126 		{ { 0, 1 } },
13127 		.fill_helper = bpf_fill_jmp32_jeq_imm,
13128 		.nr_testruns = NR_PATTERN_RUNS,
13129 	},
13130 	{
13131 		"JMP32_JNE_K: all immediate value magnitudes",
13132 		{ },
13133 		INTERNAL | FLAG_NO_DATA,
13134 		{ },
13135 		{ { 0, 1 } },
13136 		.fill_helper = bpf_fill_jmp32_jne_imm,
13137 		.nr_testruns = NR_PATTERN_RUNS,
13138 	},
13139 	{
13140 		"JMP32_JGT_K: all immediate value magnitudes",
13141 		{ },
13142 		INTERNAL | FLAG_NO_DATA,
13143 		{ },
13144 		{ { 0, 1 } },
13145 		.fill_helper = bpf_fill_jmp32_jgt_imm,
13146 		.nr_testruns = NR_PATTERN_RUNS,
13147 	},
13148 	{
13149 		"JMP32_JGE_K: all immediate value magnitudes",
13150 		{ },
13151 		INTERNAL | FLAG_NO_DATA,
13152 		{ },
13153 		{ { 0, 1 } },
13154 		.fill_helper = bpf_fill_jmp32_jge_imm,
13155 		.nr_testruns = NR_PATTERN_RUNS,
13156 	},
13157 	{
13158 		"JMP32_JLT_K: all immediate value magnitudes",
13159 		{ },
13160 		INTERNAL | FLAG_NO_DATA,
13161 		{ },
13162 		{ { 0, 1 } },
13163 		.fill_helper = bpf_fill_jmp32_jlt_imm,
13164 		.nr_testruns = NR_PATTERN_RUNS,
13165 	},
13166 	{
13167 		"JMP32_JLE_K: all immediate value magnitudes",
13168 		{ },
13169 		INTERNAL | FLAG_NO_DATA,
13170 		{ },
13171 		{ { 0, 1 } },
13172 		.fill_helper = bpf_fill_jmp32_jle_imm,
13173 		.nr_testruns = NR_PATTERN_RUNS,
13174 	},
13175 	{
13176 		"JMP32_JSGT_K: all immediate value magnitudes",
13177 		{ },
13178 		INTERNAL | FLAG_NO_DATA,
13179 		{ },
13180 		{ { 0, 1 } },
13181 		.fill_helper = bpf_fill_jmp32_jsgt_imm,
13182 		.nr_testruns = NR_PATTERN_RUNS,
13183 	},
13184 	{
13185 		"JMP32_JSGE_K: all immediate value magnitudes",
13186 		{ },
13187 		INTERNAL | FLAG_NO_DATA,
13188 		{ },
13189 		{ { 0, 1 } },
13190 		.fill_helper = bpf_fill_jmp32_jsge_imm,
13191 		.nr_testruns = NR_PATTERN_RUNS,
13192 	},
13193 	{
13194 		"JMP32_JSLT_K: all immediate value magnitudes",
13195 		{ },
13196 		INTERNAL | FLAG_NO_DATA,
13197 		{ },
13198 		{ { 0, 1 } },
13199 		.fill_helper = bpf_fill_jmp32_jslt_imm,
13200 		.nr_testruns = NR_PATTERN_RUNS,
13201 	},
13202 	{
13203 		"JMP32_JSLE_K: all immediate value magnitudes",
13204 		{ },
13205 		INTERNAL | FLAG_NO_DATA,
13206 		{ },
13207 		{ { 0, 1 } },
13208 		.fill_helper = bpf_fill_jmp32_jsle_imm,
13209 		.nr_testruns = NR_PATTERN_RUNS,
13210 	},
13211 	/* JMP32 register magnitudes */
13212 	{
13213 		"JMP32_JSET_X: all register value magnitudes",
13214 		{ },
13215 		INTERNAL | FLAG_NO_DATA,
13216 		{ },
13217 		{ { 0, 1 } },
13218 		.fill_helper = bpf_fill_jmp32_jset_reg,
13219 		.nr_testruns = NR_PATTERN_RUNS,
13220 	},
13221 	{
13222 		"JMP32_JEQ_X: all register value magnitudes",
13223 		{ },
13224 		INTERNAL | FLAG_NO_DATA,
13225 		{ },
13226 		{ { 0, 1 } },
13227 		.fill_helper = bpf_fill_jmp32_jeq_reg,
13228 		.nr_testruns = NR_PATTERN_RUNS,
13229 	},
13230 	{
13231 		"JMP32_JNE_X: all register value magnitudes",
13232 		{ },
13233 		INTERNAL | FLAG_NO_DATA,
13234 		{ },
13235 		{ { 0, 1 } },
13236 		.fill_helper = bpf_fill_jmp32_jne_reg,
13237 		.nr_testruns = NR_PATTERN_RUNS,
13238 	},
13239 	{
13240 		"JMP32_JGT_X: all register value magnitudes",
13241 		{ },
13242 		INTERNAL | FLAG_NO_DATA,
13243 		{ },
13244 		{ { 0, 1 } },
13245 		.fill_helper = bpf_fill_jmp32_jgt_reg,
13246 		.nr_testruns = NR_PATTERN_RUNS,
13247 	},
13248 	{
13249 		"JMP32_JGE_X: all register value magnitudes",
13250 		{ },
13251 		INTERNAL | FLAG_NO_DATA,
13252 		{ },
13253 		{ { 0, 1 } },
13254 		.fill_helper = bpf_fill_jmp32_jge_reg,
13255 		.nr_testruns = NR_PATTERN_RUNS,
13256 	},
13257 	{
13258 		"JMP32_JLT_X: all register value magnitudes",
13259 		{ },
13260 		INTERNAL | FLAG_NO_DATA,
13261 		{ },
13262 		{ { 0, 1 } },
13263 		.fill_helper = bpf_fill_jmp32_jlt_reg,
13264 		.nr_testruns = NR_PATTERN_RUNS,
13265 	},
13266 	{
13267 		"JMP32_JLE_X: all register value magnitudes",
13268 		{ },
13269 		INTERNAL | FLAG_NO_DATA,
13270 		{ },
13271 		{ { 0, 1 } },
13272 		.fill_helper = bpf_fill_jmp32_jle_reg,
13273 		.nr_testruns = NR_PATTERN_RUNS,
13274 	},
13275 	{
13276 		"JMP32_JSGT_X: all register value magnitudes",
13277 		{ },
13278 		INTERNAL | FLAG_NO_DATA,
13279 		{ },
13280 		{ { 0, 1 } },
13281 		.fill_helper = bpf_fill_jmp32_jsgt_reg,
13282 		.nr_testruns = NR_PATTERN_RUNS,
13283 	},
13284 	{
13285 		"JMP32_JSGE_X: all register value magnitudes",
13286 		{ },
13287 		INTERNAL | FLAG_NO_DATA,
13288 		{ },
13289 		{ { 0, 1 } },
13290 		.fill_helper = bpf_fill_jmp32_jsge_reg,
13291 		.nr_testruns = NR_PATTERN_RUNS,
13292 	},
13293 	{
13294 		"JMP32_JSLT_X: all register value magnitudes",
13295 		{ },
13296 		INTERNAL | FLAG_NO_DATA,
13297 		{ },
13298 		{ { 0, 1 } },
13299 		.fill_helper = bpf_fill_jmp32_jslt_reg,
13300 		.nr_testruns = NR_PATTERN_RUNS,
13301 	},
13302 	{
13303 		"JMP32_JSLE_X: all register value magnitudes",
13304 		{ },
13305 		INTERNAL | FLAG_NO_DATA,
13306 		{ },
13307 		{ { 0, 1 } },
13308 		.fill_helper = bpf_fill_jmp32_jsle_reg,
13309 		.nr_testruns = NR_PATTERN_RUNS,
13310 	},
13311 	/* Conditional jumps with constant decision */
13312 	{
13313 		"JMP_JSET_K: imm = 0 -> never taken",
13314 		.u.insns_int = {
13315 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13316 			BPF_JMP_IMM(BPF_JSET, R1, 0, 1),
13317 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13318 			BPF_EXIT_INSN(),
13319 		},
13320 		INTERNAL | FLAG_NO_DATA,
13321 		{ },
13322 		{ { 0, 0 } },
13323 	},
13324 	{
13325 		"JMP_JLT_K: imm = 0 -> never taken",
13326 		.u.insns_int = {
13327 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13328 			BPF_JMP_IMM(BPF_JLT, R1, 0, 1),
13329 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13330 			BPF_EXIT_INSN(),
13331 		},
13332 		INTERNAL | FLAG_NO_DATA,
13333 		{ },
13334 		{ { 0, 0 } },
13335 	},
13336 	{
13337 		"JMP_JGE_K: imm = 0 -> always taken",
13338 		.u.insns_int = {
13339 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13340 			BPF_JMP_IMM(BPF_JGE, R1, 0, 1),
13341 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13342 			BPF_EXIT_INSN(),
13343 		},
13344 		INTERNAL | FLAG_NO_DATA,
13345 		{ },
13346 		{ { 0, 1 } },
13347 	},
13348 	{
13349 		"JMP_JGT_K: imm = 0xffffffff -> never taken",
13350 		.u.insns_int = {
13351 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13352 			BPF_JMP_IMM(BPF_JGT, R1, U32_MAX, 1),
13353 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13354 			BPF_EXIT_INSN(),
13355 		},
13356 		INTERNAL | FLAG_NO_DATA,
13357 		{ },
13358 		{ { 0, 0 } },
13359 	},
13360 	{
13361 		"JMP_JLE_K: imm = 0xffffffff -> always taken",
13362 		.u.insns_int = {
13363 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13364 			BPF_JMP_IMM(BPF_JLE, R1, U32_MAX, 1),
13365 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13366 			BPF_EXIT_INSN(),
13367 		},
13368 		INTERNAL | FLAG_NO_DATA,
13369 		{ },
13370 		{ { 0, 1 } },
13371 	},
13372 	{
13373 		"JMP32_JSGT_K: imm = 0x7fffffff -> never taken",
13374 		.u.insns_int = {
13375 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13376 			BPF_JMP32_IMM(BPF_JSGT, R1, S32_MAX, 1),
13377 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13378 			BPF_EXIT_INSN(),
13379 		},
13380 		INTERNAL | FLAG_NO_DATA,
13381 		{ },
13382 		{ { 0, 0 } },
13383 	},
13384 	{
13385 		"JMP32_JSGE_K: imm = -0x80000000 -> always taken",
13386 		.u.insns_int = {
13387 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13388 			BPF_JMP32_IMM(BPF_JSGE, R1, S32_MIN, 1),
13389 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13390 			BPF_EXIT_INSN(),
13391 		},
13392 		INTERNAL | FLAG_NO_DATA,
13393 		{ },
13394 		{ { 0, 1 } },
13395 	},
13396 	{
13397 		"JMP32_JSLT_K: imm = -0x80000000 -> never taken",
13398 		.u.insns_int = {
13399 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13400 			BPF_JMP32_IMM(BPF_JSLT, R1, S32_MIN, 1),
13401 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13402 			BPF_EXIT_INSN(),
13403 		},
13404 		INTERNAL | FLAG_NO_DATA,
13405 		{ },
13406 		{ { 0, 0 } },
13407 	},
13408 	{
13409 		"JMP32_JSLE_K: imm = 0x7fffffff -> always taken",
13410 		.u.insns_int = {
13411 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13412 			BPF_JMP32_IMM(BPF_JSLE, R1, S32_MAX, 1),
13413 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13414 			BPF_EXIT_INSN(),
13415 		},
13416 		INTERNAL | FLAG_NO_DATA,
13417 		{ },
13418 		{ { 0, 1 } },
13419 	},
13420 	{
13421 		"JMP_JEQ_X: dst = src -> always taken",
13422 		.u.insns_int = {
13423 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13424 			BPF_JMP_REG(BPF_JEQ, R1, R1, 1),
13425 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13426 			BPF_EXIT_INSN(),
13427 		},
13428 		INTERNAL | FLAG_NO_DATA,
13429 		{ },
13430 		{ { 0, 1 } },
13431 	},
13432 	{
13433 		"JMP_JGE_X: dst = src -> always taken",
13434 		.u.insns_int = {
13435 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13436 			BPF_JMP_REG(BPF_JGE, R1, R1, 1),
13437 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13438 			BPF_EXIT_INSN(),
13439 		},
13440 		INTERNAL | FLAG_NO_DATA,
13441 		{ },
13442 		{ { 0, 1 } },
13443 	},
13444 	{
13445 		"JMP_JLE_X: dst = src -> always taken",
13446 		.u.insns_int = {
13447 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13448 			BPF_JMP_REG(BPF_JLE, R1, R1, 1),
13449 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13450 			BPF_EXIT_INSN(),
13451 		},
13452 		INTERNAL | FLAG_NO_DATA,
13453 		{ },
13454 		{ { 0, 1 } },
13455 	},
13456 	{
13457 		"JMP_JSGE_X: dst = src -> always taken",
13458 		.u.insns_int = {
13459 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13460 			BPF_JMP_REG(BPF_JSGE, R1, R1, 1),
13461 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13462 			BPF_EXIT_INSN(),
13463 		},
13464 		INTERNAL | FLAG_NO_DATA,
13465 		{ },
13466 		{ { 0, 1 } },
13467 	},
13468 	{
13469 		"JMP_JSLE_X: dst = src -> always taken",
13470 		.u.insns_int = {
13471 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13472 			BPF_JMP_REG(BPF_JSLE, R1, R1, 1),
13473 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13474 			BPF_EXIT_INSN(),
13475 		},
13476 		INTERNAL | FLAG_NO_DATA,
13477 		{ },
13478 		{ { 0, 1 } },
13479 	},
13480 	{
13481 		"JMP_JNE_X: dst = src -> never taken",
13482 		.u.insns_int = {
13483 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13484 			BPF_JMP_REG(BPF_JNE, R1, R1, 1),
13485 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13486 			BPF_EXIT_INSN(),
13487 		},
13488 		INTERNAL | FLAG_NO_DATA,
13489 		{ },
13490 		{ { 0, 0 } },
13491 	},
13492 	{
13493 		"JMP_JGT_X: dst = src -> never taken",
13494 		.u.insns_int = {
13495 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13496 			BPF_JMP_REG(BPF_JGT, R1, R1, 1),
13497 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13498 			BPF_EXIT_INSN(),
13499 		},
13500 		INTERNAL | FLAG_NO_DATA,
13501 		{ },
13502 		{ { 0, 0 } },
13503 	},
13504 	{
13505 		"JMP_JLT_X: dst = src -> never taken",
13506 		.u.insns_int = {
13507 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13508 			BPF_JMP_REG(BPF_JLT, R1, R1, 1),
13509 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13510 			BPF_EXIT_INSN(),
13511 		},
13512 		INTERNAL | FLAG_NO_DATA,
13513 		{ },
13514 		{ { 0, 0 } },
13515 	},
13516 	{
13517 		"JMP_JSGT_X: dst = src -> never taken",
13518 		.u.insns_int = {
13519 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13520 			BPF_JMP_REG(BPF_JSGT, R1, R1, 1),
13521 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13522 			BPF_EXIT_INSN(),
13523 		},
13524 		INTERNAL | FLAG_NO_DATA,
13525 		{ },
13526 		{ { 0, 0 } },
13527 	},
13528 	{
13529 		"JMP_JSLT_X: dst = src -> never taken",
13530 		.u.insns_int = {
13531 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13532 			BPF_JMP_REG(BPF_JSLT, R1, R1, 1),
13533 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13534 			BPF_EXIT_INSN(),
13535 		},
13536 		INTERNAL | FLAG_NO_DATA,
13537 		{ },
13538 		{ { 0, 0 } },
13539 	},
13540 	/* Short relative jumps */
13541 	{
13542 		"Short relative jump: offset=0",
13543 		.u.insns_int = {
13544 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13545 			BPF_JMP_IMM(BPF_JEQ, R0, 0, 0),
13546 			BPF_EXIT_INSN(),
13547 			BPF_ALU32_IMM(BPF_MOV, R0, -1),
13548 		},
13549 		INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
13550 		{ },
13551 		{ { 0, 0 } },
13552 	},
13553 	{
13554 		"Short relative jump: offset=1",
13555 		.u.insns_int = {
13556 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13557 			BPF_JMP_IMM(BPF_JEQ, R0, 0, 1),
13558 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
13559 			BPF_EXIT_INSN(),
13560 			BPF_ALU32_IMM(BPF_MOV, R0, -1),
13561 		},
13562 		INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
13563 		{ },
13564 		{ { 0, 0 } },
13565 	},
13566 	{
13567 		"Short relative jump: offset=2",
13568 		.u.insns_int = {
13569 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13570 			BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
13571 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
13572 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
13573 			BPF_EXIT_INSN(),
13574 			BPF_ALU32_IMM(BPF_MOV, R0, -1),
13575 		},
13576 		INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
13577 		{ },
13578 		{ { 0, 0 } },
13579 	},
13580 	{
13581 		"Short relative jump: offset=3",
13582 		.u.insns_int = {
13583 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13584 			BPF_JMP_IMM(BPF_JEQ, R0, 0, 3),
13585 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
13586 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
13587 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
13588 			BPF_EXIT_INSN(),
13589 			BPF_ALU32_IMM(BPF_MOV, R0, -1),
13590 		},
13591 		INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
13592 		{ },
13593 		{ { 0, 0 } },
13594 	},
13595 	{
13596 		"Short relative jump: offset=4",
13597 		.u.insns_int = {
13598 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13599 			BPF_JMP_IMM(BPF_JEQ, R0, 0, 4),
13600 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
13601 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
13602 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
13603 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
13604 			BPF_EXIT_INSN(),
13605 			BPF_ALU32_IMM(BPF_MOV, R0, -1),
13606 		},
13607 		INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
13608 		{ },
13609 		{ { 0, 0 } },
13610 	},
13611 	/* Conditional branch conversions */
13612 	{
13613 		"Long conditional jump: taken at runtime",
13614 		{ },
13615 		INTERNAL | FLAG_NO_DATA,
13616 		{ },
13617 		{ { 0, 1 } },
13618 		.fill_helper = bpf_fill_max_jmp_taken,
13619 	},
13620 	{
13621 		"Long conditional jump: not taken at runtime",
13622 		{ },
13623 		INTERNAL | FLAG_NO_DATA,
13624 		{ },
13625 		{ { 0, 2 } },
13626 		.fill_helper = bpf_fill_max_jmp_not_taken,
13627 	},
13628 	{
13629 		"Long conditional jump: always taken, known at JIT time",
13630 		{ },
13631 		INTERNAL | FLAG_NO_DATA,
13632 		{ },
13633 		{ { 0, 1 } },
13634 		.fill_helper = bpf_fill_max_jmp_always_taken,
13635 	},
13636 	{
13637 		"Long conditional jump: never taken, known at JIT time",
13638 		{ },
13639 		INTERNAL | FLAG_NO_DATA,
13640 		{ },
13641 		{ { 0, 2 } },
13642 		.fill_helper = bpf_fill_max_jmp_never_taken,
13643 	},
13644 	/* Staggered jump sequences, immediate */
13645 	{
13646 		"Staggered jumps: JMP_JA",
13647 		{ },
13648 		INTERNAL | FLAG_NO_DATA,
13649 		{ },
13650 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13651 		.fill_helper = bpf_fill_staggered_ja,
13652 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13653 	},
13654 	{
13655 		"Staggered jumps: JMP_JEQ_K",
13656 		{ },
13657 		INTERNAL | FLAG_NO_DATA,
13658 		{ },
13659 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13660 		.fill_helper = bpf_fill_staggered_jeq_imm,
13661 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13662 	},
13663 	{
13664 		"Staggered jumps: JMP_JNE_K",
13665 		{ },
13666 		INTERNAL | FLAG_NO_DATA,
13667 		{ },
13668 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13669 		.fill_helper = bpf_fill_staggered_jne_imm,
13670 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13671 	},
13672 	{
13673 		"Staggered jumps: JMP_JSET_K",
13674 		{ },
13675 		INTERNAL | FLAG_NO_DATA,
13676 		{ },
13677 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13678 		.fill_helper = bpf_fill_staggered_jset_imm,
13679 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13680 	},
13681 	{
13682 		"Staggered jumps: JMP_JGT_K",
13683 		{ },
13684 		INTERNAL | FLAG_NO_DATA,
13685 		{ },
13686 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13687 		.fill_helper = bpf_fill_staggered_jgt_imm,
13688 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13689 	},
13690 	{
13691 		"Staggered jumps: JMP_JGE_K",
13692 		{ },
13693 		INTERNAL | FLAG_NO_DATA,
13694 		{ },
13695 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13696 		.fill_helper = bpf_fill_staggered_jge_imm,
13697 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13698 	},
13699 	{
13700 		"Staggered jumps: JMP_JLT_K",
13701 		{ },
13702 		INTERNAL | FLAG_NO_DATA,
13703 		{ },
13704 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13705 		.fill_helper = bpf_fill_staggered_jlt_imm,
13706 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13707 	},
13708 	{
13709 		"Staggered jumps: JMP_JLE_K",
13710 		{ },
13711 		INTERNAL | FLAG_NO_DATA,
13712 		{ },
13713 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13714 		.fill_helper = bpf_fill_staggered_jle_imm,
13715 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13716 	},
13717 	{
13718 		"Staggered jumps: JMP_JSGT_K",
13719 		{ },
13720 		INTERNAL | FLAG_NO_DATA,
13721 		{ },
13722 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13723 		.fill_helper = bpf_fill_staggered_jsgt_imm,
13724 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13725 	},
13726 	{
13727 		"Staggered jumps: JMP_JSGE_K",
13728 		{ },
13729 		INTERNAL | FLAG_NO_DATA,
13730 		{ },
13731 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13732 		.fill_helper = bpf_fill_staggered_jsge_imm,
13733 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13734 	},
13735 	{
13736 		"Staggered jumps: JMP_JSLT_K",
13737 		{ },
13738 		INTERNAL | FLAG_NO_DATA,
13739 		{ },
13740 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13741 		.fill_helper = bpf_fill_staggered_jslt_imm,
13742 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13743 	},
13744 	{
13745 		"Staggered jumps: JMP_JSLE_K",
13746 		{ },
13747 		INTERNAL | FLAG_NO_DATA,
13748 		{ },
13749 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13750 		.fill_helper = bpf_fill_staggered_jsle_imm,
13751 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13752 	},
13753 	/* Staggered jump sequences, register */
13754 	{
13755 		"Staggered jumps: JMP_JEQ_X",
13756 		{ },
13757 		INTERNAL | FLAG_NO_DATA,
13758 		{ },
13759 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13760 		.fill_helper = bpf_fill_staggered_jeq_reg,
13761 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13762 	},
13763 	{
13764 		"Staggered jumps: JMP_JNE_X",
13765 		{ },
13766 		INTERNAL | FLAG_NO_DATA,
13767 		{ },
13768 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13769 		.fill_helper = bpf_fill_staggered_jne_reg,
13770 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13771 	},
13772 	{
13773 		"Staggered jumps: JMP_JSET_X",
13774 		{ },
13775 		INTERNAL | FLAG_NO_DATA,
13776 		{ },
13777 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13778 		.fill_helper = bpf_fill_staggered_jset_reg,
13779 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13780 	},
13781 	{
13782 		"Staggered jumps: JMP_JGT_X",
13783 		{ },
13784 		INTERNAL | FLAG_NO_DATA,
13785 		{ },
13786 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13787 		.fill_helper = bpf_fill_staggered_jgt_reg,
13788 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13789 	},
13790 	{
13791 		"Staggered jumps: JMP_JGE_X",
13792 		{ },
13793 		INTERNAL | FLAG_NO_DATA,
13794 		{ },
13795 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13796 		.fill_helper = bpf_fill_staggered_jge_reg,
13797 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13798 	},
13799 	{
13800 		"Staggered jumps: JMP_JLT_X",
13801 		{ },
13802 		INTERNAL | FLAG_NO_DATA,
13803 		{ },
13804 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13805 		.fill_helper = bpf_fill_staggered_jlt_reg,
13806 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13807 	},
13808 	{
13809 		"Staggered jumps: JMP_JLE_X",
13810 		{ },
13811 		INTERNAL | FLAG_NO_DATA,
13812 		{ },
13813 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13814 		.fill_helper = bpf_fill_staggered_jle_reg,
13815 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13816 	},
13817 	{
13818 		"Staggered jumps: JMP_JSGT_X",
13819 		{ },
13820 		INTERNAL | FLAG_NO_DATA,
13821 		{ },
13822 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13823 		.fill_helper = bpf_fill_staggered_jsgt_reg,
13824 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13825 	},
13826 	{
13827 		"Staggered jumps: JMP_JSGE_X",
13828 		{ },
13829 		INTERNAL | FLAG_NO_DATA,
13830 		{ },
13831 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13832 		.fill_helper = bpf_fill_staggered_jsge_reg,
13833 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13834 	},
13835 	{
13836 		"Staggered jumps: JMP_JSLT_X",
13837 		{ },
13838 		INTERNAL | FLAG_NO_DATA,
13839 		{ },
13840 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13841 		.fill_helper = bpf_fill_staggered_jslt_reg,
13842 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13843 	},
13844 	{
13845 		"Staggered jumps: JMP_JSLE_X",
13846 		{ },
13847 		INTERNAL | FLAG_NO_DATA,
13848 		{ },
13849 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13850 		.fill_helper = bpf_fill_staggered_jsle_reg,
13851 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13852 	},
13853 	/* Staggered jump sequences, JMP32 immediate */
13854 	{
13855 		"Staggered jumps: JMP32_JEQ_K",
13856 		{ },
13857 		INTERNAL | FLAG_NO_DATA,
13858 		{ },
13859 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13860 		.fill_helper = bpf_fill_staggered_jeq32_imm,
13861 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13862 	},
13863 	{
13864 		"Staggered jumps: JMP32_JNE_K",
13865 		{ },
13866 		INTERNAL | FLAG_NO_DATA,
13867 		{ },
13868 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13869 		.fill_helper = bpf_fill_staggered_jne32_imm,
13870 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13871 	},
13872 	{
13873 		"Staggered jumps: JMP32_JSET_K",
13874 		{ },
13875 		INTERNAL | FLAG_NO_DATA,
13876 		{ },
13877 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13878 		.fill_helper = bpf_fill_staggered_jset32_imm,
13879 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13880 	},
13881 	{
13882 		"Staggered jumps: JMP32_JGT_K",
13883 		{ },
13884 		INTERNAL | FLAG_NO_DATA,
13885 		{ },
13886 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13887 		.fill_helper = bpf_fill_staggered_jgt32_imm,
13888 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13889 	},
13890 	{
13891 		"Staggered jumps: JMP32_JGE_K",
13892 		{ },
13893 		INTERNAL | FLAG_NO_DATA,
13894 		{ },
13895 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13896 		.fill_helper = bpf_fill_staggered_jge32_imm,
13897 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13898 	},
13899 	{
13900 		"Staggered jumps: JMP32_JLT_K",
13901 		{ },
13902 		INTERNAL | FLAG_NO_DATA,
13903 		{ },
13904 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13905 		.fill_helper = bpf_fill_staggered_jlt32_imm,
13906 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13907 	},
13908 	{
13909 		"Staggered jumps: JMP32_JLE_K",
13910 		{ },
13911 		INTERNAL | FLAG_NO_DATA,
13912 		{ },
13913 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13914 		.fill_helper = bpf_fill_staggered_jle32_imm,
13915 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13916 	},
13917 	{
13918 		"Staggered jumps: JMP32_JSGT_K",
13919 		{ },
13920 		INTERNAL | FLAG_NO_DATA,
13921 		{ },
13922 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13923 		.fill_helper = bpf_fill_staggered_jsgt32_imm,
13924 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13925 	},
13926 	{
13927 		"Staggered jumps: JMP32_JSGE_K",
13928 		{ },
13929 		INTERNAL | FLAG_NO_DATA,
13930 		{ },
13931 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13932 		.fill_helper = bpf_fill_staggered_jsge32_imm,
13933 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13934 	},
13935 	{
13936 		"Staggered jumps: JMP32_JSLT_K",
13937 		{ },
13938 		INTERNAL | FLAG_NO_DATA,
13939 		{ },
13940 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13941 		.fill_helper = bpf_fill_staggered_jslt32_imm,
13942 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13943 	},
13944 	{
13945 		"Staggered jumps: JMP32_JSLE_K",
13946 		{ },
13947 		INTERNAL | FLAG_NO_DATA,
13948 		{ },
13949 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13950 		.fill_helper = bpf_fill_staggered_jsle32_imm,
13951 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13952 	},
13953 	/* Staggered jump sequences, JMP32 register */
13954 	{
13955 		"Staggered jumps: JMP32_JEQ_X",
13956 		{ },
13957 		INTERNAL | FLAG_NO_DATA,
13958 		{ },
13959 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13960 		.fill_helper = bpf_fill_staggered_jeq32_reg,
13961 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13962 	},
13963 	{
13964 		"Staggered jumps: JMP32_JNE_X",
13965 		{ },
13966 		INTERNAL | FLAG_NO_DATA,
13967 		{ },
13968 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13969 		.fill_helper = bpf_fill_staggered_jne32_reg,
13970 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13971 	},
13972 	{
13973 		"Staggered jumps: JMP32_JSET_X",
13974 		{ },
13975 		INTERNAL | FLAG_NO_DATA,
13976 		{ },
13977 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13978 		.fill_helper = bpf_fill_staggered_jset32_reg,
13979 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13980 	},
13981 	{
13982 		"Staggered jumps: JMP32_JGT_X",
13983 		{ },
13984 		INTERNAL | FLAG_NO_DATA,
13985 		{ },
13986 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13987 		.fill_helper = bpf_fill_staggered_jgt32_reg,
13988 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13989 	},
13990 	{
13991 		"Staggered jumps: JMP32_JGE_X",
13992 		{ },
13993 		INTERNAL | FLAG_NO_DATA,
13994 		{ },
13995 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13996 		.fill_helper = bpf_fill_staggered_jge32_reg,
13997 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13998 	},
13999 	{
14000 		"Staggered jumps: JMP32_JLT_X",
14001 		{ },
14002 		INTERNAL | FLAG_NO_DATA,
14003 		{ },
14004 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14005 		.fill_helper = bpf_fill_staggered_jlt32_reg,
14006 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14007 	},
14008 	{
14009 		"Staggered jumps: JMP32_JLE_X",
14010 		{ },
14011 		INTERNAL | FLAG_NO_DATA,
14012 		{ },
14013 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14014 		.fill_helper = bpf_fill_staggered_jle32_reg,
14015 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14016 	},
14017 	{
14018 		"Staggered jumps: JMP32_JSGT_X",
14019 		{ },
14020 		INTERNAL | FLAG_NO_DATA,
14021 		{ },
14022 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14023 		.fill_helper = bpf_fill_staggered_jsgt32_reg,
14024 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14025 	},
14026 	{
14027 		"Staggered jumps: JMP32_JSGE_X",
14028 		{ },
14029 		INTERNAL | FLAG_NO_DATA,
14030 		{ },
14031 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14032 		.fill_helper = bpf_fill_staggered_jsge32_reg,
14033 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14034 	},
14035 	{
14036 		"Staggered jumps: JMP32_JSLT_X",
14037 		{ },
14038 		INTERNAL | FLAG_NO_DATA,
14039 		{ },
14040 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14041 		.fill_helper = bpf_fill_staggered_jslt32_reg,
14042 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14043 	},
14044 	{
14045 		"Staggered jumps: JMP32_JSLE_X",
14046 		{ },
14047 		INTERNAL | FLAG_NO_DATA,
14048 		{ },
14049 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14050 		.fill_helper = bpf_fill_staggered_jsle32_reg,
14051 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14052 	},
14053 };
14054 
14055 static struct net_device dev;
14056 
14057 static struct sk_buff *populate_skb(char *buf, int size)
14058 {
14059 	struct sk_buff *skb;
14060 
14061 	if (size >= MAX_DATA)
14062 		return NULL;
14063 
14064 	skb = alloc_skb(MAX_DATA, GFP_KERNEL);
14065 	if (!skb)
14066 		return NULL;
14067 
14068 	__skb_put_data(skb, buf, size);
14069 
14070 	/* Initialize a fake skb with test pattern. */
14071 	skb_reset_mac_header(skb);
14072 	skb->protocol = htons(ETH_P_IP);
14073 	skb->pkt_type = SKB_TYPE;
14074 	skb->mark = SKB_MARK;
14075 	skb->hash = SKB_HASH;
14076 	skb->queue_mapping = SKB_QUEUE_MAP;
14077 	skb->vlan_tci = SKB_VLAN_TCI;
14078 	skb->vlan_present = SKB_VLAN_PRESENT;
14079 	skb->vlan_proto = htons(ETH_P_IP);
14080 	dev_net_set(&dev, &init_net);
14081 	skb->dev = &dev;
14082 	skb->dev->ifindex = SKB_DEV_IFINDEX;
14083 	skb->dev->type = SKB_DEV_TYPE;
14084 	skb_set_network_header(skb, min(size, ETH_HLEN));
14085 
14086 	return skb;
14087 }
14088 
14089 static void *generate_test_data(struct bpf_test *test, int sub)
14090 {
14091 	struct sk_buff *skb;
14092 	struct page *page;
14093 
14094 	if (test->aux & FLAG_NO_DATA)
14095 		return NULL;
14096 
14097 	/* Test case expects an skb, so populate one. Various
14098 	 * subtests generate skbs of different sizes based on
14099 	 * the same data.
14100 	 */
14101 	skb = populate_skb(test->data, test->test[sub].data_size);
14102 	if (!skb)
14103 		return NULL;
14104 
14105 	if (test->aux & FLAG_SKB_FRAG) {
14106 		/*
14107 		 * when the test requires a fragmented skb, add a
14108 		 * single fragment to the skb, filled with
14109 		 * test->frag_data.
14110 		 */
14111 		void *ptr;
14112 
14113 		page = alloc_page(GFP_KERNEL);
14114 
14115 		if (!page)
14116 			goto err_kfree_skb;
14117 
14118 		ptr = kmap(page);
14119 		if (!ptr)
14120 			goto err_free_page;
14121 		memcpy(ptr, test->frag_data, MAX_DATA);
14122 		kunmap(page);
14123 		skb_add_rx_frag(skb, 0, page, 0, MAX_DATA, MAX_DATA);
14124 	}
14125 
14126 	return skb;
14127 
14128 err_free_page:
14129 	__free_page(page);
14130 err_kfree_skb:
14131 	kfree_skb(skb);
14132 	return NULL;
14133 }
14134 
14135 static void release_test_data(const struct bpf_test *test, void *data)
14136 {
14137 	if (test->aux & FLAG_NO_DATA)
14138 		return;
14139 
14140 	kfree_skb(data);
14141 }
14142 
14143 static int filter_length(int which)
14144 {
14145 	struct sock_filter *fp;
14146 	int len;
14147 
14148 	if (tests[which].fill_helper)
14149 		return tests[which].u.ptr.len;
14150 
14151 	fp = tests[which].u.insns;
14152 	for (len = MAX_INSNS - 1; len > 0; --len)
14153 		if (fp[len].code != 0 || fp[len].k != 0)
14154 			break;
14155 
14156 	return len + 1;
14157 }
14158 
14159 static void *filter_pointer(int which)
14160 {
14161 	if (tests[which].fill_helper)
14162 		return tests[which].u.ptr.insns;
14163 	else
14164 		return tests[which].u.insns;
14165 }
14166 
14167 static struct bpf_prog *generate_filter(int which, int *err)
14168 {
14169 	__u8 test_type = tests[which].aux & TEST_TYPE_MASK;
14170 	unsigned int flen = filter_length(which);
14171 	void *fptr = filter_pointer(which);
14172 	struct sock_fprog_kern fprog;
14173 	struct bpf_prog *fp;
14174 
14175 	switch (test_type) {
14176 	case CLASSIC:
14177 		fprog.filter = fptr;
14178 		fprog.len = flen;
14179 
14180 		*err = bpf_prog_create(&fp, &fprog);
14181 		if (tests[which].aux & FLAG_EXPECTED_FAIL) {
14182 			if (*err == tests[which].expected_errcode) {
14183 				pr_cont("PASS\n");
14184 				/* Verifier rejected filter as expected. */
14185 				*err = 0;
14186 				return NULL;
14187 			} else {
14188 				pr_cont("UNEXPECTED_PASS\n");
14189 				/* Verifier didn't reject the test that's
14190 				 * bad enough, just return!
14191 				 */
14192 				*err = -EINVAL;
14193 				return NULL;
14194 			}
14195 		}
14196 		if (*err) {
14197 			pr_cont("FAIL to prog_create err=%d len=%d\n",
14198 				*err, fprog.len);
14199 			return NULL;
14200 		}
14201 		break;
14202 
14203 	case INTERNAL:
14204 		fp = bpf_prog_alloc(bpf_prog_size(flen), 0);
14205 		if (fp == NULL) {
14206 			pr_cont("UNEXPECTED_FAIL no memory left\n");
14207 			*err = -ENOMEM;
14208 			return NULL;
14209 		}
14210 
14211 		fp->len = flen;
14212 		/* Type doesn't really matter here as long as it's not unspec. */
14213 		fp->type = BPF_PROG_TYPE_SOCKET_FILTER;
14214 		memcpy(fp->insnsi, fptr, fp->len * sizeof(struct bpf_insn));
14215 		fp->aux->stack_depth = tests[which].stack_depth;
14216 		fp->aux->verifier_zext = !!(tests[which].aux &
14217 					    FLAG_VERIFIER_ZEXT);
14218 
14219 		/* We cannot error here as we don't need type compatibility
14220 		 * checks.
14221 		 */
14222 		fp = bpf_prog_select_runtime(fp, err);
14223 		if (*err) {
14224 			pr_cont("FAIL to select_runtime err=%d\n", *err);
14225 			return NULL;
14226 		}
14227 		break;
14228 	}
14229 
14230 	*err = 0;
14231 	return fp;
14232 }
14233 
14234 static void release_filter(struct bpf_prog *fp, int which)
14235 {
14236 	__u8 test_type = tests[which].aux & TEST_TYPE_MASK;
14237 
14238 	switch (test_type) {
14239 	case CLASSIC:
14240 		bpf_prog_destroy(fp);
14241 		break;
14242 	case INTERNAL:
14243 		bpf_prog_free(fp);
14244 		break;
14245 	}
14246 }
14247 
14248 static int __run_one(const struct bpf_prog *fp, const void *data,
14249 		     int runs, u64 *duration)
14250 {
14251 	u64 start, finish;
14252 	int ret = 0, i;
14253 
14254 	migrate_disable();
14255 	start = ktime_get_ns();
14256 
14257 	for (i = 0; i < runs; i++)
14258 		ret = bpf_prog_run(fp, data);
14259 
14260 	finish = ktime_get_ns();
14261 	migrate_enable();
14262 
14263 	*duration = finish - start;
14264 	do_div(*duration, runs);
14265 
14266 	return ret;
14267 }
14268 
14269 static int run_one(const struct bpf_prog *fp, struct bpf_test *test)
14270 {
14271 	int err_cnt = 0, i, runs = MAX_TESTRUNS;
14272 
14273 	if (test->nr_testruns)
14274 		runs = min(test->nr_testruns, MAX_TESTRUNS);
14275 
14276 	for (i = 0; i < MAX_SUBTESTS; i++) {
14277 		void *data;
14278 		u64 duration;
14279 		u32 ret;
14280 
14281 		/*
14282 		 * NOTE: Several sub-tests may be present, in which case
14283 		 * a zero {data_size, result} tuple indicates the end of
14284 		 * the sub-test array. The first test is always run,
14285 		 * even if both data_size and result happen to be zero.
14286 		 */
14287 		if (i > 0 &&
14288 		    test->test[i].data_size == 0 &&
14289 		    test->test[i].result == 0)
14290 			break;
14291 
14292 		data = generate_test_data(test, i);
14293 		if (!data && !(test->aux & FLAG_NO_DATA)) {
14294 			pr_cont("data generation failed ");
14295 			err_cnt++;
14296 			break;
14297 		}
14298 		ret = __run_one(fp, data, runs, &duration);
14299 		release_test_data(test, data);
14300 
14301 		if (ret == test->test[i].result) {
14302 			pr_cont("%lld ", duration);
14303 		} else {
14304 			pr_cont("ret %d != %d ", ret,
14305 				test->test[i].result);
14306 			err_cnt++;
14307 		}
14308 	}
14309 
14310 	return err_cnt;
14311 }
14312 
14313 static char test_name[64];
14314 module_param_string(test_name, test_name, sizeof(test_name), 0);
14315 
14316 static int test_id = -1;
14317 module_param(test_id, int, 0);
14318 
14319 static int test_range[2] = { 0, INT_MAX };
14320 module_param_array(test_range, int, NULL, 0);
14321 
14322 static bool exclude_test(int test_id)
14323 {
14324 	return test_id < test_range[0] || test_id > test_range[1];
14325 }
14326 
14327 static __init struct sk_buff *build_test_skb(void)
14328 {
14329 	u32 headroom = NET_SKB_PAD + NET_IP_ALIGN + ETH_HLEN;
14330 	struct sk_buff *skb[2];
14331 	struct page *page[2];
14332 	int i, data_size = 8;
14333 
14334 	for (i = 0; i < 2; i++) {
14335 		page[i] = alloc_page(GFP_KERNEL);
14336 		if (!page[i]) {
14337 			if (i == 0)
14338 				goto err_page0;
14339 			else
14340 				goto err_page1;
14341 		}
14342 
14343 		/* this will set skb[i]->head_frag */
14344 		skb[i] = dev_alloc_skb(headroom + data_size);
14345 		if (!skb[i]) {
14346 			if (i == 0)
14347 				goto err_skb0;
14348 			else
14349 				goto err_skb1;
14350 		}
14351 
14352 		skb_reserve(skb[i], headroom);
14353 		skb_put(skb[i], data_size);
14354 		skb[i]->protocol = htons(ETH_P_IP);
14355 		skb_reset_network_header(skb[i]);
14356 		skb_set_mac_header(skb[i], -ETH_HLEN);
14357 
14358 		skb_add_rx_frag(skb[i], 0, page[i], 0, 64, 64);
14359 		// skb_headlen(skb[i]): 8, skb[i]->head_frag = 1
14360 	}
14361 
14362 	/* setup shinfo */
14363 	skb_shinfo(skb[0])->gso_size = 1448;
14364 	skb_shinfo(skb[0])->gso_type = SKB_GSO_TCPV4;
14365 	skb_shinfo(skb[0])->gso_type |= SKB_GSO_DODGY;
14366 	skb_shinfo(skb[0])->gso_segs = 0;
14367 	skb_shinfo(skb[0])->frag_list = skb[1];
14368 	skb_shinfo(skb[0])->hwtstamps.hwtstamp = 1000;
14369 
14370 	/* adjust skb[0]'s len */
14371 	skb[0]->len += skb[1]->len;
14372 	skb[0]->data_len += skb[1]->data_len;
14373 	skb[0]->truesize += skb[1]->truesize;
14374 
14375 	return skb[0];
14376 
14377 err_skb1:
14378 	__free_page(page[1]);
14379 err_page1:
14380 	kfree_skb(skb[0]);
14381 err_skb0:
14382 	__free_page(page[0]);
14383 err_page0:
14384 	return NULL;
14385 }
14386 
14387 static __init struct sk_buff *build_test_skb_linear_no_head_frag(void)
14388 {
14389 	unsigned int alloc_size = 2000;
14390 	unsigned int headroom = 102, doffset = 72, data_size = 1308;
14391 	struct sk_buff *skb[2];
14392 	int i;
14393 
14394 	/* skbs linked in a frag_list, both with linear data, with head_frag=0
14395 	 * (data allocated by kmalloc), both have tcp data of 1308 bytes
14396 	 * (total payload is 2616 bytes).
14397 	 * Data offset is 72 bytes (40 ipv6 hdr, 32 tcp hdr). Some headroom.
14398 	 */
14399 	for (i = 0; i < 2; i++) {
14400 		skb[i] = alloc_skb(alloc_size, GFP_KERNEL);
14401 		if (!skb[i]) {
14402 			if (i == 0)
14403 				goto err_skb0;
14404 			else
14405 				goto err_skb1;
14406 		}
14407 
14408 		skb[i]->protocol = htons(ETH_P_IPV6);
14409 		skb_reserve(skb[i], headroom);
14410 		skb_put(skb[i], doffset + data_size);
14411 		skb_reset_network_header(skb[i]);
14412 		if (i == 0)
14413 			skb_reset_mac_header(skb[i]);
14414 		else
14415 			skb_set_mac_header(skb[i], -ETH_HLEN);
14416 		__skb_pull(skb[i], doffset);
14417 	}
14418 
14419 	/* setup shinfo.
14420 	 * mimic bpf_skb_proto_4_to_6, which resets gso_segs and assigns a
14421 	 * reduced gso_size.
14422 	 */
14423 	skb_shinfo(skb[0])->gso_size = 1288;
14424 	skb_shinfo(skb[0])->gso_type = SKB_GSO_TCPV6 | SKB_GSO_DODGY;
14425 	skb_shinfo(skb[0])->gso_segs = 0;
14426 	skb_shinfo(skb[0])->frag_list = skb[1];
14427 
14428 	/* adjust skb[0]'s len */
14429 	skb[0]->len += skb[1]->len;
14430 	skb[0]->data_len += skb[1]->len;
14431 	skb[0]->truesize += skb[1]->truesize;
14432 
14433 	return skb[0];
14434 
14435 err_skb1:
14436 	kfree_skb(skb[0]);
14437 err_skb0:
14438 	return NULL;
14439 }
14440 
14441 struct skb_segment_test {
14442 	const char *descr;
14443 	struct sk_buff *(*build_skb)(void);
14444 	netdev_features_t features;
14445 };
14446 
14447 static struct skb_segment_test skb_segment_tests[] __initconst = {
14448 	{
14449 		.descr = "gso_with_rx_frags",
14450 		.build_skb = build_test_skb,
14451 		.features = NETIF_F_SG | NETIF_F_GSO_PARTIAL | NETIF_F_IP_CSUM |
14452 			    NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM
14453 	},
14454 	{
14455 		.descr = "gso_linear_no_head_frag",
14456 		.build_skb = build_test_skb_linear_no_head_frag,
14457 		.features = NETIF_F_SG | NETIF_F_FRAGLIST |
14458 			    NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_GSO |
14459 			    NETIF_F_LLTX_BIT | NETIF_F_GRO |
14460 			    NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM |
14461 			    NETIF_F_HW_VLAN_STAG_TX_BIT
14462 	}
14463 };
14464 
14465 static __init int test_skb_segment_single(const struct skb_segment_test *test)
14466 {
14467 	struct sk_buff *skb, *segs;
14468 	int ret = -1;
14469 
14470 	skb = test->build_skb();
14471 	if (!skb) {
14472 		pr_info("%s: failed to build_test_skb", __func__);
14473 		goto done;
14474 	}
14475 
14476 	segs = skb_segment(skb, test->features);
14477 	if (!IS_ERR(segs)) {
14478 		kfree_skb_list(segs);
14479 		ret = 0;
14480 	}
14481 	kfree_skb(skb);
14482 done:
14483 	return ret;
14484 }
14485 
14486 static __init int test_skb_segment(void)
14487 {
14488 	int i, err_cnt = 0, pass_cnt = 0;
14489 
14490 	for (i = 0; i < ARRAY_SIZE(skb_segment_tests); i++) {
14491 		const struct skb_segment_test *test = &skb_segment_tests[i];
14492 
14493 		cond_resched();
14494 		if (exclude_test(i))
14495 			continue;
14496 
14497 		pr_info("#%d %s ", i, test->descr);
14498 
14499 		if (test_skb_segment_single(test)) {
14500 			pr_cont("FAIL\n");
14501 			err_cnt++;
14502 		} else {
14503 			pr_cont("PASS\n");
14504 			pass_cnt++;
14505 		}
14506 	}
14507 
14508 	pr_info("%s: Summary: %d PASSED, %d FAILED\n", __func__,
14509 		pass_cnt, err_cnt);
14510 	return err_cnt ? -EINVAL : 0;
14511 }
14512 
14513 static __init int test_bpf(void)
14514 {
14515 	int i, err_cnt = 0, pass_cnt = 0;
14516 	int jit_cnt = 0, run_cnt = 0;
14517 
14518 	for (i = 0; i < ARRAY_SIZE(tests); i++) {
14519 		struct bpf_prog *fp;
14520 		int err;
14521 
14522 		cond_resched();
14523 		if (exclude_test(i))
14524 			continue;
14525 
14526 		pr_info("#%d %s ", i, tests[i].descr);
14527 
14528 		if (tests[i].fill_helper &&
14529 		    tests[i].fill_helper(&tests[i]) < 0) {
14530 			pr_cont("FAIL to prog_fill\n");
14531 			continue;
14532 		}
14533 
14534 		fp = generate_filter(i, &err);
14535 
14536 		if (tests[i].fill_helper) {
14537 			kfree(tests[i].u.ptr.insns);
14538 			tests[i].u.ptr.insns = NULL;
14539 		}
14540 
14541 		if (fp == NULL) {
14542 			if (err == 0) {
14543 				pass_cnt++;
14544 				continue;
14545 			}
14546 			err_cnt++;
14547 			continue;
14548 		}
14549 
14550 		pr_cont("jited:%u ", fp->jited);
14551 
14552 		run_cnt++;
14553 		if (fp->jited)
14554 			jit_cnt++;
14555 
14556 		err = run_one(fp, &tests[i]);
14557 		release_filter(fp, i);
14558 
14559 		if (err) {
14560 			pr_cont("FAIL (%d times)\n", err);
14561 			err_cnt++;
14562 		} else {
14563 			pr_cont("PASS\n");
14564 			pass_cnt++;
14565 		}
14566 	}
14567 
14568 	pr_info("Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n",
14569 		pass_cnt, err_cnt, jit_cnt, run_cnt);
14570 
14571 	return err_cnt ? -EINVAL : 0;
14572 }
14573 
14574 struct tail_call_test {
14575 	const char *descr;
14576 	struct bpf_insn insns[MAX_INSNS];
14577 	int flags;
14578 	int result;
14579 	int stack_depth;
14580 };
14581 
14582 /* Flags that can be passed to tail call test cases */
14583 #define FLAG_NEED_STATE		BIT(0)
14584 #define FLAG_RESULT_IN_STATE	BIT(1)
14585 
14586 /*
14587  * Magic marker used in test snippets for tail calls below.
14588  * BPF_LD/MOV to R2 and R2 with this immediate value is replaced
14589  * with the proper values by the test runner.
14590  */
14591 #define TAIL_CALL_MARKER 0x7a11ca11
14592 
14593 /* Special offset to indicate a NULL call target */
14594 #define TAIL_CALL_NULL 0x7fff
14595 
14596 /* Special offset to indicate an out-of-range index */
14597 #define TAIL_CALL_INVALID 0x7ffe
14598 
14599 #define TAIL_CALL(offset)			       \
14600 	BPF_LD_IMM64(R2, TAIL_CALL_MARKER),	       \
14601 	BPF_RAW_INSN(BPF_ALU | BPF_MOV | BPF_K, R3, 0, \
14602 		     offset, TAIL_CALL_MARKER),	       \
14603 	BPF_JMP_IMM(BPF_TAIL_CALL, 0, 0, 0)
14604 
14605 /*
14606  * A test function to be called from a BPF program, clobbering a lot of
14607  * CPU registers in the process. A JITed BPF program calling this function
14608  * must save and restore any caller-saved registers it uses for internal
14609  * state, for example the current tail call count.
14610  */
14611 BPF_CALL_1(bpf_test_func, u64, arg)
14612 {
14613 	char buf[64];
14614 	long a = 0;
14615 	long b = 1;
14616 	long c = 2;
14617 	long d = 3;
14618 	long e = 4;
14619 	long f = 5;
14620 	long g = 6;
14621 	long h = 7;
14622 
14623 	return snprintf(buf, sizeof(buf),
14624 			"%ld %lu %lx %ld %lu %lx %ld %lu %x",
14625 			a, b, c, d, e, f, g, h, (int)arg);
14626 }
14627 #define BPF_FUNC_test_func __BPF_FUNC_MAX_ID
14628 
14629 /*
14630  * Tail call tests. Each test case may call any other test in the table,
14631  * including itself, specified as a relative index offset from the calling
14632  * test. The index TAIL_CALL_NULL can be used to specify a NULL target
14633  * function to test the JIT error path. Similarly, the index TAIL_CALL_INVALID
14634  * results in a target index that is out of range.
14635  */
14636 static struct tail_call_test tail_call_tests[] = {
14637 	{
14638 		"Tail call leaf",
14639 		.insns = {
14640 			BPF_ALU64_REG(BPF_MOV, R0, R1),
14641 			BPF_ALU64_IMM(BPF_ADD, R0, 1),
14642 			BPF_EXIT_INSN(),
14643 		},
14644 		.result = 1,
14645 	},
14646 	{
14647 		"Tail call 2",
14648 		.insns = {
14649 			BPF_ALU64_IMM(BPF_ADD, R1, 2),
14650 			TAIL_CALL(-1),
14651 			BPF_ALU64_IMM(BPF_MOV, R0, -1),
14652 			BPF_EXIT_INSN(),
14653 		},
14654 		.result = 3,
14655 	},
14656 	{
14657 		"Tail call 3",
14658 		.insns = {
14659 			BPF_ALU64_IMM(BPF_ADD, R1, 3),
14660 			TAIL_CALL(-1),
14661 			BPF_ALU64_IMM(BPF_MOV, R0, -1),
14662 			BPF_EXIT_INSN(),
14663 		},
14664 		.result = 6,
14665 	},
14666 	{
14667 		"Tail call 4",
14668 		.insns = {
14669 			BPF_ALU64_IMM(BPF_ADD, R1, 4),
14670 			TAIL_CALL(-1),
14671 			BPF_ALU64_IMM(BPF_MOV, R0, -1),
14672 			BPF_EXIT_INSN(),
14673 		},
14674 		.result = 10,
14675 	},
14676 	{
14677 		"Tail call error path, max count reached",
14678 		.insns = {
14679 			BPF_LDX_MEM(BPF_W, R2, R1, 0),
14680 			BPF_ALU64_IMM(BPF_ADD, R2, 1),
14681 			BPF_STX_MEM(BPF_W, R1, R2, 0),
14682 			TAIL_CALL(0),
14683 			BPF_EXIT_INSN(),
14684 		},
14685 		.flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE,
14686 		.result = (MAX_TAIL_CALL_CNT + 1) * MAX_TESTRUNS,
14687 	},
14688 	{
14689 		"Tail call count preserved across function calls",
14690 		.insns = {
14691 			BPF_LDX_MEM(BPF_W, R2, R1, 0),
14692 			BPF_ALU64_IMM(BPF_ADD, R2, 1),
14693 			BPF_STX_MEM(BPF_W, R1, R2, 0),
14694 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
14695 			BPF_CALL_REL(BPF_FUNC_get_numa_node_id),
14696 			BPF_CALL_REL(BPF_FUNC_ktime_get_ns),
14697 			BPF_CALL_REL(BPF_FUNC_ktime_get_boot_ns),
14698 			BPF_CALL_REL(BPF_FUNC_ktime_get_coarse_ns),
14699 			BPF_CALL_REL(BPF_FUNC_jiffies64),
14700 			BPF_CALL_REL(BPF_FUNC_test_func),
14701 			BPF_LDX_MEM(BPF_DW, R1, R10, -8),
14702 			BPF_ALU32_REG(BPF_MOV, R0, R1),
14703 			TAIL_CALL(0),
14704 			BPF_EXIT_INSN(),
14705 		},
14706 		.stack_depth = 8,
14707 		.flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE,
14708 		.result = (MAX_TAIL_CALL_CNT + 1) * MAX_TESTRUNS,
14709 	},
14710 	{
14711 		"Tail call error path, NULL target",
14712 		.insns = {
14713 			BPF_LDX_MEM(BPF_W, R2, R1, 0),
14714 			BPF_ALU64_IMM(BPF_ADD, R2, 1),
14715 			BPF_STX_MEM(BPF_W, R1, R2, 0),
14716 			TAIL_CALL(TAIL_CALL_NULL),
14717 			BPF_EXIT_INSN(),
14718 		},
14719 		.flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE,
14720 		.result = MAX_TESTRUNS,
14721 	},
14722 	{
14723 		"Tail call error path, index out of range",
14724 		.insns = {
14725 			BPF_LDX_MEM(BPF_W, R2, R1, 0),
14726 			BPF_ALU64_IMM(BPF_ADD, R2, 1),
14727 			BPF_STX_MEM(BPF_W, R1, R2, 0),
14728 			TAIL_CALL(TAIL_CALL_INVALID),
14729 			BPF_EXIT_INSN(),
14730 		},
14731 		.flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE,
14732 		.result = MAX_TESTRUNS,
14733 	},
14734 };
14735 
14736 static void __init destroy_tail_call_tests(struct bpf_array *progs)
14737 {
14738 	int i;
14739 
14740 	for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++)
14741 		if (progs->ptrs[i])
14742 			bpf_prog_free(progs->ptrs[i]);
14743 	kfree(progs);
14744 }
14745 
14746 static __init int prepare_tail_call_tests(struct bpf_array **pprogs)
14747 {
14748 	int ntests = ARRAY_SIZE(tail_call_tests);
14749 	struct bpf_array *progs;
14750 	int which, err;
14751 
14752 	/* Allocate the table of programs to be used for tall calls */
14753 	progs = kzalloc(sizeof(*progs) + (ntests + 1) * sizeof(progs->ptrs[0]),
14754 			GFP_KERNEL);
14755 	if (!progs)
14756 		goto out_nomem;
14757 
14758 	/* Create all eBPF programs and populate the table */
14759 	for (which = 0; which < ntests; which++) {
14760 		struct tail_call_test *test = &tail_call_tests[which];
14761 		struct bpf_prog *fp;
14762 		int len, i;
14763 
14764 		/* Compute the number of program instructions */
14765 		for (len = 0; len < MAX_INSNS; len++) {
14766 			struct bpf_insn *insn = &test->insns[len];
14767 
14768 			if (len < MAX_INSNS - 1 &&
14769 			    insn->code == (BPF_LD | BPF_DW | BPF_IMM))
14770 				len++;
14771 			if (insn->code == 0)
14772 				break;
14773 		}
14774 
14775 		/* Allocate and initialize the program */
14776 		fp = bpf_prog_alloc(bpf_prog_size(len), 0);
14777 		if (!fp)
14778 			goto out_nomem;
14779 
14780 		fp->len = len;
14781 		fp->type = BPF_PROG_TYPE_SOCKET_FILTER;
14782 		fp->aux->stack_depth = test->stack_depth;
14783 		memcpy(fp->insnsi, test->insns, len * sizeof(struct bpf_insn));
14784 
14785 		/* Relocate runtime tail call offsets and addresses */
14786 		for (i = 0; i < len; i++) {
14787 			struct bpf_insn *insn = &fp->insnsi[i];
14788 			long addr = 0;
14789 
14790 			switch (insn->code) {
14791 			case BPF_LD | BPF_DW | BPF_IMM:
14792 				if (insn->imm != TAIL_CALL_MARKER)
14793 					break;
14794 				insn[0].imm = (u32)(long)progs;
14795 				insn[1].imm = ((u64)(long)progs) >> 32;
14796 				break;
14797 
14798 			case BPF_ALU | BPF_MOV | BPF_K:
14799 				if (insn->imm != TAIL_CALL_MARKER)
14800 					break;
14801 				if (insn->off == TAIL_CALL_NULL)
14802 					insn->imm = ntests;
14803 				else if (insn->off == TAIL_CALL_INVALID)
14804 					insn->imm = ntests + 1;
14805 				else
14806 					insn->imm = which + insn->off;
14807 				insn->off = 0;
14808 				break;
14809 
14810 			case BPF_JMP | BPF_CALL:
14811 				if (insn->src_reg != BPF_PSEUDO_CALL)
14812 					break;
14813 				switch (insn->imm) {
14814 				case BPF_FUNC_get_numa_node_id:
14815 					addr = (long)&numa_node_id;
14816 					break;
14817 				case BPF_FUNC_ktime_get_ns:
14818 					addr = (long)&ktime_get_ns;
14819 					break;
14820 				case BPF_FUNC_ktime_get_boot_ns:
14821 					addr = (long)&ktime_get_boot_fast_ns;
14822 					break;
14823 				case BPF_FUNC_ktime_get_coarse_ns:
14824 					addr = (long)&ktime_get_coarse_ns;
14825 					break;
14826 				case BPF_FUNC_jiffies64:
14827 					addr = (long)&get_jiffies_64;
14828 					break;
14829 				case BPF_FUNC_test_func:
14830 					addr = (long)&bpf_test_func;
14831 					break;
14832 				default:
14833 					err = -EFAULT;
14834 					goto out_err;
14835 				}
14836 				*insn = BPF_EMIT_CALL(addr);
14837 				if ((long)__bpf_call_base + insn->imm != addr)
14838 					*insn = BPF_JMP_A(0); /* Skip: NOP */
14839 				break;
14840 			}
14841 		}
14842 
14843 		fp = bpf_prog_select_runtime(fp, &err);
14844 		if (err)
14845 			goto out_err;
14846 
14847 		progs->ptrs[which] = fp;
14848 	}
14849 
14850 	/* The last entry contains a NULL program pointer */
14851 	progs->map.max_entries = ntests + 1;
14852 	*pprogs = progs;
14853 	return 0;
14854 
14855 out_nomem:
14856 	err = -ENOMEM;
14857 
14858 out_err:
14859 	if (progs)
14860 		destroy_tail_call_tests(progs);
14861 	return err;
14862 }
14863 
14864 static __init int test_tail_calls(struct bpf_array *progs)
14865 {
14866 	int i, err_cnt = 0, pass_cnt = 0;
14867 	int jit_cnt = 0, run_cnt = 0;
14868 
14869 	for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++) {
14870 		struct tail_call_test *test = &tail_call_tests[i];
14871 		struct bpf_prog *fp = progs->ptrs[i];
14872 		int *data = NULL;
14873 		int state = 0;
14874 		u64 duration;
14875 		int ret;
14876 
14877 		cond_resched();
14878 		if (exclude_test(i))
14879 			continue;
14880 
14881 		pr_info("#%d %s ", i, test->descr);
14882 		if (!fp) {
14883 			err_cnt++;
14884 			continue;
14885 		}
14886 		pr_cont("jited:%u ", fp->jited);
14887 
14888 		run_cnt++;
14889 		if (fp->jited)
14890 			jit_cnt++;
14891 
14892 		if (test->flags & FLAG_NEED_STATE)
14893 			data = &state;
14894 		ret = __run_one(fp, data, MAX_TESTRUNS, &duration);
14895 		if (test->flags & FLAG_RESULT_IN_STATE)
14896 			ret = state;
14897 		if (ret == test->result) {
14898 			pr_cont("%lld PASS", duration);
14899 			pass_cnt++;
14900 		} else {
14901 			pr_cont("ret %d != %d FAIL", ret, test->result);
14902 			err_cnt++;
14903 		}
14904 	}
14905 
14906 	pr_info("%s: Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n",
14907 		__func__, pass_cnt, err_cnt, jit_cnt, run_cnt);
14908 
14909 	return err_cnt ? -EINVAL : 0;
14910 }
14911 
14912 static char test_suite[32];
14913 module_param_string(test_suite, test_suite, sizeof(test_suite), 0);
14914 
14915 static __init int find_test_index(const char *test_name)
14916 {
14917 	int i;
14918 
14919 	if (!strcmp(test_suite, "test_bpf")) {
14920 		for (i = 0; i < ARRAY_SIZE(tests); i++) {
14921 			if (!strcmp(tests[i].descr, test_name))
14922 				return i;
14923 		}
14924 	}
14925 
14926 	if (!strcmp(test_suite, "test_tail_calls")) {
14927 		for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++) {
14928 			if (!strcmp(tail_call_tests[i].descr, test_name))
14929 				return i;
14930 		}
14931 	}
14932 
14933 	if (!strcmp(test_suite, "test_skb_segment")) {
14934 		for (i = 0; i < ARRAY_SIZE(skb_segment_tests); i++) {
14935 			if (!strcmp(skb_segment_tests[i].descr, test_name))
14936 				return i;
14937 		}
14938 	}
14939 
14940 	return -1;
14941 }
14942 
14943 static __init int prepare_test_range(void)
14944 {
14945 	int valid_range;
14946 
14947 	if (!strcmp(test_suite, "test_bpf"))
14948 		valid_range = ARRAY_SIZE(tests);
14949 	else if (!strcmp(test_suite, "test_tail_calls"))
14950 		valid_range = ARRAY_SIZE(tail_call_tests);
14951 	else if (!strcmp(test_suite, "test_skb_segment"))
14952 		valid_range = ARRAY_SIZE(skb_segment_tests);
14953 	else
14954 		return 0;
14955 
14956 	if (test_id >= 0) {
14957 		/*
14958 		 * if a test_id was specified, use test_range to
14959 		 * cover only that test.
14960 		 */
14961 		if (test_id >= valid_range) {
14962 			pr_err("test_bpf: invalid test_id specified for '%s' suite.\n",
14963 			       test_suite);
14964 			return -EINVAL;
14965 		}
14966 
14967 		test_range[0] = test_id;
14968 		test_range[1] = test_id;
14969 	} else if (*test_name) {
14970 		/*
14971 		 * if a test_name was specified, find it and setup
14972 		 * test_range to cover only that test.
14973 		 */
14974 		int idx = find_test_index(test_name);
14975 
14976 		if (idx < 0) {
14977 			pr_err("test_bpf: no test named '%s' found for '%s' suite.\n",
14978 			       test_name, test_suite);
14979 			return -EINVAL;
14980 		}
14981 		test_range[0] = idx;
14982 		test_range[1] = idx;
14983 	} else if (test_range[0] != 0 || test_range[1] != INT_MAX) {
14984 		/*
14985 		 * check that the supplied test_range is valid.
14986 		 */
14987 		if (test_range[0] < 0 || test_range[1] >= valid_range) {
14988 			pr_err("test_bpf: test_range is out of bound for '%s' suite.\n",
14989 			       test_suite);
14990 			return -EINVAL;
14991 		}
14992 
14993 		if (test_range[1] < test_range[0]) {
14994 			pr_err("test_bpf: test_range is ending before it starts.\n");
14995 			return -EINVAL;
14996 		}
14997 	}
14998 
14999 	return 0;
15000 }
15001 
15002 static int __init test_bpf_init(void)
15003 {
15004 	struct bpf_array *progs = NULL;
15005 	int ret;
15006 
15007 	if (strlen(test_suite) &&
15008 	    strcmp(test_suite, "test_bpf") &&
15009 	    strcmp(test_suite, "test_tail_calls") &&
15010 	    strcmp(test_suite, "test_skb_segment")) {
15011 		pr_err("test_bpf: invalid test_suite '%s' specified.\n", test_suite);
15012 		return -EINVAL;
15013 	}
15014 
15015 	/*
15016 	 * if test_suite is not specified, but test_id, test_name or test_range
15017 	 * is specified, set 'test_bpf' as the default test suite.
15018 	 */
15019 	if (!strlen(test_suite) &&
15020 	    (test_id != -1 || strlen(test_name) ||
15021 	    (test_range[0] != 0 || test_range[1] != INT_MAX))) {
15022 		pr_info("test_bpf: set 'test_bpf' as the default test_suite.\n");
15023 		strscpy(test_suite, "test_bpf", sizeof(test_suite));
15024 	}
15025 
15026 	ret = prepare_test_range();
15027 	if (ret < 0)
15028 		return ret;
15029 
15030 	if (!strlen(test_suite) || !strcmp(test_suite, "test_bpf")) {
15031 		ret = test_bpf();
15032 		if (ret)
15033 			return ret;
15034 	}
15035 
15036 	if (!strlen(test_suite) || !strcmp(test_suite, "test_tail_calls")) {
15037 		ret = prepare_tail_call_tests(&progs);
15038 		if (ret)
15039 			return ret;
15040 		ret = test_tail_calls(progs);
15041 		destroy_tail_call_tests(progs);
15042 		if (ret)
15043 			return ret;
15044 	}
15045 
15046 	if (!strlen(test_suite) || !strcmp(test_suite, "test_skb_segment"))
15047 		return test_skb_segment();
15048 
15049 	return 0;
15050 }
15051 
15052 static void __exit test_bpf_exit(void)
15053 {
15054 }
15055 
15056 module_init(test_bpf_init);
15057 module_exit(test_bpf_exit);
15058 
15059 MODULE_LICENSE("GPL");
15060