xref: /linux/lib/test_bpf.c (revision c8f0ee969f76277e562e44a20a6ff8bb47acab15) 
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/prandom.h>
18 #include <linux/highmem.h>
19 #include <linux/sched.h>
20 
21 /* General test specific settings */
22 #define MAX_SUBTESTS	3
23 #define MAX_TESTRUNS	1000
24 #define MAX_DATA	128
25 #define MAX_INSNS	512
26 #define MAX_K		0xffffFFFF
27 
28 /* Few constants used to init test 'skb' */
29 #define SKB_TYPE	3
30 #define SKB_MARK	0x1234aaaa
31 #define SKB_HASH	0x1234aaab
32 #define SKB_QUEUE_MAP	123
33 #define SKB_VLAN_TCI	0xffff
34 #define SKB_VLAN_PRESENT	1
35 #define SKB_DEV_IFINDEX	577
36 #define SKB_DEV_TYPE	588
37 
38 /* Redefine REGs to make tests less verbose */
39 #define R0		BPF_REG_0
40 #define R1		BPF_REG_1
41 #define R2		BPF_REG_2
42 #define R3		BPF_REG_3
43 #define R4		BPF_REG_4
44 #define R5		BPF_REG_5
45 #define R6		BPF_REG_6
46 #define R7		BPF_REG_7
47 #define R8		BPF_REG_8
48 #define R9		BPF_REG_9
49 #define R10		BPF_REG_10
50 
51 /* Flags that can be passed to test cases */
52 #define FLAG_NO_DATA		BIT(0)
53 #define FLAG_EXPECTED_FAIL	BIT(1)
54 #define FLAG_SKB_FRAG		BIT(2)
55 #define FLAG_VERIFIER_ZEXT	BIT(3)
56 #define FLAG_LARGE_MEM		BIT(4)
57 
58 enum {
59 	CLASSIC  = BIT(6),	/* Old BPF instructions only. */
60 	INTERNAL = BIT(7),	/* Extended instruction set.  */
61 };
62 
63 #define TEST_TYPE_MASK		(CLASSIC | INTERNAL)
64 
65 struct bpf_test {
66 	const char *descr;
67 	union {
68 		struct sock_filter insns[MAX_INSNS];
69 		struct bpf_insn insns_int[MAX_INSNS];
70 		struct {
71 			void *insns;
72 			unsigned int len;
73 		} ptr;
74 	} u;
75 	__u8 aux;
76 	__u8 data[MAX_DATA];
77 	struct {
78 		int data_size;
79 		__u32 result;
80 	} test[MAX_SUBTESTS];
81 	int (*fill_helper)(struct bpf_test *self);
82 	int expected_errcode; /* used when FLAG_EXPECTED_FAIL is set in the aux */
83 	__u8 frag_data[MAX_DATA];
84 	int stack_depth; /* for eBPF only, since tests don't call verifier */
85 	int nr_testruns; /* Custom run count, defaults to MAX_TESTRUNS if 0 */
86 };
87 
88 /* Large test cases need separate allocation and fill handler. */
89 
90 static int bpf_fill_maxinsns1(struct bpf_test *self)
91 {
92 	unsigned int len = BPF_MAXINSNS;
93 	struct sock_filter *insn;
94 	__u32 k = ~0;
95 	int i;
96 
97 	insn = kmalloc_objs(*insn, len);
98 	if (!insn)
99 		return -ENOMEM;
100 
101 	for (i = 0; i < len; i++, k--)
102 		insn[i] = __BPF_STMT(BPF_RET | BPF_K, k);
103 
104 	self->u.ptr.insns = insn;
105 	self->u.ptr.len = len;
106 
107 	return 0;
108 }
109 
110 static int bpf_fill_maxinsns2(struct bpf_test *self)
111 {
112 	unsigned int len = BPF_MAXINSNS;
113 	struct sock_filter *insn;
114 	int i;
115 
116 	insn = kmalloc_objs(*insn, len);
117 	if (!insn)
118 		return -ENOMEM;
119 
120 	for (i = 0; i < len; i++)
121 		insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
122 
123 	self->u.ptr.insns = insn;
124 	self->u.ptr.len = len;
125 
126 	return 0;
127 }
128 
129 static int bpf_fill_maxinsns3(struct bpf_test *self)
130 {
131 	unsigned int len = BPF_MAXINSNS;
132 	struct sock_filter *insn;
133 	struct rnd_state rnd;
134 	int i;
135 
136 	insn = kmalloc_objs(*insn, len);
137 	if (!insn)
138 		return -ENOMEM;
139 
140 	prandom_seed_state(&rnd, 3141592653589793238ULL);
141 
142 	for (i = 0; i < len - 1; i++) {
143 		__u32 k = prandom_u32_state(&rnd);
144 
145 		insn[i] = __BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, k);
146 	}
147 
148 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
149 
150 	self->u.ptr.insns = insn;
151 	self->u.ptr.len = len;
152 
153 	return 0;
154 }
155 
156 static int bpf_fill_maxinsns4(struct bpf_test *self)
157 {
158 	unsigned int len = BPF_MAXINSNS + 1;
159 	struct sock_filter *insn;
160 	int i;
161 
162 	insn = kmalloc_objs(*insn, len);
163 	if (!insn)
164 		return -ENOMEM;
165 
166 	for (i = 0; i < len; i++)
167 		insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
168 
169 	self->u.ptr.insns = insn;
170 	self->u.ptr.len = len;
171 
172 	return 0;
173 }
174 
175 static int bpf_fill_maxinsns5(struct bpf_test *self)
176 {
177 	unsigned int len = BPF_MAXINSNS;
178 	struct sock_filter *insn;
179 	int i;
180 
181 	insn = kmalloc_objs(*insn, len);
182 	if (!insn)
183 		return -ENOMEM;
184 
185 	insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0);
186 
187 	for (i = 1; i < len - 1; i++)
188 		insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
189 
190 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab);
191 
192 	self->u.ptr.insns = insn;
193 	self->u.ptr.len = len;
194 
195 	return 0;
196 }
197 
198 static int bpf_fill_maxinsns6(struct bpf_test *self)
199 {
200 	unsigned int len = BPF_MAXINSNS;
201 	struct sock_filter *insn;
202 	int i;
203 
204 	insn = kmalloc_objs(*insn, len);
205 	if (!insn)
206 		return -ENOMEM;
207 
208 	for (i = 0; i < len - 1; i++)
209 		insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
210 				     SKF_AD_VLAN_TAG_PRESENT);
211 
212 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
213 
214 	self->u.ptr.insns = insn;
215 	self->u.ptr.len = len;
216 
217 	return 0;
218 }
219 
220 static int bpf_fill_maxinsns7(struct bpf_test *self)
221 {
222 	unsigned int len = BPF_MAXINSNS;
223 	struct sock_filter *insn;
224 	int i;
225 
226 	insn = kmalloc_objs(*insn, len);
227 	if (!insn)
228 		return -ENOMEM;
229 
230 	for (i = 0; i < len - 4; i++)
231 		insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
232 				     SKF_AD_CPU);
233 
234 	insn[len - 4] = __BPF_STMT(BPF_MISC | BPF_TAX, 0);
235 	insn[len - 3] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
236 				   SKF_AD_CPU);
237 	insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0);
238 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
239 
240 	self->u.ptr.insns = insn;
241 	self->u.ptr.len = len;
242 
243 	return 0;
244 }
245 
246 static int bpf_fill_maxinsns8(struct bpf_test *self)
247 {
248 	unsigned int len = BPF_MAXINSNS;
249 	struct sock_filter *insn;
250 	int i, jmp_off = len - 3;
251 
252 	insn = kmalloc_objs(*insn, len);
253 	if (!insn)
254 		return -ENOMEM;
255 
256 	insn[0] = __BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff);
257 
258 	for (i = 1; i < len - 1; i++)
259 		insn[i] = __BPF_JUMP(BPF_JMP | BPF_JGT, 0xffffffff, jmp_off--, 0);
260 
261 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
262 
263 	self->u.ptr.insns = insn;
264 	self->u.ptr.len = len;
265 
266 	return 0;
267 }
268 
269 static int bpf_fill_maxinsns9(struct bpf_test *self)
270 {
271 	unsigned int len = BPF_MAXINSNS;
272 	struct bpf_insn *insn;
273 	int i;
274 
275 	insn = kmalloc_objs(*insn, len);
276 	if (!insn)
277 		return -ENOMEM;
278 
279 	insn[0] = BPF_JMP_IMM(BPF_JA, 0, 0, len - 2);
280 	insn[1] = BPF_ALU32_IMM(BPF_MOV, R0, 0xcbababab);
281 	insn[2] = BPF_EXIT_INSN();
282 
283 	for (i = 3; i < len - 2; i++)
284 		insn[i] = BPF_ALU32_IMM(BPF_MOV, R0, 0xfefefefe);
285 
286 	insn[len - 2] = BPF_EXIT_INSN();
287 	insn[len - 1] = BPF_JMP_IMM(BPF_JA, 0, 0, -(len - 1));
288 
289 	self->u.ptr.insns = insn;
290 	self->u.ptr.len = len;
291 
292 	return 0;
293 }
294 
295 static int bpf_fill_maxinsns10(struct bpf_test *self)
296 {
297 	unsigned int len = BPF_MAXINSNS, hlen = len - 2;
298 	struct bpf_insn *insn;
299 	int i;
300 
301 	insn = kmalloc_objs(*insn, len);
302 	if (!insn)
303 		return -ENOMEM;
304 
305 	for (i = 0; i < hlen / 2; i++)
306 		insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 2 - 2 * i);
307 	for (i = hlen - 1; i > hlen / 2; i--)
308 		insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 1 - 2 * i);
309 
310 	insn[hlen / 2] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen / 2 - 1);
311 	insn[hlen]     = BPF_ALU32_IMM(BPF_MOV, R0, 0xabababac);
312 	insn[hlen + 1] = BPF_EXIT_INSN();
313 
314 	self->u.ptr.insns = insn;
315 	self->u.ptr.len = len;
316 
317 	return 0;
318 }
319 
320 static int __bpf_fill_ja(struct bpf_test *self, unsigned int len,
321 			 unsigned int plen)
322 {
323 	struct sock_filter *insn;
324 	unsigned int rlen;
325 	int i, j;
326 
327 	insn = kmalloc_objs(*insn, len);
328 	if (!insn)
329 		return -ENOMEM;
330 
331 	rlen = (len % plen) - 1;
332 
333 	for (i = 0; i + plen < len; i += plen)
334 		for (j = 0; j < plen; j++)
335 			insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA,
336 						 plen - 1 - j, 0, 0);
337 	for (j = 0; j < rlen; j++)
338 		insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA, rlen - 1 - j,
339 					 0, 0);
340 
341 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xababcbac);
342 
343 	self->u.ptr.insns = insn;
344 	self->u.ptr.len = len;
345 
346 	return 0;
347 }
348 
349 static int bpf_fill_maxinsns11(struct bpf_test *self)
350 {
351 	/* Hits 70 passes on x86_64 and triggers NOPs padding. */
352 	return __bpf_fill_ja(self, BPF_MAXINSNS, 68);
353 }
354 
355 static int bpf_fill_maxinsns12(struct bpf_test *self)
356 {
357 	unsigned int len = BPF_MAXINSNS;
358 	struct sock_filter *insn;
359 	int i = 0;
360 
361 	insn = kmalloc_objs(*insn, len);
362 	if (!insn)
363 		return -ENOMEM;
364 
365 	insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0);
366 
367 	for (i = 1; i < len - 1; i++)
368 		insn[i] = __BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0);
369 
370 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab);
371 
372 	self->u.ptr.insns = insn;
373 	self->u.ptr.len = len;
374 
375 	return 0;
376 }
377 
378 static int bpf_fill_maxinsns13(struct bpf_test *self)
379 {
380 	unsigned int len = BPF_MAXINSNS;
381 	struct sock_filter *insn;
382 	int i = 0;
383 
384 	insn = kmalloc_objs(*insn, len);
385 	if (!insn)
386 		return -ENOMEM;
387 
388 	for (i = 0; i < len - 3; i++)
389 		insn[i] = __BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0);
390 
391 	insn[len - 3] = __BPF_STMT(BPF_LD | BPF_IMM, 0xabababab);
392 	insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0);
393 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
394 
395 	self->u.ptr.insns = insn;
396 	self->u.ptr.len = len;
397 
398 	return 0;
399 }
400 
401 static int bpf_fill_ja(struct bpf_test *self)
402 {
403 	/* Hits exactly 11 passes on x86_64 JIT. */
404 	return __bpf_fill_ja(self, 12, 9);
405 }
406 
407 static int bpf_fill_ld_abs_get_processor_id(struct bpf_test *self)
408 {
409 	unsigned int len = BPF_MAXINSNS;
410 	struct sock_filter *insn;
411 	int i;
412 
413 	insn = kmalloc_objs(*insn, len);
414 	if (!insn)
415 		return -ENOMEM;
416 
417 	for (i = 0; i < len - 1; i += 2) {
418 		insn[i] = __BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 0);
419 		insn[i + 1] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
420 					 SKF_AD_OFF + SKF_AD_CPU);
421 	}
422 
423 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xbee);
424 
425 	self->u.ptr.insns = insn;
426 	self->u.ptr.len = len;
427 
428 	return 0;
429 }
430 
431 static int __bpf_fill_stxdw(struct bpf_test *self, int size)
432 {
433 	unsigned int len = BPF_MAXINSNS;
434 	struct bpf_insn *insn;
435 	int i;
436 
437 	insn = kmalloc_objs(*insn, len);
438 	if (!insn)
439 		return -ENOMEM;
440 
441 	insn[0] = BPF_ALU32_IMM(BPF_MOV, R0, 1);
442 	insn[1] = BPF_ST_MEM(size, R10, -40, 42);
443 
444 	for (i = 2; i < len - 2; i++)
445 		insn[i] = BPF_STX_XADD(size, R10, R0, -40);
446 
447 	insn[len - 2] = BPF_LDX_MEM(size, R0, R10, -40);
448 	insn[len - 1] = BPF_EXIT_INSN();
449 
450 	self->u.ptr.insns = insn;
451 	self->u.ptr.len = len;
452 	self->stack_depth = 40;
453 
454 	return 0;
455 }
456 
457 static int bpf_fill_stxw(struct bpf_test *self)
458 {
459 	return __bpf_fill_stxdw(self, BPF_W);
460 }
461 
462 static int bpf_fill_stxdw(struct bpf_test *self)
463 {
464 	return __bpf_fill_stxdw(self, BPF_DW);
465 }
466 
467 static int __bpf_ld_imm64(struct bpf_insn insns[2], u8 reg, s64 imm64)
468 {
469 	struct bpf_insn tmp[] = {BPF_LD_IMM64(reg, imm64)};
470 
471 	memcpy(insns, tmp, sizeof(tmp));
472 	return 2;
473 }
474 
475 /*
476  * Branch conversion tests. Complex operations can expand to a lot
477  * of instructions when JITed. This in turn may cause jump offsets
478  * to overflow the field size of the native instruction, triggering
479  * a branch conversion mechanism in some JITs.
480  */
481 static int __bpf_fill_max_jmp(struct bpf_test *self, int jmp, int imm, bool alu32)
482 {
483 	struct bpf_insn *insns;
484 	int len = S16_MAX + 5;
485 	int i;
486 
487 	insns = kmalloc_objs(*insns, len);
488 	if (!insns)
489 		return -ENOMEM;
490 
491 	i = __bpf_ld_imm64(insns, R1, 0x0123456789abcdefULL);
492 	insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
493 	insns[i++] = BPF_JMP_IMM(jmp, R0, imm, S16_MAX);
494 	insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 2);
495 	insns[i++] = BPF_EXIT_INSN();
496 
497 	while (i < len - 1) {
498 		static const int ops[] = {
499 			BPF_LSH, BPF_RSH, BPF_ARSH, BPF_ADD,
500 			BPF_SUB, BPF_MUL, BPF_DIV, BPF_MOD,
501 		};
502 		int op = ops[(i >> 1) % ARRAY_SIZE(ops)];
503 
504 		if ((i & 1) || alu32)
505 			insns[i++] = BPF_ALU32_REG(op, R0, R1);
506 		else
507 			insns[i++] = BPF_ALU64_REG(op, R0, R1);
508 	}
509 
510 	insns[i++] = BPF_EXIT_INSN();
511 	self->u.ptr.insns = insns;
512 	self->u.ptr.len = len;
513 	BUG_ON(i != len);
514 
515 	return 0;
516 }
517 
518 /* Branch taken by runtime decision */
519 static int bpf_fill_max_jmp_taken_32(struct bpf_test *self)
520 {
521 	return __bpf_fill_max_jmp(self, BPF_JEQ, 1, true);
522 }
523 
524 static int bpf_fill_max_jmp_taken(struct bpf_test *self)
525 {
526 	return __bpf_fill_max_jmp(self, BPF_JEQ, 1, false);
527 }
528 
529 /* Branch not taken by runtime decision */
530 static int bpf_fill_max_jmp_not_taken_32(struct bpf_test *self)
531 {
532 	return __bpf_fill_max_jmp(self, BPF_JEQ, 0, true);
533 }
534 
535 static int bpf_fill_max_jmp_not_taken(struct bpf_test *self)
536 {
537 	return __bpf_fill_max_jmp(self, BPF_JEQ, 0, false);
538 }
539 
540 /* Branch always taken, known at JIT time */
541 static int bpf_fill_max_jmp_always_taken_32(struct bpf_test *self)
542 {
543 	return __bpf_fill_max_jmp(self, BPF_JGE, 0, true);
544 }
545 
546 static int bpf_fill_max_jmp_always_taken(struct bpf_test *self)
547 {
548 	return __bpf_fill_max_jmp(self, BPF_JGE, 0, false);
549 }
550 
551 /* Branch never taken, known at JIT time */
552 static int bpf_fill_max_jmp_never_taken_32(struct bpf_test *self)
553 {
554 	return __bpf_fill_max_jmp(self, BPF_JLT, 0, true);
555 }
556 
557 static int bpf_fill_max_jmp_never_taken(struct bpf_test *self)
558 {
559 	return __bpf_fill_max_jmp(self, BPF_JLT, 0, false);
560 }
561 
562 /* ALU result computation used in tests */
563 enum { F_ALU32 = 1, F_SIGNED = 2 };
564 
565 static bool __bpf_alu_result(u64 *res, u64 v1, u64 v2, u8 op, u32 flags)
566 {
567 	bool is_signed = flags & F_SIGNED;
568 
569 	/* Narrow operands for ALU32 */
570 	if (flags & F_ALU32) {
571 		if (is_signed) {
572 			v1 = (u64)(s32)v1;
573 			v2 = (u64)(s32)v2;
574 		} else {
575 			v1 = (u32)v1;
576 			v2 = (u32)v2;
577 		}
578 	}
579 
580 	*res = 0;
581 	switch (op) {
582 	case BPF_MOV:
583 		*res = v2;
584 		break;
585 	case BPF_AND:
586 		*res = v1 & v2;
587 		break;
588 	case BPF_OR:
589 		*res = v1 | v2;
590 		break;
591 	case BPF_XOR:
592 		*res = v1 ^ v2;
593 		break;
594 	case BPF_LSH:
595 		*res = v1 << v2;
596 		break;
597 	case BPF_RSH:
598 		*res = v1 >> v2;
599 		break;
600 	case BPF_ARSH:
601 		*res = v1 >> v2;
602 		if (v2 > 0 && v1 > S64_MAX)
603 			*res |= ~0ULL << (64 - v2);
604 		break;
605 	case BPF_ADD:
606 		*res = v1 + v2;
607 		break;
608 	case BPF_SUB:
609 		*res = v1 - v2;
610 		break;
611 	case BPF_MUL:
612 		*res = v1 * v2;
613 		break;
614 	case BPF_DIV:
615 		if (v2 == 0)
616 			return false;
617 		if (!is_signed) {
618 			*res = div64_u64(v1, v2);
619 		} else {
620 			if ((s64)v2 == -1) /* Handled by verifier */
621 				return false;
622 			*res = (u64)div64_s64(v1, v2);
623 		}
624 		break;
625 	case BPF_MOD:
626 		if (v2 == 0)
627 			return false;
628 		if (!is_signed) {
629 			div64_u64_rem(v1, v2, res);
630 		} else {
631 			if ((s64)v2 == -1)
632 				return false;
633 			/*
634 			 * Avoid s64 % s64 which generates __moddi3 on
635 			 * 32-bit architectures. Use div64_s64 instead.
636 			 */
637 			*res = (u64)((s64)v1 - div64_s64(v1, v2) * (s64)v2);
638 		}
639 		break;
640 	}
641 	return true;
642 }
643 
644 /* Test an ALU shift operation for all valid shift values */
645 static int __bpf_fill_alu_shift(struct bpf_test *self, u8 op,
646 				u8 mode, u32 flags)
647 {
648 	static const s64 regs[] = {
649 		0x0123456789abcdefLL, /* dword > 0, word < 0 */
650 		0xfedcba9876543210LL, /* dword < 0, word > 0 */
651 		0xfedcba0198765432LL, /* dword < 0, word < 0 */
652 		0x0123458967abcdefLL, /* dword > 0, word > 0 */
653 	};
654 	int bits = (flags & F_ALU32) ? 32 : 64;
655 	int len = (2 + 7 * bits) * ARRAY_SIZE(regs) + 3;
656 	struct bpf_insn *insn;
657 	int imm, k;
658 	int i = 0;
659 
660 	insn = kmalloc_objs(*insn, len);
661 	if (!insn)
662 		return -ENOMEM;
663 
664 	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
665 
666 	for (k = 0; k < ARRAY_SIZE(regs); k++) {
667 		s64 reg = regs[k];
668 
669 		i += __bpf_ld_imm64(&insn[i], R3, reg);
670 
671 		for (imm = 0; imm < bits; imm++) {
672 			u64 val;
673 
674 			/* Perform operation */
675 			insn[i++] = BPF_ALU64_REG(BPF_MOV, R1, R3);
676 			insn[i++] = BPF_ALU64_IMM(BPF_MOV, R2, imm);
677 			if (flags & F_ALU32) {
678 				if (mode == BPF_K)
679 					insn[i++] = BPF_ALU32_IMM(op, R1, imm);
680 				else
681 					insn[i++] = BPF_ALU32_REG(op, R1, R2);
682 
683 				if (op == BPF_ARSH)
684 					reg = (s32)reg;
685 				else
686 					reg = (u32)reg;
687 				__bpf_alu_result(&val, reg, imm, op, 0);
688 				val = (u32)val;
689 			} else {
690 				if (mode == BPF_K)
691 					insn[i++] = BPF_ALU64_IMM(op, R1, imm);
692 				else
693 					insn[i++] = BPF_ALU64_REG(op, R1, R2);
694 				__bpf_alu_result(&val, reg, imm, op, 0);
695 			}
696 
697 			/*
698 			 * When debugging a JIT that fails this test, one
699 			 * can write the immediate value to R0 here to find
700 			 * out which operand values that fail.
701 			 */
702 
703 			/* Load reference and check the result */
704 			i += __bpf_ld_imm64(&insn[i], R4, val);
705 			insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R4, 1);
706 			insn[i++] = BPF_EXIT_INSN();
707 		}
708 	}
709 
710 	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
711 	insn[i++] = BPF_EXIT_INSN();
712 
713 	self->u.ptr.insns = insn;
714 	self->u.ptr.len = len;
715 	BUG_ON(i != len);
716 
717 	return 0;
718 }
719 
720 static int bpf_fill_alu64_lsh_imm(struct bpf_test *self)
721 {
722 	return __bpf_fill_alu_shift(self, BPF_LSH, BPF_K, 0);
723 }
724 
725 static int bpf_fill_alu64_rsh_imm(struct bpf_test *self)
726 {
727 	return __bpf_fill_alu_shift(self, BPF_RSH, BPF_K, 0);
728 }
729 
730 static int bpf_fill_alu64_arsh_imm(struct bpf_test *self)
731 {
732 	return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_K, 0);
733 }
734 
735 static int bpf_fill_alu64_lsh_reg(struct bpf_test *self)
736 {
737 	return __bpf_fill_alu_shift(self, BPF_LSH, BPF_X, 0);
738 }
739 
740 static int bpf_fill_alu64_rsh_reg(struct bpf_test *self)
741 {
742 	return __bpf_fill_alu_shift(self, BPF_RSH, BPF_X, 0);
743 }
744 
745 static int bpf_fill_alu64_arsh_reg(struct bpf_test *self)
746 {
747 	return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_X, 0);
748 }
749 
750 static int bpf_fill_alu32_lsh_imm(struct bpf_test *self)
751 {
752 	return __bpf_fill_alu_shift(self, BPF_LSH, BPF_K, F_ALU32);
753 }
754 
755 static int bpf_fill_alu32_rsh_imm(struct bpf_test *self)
756 {
757 	return __bpf_fill_alu_shift(self, BPF_RSH, BPF_K, F_ALU32);
758 }
759 
760 static int bpf_fill_alu32_arsh_imm(struct bpf_test *self)
761 {
762 	return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_K, F_ALU32);
763 }
764 
765 static int bpf_fill_alu32_lsh_reg(struct bpf_test *self)
766 {
767 	return __bpf_fill_alu_shift(self, BPF_LSH, BPF_X, F_ALU32);
768 }
769 
770 static int bpf_fill_alu32_rsh_reg(struct bpf_test *self)
771 {
772 	return __bpf_fill_alu_shift(self, BPF_RSH, BPF_X, F_ALU32);
773 }
774 
775 static int bpf_fill_alu32_arsh_reg(struct bpf_test *self)
776 {
777 	return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_X, F_ALU32);
778 }
779 
780 /*
781  * Test an ALU register shift operation for all valid shift values
782  * for the case when the source and destination are the same.
783  */
784 static int __bpf_fill_alu_shift_same_reg(struct bpf_test *self, u8 op,
785 					 u32 flags)
786 {
787 	int bits = (flags & F_ALU32) ? 32 : 64;
788 	int len = 3 + 6 * bits;
789 	struct bpf_insn *insn;
790 	int i = 0;
791 	u64 val;
792 
793 	insn = kmalloc_objs(*insn, len);
794 	if (!insn)
795 		return -ENOMEM;
796 
797 	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
798 
799 	for (val = 0; val < bits; val++) {
800 		u64 res;
801 
802 		/* Perform operation */
803 		insn[i++] = BPF_ALU64_IMM(BPF_MOV, R1, val);
804 		if (flags & F_ALU32)
805 			insn[i++] = BPF_ALU32_REG(op, R1, R1);
806 		else
807 			insn[i++] = BPF_ALU64_REG(op, R1, R1);
808 
809 		/* Compute the reference result */
810 		__bpf_alu_result(&res, val, val, op, 0);
811 		if (flags & F_ALU32)
812 			res = (u32)res;
813 		i += __bpf_ld_imm64(&insn[i], R2, res);
814 
815 		/* Check the actual result */
816 		insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R2, 1);
817 		insn[i++] = BPF_EXIT_INSN();
818 	}
819 
820 	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
821 	insn[i++] = BPF_EXIT_INSN();
822 
823 	self->u.ptr.insns = insn;
824 	self->u.ptr.len = len;
825 	BUG_ON(i != len);
826 
827 	return 0;
828 }
829 
830 static int bpf_fill_alu64_lsh_same_reg(struct bpf_test *self)
831 {
832 	return __bpf_fill_alu_shift_same_reg(self, BPF_LSH, 0);
833 }
834 
835 static int bpf_fill_alu64_rsh_same_reg(struct bpf_test *self)
836 {
837 	return __bpf_fill_alu_shift_same_reg(self, BPF_RSH, 0);
838 }
839 
840 static int bpf_fill_alu64_arsh_same_reg(struct bpf_test *self)
841 {
842 	return __bpf_fill_alu_shift_same_reg(self, BPF_ARSH, 0);
843 }
844 
845 static int bpf_fill_alu32_lsh_same_reg(struct bpf_test *self)
846 {
847 	return __bpf_fill_alu_shift_same_reg(self, BPF_LSH, F_ALU32);
848 }
849 
850 static int bpf_fill_alu32_rsh_same_reg(struct bpf_test *self)
851 {
852 	return __bpf_fill_alu_shift_same_reg(self, BPF_RSH, F_ALU32);
853 }
854 
855 static int bpf_fill_alu32_arsh_same_reg(struct bpf_test *self)
856 {
857 	return __bpf_fill_alu_shift_same_reg(self, BPF_ARSH, F_ALU32);
858 }
859 
860 /*
861  * Common operand pattern generator for exhaustive power-of-two magnitudes
862  * tests. The block size parameters can be adjusted to increase/reduce the
863  * number of combinatons tested and thereby execution speed and memory
864  * footprint.
865  */
866 
867 static inline s64 value(int msb, int delta, int sign)
868 {
869 	return sign * (1LL << msb) + delta;
870 }
871 
872 static int __bpf_fill_pattern(struct bpf_test *self, void *arg,
873 			      int dbits, int sbits, int block1, int block2,
874 			      int (*emit)(struct bpf_test*, void*,
875 					  struct bpf_insn*, s64, s64))
876 {
877 	static const int sgn[][2] = {{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
878 	struct bpf_insn *insns;
879 	int di, si, bt, db, sb;
880 	int count, len, k;
881 	int extra = 1 + 2;
882 	int i = 0;
883 
884 	/* Total number of iterations for the two pattern */
885 	count = (dbits - 1) * (sbits - 1) * block1 * block1 * ARRAY_SIZE(sgn);
886 	count += (max(dbits, sbits) - 1) * block2 * block2 * ARRAY_SIZE(sgn);
887 
888 	/* Compute the maximum number of insns and allocate the buffer */
889 	len = extra + count * (*emit)(self, arg, NULL, 0, 0);
890 	insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL);
891 	if (!insns)
892 		return -ENOMEM;
893 
894 	/* Add head instruction(s) */
895 	insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
896 
897 	/*
898 	 * Pattern 1: all combinations of power-of-two magnitudes and sign,
899 	 * and with a block of contiguous values around each magnitude.
900 	 */
901 	for (di = 0; di < dbits - 1; di++)                 /* Dst magnitudes */
902 		for (si = 0; si < sbits - 1; si++)         /* Src magnitudes */
903 			for (k = 0; k < ARRAY_SIZE(sgn); k++) /* Sign combos */
904 				for (db = -(block1 / 2);
905 				     db < (block1 + 1) / 2; db++)
906 					for (sb = -(block1 / 2);
907 					     sb < (block1 + 1) / 2; sb++) {
908 						s64 dst, src;
909 
910 						dst = value(di, db, sgn[k][0]);
911 						src = value(si, sb, sgn[k][1]);
912 						i += (*emit)(self, arg,
913 							     &insns[i],
914 							     dst, src);
915 					}
916 	/*
917 	 * Pattern 2: all combinations for a larger block of values
918 	 * for each power-of-two magnitude and sign, where the magnitude is
919 	 * the same for both operands.
920 	 */
921 	for (bt = 0; bt < max(dbits, sbits) - 1; bt++)        /* Magnitude   */
922 		for (k = 0; k < ARRAY_SIZE(sgn); k++)         /* Sign combos */
923 			for (db = -(block2 / 2); db < (block2 + 1) / 2; db++)
924 				for (sb = -(block2 / 2);
925 				     sb < (block2 + 1) / 2; sb++) {
926 					s64 dst, src;
927 
928 					dst = value(bt % dbits, db, sgn[k][0]);
929 					src = value(bt % sbits, sb, sgn[k][1]);
930 					i += (*emit)(self, arg, &insns[i],
931 						     dst, src);
932 				}
933 
934 	/* Append tail instructions */
935 	insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
936 	insns[i++] = BPF_EXIT_INSN();
937 	BUG_ON(i > len);
938 
939 	self->u.ptr.insns = insns;
940 	self->u.ptr.len = i;
941 
942 	return 0;
943 }
944 
945 /*
946  * Block size parameters used in pattern tests below. une as needed to
947  * increase/reduce the number combinations tested, see following examples.
948  *        block   values per operand MSB
949  * ----------------------------------------
950  *           0     none
951  *           1     (1 << MSB)
952  *           2     (1 << MSB) + [-1, 0]
953  *           3     (1 << MSB) + [-1, 0, 1]
954  */
955 #define PATTERN_BLOCK1 1
956 #define PATTERN_BLOCK2 5
957 
958 /* Number of test runs for a pattern test */
959 #define NR_PATTERN_RUNS 1
960 
961 /*
962  * Exhaustive tests of ALU operations for all combinations of power-of-two
963  * magnitudes of the operands, both for positive and negative values. The
964  * test is designed to verify e.g. the ALU and ALU64 operations for JITs that
965  * emit different code depending on the magnitude of the immediate value.
966  */
967 static int __bpf_emit_alu64_imm(struct bpf_test *self, void *arg,
968 				struct bpf_insn *insns, s64 dst, s64 imm)
969 {
970 	int *a = arg;
971 	int op = a[0];
972 	u32 flags = a[1];
973 	s16 off = (flags & F_SIGNED) ? 1 : 0;
974 	int i = 0;
975 	u64 res;
976 
977 	if (!insns)
978 		return 7;
979 
980 	if (__bpf_alu_result(&res, dst, (s32)imm, op, flags)) {
981 		i += __bpf_ld_imm64(&insns[i], R1, dst);
982 		i += __bpf_ld_imm64(&insns[i], R3, res);
983 		insns[i++] = BPF_ALU64_IMM_OFF(op, R1, imm, off);
984 		insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
985 		insns[i++] = BPF_EXIT_INSN();
986 	}
987 
988 	return i;
989 }
990 
991 static int __bpf_emit_alu32_imm(struct bpf_test *self, void *arg,
992 				struct bpf_insn *insns, s64 dst, s64 imm)
993 {
994 	int *a = arg;
995 	int op = a[0];
996 	u32 flags = a[1];
997 	s16 off = (flags & F_SIGNED) ? 1 : 0;
998 	int i = 0;
999 	u64 res;
1000 
1001 	if (!insns)
1002 		return 7;
1003 
1004 	if (__bpf_alu_result(&res, dst, (s32)imm, op, flags | F_ALU32)) {
1005 		i += __bpf_ld_imm64(&insns[i], R1, dst);
1006 		i += __bpf_ld_imm64(&insns[i], R3, (u32)res);
1007 		insns[i++] = BPF_ALU32_IMM_OFF(op, R1, imm, off);
1008 		insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
1009 		insns[i++] = BPF_EXIT_INSN();
1010 	}
1011 
1012 	return i;
1013 }
1014 
1015 static int __bpf_emit_alu64_reg(struct bpf_test *self, void *arg,
1016 				struct bpf_insn *insns, s64 dst, s64 src)
1017 {
1018 	int op = *(int *)arg;
1019 	int i = 0;
1020 	u64 res;
1021 
1022 	if (!insns)
1023 		return 9;
1024 
1025 	if (__bpf_alu_result(&res, dst, src, op, 0)) {
1026 		i += __bpf_ld_imm64(&insns[i], R1, dst);
1027 		i += __bpf_ld_imm64(&insns[i], R2, src);
1028 		i += __bpf_ld_imm64(&insns[i], R3, res);
1029 		insns[i++] = BPF_ALU64_REG(op, R1, R2);
1030 		insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
1031 		insns[i++] = BPF_EXIT_INSN();
1032 	}
1033 
1034 	return i;
1035 }
1036 
1037 static int __bpf_emit_alu32_reg(struct bpf_test *self, void *arg,
1038 				struct bpf_insn *insns, s64 dst, s64 src)
1039 {
1040 	int op = *(int *)arg;
1041 	int i = 0;
1042 	u64 res;
1043 
1044 	if (!insns)
1045 		return 9;
1046 
1047 	if (__bpf_alu_result(&res, (u32)dst, (u32)src, op, 0)) {
1048 		i += __bpf_ld_imm64(&insns[i], R1, dst);
1049 		i += __bpf_ld_imm64(&insns[i], R2, src);
1050 		i += __bpf_ld_imm64(&insns[i], R3, (u32)res);
1051 		insns[i++] = BPF_ALU32_REG(op, R1, R2);
1052 		insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
1053 		insns[i++] = BPF_EXIT_INSN();
1054 	}
1055 
1056 	return i;
1057 }
1058 
1059 static int __bpf_fill_alu64_imm(struct bpf_test *self, int op, u32 flags)
1060 {
1061 	int arg[2] = {op, flags};
1062 
1063 	return __bpf_fill_pattern(self, &arg, 64, 32,
1064 				  PATTERN_BLOCK1, PATTERN_BLOCK2,
1065 				  &__bpf_emit_alu64_imm);
1066 }
1067 
1068 static int __bpf_fill_alu32_imm(struct bpf_test *self, int op, u32 flags)
1069 {
1070 	int arg[2] = {op, flags};
1071 
1072 	return __bpf_fill_pattern(self, &arg, 64, 32,
1073 				  PATTERN_BLOCK1, PATTERN_BLOCK2,
1074 				  &__bpf_emit_alu32_imm);
1075 }
1076 
1077 static int __bpf_fill_alu64_reg(struct bpf_test *self, int op)
1078 {
1079 	return __bpf_fill_pattern(self, &op, 64, 64,
1080 				  PATTERN_BLOCK1, PATTERN_BLOCK2,
1081 				  &__bpf_emit_alu64_reg);
1082 }
1083 
1084 static int __bpf_fill_alu32_reg(struct bpf_test *self, int op)
1085 {
1086 	return __bpf_fill_pattern(self, &op, 64, 64,
1087 				  PATTERN_BLOCK1, PATTERN_BLOCK2,
1088 				  &__bpf_emit_alu32_reg);
1089 }
1090 
1091 /* ALU64 immediate operations */
1092 static int bpf_fill_alu64_mov_imm(struct bpf_test *self)
1093 {
1094 	return __bpf_fill_alu64_imm(self, BPF_MOV, 0);
1095 }
1096 
1097 static int bpf_fill_alu64_and_imm(struct bpf_test *self)
1098 {
1099 	return __bpf_fill_alu64_imm(self, BPF_AND, 0);
1100 }
1101 
1102 static int bpf_fill_alu64_or_imm(struct bpf_test *self)
1103 {
1104 	return __bpf_fill_alu64_imm(self, BPF_OR, 0);
1105 }
1106 
1107 static int bpf_fill_alu64_xor_imm(struct bpf_test *self)
1108 {
1109 	return __bpf_fill_alu64_imm(self, BPF_XOR, 0);
1110 }
1111 
1112 static int bpf_fill_alu64_add_imm(struct bpf_test *self)
1113 {
1114 	return __bpf_fill_alu64_imm(self, BPF_ADD, 0);
1115 }
1116 
1117 static int bpf_fill_alu64_sub_imm(struct bpf_test *self)
1118 {
1119 	return __bpf_fill_alu64_imm(self, BPF_SUB, 0);
1120 }
1121 
1122 static int bpf_fill_alu64_mul_imm(struct bpf_test *self)
1123 {
1124 	return __bpf_fill_alu64_imm(self, BPF_MUL, 0);
1125 }
1126 
1127 static int bpf_fill_alu64_div_imm(struct bpf_test *self)
1128 {
1129 	return __bpf_fill_alu64_imm(self, BPF_DIV, 0);
1130 }
1131 
1132 static int bpf_fill_alu64_mod_imm(struct bpf_test *self)
1133 {
1134 	return __bpf_fill_alu64_imm(self, BPF_MOD, 0);
1135 }
1136 
1137 /* Signed ALU64 immediate operations */
1138 static int bpf_fill_alu64_sdiv_imm(struct bpf_test *self)
1139 {
1140 	return __bpf_fill_alu64_imm(self, BPF_DIV, F_SIGNED);
1141 }
1142 
1143 static int bpf_fill_alu64_smod_imm(struct bpf_test *self)
1144 {
1145 	return __bpf_fill_alu64_imm(self, BPF_MOD, F_SIGNED);
1146 }
1147 
1148 /* Signed ALU32 immediate operations */
1149 static int bpf_fill_alu32_sdiv_imm(struct bpf_test *self)
1150 {
1151 	return __bpf_fill_alu32_imm(self, BPF_DIV, F_SIGNED);
1152 }
1153 
1154 static int bpf_fill_alu32_smod_imm(struct bpf_test *self)
1155 {
1156 	return __bpf_fill_alu32_imm(self, BPF_MOD, F_SIGNED);
1157 }
1158 
1159 /* ALU32 immediate operations */
1160 static int bpf_fill_alu32_mov_imm(struct bpf_test *self)
1161 {
1162 	return __bpf_fill_alu32_imm(self, BPF_MOV, 0);
1163 }
1164 
1165 static int bpf_fill_alu32_and_imm(struct bpf_test *self)
1166 {
1167 	return __bpf_fill_alu32_imm(self, BPF_AND, 0);
1168 }
1169 
1170 static int bpf_fill_alu32_or_imm(struct bpf_test *self)
1171 {
1172 	return __bpf_fill_alu32_imm(self, BPF_OR, 0);
1173 }
1174 
1175 static int bpf_fill_alu32_xor_imm(struct bpf_test *self)
1176 {
1177 	return __bpf_fill_alu32_imm(self, BPF_XOR, 0);
1178 }
1179 
1180 static int bpf_fill_alu32_add_imm(struct bpf_test *self)
1181 {
1182 	return __bpf_fill_alu32_imm(self, BPF_ADD, 0);
1183 }
1184 
1185 static int bpf_fill_alu32_sub_imm(struct bpf_test *self)
1186 {
1187 	return __bpf_fill_alu32_imm(self, BPF_SUB, 0);
1188 }
1189 
1190 static int bpf_fill_alu32_mul_imm(struct bpf_test *self)
1191 {
1192 	return __bpf_fill_alu32_imm(self, BPF_MUL, 0);
1193 }
1194 
1195 static int bpf_fill_alu32_div_imm(struct bpf_test *self)
1196 {
1197 	return __bpf_fill_alu32_imm(self, BPF_DIV, 0);
1198 }
1199 
1200 static int bpf_fill_alu32_mod_imm(struct bpf_test *self)
1201 {
1202 	return __bpf_fill_alu32_imm(self, BPF_MOD, 0);
1203 }
1204 
1205 /* ALU64 register operations */
1206 static int bpf_fill_alu64_mov_reg(struct bpf_test *self)
1207 {
1208 	return __bpf_fill_alu64_reg(self, BPF_MOV);
1209 }
1210 
1211 static int bpf_fill_alu64_and_reg(struct bpf_test *self)
1212 {
1213 	return __bpf_fill_alu64_reg(self, BPF_AND);
1214 }
1215 
1216 static int bpf_fill_alu64_or_reg(struct bpf_test *self)
1217 {
1218 	return __bpf_fill_alu64_reg(self, BPF_OR);
1219 }
1220 
1221 static int bpf_fill_alu64_xor_reg(struct bpf_test *self)
1222 {
1223 	return __bpf_fill_alu64_reg(self, BPF_XOR);
1224 }
1225 
1226 static int bpf_fill_alu64_add_reg(struct bpf_test *self)
1227 {
1228 	return __bpf_fill_alu64_reg(self, BPF_ADD);
1229 }
1230 
1231 static int bpf_fill_alu64_sub_reg(struct bpf_test *self)
1232 {
1233 	return __bpf_fill_alu64_reg(self, BPF_SUB);
1234 }
1235 
1236 static int bpf_fill_alu64_mul_reg(struct bpf_test *self)
1237 {
1238 	return __bpf_fill_alu64_reg(self, BPF_MUL);
1239 }
1240 
1241 static int bpf_fill_alu64_div_reg(struct bpf_test *self)
1242 {
1243 	return __bpf_fill_alu64_reg(self, BPF_DIV);
1244 }
1245 
1246 static int bpf_fill_alu64_mod_reg(struct bpf_test *self)
1247 {
1248 	return __bpf_fill_alu64_reg(self, BPF_MOD);
1249 }
1250 
1251 /* ALU32 register operations */
1252 static int bpf_fill_alu32_mov_reg(struct bpf_test *self)
1253 {
1254 	return __bpf_fill_alu32_reg(self, BPF_MOV);
1255 }
1256 
1257 static int bpf_fill_alu32_and_reg(struct bpf_test *self)
1258 {
1259 	return __bpf_fill_alu32_reg(self, BPF_AND);
1260 }
1261 
1262 static int bpf_fill_alu32_or_reg(struct bpf_test *self)
1263 {
1264 	return __bpf_fill_alu32_reg(self, BPF_OR);
1265 }
1266 
1267 static int bpf_fill_alu32_xor_reg(struct bpf_test *self)
1268 {
1269 	return __bpf_fill_alu32_reg(self, BPF_XOR);
1270 }
1271 
1272 static int bpf_fill_alu32_add_reg(struct bpf_test *self)
1273 {
1274 	return __bpf_fill_alu32_reg(self, BPF_ADD);
1275 }
1276 
1277 static int bpf_fill_alu32_sub_reg(struct bpf_test *self)
1278 {
1279 	return __bpf_fill_alu32_reg(self, BPF_SUB);
1280 }
1281 
1282 static int bpf_fill_alu32_mul_reg(struct bpf_test *self)
1283 {
1284 	return __bpf_fill_alu32_reg(self, BPF_MUL);
1285 }
1286 
1287 static int bpf_fill_alu32_div_reg(struct bpf_test *self)
1288 {
1289 	return __bpf_fill_alu32_reg(self, BPF_DIV);
1290 }
1291 
1292 static int bpf_fill_alu32_mod_reg(struct bpf_test *self)
1293 {
1294 	return __bpf_fill_alu32_reg(self, BPF_MOD);
1295 }
1296 
1297 /*
1298  * Test JITs that implement complex ALU operations as function
1299  * calls, and must re-arrange operands for argument passing.
1300  */
1301 static int __bpf_fill_alu_imm_regs(struct bpf_test *self, u8 op,
1302 				    u32 flags)
1303 {
1304 	int len = 2 + 10 * 10;
1305 	struct bpf_insn *insns;
1306 	u64 dst, res;
1307 	int i = 0;
1308 	u32 imm;
1309 	int rd;
1310 
1311 	insns = kmalloc_objs(*insns, len);
1312 	if (!insns)
1313 		return -ENOMEM;
1314 
1315 	/* Operand and result values according to operation */
1316 	if (flags & F_SIGNED) {
1317 		if (flags & F_ALU32)
1318 			dst = -76543210;
1319 		else
1320 			dst = -7654321076543210LL;
1321 	} else {
1322 		if (flags & F_ALU32)
1323 			dst = 0x76543210U;
1324 		else
1325 			dst = 0x7edcba9876543210ULL;
1326 	}
1327 	imm = 0x01234567U;
1328 
1329 	if (op == BPF_LSH || op == BPF_RSH || op == BPF_ARSH)
1330 		imm &= 31;
1331 
1332 	__bpf_alu_result(&res, dst, imm, op, flags);
1333 
1334 	if (flags & F_ALU32)
1335 		res = (u32)res;
1336 
1337 	/* Check all operand registers */
1338 	for (rd = R0; rd <= R9; rd++) {
1339 		i += __bpf_ld_imm64(&insns[i], rd, dst);
1340 
1341 		s16 off = (flags & F_SIGNED) ? 1 : 0;
1342 
1343 		if (flags & F_ALU32)
1344 			insns[i++] = BPF_ALU32_IMM_OFF(op, rd, imm, off);
1345 		else
1346 			insns[i++] = BPF_ALU64_IMM_OFF(op, rd, imm, off);
1347 
1348 		insns[i++] = BPF_JMP32_IMM(BPF_JEQ, rd, res, 2);
1349 		insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1350 		insns[i++] = BPF_EXIT_INSN();
1351 
1352 		insns[i++] = BPF_ALU64_IMM(BPF_RSH, rd, 32);
1353 		insns[i++] = BPF_JMP32_IMM(BPF_JEQ, rd, res >> 32, 2);
1354 		insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1355 		insns[i++] = BPF_EXIT_INSN();
1356 	}
1357 
1358 	insns[i++] = BPF_MOV64_IMM(R0, 1);
1359 	insns[i++] = BPF_EXIT_INSN();
1360 
1361 	self->u.ptr.insns = insns;
1362 	self->u.ptr.len = len;
1363 	BUG_ON(i != len);
1364 
1365 	return 0;
1366 }
1367 
1368 /* ALU64 K registers */
1369 static int bpf_fill_alu64_mov_imm_regs(struct bpf_test *self)
1370 {
1371 	return __bpf_fill_alu_imm_regs(self, BPF_MOV, 0);
1372 }
1373 
1374 static int bpf_fill_alu64_and_imm_regs(struct bpf_test *self)
1375 {
1376 	return __bpf_fill_alu_imm_regs(self, BPF_AND, 0);
1377 }
1378 
1379 static int bpf_fill_alu64_or_imm_regs(struct bpf_test *self)
1380 {
1381 	return __bpf_fill_alu_imm_regs(self, BPF_OR, 0);
1382 }
1383 
1384 static int bpf_fill_alu64_xor_imm_regs(struct bpf_test *self)
1385 {
1386 	return __bpf_fill_alu_imm_regs(self, BPF_XOR, 0);
1387 }
1388 
1389 static int bpf_fill_alu64_lsh_imm_regs(struct bpf_test *self)
1390 {
1391 	return __bpf_fill_alu_imm_regs(self, BPF_LSH, 0);
1392 }
1393 
1394 static int bpf_fill_alu64_rsh_imm_regs(struct bpf_test *self)
1395 {
1396 	return __bpf_fill_alu_imm_regs(self, BPF_RSH, 0);
1397 }
1398 
1399 static int bpf_fill_alu64_arsh_imm_regs(struct bpf_test *self)
1400 {
1401 	return __bpf_fill_alu_imm_regs(self, BPF_ARSH, 0);
1402 }
1403 
1404 static int bpf_fill_alu64_add_imm_regs(struct bpf_test *self)
1405 {
1406 	return __bpf_fill_alu_imm_regs(self, BPF_ADD, 0);
1407 }
1408 
1409 static int bpf_fill_alu64_sub_imm_regs(struct bpf_test *self)
1410 {
1411 	return __bpf_fill_alu_imm_regs(self, BPF_SUB, 0);
1412 }
1413 
1414 static int bpf_fill_alu64_mul_imm_regs(struct bpf_test *self)
1415 {
1416 	return __bpf_fill_alu_imm_regs(self, BPF_MUL, 0);
1417 }
1418 
1419 static int bpf_fill_alu64_div_imm_regs(struct bpf_test *self)
1420 {
1421 	return __bpf_fill_alu_imm_regs(self, BPF_DIV, 0);
1422 }
1423 
1424 static int bpf_fill_alu64_mod_imm_regs(struct bpf_test *self)
1425 {
1426 	return __bpf_fill_alu_imm_regs(self, BPF_MOD, 0);
1427 }
1428 
1429 /* Signed ALU64 K registers */
1430 static int bpf_fill_alu64_sdiv_imm_regs(struct bpf_test *self)
1431 {
1432 	return __bpf_fill_alu_imm_regs(self, BPF_DIV, F_SIGNED);
1433 }
1434 
1435 static int bpf_fill_alu64_smod_imm_regs(struct bpf_test *self)
1436 {
1437 	return __bpf_fill_alu_imm_regs(self, BPF_MOD, F_SIGNED);
1438 }
1439 
1440 /* ALU32 K registers */
1441 static int bpf_fill_alu32_mov_imm_regs(struct bpf_test *self)
1442 {
1443 	return __bpf_fill_alu_imm_regs(self, BPF_MOV, F_ALU32);
1444 }
1445 
1446 static int bpf_fill_alu32_and_imm_regs(struct bpf_test *self)
1447 {
1448 	return __bpf_fill_alu_imm_regs(self, BPF_AND, F_ALU32);
1449 }
1450 
1451 static int bpf_fill_alu32_or_imm_regs(struct bpf_test *self)
1452 {
1453 	return __bpf_fill_alu_imm_regs(self, BPF_OR, F_ALU32);
1454 }
1455 
1456 static int bpf_fill_alu32_xor_imm_regs(struct bpf_test *self)
1457 {
1458 	return __bpf_fill_alu_imm_regs(self, BPF_XOR, F_ALU32);
1459 }
1460 
1461 static int bpf_fill_alu32_lsh_imm_regs(struct bpf_test *self)
1462 {
1463 	return __bpf_fill_alu_imm_regs(self, BPF_LSH, F_ALU32);
1464 }
1465 
1466 static int bpf_fill_alu32_rsh_imm_regs(struct bpf_test *self)
1467 {
1468 	return __bpf_fill_alu_imm_regs(self, BPF_RSH, F_ALU32);
1469 }
1470 
1471 static int bpf_fill_alu32_arsh_imm_regs(struct bpf_test *self)
1472 {
1473 	return __bpf_fill_alu_imm_regs(self, BPF_ARSH, F_ALU32);
1474 }
1475 
1476 static int bpf_fill_alu32_add_imm_regs(struct bpf_test *self)
1477 {
1478 	return __bpf_fill_alu_imm_regs(self, BPF_ADD, F_ALU32);
1479 }
1480 
1481 static int bpf_fill_alu32_sub_imm_regs(struct bpf_test *self)
1482 {
1483 	return __bpf_fill_alu_imm_regs(self, BPF_SUB, F_ALU32);
1484 }
1485 
1486 static int bpf_fill_alu32_mul_imm_regs(struct bpf_test *self)
1487 {
1488 	return __bpf_fill_alu_imm_regs(self, BPF_MUL, F_ALU32);
1489 }
1490 
1491 static int bpf_fill_alu32_div_imm_regs(struct bpf_test *self)
1492 {
1493 	return __bpf_fill_alu_imm_regs(self, BPF_DIV, F_ALU32);
1494 }
1495 
1496 static int bpf_fill_alu32_mod_imm_regs(struct bpf_test *self)
1497 {
1498 	return __bpf_fill_alu_imm_regs(self, BPF_MOD, F_ALU32);
1499 }
1500 
1501 /* Signed ALU32 K registers */
1502 static int bpf_fill_alu32_sdiv_imm_regs(struct bpf_test *self)
1503 {
1504 	return __bpf_fill_alu_imm_regs(self, BPF_DIV, F_ALU32 | F_SIGNED);
1505 }
1506 
1507 static int bpf_fill_alu32_smod_imm_regs(struct bpf_test *self)
1508 {
1509 	return __bpf_fill_alu_imm_regs(self, BPF_MOD, F_ALU32 | F_SIGNED);
1510 }
1511 
1512 /*
1513  * Test JITs that implement complex ALU operations as function
1514  * calls, and must re-arrange operands for argument passing.
1515  */
1516 static int __bpf_fill_alu_reg_pairs(struct bpf_test *self, u8 op, bool alu32)
1517 {
1518 	int len = 2 + 10 * 10 * 12;
1519 	u64 dst, src, res, same;
1520 	struct bpf_insn *insns;
1521 	int rd, rs;
1522 	int i = 0;
1523 
1524 	insns = kmalloc_objs(*insns, len);
1525 	if (!insns)
1526 		return -ENOMEM;
1527 
1528 	/* Operand and result values according to operation */
1529 	if (alu32) {
1530 		dst = 0x76543210U;
1531 		src = 0x01234567U;
1532 	} else {
1533 		dst = 0x7edcba9876543210ULL;
1534 		src = 0x0123456789abcdefULL;
1535 	}
1536 
1537 	if (op == BPF_LSH || op == BPF_RSH || op == BPF_ARSH)
1538 		src &= 31;
1539 
1540 	__bpf_alu_result(&res, dst, src, op, 0);
1541 	__bpf_alu_result(&same, src, src, op, 0);
1542 
1543 	if (alu32) {
1544 		res = (u32)res;
1545 		same = (u32)same;
1546 	}
1547 
1548 	/* Check all combinations of operand registers */
1549 	for (rd = R0; rd <= R9; rd++) {
1550 		for (rs = R0; rs <= R9; rs++) {
1551 			u64 val = rd == rs ? same : res;
1552 
1553 			i += __bpf_ld_imm64(&insns[i], rd, dst);
1554 			i += __bpf_ld_imm64(&insns[i], rs, src);
1555 
1556 			if (alu32)
1557 				insns[i++] = BPF_ALU32_REG(op, rd, rs);
1558 			else
1559 				insns[i++] = BPF_ALU64_REG(op, rd, rs);
1560 
1561 			insns[i++] = BPF_JMP32_IMM(BPF_JEQ, rd, val, 2);
1562 			insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1563 			insns[i++] = BPF_EXIT_INSN();
1564 
1565 			insns[i++] = BPF_ALU64_IMM(BPF_RSH, rd, 32);
1566 			insns[i++] = BPF_JMP32_IMM(BPF_JEQ, rd, val >> 32, 2);
1567 			insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1568 			insns[i++] = BPF_EXIT_INSN();
1569 		}
1570 	}
1571 
1572 	insns[i++] = BPF_MOV64_IMM(R0, 1);
1573 	insns[i++] = BPF_EXIT_INSN();
1574 
1575 	self->u.ptr.insns = insns;
1576 	self->u.ptr.len = len;
1577 	BUG_ON(i != len);
1578 
1579 	return 0;
1580 }
1581 
1582 /* ALU64 X register combinations */
1583 static int bpf_fill_alu64_mov_reg_pairs(struct bpf_test *self)
1584 {
1585 	return __bpf_fill_alu_reg_pairs(self, BPF_MOV, false);
1586 }
1587 
1588 static int bpf_fill_alu64_and_reg_pairs(struct bpf_test *self)
1589 {
1590 	return __bpf_fill_alu_reg_pairs(self, BPF_AND, false);
1591 }
1592 
1593 static int bpf_fill_alu64_or_reg_pairs(struct bpf_test *self)
1594 {
1595 	return __bpf_fill_alu_reg_pairs(self, BPF_OR, false);
1596 }
1597 
1598 static int bpf_fill_alu64_xor_reg_pairs(struct bpf_test *self)
1599 {
1600 	return __bpf_fill_alu_reg_pairs(self, BPF_XOR, false);
1601 }
1602 
1603 static int bpf_fill_alu64_lsh_reg_pairs(struct bpf_test *self)
1604 {
1605 	return __bpf_fill_alu_reg_pairs(self, BPF_LSH, false);
1606 }
1607 
1608 static int bpf_fill_alu64_rsh_reg_pairs(struct bpf_test *self)
1609 {
1610 	return __bpf_fill_alu_reg_pairs(self, BPF_RSH, false);
1611 }
1612 
1613 static int bpf_fill_alu64_arsh_reg_pairs(struct bpf_test *self)
1614 {
1615 	return __bpf_fill_alu_reg_pairs(self, BPF_ARSH, false);
1616 }
1617 
1618 static int bpf_fill_alu64_add_reg_pairs(struct bpf_test *self)
1619 {
1620 	return __bpf_fill_alu_reg_pairs(self, BPF_ADD, false);
1621 }
1622 
1623 static int bpf_fill_alu64_sub_reg_pairs(struct bpf_test *self)
1624 {
1625 	return __bpf_fill_alu_reg_pairs(self, BPF_SUB, false);
1626 }
1627 
1628 static int bpf_fill_alu64_mul_reg_pairs(struct bpf_test *self)
1629 {
1630 	return __bpf_fill_alu_reg_pairs(self, BPF_MUL, false);
1631 }
1632 
1633 static int bpf_fill_alu64_div_reg_pairs(struct bpf_test *self)
1634 {
1635 	return __bpf_fill_alu_reg_pairs(self, BPF_DIV, false);
1636 }
1637 
1638 static int bpf_fill_alu64_mod_reg_pairs(struct bpf_test *self)
1639 {
1640 	return __bpf_fill_alu_reg_pairs(self, BPF_MOD, false);
1641 }
1642 
1643 /* ALU32 X register combinations */
1644 static int bpf_fill_alu32_mov_reg_pairs(struct bpf_test *self)
1645 {
1646 	return __bpf_fill_alu_reg_pairs(self, BPF_MOV, true);
1647 }
1648 
1649 static int bpf_fill_alu32_and_reg_pairs(struct bpf_test *self)
1650 {
1651 	return __bpf_fill_alu_reg_pairs(self, BPF_AND, true);
1652 }
1653 
1654 static int bpf_fill_alu32_or_reg_pairs(struct bpf_test *self)
1655 {
1656 	return __bpf_fill_alu_reg_pairs(self, BPF_OR, true);
1657 }
1658 
1659 static int bpf_fill_alu32_xor_reg_pairs(struct bpf_test *self)
1660 {
1661 	return __bpf_fill_alu_reg_pairs(self, BPF_XOR, true);
1662 }
1663 
1664 static int bpf_fill_alu32_lsh_reg_pairs(struct bpf_test *self)
1665 {
1666 	return __bpf_fill_alu_reg_pairs(self, BPF_LSH, true);
1667 }
1668 
1669 static int bpf_fill_alu32_rsh_reg_pairs(struct bpf_test *self)
1670 {
1671 	return __bpf_fill_alu_reg_pairs(self, BPF_RSH, true);
1672 }
1673 
1674 static int bpf_fill_alu32_arsh_reg_pairs(struct bpf_test *self)
1675 {
1676 	return __bpf_fill_alu_reg_pairs(self, BPF_ARSH, true);
1677 }
1678 
1679 static int bpf_fill_alu32_add_reg_pairs(struct bpf_test *self)
1680 {
1681 	return __bpf_fill_alu_reg_pairs(self, BPF_ADD, true);
1682 }
1683 
1684 static int bpf_fill_alu32_sub_reg_pairs(struct bpf_test *self)
1685 {
1686 	return __bpf_fill_alu_reg_pairs(self, BPF_SUB, true);
1687 }
1688 
1689 static int bpf_fill_alu32_mul_reg_pairs(struct bpf_test *self)
1690 {
1691 	return __bpf_fill_alu_reg_pairs(self, BPF_MUL, true);
1692 }
1693 
1694 static int bpf_fill_alu32_div_reg_pairs(struct bpf_test *self)
1695 {
1696 	return __bpf_fill_alu_reg_pairs(self, BPF_DIV, true);
1697 }
1698 
1699 static int bpf_fill_alu32_mod_reg_pairs(struct bpf_test *self)
1700 {
1701 	return __bpf_fill_alu_reg_pairs(self, BPF_MOD, true);
1702 }
1703 
1704 /*
1705  * Exhaustive tests of atomic operations for all power-of-two operand
1706  * magnitudes, both for positive and negative values.
1707  */
1708 
1709 static int __bpf_emit_atomic64(struct bpf_test *self, void *arg,
1710 			       struct bpf_insn *insns, s64 dst, s64 src)
1711 {
1712 	int op = *(int *)arg;
1713 	u64 keep, fetch, res;
1714 	int i = 0;
1715 
1716 	if (!insns)
1717 		return 21;
1718 
1719 	switch (op) {
1720 	case BPF_XCHG:
1721 		res = src;
1722 		break;
1723 	default:
1724 		__bpf_alu_result(&res, dst, src, BPF_OP(op), 0);
1725 	}
1726 
1727 	keep = 0x0123456789abcdefULL;
1728 	if (op & BPF_FETCH)
1729 		fetch = dst;
1730 	else
1731 		fetch = src;
1732 
1733 	i += __bpf_ld_imm64(&insns[i], R0, keep);
1734 	i += __bpf_ld_imm64(&insns[i], R1, dst);
1735 	i += __bpf_ld_imm64(&insns[i], R2, src);
1736 	i += __bpf_ld_imm64(&insns[i], R3, res);
1737 	i += __bpf_ld_imm64(&insns[i], R4, fetch);
1738 	i += __bpf_ld_imm64(&insns[i], R5, keep);
1739 
1740 	insns[i++] = BPF_STX_MEM(BPF_DW, R10, R1, -8);
1741 	insns[i++] = BPF_ATOMIC_OP(BPF_DW, op, R10, R2, -8);
1742 	insns[i++] = BPF_LDX_MEM(BPF_DW, R1, R10, -8);
1743 
1744 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
1745 	insns[i++] = BPF_EXIT_INSN();
1746 
1747 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R2, R4, 1);
1748 	insns[i++] = BPF_EXIT_INSN();
1749 
1750 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R5, 1);
1751 	insns[i++] = BPF_EXIT_INSN();
1752 
1753 	return i;
1754 }
1755 
1756 static int __bpf_emit_atomic32(struct bpf_test *self, void *arg,
1757 			       struct bpf_insn *insns, s64 dst, s64 src)
1758 {
1759 	int op = *(int *)arg;
1760 	u64 keep, fetch, res;
1761 	int i = 0;
1762 
1763 	if (!insns)
1764 		return 21;
1765 
1766 	switch (op) {
1767 	case BPF_XCHG:
1768 		res = src;
1769 		break;
1770 	default:
1771 		__bpf_alu_result(&res, (u32)dst, (u32)src, BPF_OP(op), 0);
1772 	}
1773 
1774 	keep = 0x0123456789abcdefULL;
1775 	if (op & BPF_FETCH)
1776 		fetch = (u32)dst;
1777 	else
1778 		fetch = src;
1779 
1780 	i += __bpf_ld_imm64(&insns[i], R0, keep);
1781 	i += __bpf_ld_imm64(&insns[i], R1, (u32)dst);
1782 	i += __bpf_ld_imm64(&insns[i], R2, src);
1783 	i += __bpf_ld_imm64(&insns[i], R3, (u32)res);
1784 	i += __bpf_ld_imm64(&insns[i], R4, fetch);
1785 	i += __bpf_ld_imm64(&insns[i], R5, keep);
1786 
1787 	insns[i++] = BPF_STX_MEM(BPF_W, R10, R1, -4);
1788 	insns[i++] = BPF_ATOMIC_OP(BPF_W, op, R10, R2, -4);
1789 	insns[i++] = BPF_LDX_MEM(BPF_W, R1, R10, -4);
1790 
1791 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
1792 	insns[i++] = BPF_EXIT_INSN();
1793 
1794 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R2, R4, 1);
1795 	insns[i++] = BPF_EXIT_INSN();
1796 
1797 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R5, 1);
1798 	insns[i++] = BPF_EXIT_INSN();
1799 
1800 	return i;
1801 }
1802 
1803 static int __bpf_emit_cmpxchg64(struct bpf_test *self, void *arg,
1804 				struct bpf_insn *insns, s64 dst, s64 src)
1805 {
1806 	int i = 0;
1807 
1808 	if (!insns)
1809 		return 23;
1810 
1811 	i += __bpf_ld_imm64(&insns[i], R0, ~dst);
1812 	i += __bpf_ld_imm64(&insns[i], R1, dst);
1813 	i += __bpf_ld_imm64(&insns[i], R2, src);
1814 
1815 	/* Result unsuccessful */
1816 	insns[i++] = BPF_STX_MEM(BPF_DW, R10, R1, -8);
1817 	insns[i++] = BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -8);
1818 	insns[i++] = BPF_LDX_MEM(BPF_DW, R3, R10, -8);
1819 
1820 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 2);
1821 	insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1822 	insns[i++] = BPF_EXIT_INSN();
1823 
1824 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R3, 2);
1825 	insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1826 	insns[i++] = BPF_EXIT_INSN();
1827 
1828 	/* Result successful */
1829 	insns[i++] = BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -8);
1830 	insns[i++] = BPF_LDX_MEM(BPF_DW, R3, R10, -8);
1831 
1832 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R2, R3, 2);
1833 	insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1834 	insns[i++] = BPF_EXIT_INSN();
1835 
1836 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R1, 2);
1837 	insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1838 	insns[i++] = BPF_EXIT_INSN();
1839 
1840 	return i;
1841 }
1842 
1843 static int __bpf_emit_cmpxchg32(struct bpf_test *self, void *arg,
1844 				struct bpf_insn *insns, s64 dst, s64 src)
1845 {
1846 	int i = 0;
1847 
1848 	if (!insns)
1849 		return 27;
1850 
1851 	i += __bpf_ld_imm64(&insns[i], R0, ~dst);
1852 	i += __bpf_ld_imm64(&insns[i], R1, (u32)dst);
1853 	i += __bpf_ld_imm64(&insns[i], R2, src);
1854 
1855 	/* Result unsuccessful */
1856 	insns[i++] = BPF_STX_MEM(BPF_W, R10, R1, -4);
1857 	insns[i++] = BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R2, -4);
1858 	insns[i++] = BPF_ZEXT_REG(R0); /* Zext always inserted by verifier */
1859 	insns[i++] = BPF_LDX_MEM(BPF_W, R3, R10, -4);
1860 
1861 	insns[i++] = BPF_JMP32_REG(BPF_JEQ, R1, R3, 2);
1862 	insns[i++] = BPF_MOV32_IMM(R0, __LINE__);
1863 	insns[i++] = BPF_EXIT_INSN();
1864 
1865 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R3, 2);
1866 	insns[i++] = BPF_MOV32_IMM(R0, __LINE__);
1867 	insns[i++] = BPF_EXIT_INSN();
1868 
1869 	/* Result successful */
1870 	i += __bpf_ld_imm64(&insns[i], R0, dst);
1871 	insns[i++] = BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R2, -4);
1872 	insns[i++] = BPF_ZEXT_REG(R0); /* Zext always inserted by verifier */
1873 	insns[i++] = BPF_LDX_MEM(BPF_W, R3, R10, -4);
1874 
1875 	insns[i++] = BPF_JMP32_REG(BPF_JEQ, R2, R3, 2);
1876 	insns[i++] = BPF_MOV32_IMM(R0, __LINE__);
1877 	insns[i++] = BPF_EXIT_INSN();
1878 
1879 	insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R1, 2);
1880 	insns[i++] = BPF_MOV32_IMM(R0, __LINE__);
1881 	insns[i++] = BPF_EXIT_INSN();
1882 
1883 	return i;
1884 }
1885 
1886 static int __bpf_fill_atomic64(struct bpf_test *self, int op)
1887 {
1888 	return __bpf_fill_pattern(self, &op, 64, 64,
1889 				  0, PATTERN_BLOCK2,
1890 				  &__bpf_emit_atomic64);
1891 }
1892 
1893 static int __bpf_fill_atomic32(struct bpf_test *self, int op)
1894 {
1895 	return __bpf_fill_pattern(self, &op, 64, 64,
1896 				  0, PATTERN_BLOCK2,
1897 				  &__bpf_emit_atomic32);
1898 }
1899 
1900 /* 64-bit atomic operations */
1901 static int bpf_fill_atomic64_add(struct bpf_test *self)
1902 {
1903 	return __bpf_fill_atomic64(self, BPF_ADD);
1904 }
1905 
1906 static int bpf_fill_atomic64_and(struct bpf_test *self)
1907 {
1908 	return __bpf_fill_atomic64(self, BPF_AND);
1909 }
1910 
1911 static int bpf_fill_atomic64_or(struct bpf_test *self)
1912 {
1913 	return __bpf_fill_atomic64(self, BPF_OR);
1914 }
1915 
1916 static int bpf_fill_atomic64_xor(struct bpf_test *self)
1917 {
1918 	return __bpf_fill_atomic64(self, BPF_XOR);
1919 }
1920 
1921 static int bpf_fill_atomic64_add_fetch(struct bpf_test *self)
1922 {
1923 	return __bpf_fill_atomic64(self, BPF_ADD | BPF_FETCH);
1924 }
1925 
1926 static int bpf_fill_atomic64_and_fetch(struct bpf_test *self)
1927 {
1928 	return __bpf_fill_atomic64(self, BPF_AND | BPF_FETCH);
1929 }
1930 
1931 static int bpf_fill_atomic64_or_fetch(struct bpf_test *self)
1932 {
1933 	return __bpf_fill_atomic64(self, BPF_OR | BPF_FETCH);
1934 }
1935 
1936 static int bpf_fill_atomic64_xor_fetch(struct bpf_test *self)
1937 {
1938 	return __bpf_fill_atomic64(self, BPF_XOR | BPF_FETCH);
1939 }
1940 
1941 static int bpf_fill_atomic64_xchg(struct bpf_test *self)
1942 {
1943 	return __bpf_fill_atomic64(self, BPF_XCHG);
1944 }
1945 
1946 static int bpf_fill_cmpxchg64(struct bpf_test *self)
1947 {
1948 	return __bpf_fill_pattern(self, NULL, 64, 64, 0, PATTERN_BLOCK2,
1949 				  &__bpf_emit_cmpxchg64);
1950 }
1951 
1952 /* 32-bit atomic operations */
1953 static int bpf_fill_atomic32_add(struct bpf_test *self)
1954 {
1955 	return __bpf_fill_atomic32(self, BPF_ADD);
1956 }
1957 
1958 static int bpf_fill_atomic32_and(struct bpf_test *self)
1959 {
1960 	return __bpf_fill_atomic32(self, BPF_AND);
1961 }
1962 
1963 static int bpf_fill_atomic32_or(struct bpf_test *self)
1964 {
1965 	return __bpf_fill_atomic32(self, BPF_OR);
1966 }
1967 
1968 static int bpf_fill_atomic32_xor(struct bpf_test *self)
1969 {
1970 	return __bpf_fill_atomic32(self, BPF_XOR);
1971 }
1972 
1973 static int bpf_fill_atomic32_add_fetch(struct bpf_test *self)
1974 {
1975 	return __bpf_fill_atomic32(self, BPF_ADD | BPF_FETCH);
1976 }
1977 
1978 static int bpf_fill_atomic32_and_fetch(struct bpf_test *self)
1979 {
1980 	return __bpf_fill_atomic32(self, BPF_AND | BPF_FETCH);
1981 }
1982 
1983 static int bpf_fill_atomic32_or_fetch(struct bpf_test *self)
1984 {
1985 	return __bpf_fill_atomic32(self, BPF_OR | BPF_FETCH);
1986 }
1987 
1988 static int bpf_fill_atomic32_xor_fetch(struct bpf_test *self)
1989 {
1990 	return __bpf_fill_atomic32(self, BPF_XOR | BPF_FETCH);
1991 }
1992 
1993 static int bpf_fill_atomic32_xchg(struct bpf_test *self)
1994 {
1995 	return __bpf_fill_atomic32(self, BPF_XCHG);
1996 }
1997 
1998 static int bpf_fill_cmpxchg32(struct bpf_test *self)
1999 {
2000 	return __bpf_fill_pattern(self, NULL, 64, 64, 0, PATTERN_BLOCK2,
2001 				  &__bpf_emit_cmpxchg32);
2002 }
2003 
2004 /*
2005  * Test JITs that implement ATOMIC operations as function calls or
2006  * other primitives, and must re-arrange operands for argument passing.
2007  */
2008 static int __bpf_fill_atomic_reg_pairs(struct bpf_test *self, u8 width, u8 op)
2009 {
2010 	struct bpf_insn *insn;
2011 	int len = 2 + 34 * 10 * 10;
2012 	u64 mem, upd, res;
2013 	int rd, rs, i = 0;
2014 
2015 	insn = kmalloc_objs(*insn, len);
2016 	if (!insn)
2017 		return -ENOMEM;
2018 
2019 	/* Operand and memory values */
2020 	if (width == BPF_DW) {
2021 		mem = 0x0123456789abcdefULL;
2022 		upd = 0xfedcba9876543210ULL;
2023 	} else { /* BPF_W */
2024 		mem = 0x01234567U;
2025 		upd = 0x76543210U;
2026 	}
2027 
2028 	/* Memory updated according to operation */
2029 	switch (op) {
2030 	case BPF_XCHG:
2031 		res = upd;
2032 		break;
2033 	case BPF_CMPXCHG:
2034 		res = mem;
2035 		break;
2036 	default:
2037 		__bpf_alu_result(&res, mem, upd, BPF_OP(op), 0);
2038 	}
2039 
2040 	/* Test all operand registers */
2041 	for (rd = R0; rd <= R9; rd++) {
2042 		for (rs = R0; rs <= R9; rs++) {
2043 			u64 cmp, src;
2044 
2045 			/* Initialize value in memory */
2046 			i += __bpf_ld_imm64(&insn[i], R0, mem);
2047 			insn[i++] = BPF_STX_MEM(width, R10, R0, -8);
2048 
2049 			/* Initialize registers in order */
2050 			i += __bpf_ld_imm64(&insn[i], R0, ~mem);
2051 			i += __bpf_ld_imm64(&insn[i], rs, upd);
2052 			insn[i++] = BPF_MOV64_REG(rd, R10);
2053 
2054 			/* Perform atomic operation */
2055 			insn[i++] = BPF_ATOMIC_OP(width, op, rd, rs, -8);
2056 			if (op == BPF_CMPXCHG && width == BPF_W)
2057 				insn[i++] = BPF_ZEXT_REG(R0);
2058 
2059 			/* Check R0 register value */
2060 			if (op == BPF_CMPXCHG)
2061 				cmp = mem;  /* Expect value from memory */
2062 			else if (R0 == rd || R0 == rs)
2063 				cmp = 0;    /* Aliased, checked below */
2064 			else
2065 				cmp = ~mem; /* Expect value to be preserved */
2066 			if (cmp) {
2067 				insn[i++] = BPF_JMP32_IMM(BPF_JEQ, R0,
2068 							   (u32)cmp, 2);
2069 				insn[i++] = BPF_MOV32_IMM(R0, __LINE__);
2070 				insn[i++] = BPF_EXIT_INSN();
2071 				insn[i++] = BPF_ALU64_IMM(BPF_RSH, R0, 32);
2072 				insn[i++] = BPF_JMP32_IMM(BPF_JEQ, R0,
2073 							   cmp >> 32, 2);
2074 				insn[i++] = BPF_MOV32_IMM(R0, __LINE__);
2075 				insn[i++] = BPF_EXIT_INSN();
2076 			}
2077 
2078 			/* Check source register value */
2079 			if (rs == R0 && op == BPF_CMPXCHG)
2080 				src = 0;   /* Aliased with R0, checked above */
2081 			else if (rs == rd && (op == BPF_CMPXCHG ||
2082 					      !(op & BPF_FETCH)))
2083 				src = 0;   /* Aliased with rd, checked below */
2084 			else if (op == BPF_CMPXCHG)
2085 				src = upd; /* Expect value to be preserved */
2086 			else if (op & BPF_FETCH)
2087 				src = mem; /* Expect fetched value from mem */
2088 			else /* no fetch */
2089 				src = upd; /* Expect value to be preserved */
2090 			if (src) {
2091 				insn[i++] = BPF_JMP32_IMM(BPF_JEQ, rs,
2092 							   (u32)src, 2);
2093 				insn[i++] = BPF_MOV32_IMM(R0, __LINE__);
2094 				insn[i++] = BPF_EXIT_INSN();
2095 				insn[i++] = BPF_ALU64_IMM(BPF_RSH, rs, 32);
2096 				insn[i++] = BPF_JMP32_IMM(BPF_JEQ, rs,
2097 							   src >> 32, 2);
2098 				insn[i++] = BPF_MOV32_IMM(R0, __LINE__);
2099 				insn[i++] = BPF_EXIT_INSN();
2100 			}
2101 
2102 			/* Check destination register value */
2103 			if (!(rd == R0 && op == BPF_CMPXCHG) &&
2104 			    !(rd == rs && (op & BPF_FETCH))) {
2105 				insn[i++] = BPF_JMP_REG(BPF_JEQ, rd, R10, 2);
2106 				insn[i++] = BPF_MOV32_IMM(R0, __LINE__);
2107 				insn[i++] = BPF_EXIT_INSN();
2108 			}
2109 
2110 			/* Check value in memory */
2111 			if (rs != rd) {                  /* No aliasing */
2112 				i += __bpf_ld_imm64(&insn[i], R1, res);
2113 			} else if (op == BPF_XCHG) {     /* Aliased, XCHG */
2114 				insn[i++] = BPF_MOV64_REG(R1, R10);
2115 			} else if (op == BPF_CMPXCHG) {  /* Aliased, CMPXCHG */
2116 				i += __bpf_ld_imm64(&insn[i], R1, mem);
2117 			} else {                        /* Aliased, ALU oper */
2118 				i += __bpf_ld_imm64(&insn[i], R1, mem);
2119 				insn[i++] = BPF_ALU64_REG(BPF_OP(op), R1, R10);
2120 			}
2121 
2122 			insn[i++] = BPF_LDX_MEM(width, R0, R10, -8);
2123 			if (width == BPF_DW)
2124 				insn[i++] = BPF_JMP_REG(BPF_JEQ, R0, R1, 2);
2125 			else /* width == BPF_W */
2126 				insn[i++] = BPF_JMP32_REG(BPF_JEQ, R0, R1, 2);
2127 			insn[i++] = BPF_MOV32_IMM(R0, __LINE__);
2128 			insn[i++] = BPF_EXIT_INSN();
2129 		}
2130 	}
2131 
2132 	insn[i++] = BPF_MOV64_IMM(R0, 1);
2133 	insn[i++] = BPF_EXIT_INSN();
2134 
2135 	self->u.ptr.insns = insn;
2136 	self->u.ptr.len = i;
2137 	BUG_ON(i > len);
2138 
2139 	return 0;
2140 }
2141 
2142 /* 64-bit atomic register tests */
2143 static int bpf_fill_atomic64_add_reg_pairs(struct bpf_test *self)
2144 {
2145 	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_ADD);
2146 }
2147 
2148 static int bpf_fill_atomic64_and_reg_pairs(struct bpf_test *self)
2149 {
2150 	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_AND);
2151 }
2152 
2153 static int bpf_fill_atomic64_or_reg_pairs(struct bpf_test *self)
2154 {
2155 	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_OR);
2156 }
2157 
2158 static int bpf_fill_atomic64_xor_reg_pairs(struct bpf_test *self)
2159 {
2160 	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_XOR);
2161 }
2162 
2163 static int bpf_fill_atomic64_add_fetch_reg_pairs(struct bpf_test *self)
2164 {
2165 	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_ADD | BPF_FETCH);
2166 }
2167 
2168 static int bpf_fill_atomic64_and_fetch_reg_pairs(struct bpf_test *self)
2169 {
2170 	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_AND | BPF_FETCH);
2171 }
2172 
2173 static int bpf_fill_atomic64_or_fetch_reg_pairs(struct bpf_test *self)
2174 {
2175 	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_OR | BPF_FETCH);
2176 }
2177 
2178 static int bpf_fill_atomic64_xor_fetch_reg_pairs(struct bpf_test *self)
2179 {
2180 	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_XOR | BPF_FETCH);
2181 }
2182 
2183 static int bpf_fill_atomic64_xchg_reg_pairs(struct bpf_test *self)
2184 {
2185 	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_XCHG);
2186 }
2187 
2188 static int bpf_fill_atomic64_cmpxchg_reg_pairs(struct bpf_test *self)
2189 {
2190 	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_CMPXCHG);
2191 }
2192 
2193 /* 32-bit atomic register tests */
2194 static int bpf_fill_atomic32_add_reg_pairs(struct bpf_test *self)
2195 {
2196 	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_ADD);
2197 }
2198 
2199 static int bpf_fill_atomic32_and_reg_pairs(struct bpf_test *self)
2200 {
2201 	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_AND);
2202 }
2203 
2204 static int bpf_fill_atomic32_or_reg_pairs(struct bpf_test *self)
2205 {
2206 	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_OR);
2207 }
2208 
2209 static int bpf_fill_atomic32_xor_reg_pairs(struct bpf_test *self)
2210 {
2211 	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_XOR);
2212 }
2213 
2214 static int bpf_fill_atomic32_add_fetch_reg_pairs(struct bpf_test *self)
2215 {
2216 	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_ADD | BPF_FETCH);
2217 }
2218 
2219 static int bpf_fill_atomic32_and_fetch_reg_pairs(struct bpf_test *self)
2220 {
2221 	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_AND | BPF_FETCH);
2222 }
2223 
2224 static int bpf_fill_atomic32_or_fetch_reg_pairs(struct bpf_test *self)
2225 {
2226 	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_OR | BPF_FETCH);
2227 }
2228 
2229 static int bpf_fill_atomic32_xor_fetch_reg_pairs(struct bpf_test *self)
2230 {
2231 	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_XOR | BPF_FETCH);
2232 }
2233 
2234 static int bpf_fill_atomic32_xchg_reg_pairs(struct bpf_test *self)
2235 {
2236 	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_XCHG);
2237 }
2238 
2239 static int bpf_fill_atomic32_cmpxchg_reg_pairs(struct bpf_test *self)
2240 {
2241 	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_CMPXCHG);
2242 }
2243 
2244 /*
2245  * Test the two-instruction 64-bit immediate load operation for all
2246  * power-of-two magnitudes of the immediate operand. For each MSB, a block
2247  * of immediate values centered around the power-of-two MSB are tested,
2248  * both for positive and negative values. The test is designed to verify
2249  * the operation for JITs that emit different code depending on the magnitude
2250  * of the immediate value. This is often the case if the native instruction
2251  * immediate field width is narrower than 32 bits.
2252  */
2253 static int bpf_fill_ld_imm64_magn(struct bpf_test *self)
2254 {
2255 	int block = 64; /* Increase for more tests per MSB position */
2256 	int len = 3 + 8 * 63 * block * 2;
2257 	struct bpf_insn *insn;
2258 	int bit, adj, sign;
2259 	int i = 0;
2260 
2261 	insn = kmalloc_objs(*insn, len);
2262 	if (!insn)
2263 		return -ENOMEM;
2264 
2265 	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
2266 
2267 	for (bit = 0; bit <= 62; bit++) {
2268 		for (adj = -block / 2; adj < block / 2; adj++) {
2269 			for (sign = -1; sign <= 1; sign += 2) {
2270 				s64 imm = sign * ((1LL << bit) + adj);
2271 
2272 				/* Perform operation */
2273 				i += __bpf_ld_imm64(&insn[i], R1, imm);
2274 
2275 				/* Load reference */
2276 				insn[i++] = BPF_ALU32_IMM(BPF_MOV, R2, imm);
2277 				insn[i++] = BPF_ALU32_IMM(BPF_MOV, R3,
2278 							  (u32)(imm >> 32));
2279 				insn[i++] = BPF_ALU64_IMM(BPF_LSH, R3, 32);
2280 				insn[i++] = BPF_ALU64_REG(BPF_OR, R2, R3);
2281 
2282 				/* Check result */
2283 				insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R2, 1);
2284 				insn[i++] = BPF_EXIT_INSN();
2285 			}
2286 		}
2287 	}
2288 
2289 	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
2290 	insn[i++] = BPF_EXIT_INSN();
2291 
2292 	self->u.ptr.insns = insn;
2293 	self->u.ptr.len = len;
2294 	BUG_ON(i != len);
2295 
2296 	return 0;
2297 }
2298 
2299 /*
2300  * Test the two-instruction 64-bit immediate load operation for different
2301  * combinations of bytes. Each byte in the 64-bit word is constructed as
2302  * (base & mask) | (rand() & ~mask), where rand() is a deterministic LCG.
2303  * All patterns (base1, mask1) and (base2, mask2) bytes are tested.
2304  */
2305 static int __bpf_fill_ld_imm64_bytes(struct bpf_test *self,
2306 				     u8 base1, u8 mask1,
2307 				     u8 base2, u8 mask2)
2308 {
2309 	struct bpf_insn *insn;
2310 	int len = 3 + 8 * BIT(8);
2311 	int pattern, index;
2312 	u32 rand = 1;
2313 	int i = 0;
2314 
2315 	insn = kmalloc_objs(*insn, len);
2316 	if (!insn)
2317 		return -ENOMEM;
2318 
2319 	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
2320 
2321 	for (pattern = 0; pattern < BIT(8); pattern++) {
2322 		u64 imm = 0;
2323 
2324 		for (index = 0; index < 8; index++) {
2325 			int byte;
2326 
2327 			if (pattern & BIT(index))
2328 				byte = (base1 & mask1) | (rand & ~mask1);
2329 			else
2330 				byte = (base2 & mask2) | (rand & ~mask2);
2331 			imm = (imm << 8) | byte;
2332 		}
2333 
2334 		/* Update our LCG */
2335 		rand = rand * 1664525 + 1013904223;
2336 
2337 		/* Perform operation */
2338 		i += __bpf_ld_imm64(&insn[i], R1, imm);
2339 
2340 		/* Load reference */
2341 		insn[i++] = BPF_ALU32_IMM(BPF_MOV, R2, imm);
2342 		insn[i++] = BPF_ALU32_IMM(BPF_MOV, R3, (u32)(imm >> 32));
2343 		insn[i++] = BPF_ALU64_IMM(BPF_LSH, R3, 32);
2344 		insn[i++] = BPF_ALU64_REG(BPF_OR, R2, R3);
2345 
2346 		/* Check result */
2347 		insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R2, 1);
2348 		insn[i++] = BPF_EXIT_INSN();
2349 	}
2350 
2351 	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
2352 	insn[i++] = BPF_EXIT_INSN();
2353 
2354 	self->u.ptr.insns = insn;
2355 	self->u.ptr.len = len;
2356 	BUG_ON(i != len);
2357 
2358 	return 0;
2359 }
2360 
2361 static int bpf_fill_ld_imm64_checker(struct bpf_test *self)
2362 {
2363 	return __bpf_fill_ld_imm64_bytes(self, 0, 0xff, 0xff, 0xff);
2364 }
2365 
2366 static int bpf_fill_ld_imm64_pos_neg(struct bpf_test *self)
2367 {
2368 	return __bpf_fill_ld_imm64_bytes(self, 1, 0x81, 0x80, 0x80);
2369 }
2370 
2371 static int bpf_fill_ld_imm64_pos_zero(struct bpf_test *self)
2372 {
2373 	return __bpf_fill_ld_imm64_bytes(self, 1, 0x81, 0, 0xff);
2374 }
2375 
2376 static int bpf_fill_ld_imm64_neg_zero(struct bpf_test *self)
2377 {
2378 	return __bpf_fill_ld_imm64_bytes(self, 0x80, 0x80, 0, 0xff);
2379 }
2380 
2381 /*
2382  * Exhaustive tests of JMP operations for all combinations of power-of-two
2383  * magnitudes of the operands, both for positive and negative values. The
2384  * test is designed to verify e.g. the JMP and JMP32 operations for JITs that
2385  * emit different code depending on the magnitude of the immediate value.
2386  */
2387 
2388 static bool __bpf_match_jmp_cond(s64 v1, s64 v2, u8 op)
2389 {
2390 	switch (op) {
2391 	case BPF_JSET:
2392 		return !!(v1 & v2);
2393 	case BPF_JEQ:
2394 		return v1 == v2;
2395 	case BPF_JNE:
2396 		return v1 != v2;
2397 	case BPF_JGT:
2398 		return (u64)v1 > (u64)v2;
2399 	case BPF_JGE:
2400 		return (u64)v1 >= (u64)v2;
2401 	case BPF_JLT:
2402 		return (u64)v1 < (u64)v2;
2403 	case BPF_JLE:
2404 		return (u64)v1 <= (u64)v2;
2405 	case BPF_JSGT:
2406 		return v1 > v2;
2407 	case BPF_JSGE:
2408 		return v1 >= v2;
2409 	case BPF_JSLT:
2410 		return v1 < v2;
2411 	case BPF_JSLE:
2412 		return v1 <= v2;
2413 	}
2414 	return false;
2415 }
2416 
2417 static int __bpf_emit_jmp_imm(struct bpf_test *self, void *arg,
2418 			      struct bpf_insn *insns, s64 dst, s64 imm)
2419 {
2420 	int op = *(int *)arg;
2421 
2422 	if (insns) {
2423 		bool match = __bpf_match_jmp_cond(dst, (s32)imm, op);
2424 		int i = 0;
2425 
2426 		insns[i++] = BPF_ALU32_IMM(BPF_MOV, R0, match);
2427 
2428 		i += __bpf_ld_imm64(&insns[i], R1, dst);
2429 		insns[i++] = BPF_JMP_IMM(op, R1, imm, 1);
2430 		if (!match)
2431 			insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
2432 		insns[i++] = BPF_EXIT_INSN();
2433 
2434 		return i;
2435 	}
2436 
2437 	return 5 + 1;
2438 }
2439 
2440 static int __bpf_emit_jmp32_imm(struct bpf_test *self, void *arg,
2441 				struct bpf_insn *insns, s64 dst, s64 imm)
2442 {
2443 	int op = *(int *)arg;
2444 
2445 	if (insns) {
2446 		bool match = __bpf_match_jmp_cond((s32)dst, (s32)imm, op);
2447 		int i = 0;
2448 
2449 		i += __bpf_ld_imm64(&insns[i], R1, dst);
2450 		insns[i++] = BPF_JMP32_IMM(op, R1, imm, 1);
2451 		if (!match)
2452 			insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
2453 		insns[i++] = BPF_EXIT_INSN();
2454 
2455 		return i;
2456 	}
2457 
2458 	return 5;
2459 }
2460 
2461 static int __bpf_emit_jmp_reg(struct bpf_test *self, void *arg,
2462 			      struct bpf_insn *insns, s64 dst, s64 src)
2463 {
2464 	int op = *(int *)arg;
2465 
2466 	if (insns) {
2467 		bool match = __bpf_match_jmp_cond(dst, src, op);
2468 		int i = 0;
2469 
2470 		i += __bpf_ld_imm64(&insns[i], R1, dst);
2471 		i += __bpf_ld_imm64(&insns[i], R2, src);
2472 		insns[i++] = BPF_JMP_REG(op, R1, R2, 1);
2473 		if (!match)
2474 			insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
2475 		insns[i++] = BPF_EXIT_INSN();
2476 
2477 		return i;
2478 	}
2479 
2480 	return 7;
2481 }
2482 
2483 static int __bpf_emit_jmp32_reg(struct bpf_test *self, void *arg,
2484 				struct bpf_insn *insns, s64 dst, s64 src)
2485 {
2486 	int op = *(int *)arg;
2487 
2488 	if (insns) {
2489 		bool match = __bpf_match_jmp_cond((s32)dst, (s32)src, op);
2490 		int i = 0;
2491 
2492 		i += __bpf_ld_imm64(&insns[i], R1, dst);
2493 		i += __bpf_ld_imm64(&insns[i], R2, src);
2494 		insns[i++] = BPF_JMP32_REG(op, R1, R2, 1);
2495 		if (!match)
2496 			insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
2497 		insns[i++] = BPF_EXIT_INSN();
2498 
2499 		return i;
2500 	}
2501 
2502 	return 7;
2503 }
2504 
2505 static int __bpf_fill_jmp_imm(struct bpf_test *self, int op)
2506 {
2507 	return __bpf_fill_pattern(self, &op, 64, 32,
2508 				  PATTERN_BLOCK1, PATTERN_BLOCK2,
2509 				  &__bpf_emit_jmp_imm);
2510 }
2511 
2512 static int __bpf_fill_jmp32_imm(struct bpf_test *self, int op)
2513 {
2514 	return __bpf_fill_pattern(self, &op, 64, 32,
2515 				  PATTERN_BLOCK1, PATTERN_BLOCK2,
2516 				  &__bpf_emit_jmp32_imm);
2517 }
2518 
2519 static int __bpf_fill_jmp_reg(struct bpf_test *self, int op)
2520 {
2521 	return __bpf_fill_pattern(self, &op, 64, 64,
2522 				  PATTERN_BLOCK1, PATTERN_BLOCK2,
2523 				  &__bpf_emit_jmp_reg);
2524 }
2525 
2526 static int __bpf_fill_jmp32_reg(struct bpf_test *self, int op)
2527 {
2528 	return __bpf_fill_pattern(self, &op, 64, 64,
2529 				  PATTERN_BLOCK1, PATTERN_BLOCK2,
2530 				  &__bpf_emit_jmp32_reg);
2531 }
2532 
2533 /* JMP immediate tests */
2534 static int bpf_fill_jmp_jset_imm(struct bpf_test *self)
2535 {
2536 	return __bpf_fill_jmp_imm(self, BPF_JSET);
2537 }
2538 
2539 static int bpf_fill_jmp_jeq_imm(struct bpf_test *self)
2540 {
2541 	return __bpf_fill_jmp_imm(self, BPF_JEQ);
2542 }
2543 
2544 static int bpf_fill_jmp_jne_imm(struct bpf_test *self)
2545 {
2546 	return __bpf_fill_jmp_imm(self, BPF_JNE);
2547 }
2548 
2549 static int bpf_fill_jmp_jgt_imm(struct bpf_test *self)
2550 {
2551 	return __bpf_fill_jmp_imm(self, BPF_JGT);
2552 }
2553 
2554 static int bpf_fill_jmp_jge_imm(struct bpf_test *self)
2555 {
2556 	return __bpf_fill_jmp_imm(self, BPF_JGE);
2557 }
2558 
2559 static int bpf_fill_jmp_jlt_imm(struct bpf_test *self)
2560 {
2561 	return __bpf_fill_jmp_imm(self, BPF_JLT);
2562 }
2563 
2564 static int bpf_fill_jmp_jle_imm(struct bpf_test *self)
2565 {
2566 	return __bpf_fill_jmp_imm(self, BPF_JLE);
2567 }
2568 
2569 static int bpf_fill_jmp_jsgt_imm(struct bpf_test *self)
2570 {
2571 	return __bpf_fill_jmp_imm(self, BPF_JSGT);
2572 }
2573 
2574 static int bpf_fill_jmp_jsge_imm(struct bpf_test *self)
2575 {
2576 	return __bpf_fill_jmp_imm(self, BPF_JSGE);
2577 }
2578 
2579 static int bpf_fill_jmp_jslt_imm(struct bpf_test *self)
2580 {
2581 	return __bpf_fill_jmp_imm(self, BPF_JSLT);
2582 }
2583 
2584 static int bpf_fill_jmp_jsle_imm(struct bpf_test *self)
2585 {
2586 	return __bpf_fill_jmp_imm(self, BPF_JSLE);
2587 }
2588 
2589 /* JMP32 immediate tests */
2590 static int bpf_fill_jmp32_jset_imm(struct bpf_test *self)
2591 {
2592 	return __bpf_fill_jmp32_imm(self, BPF_JSET);
2593 }
2594 
2595 static int bpf_fill_jmp32_jeq_imm(struct bpf_test *self)
2596 {
2597 	return __bpf_fill_jmp32_imm(self, BPF_JEQ);
2598 }
2599 
2600 static int bpf_fill_jmp32_jne_imm(struct bpf_test *self)
2601 {
2602 	return __bpf_fill_jmp32_imm(self, BPF_JNE);
2603 }
2604 
2605 static int bpf_fill_jmp32_jgt_imm(struct bpf_test *self)
2606 {
2607 	return __bpf_fill_jmp32_imm(self, BPF_JGT);
2608 }
2609 
2610 static int bpf_fill_jmp32_jge_imm(struct bpf_test *self)
2611 {
2612 	return __bpf_fill_jmp32_imm(self, BPF_JGE);
2613 }
2614 
2615 static int bpf_fill_jmp32_jlt_imm(struct bpf_test *self)
2616 {
2617 	return __bpf_fill_jmp32_imm(self, BPF_JLT);
2618 }
2619 
2620 static int bpf_fill_jmp32_jle_imm(struct bpf_test *self)
2621 {
2622 	return __bpf_fill_jmp32_imm(self, BPF_JLE);
2623 }
2624 
2625 static int bpf_fill_jmp32_jsgt_imm(struct bpf_test *self)
2626 {
2627 	return __bpf_fill_jmp32_imm(self, BPF_JSGT);
2628 }
2629 
2630 static int bpf_fill_jmp32_jsge_imm(struct bpf_test *self)
2631 {
2632 	return __bpf_fill_jmp32_imm(self, BPF_JSGE);
2633 }
2634 
2635 static int bpf_fill_jmp32_jslt_imm(struct bpf_test *self)
2636 {
2637 	return __bpf_fill_jmp32_imm(self, BPF_JSLT);
2638 }
2639 
2640 static int bpf_fill_jmp32_jsle_imm(struct bpf_test *self)
2641 {
2642 	return __bpf_fill_jmp32_imm(self, BPF_JSLE);
2643 }
2644 
2645 /* JMP register tests */
2646 static int bpf_fill_jmp_jset_reg(struct bpf_test *self)
2647 {
2648 	return __bpf_fill_jmp_reg(self, BPF_JSET);
2649 }
2650 
2651 static int bpf_fill_jmp_jeq_reg(struct bpf_test *self)
2652 {
2653 	return __bpf_fill_jmp_reg(self, BPF_JEQ);
2654 }
2655 
2656 static int bpf_fill_jmp_jne_reg(struct bpf_test *self)
2657 {
2658 	return __bpf_fill_jmp_reg(self, BPF_JNE);
2659 }
2660 
2661 static int bpf_fill_jmp_jgt_reg(struct bpf_test *self)
2662 {
2663 	return __bpf_fill_jmp_reg(self, BPF_JGT);
2664 }
2665 
2666 static int bpf_fill_jmp_jge_reg(struct bpf_test *self)
2667 {
2668 	return __bpf_fill_jmp_reg(self, BPF_JGE);
2669 }
2670 
2671 static int bpf_fill_jmp_jlt_reg(struct bpf_test *self)
2672 {
2673 	return __bpf_fill_jmp_reg(self, BPF_JLT);
2674 }
2675 
2676 static int bpf_fill_jmp_jle_reg(struct bpf_test *self)
2677 {
2678 	return __bpf_fill_jmp_reg(self, BPF_JLE);
2679 }
2680 
2681 static int bpf_fill_jmp_jsgt_reg(struct bpf_test *self)
2682 {
2683 	return __bpf_fill_jmp_reg(self, BPF_JSGT);
2684 }
2685 
2686 static int bpf_fill_jmp_jsge_reg(struct bpf_test *self)
2687 {
2688 	return __bpf_fill_jmp_reg(self, BPF_JSGE);
2689 }
2690 
2691 static int bpf_fill_jmp_jslt_reg(struct bpf_test *self)
2692 {
2693 	return __bpf_fill_jmp_reg(self, BPF_JSLT);
2694 }
2695 
2696 static int bpf_fill_jmp_jsle_reg(struct bpf_test *self)
2697 {
2698 	return __bpf_fill_jmp_reg(self, BPF_JSLE);
2699 }
2700 
2701 /* JMP32 register tests */
2702 static int bpf_fill_jmp32_jset_reg(struct bpf_test *self)
2703 {
2704 	return __bpf_fill_jmp32_reg(self, BPF_JSET);
2705 }
2706 
2707 static int bpf_fill_jmp32_jeq_reg(struct bpf_test *self)
2708 {
2709 	return __bpf_fill_jmp32_reg(self, BPF_JEQ);
2710 }
2711 
2712 static int bpf_fill_jmp32_jne_reg(struct bpf_test *self)
2713 {
2714 	return __bpf_fill_jmp32_reg(self, BPF_JNE);
2715 }
2716 
2717 static int bpf_fill_jmp32_jgt_reg(struct bpf_test *self)
2718 {
2719 	return __bpf_fill_jmp32_reg(self, BPF_JGT);
2720 }
2721 
2722 static int bpf_fill_jmp32_jge_reg(struct bpf_test *self)
2723 {
2724 	return __bpf_fill_jmp32_reg(self, BPF_JGE);
2725 }
2726 
2727 static int bpf_fill_jmp32_jlt_reg(struct bpf_test *self)
2728 {
2729 	return __bpf_fill_jmp32_reg(self, BPF_JLT);
2730 }
2731 
2732 static int bpf_fill_jmp32_jle_reg(struct bpf_test *self)
2733 {
2734 	return __bpf_fill_jmp32_reg(self, BPF_JLE);
2735 }
2736 
2737 static int bpf_fill_jmp32_jsgt_reg(struct bpf_test *self)
2738 {
2739 	return __bpf_fill_jmp32_reg(self, BPF_JSGT);
2740 }
2741 
2742 static int bpf_fill_jmp32_jsge_reg(struct bpf_test *self)
2743 {
2744 	return __bpf_fill_jmp32_reg(self, BPF_JSGE);
2745 }
2746 
2747 static int bpf_fill_jmp32_jslt_reg(struct bpf_test *self)
2748 {
2749 	return __bpf_fill_jmp32_reg(self, BPF_JSLT);
2750 }
2751 
2752 static int bpf_fill_jmp32_jsle_reg(struct bpf_test *self)
2753 {
2754 	return __bpf_fill_jmp32_reg(self, BPF_JSLE);
2755 }
2756 
2757 /*
2758  * Set up a sequence of staggered jumps, forwards and backwards with
2759  * increasing offset. This tests the conversion of relative jumps to
2760  * JITed native jumps. On some architectures, for example MIPS, a large
2761  * PC-relative jump offset may overflow the immediate field of the native
2762  * conditional branch instruction, triggering a conversion to use an
2763  * absolute jump instead. Since this changes the jump offsets, another
2764  * offset computation pass is necessary, and that may in turn trigger
2765  * another branch conversion. This jump sequence is particularly nasty
2766  * in that regard.
2767  *
2768  * The sequence generation is parameterized by size and jump type.
2769  * The size must be even, and the expected result is always size + 1.
2770  * Below is an example with size=8 and result=9.
2771  *
2772  *                     ________________________Start
2773  *                     R0 = 0
2774  *                     R1 = r1
2775  *                     R2 = r2
2776  *            ,------- JMP +4 * 3______________Preamble: 4 insns
2777  * ,----------|-ind 0- if R0 != 7 JMP 8 * 3 + 1 <--------------------.
2778  * |          |        R0 = 8                                        |
2779  * |          |        JMP +7 * 3               ------------------------.
2780  * | ,--------|-----1- if R0 != 5 JMP 7 * 3 + 1 <--------------.     |  |
2781  * | |        |        R0 = 6                                  |     |  |
2782  * | |        |        JMP +5 * 3               ------------------.  |  |
2783  * | | ,------|-----2- if R0 != 3 JMP 6 * 3 + 1 <--------.     |  |  |  |
2784  * | | |      |        R0 = 4                            |     |  |  |  |
2785  * | | |      |        JMP +3 * 3               ------------.  |  |  |  |
2786  * | | | ,----|-----3- if R0 != 1 JMP 5 * 3 + 1 <--.     |  |  |  |  |  |
2787  * | | | |    |        R0 = 2                      |     |  |  |  |  |  |
2788  * | | | |    |        JMP +1 * 3               ------.  |  |  |  |  |  |
2789  * | | | | ,--t=====4> if R0 != 0 JMP 4 * 3 + 1    1  2  3  4  5  6  7  8 loc
2790  * | | | | |           R0 = 1                     -1 +2 -3 +4 -5 +6 -7 +8 off
2791  * | | | | |           JMP -2 * 3               ---'  |  |  |  |  |  |  |
2792  * | | | | | ,------5- if R0 != 2 JMP 3 * 3 + 1 <-----'  |  |  |  |  |  |
2793  * | | | | | |         R0 = 3                            |  |  |  |  |  |
2794  * | | | | | |         JMP -4 * 3               ---------'  |  |  |  |  |
2795  * | | | | | | ,----6- if R0 != 4 JMP 2 * 3 + 1 <-----------'  |  |  |  |
2796  * | | | | | | |       R0 = 5                                  |  |  |  |
2797  * | | | | | | |       JMP -6 * 3               ---------------'  |  |  |
2798  * | | | | | | | ,--7- if R0 != 6 JMP 1 * 3 + 1 <-----------------'  |  |
2799  * | | | | | | | |     R0 = 7                                        |  |
2800  * | | Error | | |     JMP -8 * 3               ---------------------'  |
2801  * | | paths | | | ,8- if R0 != 8 JMP 0 * 3 + 1 <-----------------------'
2802  * | | | | | | | | |   R0 = 9__________________Sequence: 3 * size - 1 insns
2803  * `-+-+-+-+-+-+-+-+-> EXIT____________________Return: 1 insn
2804  *
2805  */
2806 
2807 /* The maximum size parameter */
2808 #define MAX_STAGGERED_JMP_SIZE ((0x7fff / 3) & ~1)
2809 
2810 /* We use a reduced number of iterations to get a reasonable execution time */
2811 #define NR_STAGGERED_JMP_RUNS 10
2812 
2813 static int __bpf_fill_staggered_jumps(struct bpf_test *self,
2814 				      const struct bpf_insn *jmp,
2815 				      u64 r1, u64 r2)
2816 {
2817 	int size = self->test[0].result - 1;
2818 	int len = 4 + 3 * (size + 1);
2819 	struct bpf_insn *insns;
2820 	int off, ind;
2821 
2822 	insns = kmalloc_objs(*insns, len);
2823 	if (!insns)
2824 		return -ENOMEM;
2825 
2826 	/* Preamble */
2827 	insns[0] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
2828 	insns[1] = BPF_ALU64_IMM(BPF_MOV, R1, r1);
2829 	insns[2] = BPF_ALU64_IMM(BPF_MOV, R2, r2);
2830 	insns[3] = BPF_JMP_IMM(BPF_JA, 0, 0, 3 * size / 2);
2831 
2832 	/* Sequence */
2833 	for (ind = 0, off = size; ind <= size; ind++, off -= 2) {
2834 		struct bpf_insn *ins = &insns[4 + 3 * ind];
2835 		int loc;
2836 
2837 		if (off == 0)
2838 			off--;
2839 
2840 		loc = abs(off);
2841 		ins[0] = BPF_JMP_IMM(BPF_JNE, R0, loc - 1,
2842 				     3 * (size - ind) + 1);
2843 		ins[1] = BPF_ALU64_IMM(BPF_MOV, R0, loc);
2844 		ins[2] = *jmp;
2845 		ins[2].off = 3 * (off - 1);
2846 	}
2847 
2848 	/* Return */
2849 	insns[len - 1] = BPF_EXIT_INSN();
2850 
2851 	self->u.ptr.insns = insns;
2852 	self->u.ptr.len = len;
2853 
2854 	return 0;
2855 }
2856 
2857 /* 64-bit unconditional jump */
2858 static int bpf_fill_staggered_ja(struct bpf_test *self)
2859 {
2860 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JA, 0, 0, 0);
2861 
2862 	return __bpf_fill_staggered_jumps(self, &jmp, 0, 0);
2863 }
2864 
2865 /* 64-bit immediate jumps */
2866 static int bpf_fill_staggered_jeq_imm(struct bpf_test *self)
2867 {
2868 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JEQ, R1, 1234, 0);
2869 
2870 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2871 }
2872 
2873 static int bpf_fill_staggered_jne_imm(struct bpf_test *self)
2874 {
2875 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JNE, R1, 1234, 0);
2876 
2877 	return __bpf_fill_staggered_jumps(self, &jmp, 4321, 0);
2878 }
2879 
2880 static int bpf_fill_staggered_jset_imm(struct bpf_test *self)
2881 {
2882 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSET, R1, 0x82, 0);
2883 
2884 	return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0);
2885 }
2886 
2887 static int bpf_fill_staggered_jgt_imm(struct bpf_test *self)
2888 {
2889 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JGT, R1, 1234, 0);
2890 
2891 	return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 0);
2892 }
2893 
2894 static int bpf_fill_staggered_jge_imm(struct bpf_test *self)
2895 {
2896 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JGE, R1, 1234, 0);
2897 
2898 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2899 }
2900 
2901 static int bpf_fill_staggered_jlt_imm(struct bpf_test *self)
2902 {
2903 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JLT, R1, 0x80000000, 0);
2904 
2905 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2906 }
2907 
2908 static int bpf_fill_staggered_jle_imm(struct bpf_test *self)
2909 {
2910 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JLE, R1, 1234, 0);
2911 
2912 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2913 }
2914 
2915 static int bpf_fill_staggered_jsgt_imm(struct bpf_test *self)
2916 {
2917 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSGT, R1, -2, 0);
2918 
2919 	return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
2920 }
2921 
2922 static int bpf_fill_staggered_jsge_imm(struct bpf_test *self)
2923 {
2924 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSGE, R1, -2, 0);
2925 
2926 	return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
2927 }
2928 
2929 static int bpf_fill_staggered_jslt_imm(struct bpf_test *self)
2930 {
2931 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSLT, R1, -1, 0);
2932 
2933 	return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
2934 }
2935 
2936 static int bpf_fill_staggered_jsle_imm(struct bpf_test *self)
2937 {
2938 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSLE, R1, -1, 0);
2939 
2940 	return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
2941 }
2942 
2943 /* 64-bit register jumps */
2944 static int bpf_fill_staggered_jeq_reg(struct bpf_test *self)
2945 {
2946 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JEQ, R1, R2, 0);
2947 
2948 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
2949 }
2950 
2951 static int bpf_fill_staggered_jne_reg(struct bpf_test *self)
2952 {
2953 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JNE, R1, R2, 0);
2954 
2955 	return __bpf_fill_staggered_jumps(self, &jmp, 4321, 1234);
2956 }
2957 
2958 static int bpf_fill_staggered_jset_reg(struct bpf_test *self)
2959 {
2960 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JSET, R1, R2, 0);
2961 
2962 	return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0x82);
2963 }
2964 
2965 static int bpf_fill_staggered_jgt_reg(struct bpf_test *self)
2966 {
2967 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JGT, R1, R2, 0);
2968 
2969 	return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 1234);
2970 }
2971 
2972 static int bpf_fill_staggered_jge_reg(struct bpf_test *self)
2973 {
2974 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JGE, R1, R2, 0);
2975 
2976 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
2977 }
2978 
2979 static int bpf_fill_staggered_jlt_reg(struct bpf_test *self)
2980 {
2981 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JLT, R1, R2, 0);
2982 
2983 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0x80000000);
2984 }
2985 
2986 static int bpf_fill_staggered_jle_reg(struct bpf_test *self)
2987 {
2988 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JLE, R1, R2, 0);
2989 
2990 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
2991 }
2992 
2993 static int bpf_fill_staggered_jsgt_reg(struct bpf_test *self)
2994 {
2995 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JSGT, R1, R2, 0);
2996 
2997 	return __bpf_fill_staggered_jumps(self, &jmp, -1, -2);
2998 }
2999 
3000 static int bpf_fill_staggered_jsge_reg(struct bpf_test *self)
3001 {
3002 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JSGE, R1, R2, 0);
3003 
3004 	return __bpf_fill_staggered_jumps(self, &jmp, -2, -2);
3005 }
3006 
3007 static int bpf_fill_staggered_jslt_reg(struct bpf_test *self)
3008 {
3009 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JSLT, R1, R2, 0);
3010 
3011 	return __bpf_fill_staggered_jumps(self, &jmp, -2, -1);
3012 }
3013 
3014 static int bpf_fill_staggered_jsle_reg(struct bpf_test *self)
3015 {
3016 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JSLE, R1, R2, 0);
3017 
3018 	return __bpf_fill_staggered_jumps(self, &jmp, -1, -1);
3019 }
3020 
3021 /* 32-bit immediate jumps */
3022 static int bpf_fill_staggered_jeq32_imm(struct bpf_test *self)
3023 {
3024 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JEQ, R1, 1234, 0);
3025 
3026 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
3027 }
3028 
3029 static int bpf_fill_staggered_jne32_imm(struct bpf_test *self)
3030 {
3031 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JNE, R1, 1234, 0);
3032 
3033 	return __bpf_fill_staggered_jumps(self, &jmp, 4321, 0);
3034 }
3035 
3036 static int bpf_fill_staggered_jset32_imm(struct bpf_test *self)
3037 {
3038 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSET, R1, 0x82, 0);
3039 
3040 	return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0);
3041 }
3042 
3043 static int bpf_fill_staggered_jgt32_imm(struct bpf_test *self)
3044 {
3045 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JGT, R1, 1234, 0);
3046 
3047 	return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 0);
3048 }
3049 
3050 static int bpf_fill_staggered_jge32_imm(struct bpf_test *self)
3051 {
3052 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JGE, R1, 1234, 0);
3053 
3054 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
3055 }
3056 
3057 static int bpf_fill_staggered_jlt32_imm(struct bpf_test *self)
3058 {
3059 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JLT, R1, 0x80000000, 0);
3060 
3061 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
3062 }
3063 
3064 static int bpf_fill_staggered_jle32_imm(struct bpf_test *self)
3065 {
3066 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JLE, R1, 1234, 0);
3067 
3068 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
3069 }
3070 
3071 static int bpf_fill_staggered_jsgt32_imm(struct bpf_test *self)
3072 {
3073 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSGT, R1, -2, 0);
3074 
3075 	return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
3076 }
3077 
3078 static int bpf_fill_staggered_jsge32_imm(struct bpf_test *self)
3079 {
3080 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSGE, R1, -2, 0);
3081 
3082 	return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
3083 }
3084 
3085 static int bpf_fill_staggered_jslt32_imm(struct bpf_test *self)
3086 {
3087 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSLT, R1, -1, 0);
3088 
3089 	return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
3090 }
3091 
3092 static int bpf_fill_staggered_jsle32_imm(struct bpf_test *self)
3093 {
3094 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSLE, R1, -1, 0);
3095 
3096 	return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
3097 }
3098 
3099 /* 32-bit register jumps */
3100 static int bpf_fill_staggered_jeq32_reg(struct bpf_test *self)
3101 {
3102 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JEQ, R1, R2, 0);
3103 
3104 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
3105 }
3106 
3107 static int bpf_fill_staggered_jne32_reg(struct bpf_test *self)
3108 {
3109 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JNE, R1, R2, 0);
3110 
3111 	return __bpf_fill_staggered_jumps(self, &jmp, 4321, 1234);
3112 }
3113 
3114 static int bpf_fill_staggered_jset32_reg(struct bpf_test *self)
3115 {
3116 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSET, R1, R2, 0);
3117 
3118 	return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0x82);
3119 }
3120 
3121 static int bpf_fill_staggered_jgt32_reg(struct bpf_test *self)
3122 {
3123 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JGT, R1, R2, 0);
3124 
3125 	return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 1234);
3126 }
3127 
3128 static int bpf_fill_staggered_jge32_reg(struct bpf_test *self)
3129 {
3130 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JGE, R1, R2, 0);
3131 
3132 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
3133 }
3134 
3135 static int bpf_fill_staggered_jlt32_reg(struct bpf_test *self)
3136 {
3137 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JLT, R1, R2, 0);
3138 
3139 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0x80000000);
3140 }
3141 
3142 static int bpf_fill_staggered_jle32_reg(struct bpf_test *self)
3143 {
3144 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JLE, R1, R2, 0);
3145 
3146 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
3147 }
3148 
3149 static int bpf_fill_staggered_jsgt32_reg(struct bpf_test *self)
3150 {
3151 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSGT, R1, R2, 0);
3152 
3153 	return __bpf_fill_staggered_jumps(self, &jmp, -1, -2);
3154 }
3155 
3156 static int bpf_fill_staggered_jsge32_reg(struct bpf_test *self)
3157 {
3158 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSGE, R1, R2, 0);
3159 
3160 	return __bpf_fill_staggered_jumps(self, &jmp, -2, -2);
3161 }
3162 
3163 static int bpf_fill_staggered_jslt32_reg(struct bpf_test *self)
3164 {
3165 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSLT, R1, R2, 0);
3166 
3167 	return __bpf_fill_staggered_jumps(self, &jmp, -2, -1);
3168 }
3169 
3170 static int bpf_fill_staggered_jsle32_reg(struct bpf_test *self)
3171 {
3172 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSLE, R1, R2, 0);
3173 
3174 	return __bpf_fill_staggered_jumps(self, &jmp, -1, -1);
3175 }
3176 
3177 
3178 static struct bpf_test tests[] = {
3179 	{
3180 		"TAX",
3181 		.u.insns = {
3182 			BPF_STMT(BPF_LD | BPF_IMM, 1),
3183 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3184 			BPF_STMT(BPF_LD | BPF_IMM, 2),
3185 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3186 			BPF_STMT(BPF_ALU | BPF_NEG, 0), /* A == -3 */
3187 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3188 			BPF_STMT(BPF_LD | BPF_LEN, 0),
3189 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3190 			BPF_STMT(BPF_MISC | BPF_TAX, 0), /* X == len - 3 */
3191 			BPF_STMT(BPF_LD | BPF_B | BPF_IND, 1),
3192 			BPF_STMT(BPF_RET | BPF_A, 0)
3193 		},
3194 		CLASSIC,
3195 		{ 10, 20, 30, 40, 50 },
3196 		{ { 2, 10 }, { 3, 20 }, { 4, 30 } },
3197 	},
3198 	{
3199 		"TXA",
3200 		.u.insns = {
3201 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3202 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
3203 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3204 			BPF_STMT(BPF_RET | BPF_A, 0) /* A == len * 2 */
3205 		},
3206 		CLASSIC,
3207 		{ 10, 20, 30, 40, 50 },
3208 		{ { 1, 2 }, { 3, 6 }, { 4, 8 } },
3209 	},
3210 	{
3211 		"ADD_SUB_MUL_K",
3212 		.u.insns = {
3213 			BPF_STMT(BPF_LD | BPF_IMM, 1),
3214 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 2),
3215 			BPF_STMT(BPF_LDX | BPF_IMM, 3),
3216 			BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
3217 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0xffffffff),
3218 			BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 3),
3219 			BPF_STMT(BPF_RET | BPF_A, 0)
3220 		},
3221 		CLASSIC | FLAG_NO_DATA,
3222 		{ },
3223 		{ { 0, 0xfffffffd } }
3224 	},
3225 	{
3226 		"DIV_MOD_KX",
3227 		.u.insns = {
3228 			BPF_STMT(BPF_LD | BPF_IMM, 8),
3229 			BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 2),
3230 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3231 			BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
3232 			BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
3233 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3234 			BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
3235 			BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x70000000),
3236 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3237 			BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
3238 			BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
3239 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3240 			BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
3241 			BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x70000000),
3242 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3243 			BPF_STMT(BPF_RET | BPF_A, 0)
3244 		},
3245 		CLASSIC | FLAG_NO_DATA,
3246 		{ },
3247 		{ { 0, 0x20000000 } }
3248 	},
3249 	{
3250 		"AND_OR_LSH_K",
3251 		.u.insns = {
3252 			BPF_STMT(BPF_LD | BPF_IMM, 0xff),
3253 			BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
3254 			BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 27),
3255 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3256 			BPF_STMT(BPF_LD | BPF_IMM, 0xf),
3257 			BPF_STMT(BPF_ALU | BPF_OR | BPF_K, 0xf0),
3258 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3259 			BPF_STMT(BPF_RET | BPF_A, 0)
3260 		},
3261 		CLASSIC | FLAG_NO_DATA,
3262 		{ },
3263 		{ { 0, 0x800000ff }, { 1, 0x800000ff } },
3264 	},
3265 	{
3266 		"LD_IMM_0",
3267 		.u.insns = {
3268 			BPF_STMT(BPF_LD | BPF_IMM, 0), /* ld #0 */
3269 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0, 1, 0),
3270 			BPF_STMT(BPF_RET | BPF_K, 0),
3271 			BPF_STMT(BPF_RET | BPF_K, 1),
3272 		},
3273 		CLASSIC,
3274 		{ },
3275 		{ { 1, 1 } },
3276 	},
3277 	{
3278 		"LD_IND",
3279 		.u.insns = {
3280 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3281 			BPF_STMT(BPF_LD | BPF_H | BPF_IND, MAX_K),
3282 			BPF_STMT(BPF_RET | BPF_K, 1)
3283 		},
3284 		CLASSIC,
3285 		{ },
3286 		{ { 1, 0 }, { 10, 0 }, { 60, 0 } },
3287 	},
3288 	{
3289 		"LD_ABS",
3290 		.u.insns = {
3291 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1000),
3292 			BPF_STMT(BPF_RET | BPF_K, 1)
3293 		},
3294 		CLASSIC,
3295 		{ },
3296 		{ { 1, 0 }, { 10, 0 }, { 60, 0 } },
3297 	},
3298 	{
3299 		"LD_ABS_LL",
3300 		.u.insns = {
3301 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF),
3302 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3303 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF + 1),
3304 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3305 			BPF_STMT(BPF_RET | BPF_A, 0)
3306 		},
3307 		CLASSIC,
3308 		{ 1, 2, 3 },
3309 		{ { 1, 0 }, { 2, 3 } },
3310 	},
3311 	{
3312 		"LD_IND_LL",
3313 		.u.insns = {
3314 			BPF_STMT(BPF_LD | BPF_IMM, SKF_LL_OFF - 1),
3315 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3316 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3317 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3318 			BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
3319 			BPF_STMT(BPF_RET | BPF_A, 0)
3320 		},
3321 		CLASSIC,
3322 		{ 1, 2, 3, 0xff },
3323 		{ { 1, 1 }, { 3, 3 }, { 4, 0xff } },
3324 	},
3325 	{
3326 		"LD_ABS_NET",
3327 		.u.insns = {
3328 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF),
3329 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3330 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF + 1),
3331 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3332 			BPF_STMT(BPF_RET | BPF_A, 0)
3333 		},
3334 		CLASSIC,
3335 		{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
3336 		{ { 15, 0 }, { 16, 3 } },
3337 	},
3338 	{
3339 		"LD_IND_NET",
3340 		.u.insns = {
3341 			BPF_STMT(BPF_LD | BPF_IMM, SKF_NET_OFF - 15),
3342 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3343 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3344 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3345 			BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
3346 			BPF_STMT(BPF_RET | BPF_A, 0)
3347 		},
3348 		CLASSIC,
3349 		{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
3350 		{ { 14, 0 }, { 15, 1 }, { 17, 3 } },
3351 	},
3352 	{
3353 		"LD_PKTTYPE",
3354 		.u.insns = {
3355 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3356 				 SKF_AD_OFF + SKF_AD_PKTTYPE),
3357 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
3358 			BPF_STMT(BPF_RET | BPF_K, 1),
3359 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3360 				 SKF_AD_OFF + SKF_AD_PKTTYPE),
3361 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
3362 			BPF_STMT(BPF_RET | BPF_K, 1),
3363 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3364 				 SKF_AD_OFF + SKF_AD_PKTTYPE),
3365 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
3366 			BPF_STMT(BPF_RET | BPF_K, 1),
3367 			BPF_STMT(BPF_RET | BPF_A, 0)
3368 		},
3369 		CLASSIC,
3370 		{ },
3371 		{ { 1, 3 }, { 10, 3 } },
3372 	},
3373 	{
3374 		"LD_MARK",
3375 		.u.insns = {
3376 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3377 				 SKF_AD_OFF + SKF_AD_MARK),
3378 			BPF_STMT(BPF_RET | BPF_A, 0)
3379 		},
3380 		CLASSIC,
3381 		{ },
3382 		{ { 1, SKB_MARK}, { 10, SKB_MARK} },
3383 	},
3384 	{
3385 		"LD_RXHASH",
3386 		.u.insns = {
3387 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3388 				 SKF_AD_OFF + SKF_AD_RXHASH),
3389 			BPF_STMT(BPF_RET | BPF_A, 0)
3390 		},
3391 		CLASSIC,
3392 		{ },
3393 		{ { 1, SKB_HASH}, { 10, SKB_HASH} },
3394 	},
3395 	{
3396 		"LD_QUEUE",
3397 		.u.insns = {
3398 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3399 				 SKF_AD_OFF + SKF_AD_QUEUE),
3400 			BPF_STMT(BPF_RET | BPF_A, 0)
3401 		},
3402 		CLASSIC,
3403 		{ },
3404 		{ { 1, SKB_QUEUE_MAP }, { 10, SKB_QUEUE_MAP } },
3405 	},
3406 	{
3407 		"LD_PROTOCOL",
3408 		.u.insns = {
3409 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 1),
3410 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 20, 1, 0),
3411 			BPF_STMT(BPF_RET | BPF_K, 0),
3412 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3413 				 SKF_AD_OFF + SKF_AD_PROTOCOL),
3414 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3415 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
3416 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 30, 1, 0),
3417 			BPF_STMT(BPF_RET | BPF_K, 0),
3418 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
3419 			BPF_STMT(BPF_RET | BPF_A, 0)
3420 		},
3421 		CLASSIC,
3422 		{ 10, 20, 30 },
3423 		{ { 10, ETH_P_IP }, { 100, ETH_P_IP } },
3424 	},
3425 	{
3426 		"LD_VLAN_TAG",
3427 		.u.insns = {
3428 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3429 				 SKF_AD_OFF + SKF_AD_VLAN_TAG),
3430 			BPF_STMT(BPF_RET | BPF_A, 0)
3431 		},
3432 		CLASSIC,
3433 		{ },
3434 		{
3435 			{ 1, SKB_VLAN_TCI },
3436 			{ 10, SKB_VLAN_TCI }
3437 		},
3438 	},
3439 	{
3440 		"LD_VLAN_TAG_PRESENT",
3441 		.u.insns = {
3442 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3443 				 SKF_AD_OFF + SKF_AD_VLAN_TAG_PRESENT),
3444 			BPF_STMT(BPF_RET | BPF_A, 0)
3445 		},
3446 		CLASSIC,
3447 		{ },
3448 		{
3449 			{ 1, SKB_VLAN_PRESENT },
3450 			{ 10, SKB_VLAN_PRESENT }
3451 		},
3452 	},
3453 	{
3454 		"LD_IFINDEX",
3455 		.u.insns = {
3456 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3457 				 SKF_AD_OFF + SKF_AD_IFINDEX),
3458 			BPF_STMT(BPF_RET | BPF_A, 0)
3459 		},
3460 		CLASSIC,
3461 		{ },
3462 		{ { 1, SKB_DEV_IFINDEX }, { 10, SKB_DEV_IFINDEX } },
3463 	},
3464 	{
3465 		"LD_HATYPE",
3466 		.u.insns = {
3467 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3468 				 SKF_AD_OFF + SKF_AD_HATYPE),
3469 			BPF_STMT(BPF_RET | BPF_A, 0)
3470 		},
3471 		CLASSIC,
3472 		{ },
3473 		{ { 1, SKB_DEV_TYPE }, { 10, SKB_DEV_TYPE } },
3474 	},
3475 	{
3476 		"LD_CPU",
3477 		.u.insns = {
3478 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3479 				 SKF_AD_OFF + SKF_AD_CPU),
3480 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3481 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3482 				 SKF_AD_OFF + SKF_AD_CPU),
3483 			BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
3484 			BPF_STMT(BPF_RET | BPF_A, 0)
3485 		},
3486 		CLASSIC,
3487 		{ },
3488 		{ { 1, 0 }, { 10, 0 } },
3489 	},
3490 	{
3491 		"LD_NLATTR",
3492 		.u.insns = {
3493 			BPF_STMT(BPF_LDX | BPF_IMM, 2),
3494 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
3495 			BPF_STMT(BPF_LDX | BPF_IMM, 3),
3496 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3497 				 SKF_AD_OFF + SKF_AD_NLATTR),
3498 			BPF_STMT(BPF_RET | BPF_A, 0)
3499 		},
3500 		CLASSIC,
3501 #ifdef __BIG_ENDIAN
3502 		{ 0xff, 0xff, 0, 4, 0, 2, 0, 4, 0, 3 },
3503 #else
3504 		{ 0xff, 0xff, 4, 0, 2, 0, 4, 0, 3, 0 },
3505 #endif
3506 		{ { 4, 0 }, { 20, 6 } },
3507 	},
3508 	{
3509 		"LD_NLATTR_NEST",
3510 		.u.insns = {
3511 			BPF_STMT(BPF_LD | BPF_IMM, 2),
3512 			BPF_STMT(BPF_LDX | BPF_IMM, 3),
3513 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3514 				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3515 			BPF_STMT(BPF_LD | BPF_IMM, 2),
3516 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3517 				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3518 			BPF_STMT(BPF_LD | BPF_IMM, 2),
3519 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3520 				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3521 			BPF_STMT(BPF_LD | BPF_IMM, 2),
3522 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3523 				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3524 			BPF_STMT(BPF_LD | BPF_IMM, 2),
3525 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3526 				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3527 			BPF_STMT(BPF_LD | BPF_IMM, 2),
3528 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3529 				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3530 			BPF_STMT(BPF_LD | BPF_IMM, 2),
3531 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3532 				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3533 			BPF_STMT(BPF_LD | BPF_IMM, 2),
3534 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3535 				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3536 			BPF_STMT(BPF_RET | BPF_A, 0)
3537 		},
3538 		CLASSIC,
3539 #ifdef __BIG_ENDIAN
3540 		{ 0xff, 0xff, 0, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3 },
3541 #else
3542 		{ 0xff, 0xff, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3, 0 },
3543 #endif
3544 		{ { 4, 0 }, { 20, 10 } },
3545 	},
3546 	{
3547 		"LD_PAYLOAD_OFF",
3548 		.u.insns = {
3549 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3550 				 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
3551 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3552 				 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
3553 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3554 				 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
3555 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3556 				 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
3557 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3558 				 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
3559 			BPF_STMT(BPF_RET | BPF_A, 0)
3560 		},
3561 		CLASSIC,
3562 		/* 00:00:00:00:00:00 > 00:00:00:00:00:00, ethtype IPv4 (0x0800),
3563 		 * length 98: 127.0.0.1 > 127.0.0.1: ICMP echo request,
3564 		 * id 9737, seq 1, length 64
3565 		 */
3566 		{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3567 		  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3568 		  0x08, 0x00,
3569 		  0x45, 0x00, 0x00, 0x54, 0xac, 0x8b, 0x40, 0x00, 0x40,
3570 		  0x01, 0x90, 0x1b, 0x7f, 0x00, 0x00, 0x01 },
3571 		{ { 30, 0 }, { 100, 42 } },
3572 	},
3573 	{
3574 		"LD_ANC_XOR",
3575 		.u.insns = {
3576 			BPF_STMT(BPF_LD | BPF_IMM, 10),
3577 			BPF_STMT(BPF_LDX | BPF_IMM, 300),
3578 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3579 				 SKF_AD_OFF + SKF_AD_ALU_XOR_X),
3580 			BPF_STMT(BPF_RET | BPF_A, 0)
3581 		},
3582 		CLASSIC,
3583 		{ },
3584 		{ { 4, 0xA ^ 300 }, { 20, 0xA ^ 300 } },
3585 	},
3586 	{
3587 		"SPILL_FILL",
3588 		.u.insns = {
3589 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3590 			BPF_STMT(BPF_LD | BPF_IMM, 2),
3591 			BPF_STMT(BPF_ALU | BPF_RSH, 1),
3592 			BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
3593 			BPF_STMT(BPF_ST, 1), /* M1 = 1 ^ len */
3594 			BPF_STMT(BPF_ALU | BPF_XOR | BPF_K, 0x80000000),
3595 			BPF_STMT(BPF_ST, 2), /* M2 = 1 ^ len ^ 0x80000000 */
3596 			BPF_STMT(BPF_STX, 15), /* M3 = len */
3597 			BPF_STMT(BPF_LDX | BPF_MEM, 1),
3598 			BPF_STMT(BPF_LD | BPF_MEM, 2),
3599 			BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
3600 			BPF_STMT(BPF_LDX | BPF_MEM, 15),
3601 			BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
3602 			BPF_STMT(BPF_RET | BPF_A, 0)
3603 		},
3604 		CLASSIC,
3605 		{ },
3606 		{ { 1, 0x80000001 }, { 2, 0x80000002 }, { 60, 0x80000000 ^ 60 } }
3607 	},
3608 	{
3609 		"JEQ",
3610 		.u.insns = {
3611 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3612 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
3613 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 0, 1),
3614 			BPF_STMT(BPF_RET | BPF_K, 1),
3615 			BPF_STMT(BPF_RET | BPF_K, MAX_K)
3616 		},
3617 		CLASSIC,
3618 		{ 3, 3, 3, 3, 3 },
3619 		{ { 1, 0 }, { 3, 1 }, { 4, MAX_K } },
3620 	},
3621 	{
3622 		"JGT",
3623 		.u.insns = {
3624 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3625 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
3626 			BPF_JUMP(BPF_JMP | BPF_JGT | BPF_X, 0, 0, 1),
3627 			BPF_STMT(BPF_RET | BPF_K, 1),
3628 			BPF_STMT(BPF_RET | BPF_K, MAX_K)
3629 		},
3630 		CLASSIC,
3631 		{ 4, 4, 4, 3, 3 },
3632 		{ { 2, 0 }, { 3, 1 }, { 4, MAX_K } },
3633 	},
3634 	{
3635 		"JGE (jt 0), test 1",
3636 		.u.insns = {
3637 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3638 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
3639 			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 1),
3640 			BPF_STMT(BPF_RET | BPF_K, 1),
3641 			BPF_STMT(BPF_RET | BPF_K, MAX_K)
3642 		},
3643 		CLASSIC,
3644 		{ 4, 4, 4, 3, 3 },
3645 		{ { 2, 0 }, { 3, 1 }, { 4, 1 } },
3646 	},
3647 	{
3648 		"JGE (jt 0), test 2",
3649 		.u.insns = {
3650 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3651 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
3652 			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 1),
3653 			BPF_STMT(BPF_RET | BPF_K, 1),
3654 			BPF_STMT(BPF_RET | BPF_K, MAX_K)
3655 		},
3656 		CLASSIC,
3657 		{ 4, 4, 5, 3, 3 },
3658 		{ { 4, 1 }, { 5, 1 }, { 6, MAX_K } },
3659 	},
3660 	{
3661 		"JGE",
3662 		.u.insns = {
3663 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3664 			BPF_STMT(BPF_LD | BPF_B | BPF_IND, MAX_K),
3665 			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 1, 1, 0),
3666 			BPF_STMT(BPF_RET | BPF_K, 10),
3667 			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 2, 1, 0),
3668 			BPF_STMT(BPF_RET | BPF_K, 20),
3669 			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 3, 1, 0),
3670 			BPF_STMT(BPF_RET | BPF_K, 30),
3671 			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 4, 1, 0),
3672 			BPF_STMT(BPF_RET | BPF_K, 40),
3673 			BPF_STMT(BPF_RET | BPF_K, MAX_K)
3674 		},
3675 		CLASSIC,
3676 		{ 1, 2, 3, 4, 5 },
3677 		{ { 1, 20 }, { 3, 40 }, { 5, MAX_K } },
3678 	},
3679 	{
3680 		"JSET",
3681 		.u.insns = {
3682 			BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
3683 			BPF_JUMP(BPF_JMP | BPF_JA, 1, 1, 1),
3684 			BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
3685 			BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
3686 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3687 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
3688 			BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, 4),
3689 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3690 			BPF_STMT(BPF_LD | BPF_W | BPF_IND, 0),
3691 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 1, 0, 1),
3692 			BPF_STMT(BPF_RET | BPF_K, 10),
3693 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x80000000, 0, 1),
3694 			BPF_STMT(BPF_RET | BPF_K, 20),
3695 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
3696 			BPF_STMT(BPF_RET | BPF_K, 30),
3697 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
3698 			BPF_STMT(BPF_RET | BPF_K, 30),
3699 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
3700 			BPF_STMT(BPF_RET | BPF_K, 30),
3701 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
3702 			BPF_STMT(BPF_RET | BPF_K, 30),
3703 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
3704 			BPF_STMT(BPF_RET | BPF_K, 30),
3705 			BPF_STMT(BPF_RET | BPF_K, MAX_K)
3706 		},
3707 		CLASSIC,
3708 		{ 0, 0xAA, 0x55, 1 },
3709 		{ { 4, 10 }, { 5, 20 }, { 6, MAX_K } },
3710 	},
3711 	{
3712 		"tcpdump port 22",
3713 		.u.insns = {
3714 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
3715 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 0, 8), /* IPv6 */
3716 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 20),
3717 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
3718 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
3719 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 17),
3720 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 54),
3721 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 14, 0),
3722 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 56),
3723 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 12, 13),
3724 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0800, 0, 12), /* IPv4 */
3725 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
3726 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
3727 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
3728 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 8),
3729 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
3730 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 6, 0),
3731 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
3732 			BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
3733 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
3734 			BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
3735 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 1),
3736 			BPF_STMT(BPF_RET | BPF_K, 0xffff),
3737 			BPF_STMT(BPF_RET | BPF_K, 0),
3738 		},
3739 		CLASSIC,
3740 		/* 3c:07:54:43:e5:76 > 10:bf:48:d6:43:d6, ethertype IPv4(0x0800)
3741 		 * length 114: 10.1.1.149.49700 > 10.1.2.10.22: Flags [P.],
3742 		 * seq 1305692979:1305693027, ack 3650467037, win 65535,
3743 		 * options [nop,nop,TS val 2502645400 ecr 3971138], length 48
3744 		 */
3745 		{ 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
3746 		  0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
3747 		  0x08, 0x00,
3748 		  0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
3749 		  0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
3750 		  0x0a, 0x01, 0x01, 0x95, /* ip src */
3751 		  0x0a, 0x01, 0x02, 0x0a, /* ip dst */
3752 		  0xc2, 0x24,
3753 		  0x00, 0x16 /* dst port */ },
3754 		{ { 10, 0 }, { 30, 0 }, { 100, 65535 } },
3755 	},
3756 	{
3757 		"tcpdump complex",
3758 		.u.insns = {
3759 			/* tcpdump -nei eth0 'tcp port 22 and (((ip[2:2] -
3760 			 * ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0) and
3761 			 * (len > 115 or len < 30000000000)' -d
3762 			 */
3763 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
3764 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 30, 0),
3765 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x800, 0, 29),
3766 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
3767 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 0, 27),
3768 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
3769 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 25, 0),
3770 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
3771 			BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
3772 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
3773 			BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
3774 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 20),
3775 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 16),
3776 			BPF_STMT(BPF_ST, 1),
3777 			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 14),
3778 			BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf),
3779 			BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 2),
3780 			BPF_STMT(BPF_MISC | BPF_TAX, 0x5), /* libpcap emits K on TAX */
3781 			BPF_STMT(BPF_LD | BPF_MEM, 1),
3782 			BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
3783 			BPF_STMT(BPF_ST, 5),
3784 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
3785 			BPF_STMT(BPF_LD | BPF_B | BPF_IND, 26),
3786 			BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
3787 			BPF_STMT(BPF_ALU | BPF_RSH | BPF_K, 2),
3788 			BPF_STMT(BPF_MISC | BPF_TAX, 0x9), /* libpcap emits K on TAX */
3789 			BPF_STMT(BPF_LD | BPF_MEM, 5),
3790 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 4, 0),
3791 			BPF_STMT(BPF_LD | BPF_LEN, 0),
3792 			BPF_JUMP(BPF_JMP | BPF_JGT | BPF_K, 0x73, 1, 0),
3793 			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 0xfc23ac00, 1, 0),
3794 			BPF_STMT(BPF_RET | BPF_K, 0xffff),
3795 			BPF_STMT(BPF_RET | BPF_K, 0),
3796 		},
3797 		CLASSIC,
3798 		{ 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
3799 		  0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
3800 		  0x08, 0x00,
3801 		  0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
3802 		  0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
3803 		  0x0a, 0x01, 0x01, 0x95, /* ip src */
3804 		  0x0a, 0x01, 0x02, 0x0a, /* ip dst */
3805 		  0xc2, 0x24,
3806 		  0x00, 0x16 /* dst port */ },
3807 		{ { 10, 0 }, { 30, 0 }, { 100, 65535 } },
3808 	},
3809 	{
3810 		"RET_A",
3811 		.u.insns = {
3812 			/* check that uninitialized X and A contain zeros */
3813 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
3814 			BPF_STMT(BPF_RET | BPF_A, 0)
3815 		},
3816 		CLASSIC,
3817 		{ },
3818 		{ {1, 0}, {2, 0} },
3819 	},
3820 	{
3821 		"INT: ADD trivial",
3822 		.u.insns_int = {
3823 			BPF_ALU64_IMM(BPF_MOV, R1, 1),
3824 			BPF_ALU64_IMM(BPF_ADD, R1, 2),
3825 			BPF_ALU64_IMM(BPF_MOV, R2, 3),
3826 			BPF_ALU64_REG(BPF_SUB, R1, R2),
3827 			BPF_ALU64_IMM(BPF_ADD, R1, -1),
3828 			BPF_ALU64_IMM(BPF_MUL, R1, 3),
3829 			BPF_ALU64_REG(BPF_MOV, R0, R1),
3830 			BPF_EXIT_INSN(),
3831 		},
3832 		INTERNAL,
3833 		{ },
3834 		{ { 0, 0xfffffffd } }
3835 	},
3836 	{
3837 		"INT: MUL_X",
3838 		.u.insns_int = {
3839 			BPF_ALU64_IMM(BPF_MOV, R0, -1),
3840 			BPF_ALU64_IMM(BPF_MOV, R1, -1),
3841 			BPF_ALU64_IMM(BPF_MOV, R2, 3),
3842 			BPF_ALU64_REG(BPF_MUL, R1, R2),
3843 			BPF_JMP_IMM(BPF_JEQ, R1, 0xfffffffd, 1),
3844 			BPF_EXIT_INSN(),
3845 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
3846 			BPF_EXIT_INSN(),
3847 		},
3848 		INTERNAL,
3849 		{ },
3850 		{ { 0, 1 } }
3851 	},
3852 	{
3853 		"INT: MUL_X2",
3854 		.u.insns_int = {
3855 			BPF_ALU32_IMM(BPF_MOV, R0, -1),
3856 			BPF_ALU32_IMM(BPF_MOV, R1, -1),
3857 			BPF_ALU32_IMM(BPF_MOV, R2, 3),
3858 			BPF_ALU64_REG(BPF_MUL, R1, R2),
3859 			BPF_ALU64_IMM(BPF_RSH, R1, 8),
3860 			BPF_JMP_IMM(BPF_JEQ, R1, 0x2ffffff, 1),
3861 			BPF_EXIT_INSN(),
3862 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
3863 			BPF_EXIT_INSN(),
3864 		},
3865 		INTERNAL,
3866 		{ },
3867 		{ { 0, 1 } }
3868 	},
3869 	{
3870 		"INT: MUL32_X",
3871 		.u.insns_int = {
3872 			BPF_ALU32_IMM(BPF_MOV, R0, -1),
3873 			BPF_ALU64_IMM(BPF_MOV, R1, -1),
3874 			BPF_ALU32_IMM(BPF_MOV, R2, 3),
3875 			BPF_ALU32_REG(BPF_MUL, R1, R2),
3876 			BPF_ALU64_IMM(BPF_RSH, R1, 8),
3877 			BPF_JMP_IMM(BPF_JEQ, R1, 0xffffff, 1),
3878 			BPF_EXIT_INSN(),
3879 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
3880 			BPF_EXIT_INSN(),
3881 		},
3882 		INTERNAL,
3883 		{ },
3884 		{ { 0, 1 } }
3885 	},
3886 	{
3887 		/* Have to test all register combinations, since
3888 		 * JITing of different registers will produce
3889 		 * different asm code.
3890 		 */
3891 		"INT: ADD 64-bit",
3892 		.u.insns_int = {
3893 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
3894 			BPF_ALU64_IMM(BPF_MOV, R1, 1),
3895 			BPF_ALU64_IMM(BPF_MOV, R2, 2),
3896 			BPF_ALU64_IMM(BPF_MOV, R3, 3),
3897 			BPF_ALU64_IMM(BPF_MOV, R4, 4),
3898 			BPF_ALU64_IMM(BPF_MOV, R5, 5),
3899 			BPF_ALU64_IMM(BPF_MOV, R6, 6),
3900 			BPF_ALU64_IMM(BPF_MOV, R7, 7),
3901 			BPF_ALU64_IMM(BPF_MOV, R8, 8),
3902 			BPF_ALU64_IMM(BPF_MOV, R9, 9),
3903 			BPF_ALU64_IMM(BPF_ADD, R0, 20),
3904 			BPF_ALU64_IMM(BPF_ADD, R1, 20),
3905 			BPF_ALU64_IMM(BPF_ADD, R2, 20),
3906 			BPF_ALU64_IMM(BPF_ADD, R3, 20),
3907 			BPF_ALU64_IMM(BPF_ADD, R4, 20),
3908 			BPF_ALU64_IMM(BPF_ADD, R5, 20),
3909 			BPF_ALU64_IMM(BPF_ADD, R6, 20),
3910 			BPF_ALU64_IMM(BPF_ADD, R7, 20),
3911 			BPF_ALU64_IMM(BPF_ADD, R8, 20),
3912 			BPF_ALU64_IMM(BPF_ADD, R9, 20),
3913 			BPF_ALU64_IMM(BPF_SUB, R0, 10),
3914 			BPF_ALU64_IMM(BPF_SUB, R1, 10),
3915 			BPF_ALU64_IMM(BPF_SUB, R2, 10),
3916 			BPF_ALU64_IMM(BPF_SUB, R3, 10),
3917 			BPF_ALU64_IMM(BPF_SUB, R4, 10),
3918 			BPF_ALU64_IMM(BPF_SUB, R5, 10),
3919 			BPF_ALU64_IMM(BPF_SUB, R6, 10),
3920 			BPF_ALU64_IMM(BPF_SUB, R7, 10),
3921 			BPF_ALU64_IMM(BPF_SUB, R8, 10),
3922 			BPF_ALU64_IMM(BPF_SUB, R9, 10),
3923 			BPF_ALU64_REG(BPF_ADD, R0, R0),
3924 			BPF_ALU64_REG(BPF_ADD, R0, R1),
3925 			BPF_ALU64_REG(BPF_ADD, R0, R2),
3926 			BPF_ALU64_REG(BPF_ADD, R0, R3),
3927 			BPF_ALU64_REG(BPF_ADD, R0, R4),
3928 			BPF_ALU64_REG(BPF_ADD, R0, R5),
3929 			BPF_ALU64_REG(BPF_ADD, R0, R6),
3930 			BPF_ALU64_REG(BPF_ADD, R0, R7),
3931 			BPF_ALU64_REG(BPF_ADD, R0, R8),
3932 			BPF_ALU64_REG(BPF_ADD, R0, R9), /* R0 == 155 */
3933 			BPF_JMP_IMM(BPF_JEQ, R0, 155, 1),
3934 			BPF_EXIT_INSN(),
3935 			BPF_ALU64_REG(BPF_ADD, R1, R0),
3936 			BPF_ALU64_REG(BPF_ADD, R1, R1),
3937 			BPF_ALU64_REG(BPF_ADD, R1, R2),
3938 			BPF_ALU64_REG(BPF_ADD, R1, R3),
3939 			BPF_ALU64_REG(BPF_ADD, R1, R4),
3940 			BPF_ALU64_REG(BPF_ADD, R1, R5),
3941 			BPF_ALU64_REG(BPF_ADD, R1, R6),
3942 			BPF_ALU64_REG(BPF_ADD, R1, R7),
3943 			BPF_ALU64_REG(BPF_ADD, R1, R8),
3944 			BPF_ALU64_REG(BPF_ADD, R1, R9), /* R1 == 456 */
3945 			BPF_JMP_IMM(BPF_JEQ, R1, 456, 1),
3946 			BPF_EXIT_INSN(),
3947 			BPF_ALU64_REG(BPF_ADD, R2, R0),
3948 			BPF_ALU64_REG(BPF_ADD, R2, R1),
3949 			BPF_ALU64_REG(BPF_ADD, R2, R2),
3950 			BPF_ALU64_REG(BPF_ADD, R2, R3),
3951 			BPF_ALU64_REG(BPF_ADD, R2, R4),
3952 			BPF_ALU64_REG(BPF_ADD, R2, R5),
3953 			BPF_ALU64_REG(BPF_ADD, R2, R6),
3954 			BPF_ALU64_REG(BPF_ADD, R2, R7),
3955 			BPF_ALU64_REG(BPF_ADD, R2, R8),
3956 			BPF_ALU64_REG(BPF_ADD, R2, R9), /* R2 == 1358 */
3957 			BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1),
3958 			BPF_EXIT_INSN(),
3959 			BPF_ALU64_REG(BPF_ADD, R3, R0),
3960 			BPF_ALU64_REG(BPF_ADD, R3, R1),
3961 			BPF_ALU64_REG(BPF_ADD, R3, R2),
3962 			BPF_ALU64_REG(BPF_ADD, R3, R3),
3963 			BPF_ALU64_REG(BPF_ADD, R3, R4),
3964 			BPF_ALU64_REG(BPF_ADD, R3, R5),
3965 			BPF_ALU64_REG(BPF_ADD, R3, R6),
3966 			BPF_ALU64_REG(BPF_ADD, R3, R7),
3967 			BPF_ALU64_REG(BPF_ADD, R3, R8),
3968 			BPF_ALU64_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
3969 			BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
3970 			BPF_EXIT_INSN(),
3971 			BPF_ALU64_REG(BPF_ADD, R4, R0),
3972 			BPF_ALU64_REG(BPF_ADD, R4, R1),
3973 			BPF_ALU64_REG(BPF_ADD, R4, R2),
3974 			BPF_ALU64_REG(BPF_ADD, R4, R3),
3975 			BPF_ALU64_REG(BPF_ADD, R4, R4),
3976 			BPF_ALU64_REG(BPF_ADD, R4, R5),
3977 			BPF_ALU64_REG(BPF_ADD, R4, R6),
3978 			BPF_ALU64_REG(BPF_ADD, R4, R7),
3979 			BPF_ALU64_REG(BPF_ADD, R4, R8),
3980 			BPF_ALU64_REG(BPF_ADD, R4, R9), /* R4 == 12177 */
3981 			BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1),
3982 			BPF_EXIT_INSN(),
3983 			BPF_ALU64_REG(BPF_ADD, R5, R0),
3984 			BPF_ALU64_REG(BPF_ADD, R5, R1),
3985 			BPF_ALU64_REG(BPF_ADD, R5, R2),
3986 			BPF_ALU64_REG(BPF_ADD, R5, R3),
3987 			BPF_ALU64_REG(BPF_ADD, R5, R4),
3988 			BPF_ALU64_REG(BPF_ADD, R5, R5),
3989 			BPF_ALU64_REG(BPF_ADD, R5, R6),
3990 			BPF_ALU64_REG(BPF_ADD, R5, R7),
3991 			BPF_ALU64_REG(BPF_ADD, R5, R8),
3992 			BPF_ALU64_REG(BPF_ADD, R5, R9), /* R5 == 36518 */
3993 			BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1),
3994 			BPF_EXIT_INSN(),
3995 			BPF_ALU64_REG(BPF_ADD, R6, R0),
3996 			BPF_ALU64_REG(BPF_ADD, R6, R1),
3997 			BPF_ALU64_REG(BPF_ADD, R6, R2),
3998 			BPF_ALU64_REG(BPF_ADD, R6, R3),
3999 			BPF_ALU64_REG(BPF_ADD, R6, R4),
4000 			BPF_ALU64_REG(BPF_ADD, R6, R5),
4001 			BPF_ALU64_REG(BPF_ADD, R6, R6),
4002 			BPF_ALU64_REG(BPF_ADD, R6, R7),
4003 			BPF_ALU64_REG(BPF_ADD, R6, R8),
4004 			BPF_ALU64_REG(BPF_ADD, R6, R9), /* R6 == 109540 */
4005 			BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1),
4006 			BPF_EXIT_INSN(),
4007 			BPF_ALU64_REG(BPF_ADD, R7, R0),
4008 			BPF_ALU64_REG(BPF_ADD, R7, R1),
4009 			BPF_ALU64_REG(BPF_ADD, R7, R2),
4010 			BPF_ALU64_REG(BPF_ADD, R7, R3),
4011 			BPF_ALU64_REG(BPF_ADD, R7, R4),
4012 			BPF_ALU64_REG(BPF_ADD, R7, R5),
4013 			BPF_ALU64_REG(BPF_ADD, R7, R6),
4014 			BPF_ALU64_REG(BPF_ADD, R7, R7),
4015 			BPF_ALU64_REG(BPF_ADD, R7, R8),
4016 			BPF_ALU64_REG(BPF_ADD, R7, R9), /* R7 == 328605 */
4017 			BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1),
4018 			BPF_EXIT_INSN(),
4019 			BPF_ALU64_REG(BPF_ADD, R8, R0),
4020 			BPF_ALU64_REG(BPF_ADD, R8, R1),
4021 			BPF_ALU64_REG(BPF_ADD, R8, R2),
4022 			BPF_ALU64_REG(BPF_ADD, R8, R3),
4023 			BPF_ALU64_REG(BPF_ADD, R8, R4),
4024 			BPF_ALU64_REG(BPF_ADD, R8, R5),
4025 			BPF_ALU64_REG(BPF_ADD, R8, R6),
4026 			BPF_ALU64_REG(BPF_ADD, R8, R7),
4027 			BPF_ALU64_REG(BPF_ADD, R8, R8),
4028 			BPF_ALU64_REG(BPF_ADD, R8, R9), /* R8 == 985799 */
4029 			BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1),
4030 			BPF_EXIT_INSN(),
4031 			BPF_ALU64_REG(BPF_ADD, R9, R0),
4032 			BPF_ALU64_REG(BPF_ADD, R9, R1),
4033 			BPF_ALU64_REG(BPF_ADD, R9, R2),
4034 			BPF_ALU64_REG(BPF_ADD, R9, R3),
4035 			BPF_ALU64_REG(BPF_ADD, R9, R4),
4036 			BPF_ALU64_REG(BPF_ADD, R9, R5),
4037 			BPF_ALU64_REG(BPF_ADD, R9, R6),
4038 			BPF_ALU64_REG(BPF_ADD, R9, R7),
4039 			BPF_ALU64_REG(BPF_ADD, R9, R8),
4040 			BPF_ALU64_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */
4041 			BPF_ALU64_REG(BPF_MOV, R0, R9),
4042 			BPF_EXIT_INSN(),
4043 		},
4044 		INTERNAL,
4045 		{ },
4046 		{ { 0, 2957380 } }
4047 	},
4048 	{
4049 		"INT: ADD 32-bit",
4050 		.u.insns_int = {
4051 			BPF_ALU32_IMM(BPF_MOV, R0, 20),
4052 			BPF_ALU32_IMM(BPF_MOV, R1, 1),
4053 			BPF_ALU32_IMM(BPF_MOV, R2, 2),
4054 			BPF_ALU32_IMM(BPF_MOV, R3, 3),
4055 			BPF_ALU32_IMM(BPF_MOV, R4, 4),
4056 			BPF_ALU32_IMM(BPF_MOV, R5, 5),
4057 			BPF_ALU32_IMM(BPF_MOV, R6, 6),
4058 			BPF_ALU32_IMM(BPF_MOV, R7, 7),
4059 			BPF_ALU32_IMM(BPF_MOV, R8, 8),
4060 			BPF_ALU32_IMM(BPF_MOV, R9, 9),
4061 			BPF_ALU64_IMM(BPF_ADD, R1, 10),
4062 			BPF_ALU64_IMM(BPF_ADD, R2, 10),
4063 			BPF_ALU64_IMM(BPF_ADD, R3, 10),
4064 			BPF_ALU64_IMM(BPF_ADD, R4, 10),
4065 			BPF_ALU64_IMM(BPF_ADD, R5, 10),
4066 			BPF_ALU64_IMM(BPF_ADD, R6, 10),
4067 			BPF_ALU64_IMM(BPF_ADD, R7, 10),
4068 			BPF_ALU64_IMM(BPF_ADD, R8, 10),
4069 			BPF_ALU64_IMM(BPF_ADD, R9, 10),
4070 			BPF_ALU32_REG(BPF_ADD, R0, R1),
4071 			BPF_ALU32_REG(BPF_ADD, R0, R2),
4072 			BPF_ALU32_REG(BPF_ADD, R0, R3),
4073 			BPF_ALU32_REG(BPF_ADD, R0, R4),
4074 			BPF_ALU32_REG(BPF_ADD, R0, R5),
4075 			BPF_ALU32_REG(BPF_ADD, R0, R6),
4076 			BPF_ALU32_REG(BPF_ADD, R0, R7),
4077 			BPF_ALU32_REG(BPF_ADD, R0, R8),
4078 			BPF_ALU32_REG(BPF_ADD, R0, R9), /* R0 == 155 */
4079 			BPF_JMP_IMM(BPF_JEQ, R0, 155, 1),
4080 			BPF_EXIT_INSN(),
4081 			BPF_ALU32_REG(BPF_ADD, R1, R0),
4082 			BPF_ALU32_REG(BPF_ADD, R1, R1),
4083 			BPF_ALU32_REG(BPF_ADD, R1, R2),
4084 			BPF_ALU32_REG(BPF_ADD, R1, R3),
4085 			BPF_ALU32_REG(BPF_ADD, R1, R4),
4086 			BPF_ALU32_REG(BPF_ADD, R1, R5),
4087 			BPF_ALU32_REG(BPF_ADD, R1, R6),
4088 			BPF_ALU32_REG(BPF_ADD, R1, R7),
4089 			BPF_ALU32_REG(BPF_ADD, R1, R8),
4090 			BPF_ALU32_REG(BPF_ADD, R1, R9), /* R1 == 456 */
4091 			BPF_JMP_IMM(BPF_JEQ, R1, 456, 1),
4092 			BPF_EXIT_INSN(),
4093 			BPF_ALU32_REG(BPF_ADD, R2, R0),
4094 			BPF_ALU32_REG(BPF_ADD, R2, R1),
4095 			BPF_ALU32_REG(BPF_ADD, R2, R2),
4096 			BPF_ALU32_REG(BPF_ADD, R2, R3),
4097 			BPF_ALU32_REG(BPF_ADD, R2, R4),
4098 			BPF_ALU32_REG(BPF_ADD, R2, R5),
4099 			BPF_ALU32_REG(BPF_ADD, R2, R6),
4100 			BPF_ALU32_REG(BPF_ADD, R2, R7),
4101 			BPF_ALU32_REG(BPF_ADD, R2, R8),
4102 			BPF_ALU32_REG(BPF_ADD, R2, R9), /* R2 == 1358 */
4103 			BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1),
4104 			BPF_EXIT_INSN(),
4105 			BPF_ALU32_REG(BPF_ADD, R3, R0),
4106 			BPF_ALU32_REG(BPF_ADD, R3, R1),
4107 			BPF_ALU32_REG(BPF_ADD, R3, R2),
4108 			BPF_ALU32_REG(BPF_ADD, R3, R3),
4109 			BPF_ALU32_REG(BPF_ADD, R3, R4),
4110 			BPF_ALU32_REG(BPF_ADD, R3, R5),
4111 			BPF_ALU32_REG(BPF_ADD, R3, R6),
4112 			BPF_ALU32_REG(BPF_ADD, R3, R7),
4113 			BPF_ALU32_REG(BPF_ADD, R3, R8),
4114 			BPF_ALU32_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
4115 			BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
4116 			BPF_EXIT_INSN(),
4117 			BPF_ALU32_REG(BPF_ADD, R4, R0),
4118 			BPF_ALU32_REG(BPF_ADD, R4, R1),
4119 			BPF_ALU32_REG(BPF_ADD, R4, R2),
4120 			BPF_ALU32_REG(BPF_ADD, R4, R3),
4121 			BPF_ALU32_REG(BPF_ADD, R4, R4),
4122 			BPF_ALU32_REG(BPF_ADD, R4, R5),
4123 			BPF_ALU32_REG(BPF_ADD, R4, R6),
4124 			BPF_ALU32_REG(BPF_ADD, R4, R7),
4125 			BPF_ALU32_REG(BPF_ADD, R4, R8),
4126 			BPF_ALU32_REG(BPF_ADD, R4, R9), /* R4 == 12177 */
4127 			BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1),
4128 			BPF_EXIT_INSN(),
4129 			BPF_ALU32_REG(BPF_ADD, R5, R0),
4130 			BPF_ALU32_REG(BPF_ADD, R5, R1),
4131 			BPF_ALU32_REG(BPF_ADD, R5, R2),
4132 			BPF_ALU32_REG(BPF_ADD, R5, R3),
4133 			BPF_ALU32_REG(BPF_ADD, R5, R4),
4134 			BPF_ALU32_REG(BPF_ADD, R5, R5),
4135 			BPF_ALU32_REG(BPF_ADD, R5, R6),
4136 			BPF_ALU32_REG(BPF_ADD, R5, R7),
4137 			BPF_ALU32_REG(BPF_ADD, R5, R8),
4138 			BPF_ALU32_REG(BPF_ADD, R5, R9), /* R5 == 36518 */
4139 			BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1),
4140 			BPF_EXIT_INSN(),
4141 			BPF_ALU32_REG(BPF_ADD, R6, R0),
4142 			BPF_ALU32_REG(BPF_ADD, R6, R1),
4143 			BPF_ALU32_REG(BPF_ADD, R6, R2),
4144 			BPF_ALU32_REG(BPF_ADD, R6, R3),
4145 			BPF_ALU32_REG(BPF_ADD, R6, R4),
4146 			BPF_ALU32_REG(BPF_ADD, R6, R5),
4147 			BPF_ALU32_REG(BPF_ADD, R6, R6),
4148 			BPF_ALU32_REG(BPF_ADD, R6, R7),
4149 			BPF_ALU32_REG(BPF_ADD, R6, R8),
4150 			BPF_ALU32_REG(BPF_ADD, R6, R9), /* R6 == 109540 */
4151 			BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1),
4152 			BPF_EXIT_INSN(),
4153 			BPF_ALU32_REG(BPF_ADD, R7, R0),
4154 			BPF_ALU32_REG(BPF_ADD, R7, R1),
4155 			BPF_ALU32_REG(BPF_ADD, R7, R2),
4156 			BPF_ALU32_REG(BPF_ADD, R7, R3),
4157 			BPF_ALU32_REG(BPF_ADD, R7, R4),
4158 			BPF_ALU32_REG(BPF_ADD, R7, R5),
4159 			BPF_ALU32_REG(BPF_ADD, R7, R6),
4160 			BPF_ALU32_REG(BPF_ADD, R7, R7),
4161 			BPF_ALU32_REG(BPF_ADD, R7, R8),
4162 			BPF_ALU32_REG(BPF_ADD, R7, R9), /* R7 == 328605 */
4163 			BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1),
4164 			BPF_EXIT_INSN(),
4165 			BPF_ALU32_REG(BPF_ADD, R8, R0),
4166 			BPF_ALU32_REG(BPF_ADD, R8, R1),
4167 			BPF_ALU32_REG(BPF_ADD, R8, R2),
4168 			BPF_ALU32_REG(BPF_ADD, R8, R3),
4169 			BPF_ALU32_REG(BPF_ADD, R8, R4),
4170 			BPF_ALU32_REG(BPF_ADD, R8, R5),
4171 			BPF_ALU32_REG(BPF_ADD, R8, R6),
4172 			BPF_ALU32_REG(BPF_ADD, R8, R7),
4173 			BPF_ALU32_REG(BPF_ADD, R8, R8),
4174 			BPF_ALU32_REG(BPF_ADD, R8, R9), /* R8 == 985799 */
4175 			BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1),
4176 			BPF_EXIT_INSN(),
4177 			BPF_ALU32_REG(BPF_ADD, R9, R0),
4178 			BPF_ALU32_REG(BPF_ADD, R9, R1),
4179 			BPF_ALU32_REG(BPF_ADD, R9, R2),
4180 			BPF_ALU32_REG(BPF_ADD, R9, R3),
4181 			BPF_ALU32_REG(BPF_ADD, R9, R4),
4182 			BPF_ALU32_REG(BPF_ADD, R9, R5),
4183 			BPF_ALU32_REG(BPF_ADD, R9, R6),
4184 			BPF_ALU32_REG(BPF_ADD, R9, R7),
4185 			BPF_ALU32_REG(BPF_ADD, R9, R8),
4186 			BPF_ALU32_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */
4187 			BPF_ALU32_REG(BPF_MOV, R0, R9),
4188 			BPF_EXIT_INSN(),
4189 		},
4190 		INTERNAL,
4191 		{ },
4192 		{ { 0, 2957380 } }
4193 	},
4194 	{	/* Mainly checking JIT here. */
4195 		"INT: SUB",
4196 		.u.insns_int = {
4197 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
4198 			BPF_ALU64_IMM(BPF_MOV, R1, 1),
4199 			BPF_ALU64_IMM(BPF_MOV, R2, 2),
4200 			BPF_ALU64_IMM(BPF_MOV, R3, 3),
4201 			BPF_ALU64_IMM(BPF_MOV, R4, 4),
4202 			BPF_ALU64_IMM(BPF_MOV, R5, 5),
4203 			BPF_ALU64_IMM(BPF_MOV, R6, 6),
4204 			BPF_ALU64_IMM(BPF_MOV, R7, 7),
4205 			BPF_ALU64_IMM(BPF_MOV, R8, 8),
4206 			BPF_ALU64_IMM(BPF_MOV, R9, 9),
4207 			BPF_ALU64_REG(BPF_SUB, R0, R0),
4208 			BPF_ALU64_REG(BPF_SUB, R0, R1),
4209 			BPF_ALU64_REG(BPF_SUB, R0, R2),
4210 			BPF_ALU64_REG(BPF_SUB, R0, R3),
4211 			BPF_ALU64_REG(BPF_SUB, R0, R4),
4212 			BPF_ALU64_REG(BPF_SUB, R0, R5),
4213 			BPF_ALU64_REG(BPF_SUB, R0, R6),
4214 			BPF_ALU64_REG(BPF_SUB, R0, R7),
4215 			BPF_ALU64_REG(BPF_SUB, R0, R8),
4216 			BPF_ALU64_REG(BPF_SUB, R0, R9),
4217 			BPF_ALU64_IMM(BPF_SUB, R0, 10),
4218 			BPF_JMP_IMM(BPF_JEQ, R0, -55, 1),
4219 			BPF_EXIT_INSN(),
4220 			BPF_ALU64_REG(BPF_SUB, R1, R0),
4221 			BPF_ALU64_REG(BPF_SUB, R1, R2),
4222 			BPF_ALU64_REG(BPF_SUB, R1, R3),
4223 			BPF_ALU64_REG(BPF_SUB, R1, R4),
4224 			BPF_ALU64_REG(BPF_SUB, R1, R5),
4225 			BPF_ALU64_REG(BPF_SUB, R1, R6),
4226 			BPF_ALU64_REG(BPF_SUB, R1, R7),
4227 			BPF_ALU64_REG(BPF_SUB, R1, R8),
4228 			BPF_ALU64_REG(BPF_SUB, R1, R9),
4229 			BPF_ALU64_IMM(BPF_SUB, R1, 10),
4230 			BPF_ALU64_REG(BPF_SUB, R2, R0),
4231 			BPF_ALU64_REG(BPF_SUB, R2, R1),
4232 			BPF_ALU64_REG(BPF_SUB, R2, R3),
4233 			BPF_ALU64_REG(BPF_SUB, R2, R4),
4234 			BPF_ALU64_REG(BPF_SUB, R2, R5),
4235 			BPF_ALU64_REG(BPF_SUB, R2, R6),
4236 			BPF_ALU64_REG(BPF_SUB, R2, R7),
4237 			BPF_ALU64_REG(BPF_SUB, R2, R8),
4238 			BPF_ALU64_REG(BPF_SUB, R2, R9),
4239 			BPF_ALU64_IMM(BPF_SUB, R2, 10),
4240 			BPF_ALU64_REG(BPF_SUB, R3, R0),
4241 			BPF_ALU64_REG(BPF_SUB, R3, R1),
4242 			BPF_ALU64_REG(BPF_SUB, R3, R2),
4243 			BPF_ALU64_REG(BPF_SUB, R3, R4),
4244 			BPF_ALU64_REG(BPF_SUB, R3, R5),
4245 			BPF_ALU64_REG(BPF_SUB, R3, R6),
4246 			BPF_ALU64_REG(BPF_SUB, R3, R7),
4247 			BPF_ALU64_REG(BPF_SUB, R3, R8),
4248 			BPF_ALU64_REG(BPF_SUB, R3, R9),
4249 			BPF_ALU64_IMM(BPF_SUB, R3, 10),
4250 			BPF_ALU64_REG(BPF_SUB, R4, R0),
4251 			BPF_ALU64_REG(BPF_SUB, R4, R1),
4252 			BPF_ALU64_REG(BPF_SUB, R4, R2),
4253 			BPF_ALU64_REG(BPF_SUB, R4, R3),
4254 			BPF_ALU64_REG(BPF_SUB, R4, R5),
4255 			BPF_ALU64_REG(BPF_SUB, R4, R6),
4256 			BPF_ALU64_REG(BPF_SUB, R4, R7),
4257 			BPF_ALU64_REG(BPF_SUB, R4, R8),
4258 			BPF_ALU64_REG(BPF_SUB, R4, R9),
4259 			BPF_ALU64_IMM(BPF_SUB, R4, 10),
4260 			BPF_ALU64_REG(BPF_SUB, R5, R0),
4261 			BPF_ALU64_REG(BPF_SUB, R5, R1),
4262 			BPF_ALU64_REG(BPF_SUB, R5, R2),
4263 			BPF_ALU64_REG(BPF_SUB, R5, R3),
4264 			BPF_ALU64_REG(BPF_SUB, R5, R4),
4265 			BPF_ALU64_REG(BPF_SUB, R5, R6),
4266 			BPF_ALU64_REG(BPF_SUB, R5, R7),
4267 			BPF_ALU64_REG(BPF_SUB, R5, R8),
4268 			BPF_ALU64_REG(BPF_SUB, R5, R9),
4269 			BPF_ALU64_IMM(BPF_SUB, R5, 10),
4270 			BPF_ALU64_REG(BPF_SUB, R6, R0),
4271 			BPF_ALU64_REG(BPF_SUB, R6, R1),
4272 			BPF_ALU64_REG(BPF_SUB, R6, R2),
4273 			BPF_ALU64_REG(BPF_SUB, R6, R3),
4274 			BPF_ALU64_REG(BPF_SUB, R6, R4),
4275 			BPF_ALU64_REG(BPF_SUB, R6, R5),
4276 			BPF_ALU64_REG(BPF_SUB, R6, R7),
4277 			BPF_ALU64_REG(BPF_SUB, R6, R8),
4278 			BPF_ALU64_REG(BPF_SUB, R6, R9),
4279 			BPF_ALU64_IMM(BPF_SUB, R6, 10),
4280 			BPF_ALU64_REG(BPF_SUB, R7, R0),
4281 			BPF_ALU64_REG(BPF_SUB, R7, R1),
4282 			BPF_ALU64_REG(BPF_SUB, R7, R2),
4283 			BPF_ALU64_REG(BPF_SUB, R7, R3),
4284 			BPF_ALU64_REG(BPF_SUB, R7, R4),
4285 			BPF_ALU64_REG(BPF_SUB, R7, R5),
4286 			BPF_ALU64_REG(BPF_SUB, R7, R6),
4287 			BPF_ALU64_REG(BPF_SUB, R7, R8),
4288 			BPF_ALU64_REG(BPF_SUB, R7, R9),
4289 			BPF_ALU64_IMM(BPF_SUB, R7, 10),
4290 			BPF_ALU64_REG(BPF_SUB, R8, R0),
4291 			BPF_ALU64_REG(BPF_SUB, R8, R1),
4292 			BPF_ALU64_REG(BPF_SUB, R8, R2),
4293 			BPF_ALU64_REG(BPF_SUB, R8, R3),
4294 			BPF_ALU64_REG(BPF_SUB, R8, R4),
4295 			BPF_ALU64_REG(BPF_SUB, R8, R5),
4296 			BPF_ALU64_REG(BPF_SUB, R8, R6),
4297 			BPF_ALU64_REG(BPF_SUB, R8, R7),
4298 			BPF_ALU64_REG(BPF_SUB, R8, R9),
4299 			BPF_ALU64_IMM(BPF_SUB, R8, 10),
4300 			BPF_ALU64_REG(BPF_SUB, R9, R0),
4301 			BPF_ALU64_REG(BPF_SUB, R9, R1),
4302 			BPF_ALU64_REG(BPF_SUB, R9, R2),
4303 			BPF_ALU64_REG(BPF_SUB, R9, R3),
4304 			BPF_ALU64_REG(BPF_SUB, R9, R4),
4305 			BPF_ALU64_REG(BPF_SUB, R9, R5),
4306 			BPF_ALU64_REG(BPF_SUB, R9, R6),
4307 			BPF_ALU64_REG(BPF_SUB, R9, R7),
4308 			BPF_ALU64_REG(BPF_SUB, R9, R8),
4309 			BPF_ALU64_IMM(BPF_SUB, R9, 10),
4310 			BPF_ALU64_IMM(BPF_SUB, R0, 10),
4311 			BPF_ALU64_IMM(BPF_NEG, R0, 0),
4312 			BPF_ALU64_REG(BPF_SUB, R0, R1),
4313 			BPF_ALU64_REG(BPF_SUB, R0, R2),
4314 			BPF_ALU64_REG(BPF_SUB, R0, R3),
4315 			BPF_ALU64_REG(BPF_SUB, R0, R4),
4316 			BPF_ALU64_REG(BPF_SUB, R0, R5),
4317 			BPF_ALU64_REG(BPF_SUB, R0, R6),
4318 			BPF_ALU64_REG(BPF_SUB, R0, R7),
4319 			BPF_ALU64_REG(BPF_SUB, R0, R8),
4320 			BPF_ALU64_REG(BPF_SUB, R0, R9),
4321 			BPF_EXIT_INSN(),
4322 		},
4323 		INTERNAL,
4324 		{ },
4325 		{ { 0, 11 } }
4326 	},
4327 	{	/* Mainly checking JIT here. */
4328 		"INT: XOR",
4329 		.u.insns_int = {
4330 			BPF_ALU64_REG(BPF_SUB, R0, R0),
4331 			BPF_ALU64_REG(BPF_XOR, R1, R1),
4332 			BPF_JMP_REG(BPF_JEQ, R0, R1, 1),
4333 			BPF_EXIT_INSN(),
4334 			BPF_ALU64_IMM(BPF_MOV, R0, 10),
4335 			BPF_ALU64_IMM(BPF_MOV, R1, -1),
4336 			BPF_ALU64_REG(BPF_SUB, R1, R1),
4337 			BPF_ALU64_REG(BPF_XOR, R2, R2),
4338 			BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
4339 			BPF_EXIT_INSN(),
4340 			BPF_ALU64_REG(BPF_SUB, R2, R2),
4341 			BPF_ALU64_REG(BPF_XOR, R3, R3),
4342 			BPF_ALU64_IMM(BPF_MOV, R0, 10),
4343 			BPF_ALU64_IMM(BPF_MOV, R1, -1),
4344 			BPF_JMP_REG(BPF_JEQ, R2, R3, 1),
4345 			BPF_EXIT_INSN(),
4346 			BPF_ALU64_REG(BPF_SUB, R3, R3),
4347 			BPF_ALU64_REG(BPF_XOR, R4, R4),
4348 			BPF_ALU64_IMM(BPF_MOV, R2, 1),
4349 			BPF_ALU64_IMM(BPF_MOV, R5, -1),
4350 			BPF_JMP_REG(BPF_JEQ, R3, R4, 1),
4351 			BPF_EXIT_INSN(),
4352 			BPF_ALU64_REG(BPF_SUB, R4, R4),
4353 			BPF_ALU64_REG(BPF_XOR, R5, R5),
4354 			BPF_ALU64_IMM(BPF_MOV, R3, 1),
4355 			BPF_ALU64_IMM(BPF_MOV, R7, -1),
4356 			BPF_JMP_REG(BPF_JEQ, R5, R4, 1),
4357 			BPF_EXIT_INSN(),
4358 			BPF_ALU64_IMM(BPF_MOV, R5, 1),
4359 			BPF_ALU64_REG(BPF_SUB, R5, R5),
4360 			BPF_ALU64_REG(BPF_XOR, R6, R6),
4361 			BPF_ALU64_IMM(BPF_MOV, R1, 1),
4362 			BPF_ALU64_IMM(BPF_MOV, R8, -1),
4363 			BPF_JMP_REG(BPF_JEQ, R5, R6, 1),
4364 			BPF_EXIT_INSN(),
4365 			BPF_ALU64_REG(BPF_SUB, R6, R6),
4366 			BPF_ALU64_REG(BPF_XOR, R7, R7),
4367 			BPF_JMP_REG(BPF_JEQ, R7, R6, 1),
4368 			BPF_EXIT_INSN(),
4369 			BPF_ALU64_REG(BPF_SUB, R7, R7),
4370 			BPF_ALU64_REG(BPF_XOR, R8, R8),
4371 			BPF_JMP_REG(BPF_JEQ, R7, R8, 1),
4372 			BPF_EXIT_INSN(),
4373 			BPF_ALU64_REG(BPF_SUB, R8, R8),
4374 			BPF_ALU64_REG(BPF_XOR, R9, R9),
4375 			BPF_JMP_REG(BPF_JEQ, R9, R8, 1),
4376 			BPF_EXIT_INSN(),
4377 			BPF_ALU64_REG(BPF_SUB, R9, R9),
4378 			BPF_ALU64_REG(BPF_XOR, R0, R0),
4379 			BPF_JMP_REG(BPF_JEQ, R9, R0, 1),
4380 			BPF_EXIT_INSN(),
4381 			BPF_ALU64_REG(BPF_SUB, R1, R1),
4382 			BPF_ALU64_REG(BPF_XOR, R0, R0),
4383 			BPF_JMP_REG(BPF_JEQ, R9, R0, 2),
4384 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
4385 			BPF_EXIT_INSN(),
4386 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
4387 			BPF_EXIT_INSN(),
4388 		},
4389 		INTERNAL,
4390 		{ },
4391 		{ { 0, 1 } }
4392 	},
4393 	{	/* Mainly checking JIT here. */
4394 		"INT: MUL",
4395 		.u.insns_int = {
4396 			BPF_ALU64_IMM(BPF_MOV, R0, 11),
4397 			BPF_ALU64_IMM(BPF_MOV, R1, 1),
4398 			BPF_ALU64_IMM(BPF_MOV, R2, 2),
4399 			BPF_ALU64_IMM(BPF_MOV, R3, 3),
4400 			BPF_ALU64_IMM(BPF_MOV, R4, 4),
4401 			BPF_ALU64_IMM(BPF_MOV, R5, 5),
4402 			BPF_ALU64_IMM(BPF_MOV, R6, 6),
4403 			BPF_ALU64_IMM(BPF_MOV, R7, 7),
4404 			BPF_ALU64_IMM(BPF_MOV, R8, 8),
4405 			BPF_ALU64_IMM(BPF_MOV, R9, 9),
4406 			BPF_ALU64_REG(BPF_MUL, R0, R0),
4407 			BPF_ALU64_REG(BPF_MUL, R0, R1),
4408 			BPF_ALU64_REG(BPF_MUL, R0, R2),
4409 			BPF_ALU64_REG(BPF_MUL, R0, R3),
4410 			BPF_ALU64_REG(BPF_MUL, R0, R4),
4411 			BPF_ALU64_REG(BPF_MUL, R0, R5),
4412 			BPF_ALU64_REG(BPF_MUL, R0, R6),
4413 			BPF_ALU64_REG(BPF_MUL, R0, R7),
4414 			BPF_ALU64_REG(BPF_MUL, R0, R8),
4415 			BPF_ALU64_REG(BPF_MUL, R0, R9),
4416 			BPF_ALU64_IMM(BPF_MUL, R0, 10),
4417 			BPF_JMP_IMM(BPF_JEQ, R0, 439084800, 1),
4418 			BPF_EXIT_INSN(),
4419 			BPF_ALU64_REG(BPF_MUL, R1, R0),
4420 			BPF_ALU64_REG(BPF_MUL, R1, R2),
4421 			BPF_ALU64_REG(BPF_MUL, R1, R3),
4422 			BPF_ALU64_REG(BPF_MUL, R1, R4),
4423 			BPF_ALU64_REG(BPF_MUL, R1, R5),
4424 			BPF_ALU64_REG(BPF_MUL, R1, R6),
4425 			BPF_ALU64_REG(BPF_MUL, R1, R7),
4426 			BPF_ALU64_REG(BPF_MUL, R1, R8),
4427 			BPF_ALU64_REG(BPF_MUL, R1, R9),
4428 			BPF_ALU64_IMM(BPF_MUL, R1, 10),
4429 			BPF_ALU64_REG(BPF_MOV, R2, R1),
4430 			BPF_ALU64_IMM(BPF_RSH, R2, 32),
4431 			BPF_JMP_IMM(BPF_JEQ, R2, 0x5a924, 1),
4432 			BPF_EXIT_INSN(),
4433 			BPF_ALU64_IMM(BPF_LSH, R1, 32),
4434 			BPF_ALU64_IMM(BPF_ARSH, R1, 32),
4435 			BPF_JMP_IMM(BPF_JEQ, R1, 0xebb90000, 1),
4436 			BPF_EXIT_INSN(),
4437 			BPF_ALU64_REG(BPF_MUL, R2, R0),
4438 			BPF_ALU64_REG(BPF_MUL, R2, R1),
4439 			BPF_ALU64_REG(BPF_MUL, R2, R3),
4440 			BPF_ALU64_REG(BPF_MUL, R2, R4),
4441 			BPF_ALU64_REG(BPF_MUL, R2, R5),
4442 			BPF_ALU64_REG(BPF_MUL, R2, R6),
4443 			BPF_ALU64_REG(BPF_MUL, R2, R7),
4444 			BPF_ALU64_REG(BPF_MUL, R2, R8),
4445 			BPF_ALU64_REG(BPF_MUL, R2, R9),
4446 			BPF_ALU64_IMM(BPF_MUL, R2, 10),
4447 			BPF_ALU64_IMM(BPF_RSH, R2, 32),
4448 			BPF_ALU64_REG(BPF_MOV, R0, R2),
4449 			BPF_EXIT_INSN(),
4450 		},
4451 		INTERNAL,
4452 		{ },
4453 		{ { 0, 0x35d97ef2 } }
4454 	},
4455 	{	/* Mainly checking JIT here. */
4456 		"MOV REG64",
4457 		.u.insns_int = {
4458 			BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
4459 			BPF_MOV64_REG(R1, R0),
4460 			BPF_MOV64_REG(R2, R1),
4461 			BPF_MOV64_REG(R3, R2),
4462 			BPF_MOV64_REG(R4, R3),
4463 			BPF_MOV64_REG(R5, R4),
4464 			BPF_MOV64_REG(R6, R5),
4465 			BPF_MOV64_REG(R7, R6),
4466 			BPF_MOV64_REG(R8, R7),
4467 			BPF_MOV64_REG(R9, R8),
4468 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
4469 			BPF_ALU64_IMM(BPF_MOV, R1, 0),
4470 			BPF_ALU64_IMM(BPF_MOV, R2, 0),
4471 			BPF_ALU64_IMM(BPF_MOV, R3, 0),
4472 			BPF_ALU64_IMM(BPF_MOV, R4, 0),
4473 			BPF_ALU64_IMM(BPF_MOV, R5, 0),
4474 			BPF_ALU64_IMM(BPF_MOV, R6, 0),
4475 			BPF_ALU64_IMM(BPF_MOV, R7, 0),
4476 			BPF_ALU64_IMM(BPF_MOV, R8, 0),
4477 			BPF_ALU64_IMM(BPF_MOV, R9, 0),
4478 			BPF_ALU64_REG(BPF_ADD, R0, R0),
4479 			BPF_ALU64_REG(BPF_ADD, R0, R1),
4480 			BPF_ALU64_REG(BPF_ADD, R0, R2),
4481 			BPF_ALU64_REG(BPF_ADD, R0, R3),
4482 			BPF_ALU64_REG(BPF_ADD, R0, R4),
4483 			BPF_ALU64_REG(BPF_ADD, R0, R5),
4484 			BPF_ALU64_REG(BPF_ADD, R0, R6),
4485 			BPF_ALU64_REG(BPF_ADD, R0, R7),
4486 			BPF_ALU64_REG(BPF_ADD, R0, R8),
4487 			BPF_ALU64_REG(BPF_ADD, R0, R9),
4488 			BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
4489 			BPF_EXIT_INSN(),
4490 		},
4491 		INTERNAL,
4492 		{ },
4493 		{ { 0, 0xfefe } }
4494 	},
4495 	{	/* Mainly checking JIT here. */
4496 		"MOV REG32",
4497 		.u.insns_int = {
4498 			BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
4499 			BPF_MOV64_REG(R1, R0),
4500 			BPF_MOV64_REG(R2, R1),
4501 			BPF_MOV64_REG(R3, R2),
4502 			BPF_MOV64_REG(R4, R3),
4503 			BPF_MOV64_REG(R5, R4),
4504 			BPF_MOV64_REG(R6, R5),
4505 			BPF_MOV64_REG(R7, R6),
4506 			BPF_MOV64_REG(R8, R7),
4507 			BPF_MOV64_REG(R9, R8),
4508 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
4509 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
4510 			BPF_ALU32_IMM(BPF_MOV, R2, 0),
4511 			BPF_ALU32_IMM(BPF_MOV, R3, 0),
4512 			BPF_ALU32_IMM(BPF_MOV, R4, 0),
4513 			BPF_ALU32_IMM(BPF_MOV, R5, 0),
4514 			BPF_ALU32_IMM(BPF_MOV, R6, 0),
4515 			BPF_ALU32_IMM(BPF_MOV, R7, 0),
4516 			BPF_ALU32_IMM(BPF_MOV, R8, 0),
4517 			BPF_ALU32_IMM(BPF_MOV, R9, 0),
4518 			BPF_ALU64_REG(BPF_ADD, R0, R0),
4519 			BPF_ALU64_REG(BPF_ADD, R0, R1),
4520 			BPF_ALU64_REG(BPF_ADD, R0, R2),
4521 			BPF_ALU64_REG(BPF_ADD, R0, R3),
4522 			BPF_ALU64_REG(BPF_ADD, R0, R4),
4523 			BPF_ALU64_REG(BPF_ADD, R0, R5),
4524 			BPF_ALU64_REG(BPF_ADD, R0, R6),
4525 			BPF_ALU64_REG(BPF_ADD, R0, R7),
4526 			BPF_ALU64_REG(BPF_ADD, R0, R8),
4527 			BPF_ALU64_REG(BPF_ADD, R0, R9),
4528 			BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
4529 			BPF_EXIT_INSN(),
4530 		},
4531 		INTERNAL,
4532 		{ },
4533 		{ { 0, 0xfefe } }
4534 	},
4535 	{	/* Mainly checking JIT here. */
4536 		"LD IMM64",
4537 		.u.insns_int = {
4538 			BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
4539 			BPF_MOV64_REG(R1, R0),
4540 			BPF_MOV64_REG(R2, R1),
4541 			BPF_MOV64_REG(R3, R2),
4542 			BPF_MOV64_REG(R4, R3),
4543 			BPF_MOV64_REG(R5, R4),
4544 			BPF_MOV64_REG(R6, R5),
4545 			BPF_MOV64_REG(R7, R6),
4546 			BPF_MOV64_REG(R8, R7),
4547 			BPF_MOV64_REG(R9, R8),
4548 			BPF_LD_IMM64(R0, 0x0LL),
4549 			BPF_LD_IMM64(R1, 0x0LL),
4550 			BPF_LD_IMM64(R2, 0x0LL),
4551 			BPF_LD_IMM64(R3, 0x0LL),
4552 			BPF_LD_IMM64(R4, 0x0LL),
4553 			BPF_LD_IMM64(R5, 0x0LL),
4554 			BPF_LD_IMM64(R6, 0x0LL),
4555 			BPF_LD_IMM64(R7, 0x0LL),
4556 			BPF_LD_IMM64(R8, 0x0LL),
4557 			BPF_LD_IMM64(R9, 0x0LL),
4558 			BPF_ALU64_REG(BPF_ADD, R0, R0),
4559 			BPF_ALU64_REG(BPF_ADD, R0, R1),
4560 			BPF_ALU64_REG(BPF_ADD, R0, R2),
4561 			BPF_ALU64_REG(BPF_ADD, R0, R3),
4562 			BPF_ALU64_REG(BPF_ADD, R0, R4),
4563 			BPF_ALU64_REG(BPF_ADD, R0, R5),
4564 			BPF_ALU64_REG(BPF_ADD, R0, R6),
4565 			BPF_ALU64_REG(BPF_ADD, R0, R7),
4566 			BPF_ALU64_REG(BPF_ADD, R0, R8),
4567 			BPF_ALU64_REG(BPF_ADD, R0, R9),
4568 			BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
4569 			BPF_EXIT_INSN(),
4570 		},
4571 		INTERNAL,
4572 		{ },
4573 		{ { 0, 0xfefe } }
4574 	},
4575 	{
4576 		"INT: ALU MIX",
4577 		.u.insns_int = {
4578 			BPF_ALU64_IMM(BPF_MOV, R0, 11),
4579 			BPF_ALU64_IMM(BPF_ADD, R0, -1),
4580 			BPF_ALU64_IMM(BPF_MOV, R2, 2),
4581 			BPF_ALU64_IMM(BPF_XOR, R2, 3),
4582 			BPF_ALU64_REG(BPF_DIV, R0, R2),
4583 			BPF_JMP_IMM(BPF_JEQ, R0, 10, 1),
4584 			BPF_EXIT_INSN(),
4585 			BPF_ALU64_IMM(BPF_MOD, R0, 3),
4586 			BPF_JMP_IMM(BPF_JEQ, R0, 1, 1),
4587 			BPF_EXIT_INSN(),
4588 			BPF_ALU64_IMM(BPF_MOV, R0, -1),
4589 			BPF_EXIT_INSN(),
4590 		},
4591 		INTERNAL,
4592 		{ },
4593 		{ { 0, -1 } }
4594 	},
4595 	{
4596 		"INT: shifts by register",
4597 		.u.insns_int = {
4598 			BPF_MOV64_IMM(R0, -1234),
4599 			BPF_MOV64_IMM(R1, 1),
4600 			BPF_ALU32_REG(BPF_RSH, R0, R1),
4601 			BPF_JMP_IMM(BPF_JEQ, R0, 0x7ffffd97, 1),
4602 			BPF_EXIT_INSN(),
4603 			BPF_MOV64_IMM(R2, 1),
4604 			BPF_ALU64_REG(BPF_LSH, R0, R2),
4605 			BPF_MOV32_IMM(R4, -1234),
4606 			BPF_JMP_REG(BPF_JEQ, R0, R4, 1),
4607 			BPF_EXIT_INSN(),
4608 			BPF_ALU64_IMM(BPF_AND, R4, 63),
4609 			BPF_ALU64_REG(BPF_LSH, R0, R4), /* R0 <= 46 */
4610 			BPF_MOV64_IMM(R3, 47),
4611 			BPF_ALU64_REG(BPF_ARSH, R0, R3),
4612 			BPF_JMP_IMM(BPF_JEQ, R0, -617, 1),
4613 			BPF_EXIT_INSN(),
4614 			BPF_MOV64_IMM(R2, 1),
4615 			BPF_ALU64_REG(BPF_LSH, R4, R2), /* R4 = 46 << 1 */
4616 			BPF_JMP_IMM(BPF_JEQ, R4, 92, 1),
4617 			BPF_EXIT_INSN(),
4618 			BPF_MOV64_IMM(R4, 4),
4619 			BPF_ALU64_REG(BPF_LSH, R4, R4), /* R4 = 4 << 4 */
4620 			BPF_JMP_IMM(BPF_JEQ, R4, 64, 1),
4621 			BPF_EXIT_INSN(),
4622 			BPF_MOV64_IMM(R4, 5),
4623 			BPF_ALU32_REG(BPF_LSH, R4, R4), /* R4 = 5 << 5 */
4624 			BPF_JMP_IMM(BPF_JEQ, R4, 160, 1),
4625 			BPF_EXIT_INSN(),
4626 			BPF_MOV64_IMM(R0, -1),
4627 			BPF_EXIT_INSN(),
4628 		},
4629 		INTERNAL,
4630 		{ },
4631 		{ { 0, -1 } }
4632 	},
4633 #ifdef CONFIG_32BIT
4634 	{
4635 		"INT: 32-bit context pointer word order and zero-extension",
4636 		.u.insns_int = {
4637 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
4638 			BPF_JMP32_IMM(BPF_JEQ, R1, 0, 3),
4639 			BPF_ALU64_IMM(BPF_RSH, R1, 32),
4640 			BPF_JMP32_IMM(BPF_JNE, R1, 0, 1),
4641 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
4642 			BPF_EXIT_INSN(),
4643 		},
4644 		INTERNAL,
4645 		{ },
4646 		{ { 0, 1 } }
4647 	},
4648 #endif
4649 	{
4650 		"check: missing ret",
4651 		.u.insns = {
4652 			BPF_STMT(BPF_LD | BPF_IMM, 1),
4653 		},
4654 		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4655 		{ },
4656 		{ },
4657 		.fill_helper = NULL,
4658 		.expected_errcode = -EINVAL,
4659 	},
4660 	{
4661 		"check: div_k_0",
4662 		.u.insns = {
4663 			BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0),
4664 			BPF_STMT(BPF_RET | BPF_K, 0)
4665 		},
4666 		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4667 		{ },
4668 		{ },
4669 		.fill_helper = NULL,
4670 		.expected_errcode = -EINVAL,
4671 	},
4672 	{
4673 		"check: unknown insn",
4674 		.u.insns = {
4675 			/* seccomp insn, rejected in socket filter */
4676 			BPF_STMT(BPF_LDX | BPF_W | BPF_ABS, 0),
4677 			BPF_STMT(BPF_RET | BPF_K, 0)
4678 		},
4679 		CLASSIC | FLAG_EXPECTED_FAIL,
4680 		{ },
4681 		{ },
4682 		.fill_helper = NULL,
4683 		.expected_errcode = -EINVAL,
4684 	},
4685 	{
4686 		"check: out of range spill/fill",
4687 		.u.insns = {
4688 			BPF_STMT(BPF_STX, 16),
4689 			BPF_STMT(BPF_RET | BPF_K, 0)
4690 		},
4691 		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4692 		{ },
4693 		{ },
4694 		.fill_helper = NULL,
4695 		.expected_errcode = -EINVAL,
4696 	},
4697 	{
4698 		"JUMPS + HOLES",
4699 		.u.insns = {
4700 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4701 			BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 15),
4702 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4703 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4704 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4705 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4706 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4707 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4708 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4709 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4710 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4711 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4712 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4713 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4714 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4715 			BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 3, 4),
4716 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4717 			BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 1, 2),
4718 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4719 			BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
4720 			BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
4721 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4722 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4723 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4724 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4725 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4726 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4727 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4728 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4729 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4730 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4731 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4732 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4733 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4734 			BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 2, 3),
4735 			BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 1, 2),
4736 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4737 			BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
4738 			BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
4739 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4740 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4741 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4742 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4743 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4744 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4745 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4746 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4747 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4748 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4749 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4750 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4751 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4752 			BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 2, 3),
4753 			BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 1, 2),
4754 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4755 			BPF_STMT(BPF_RET | BPF_A, 0),
4756 			BPF_STMT(BPF_RET | BPF_A, 0),
4757 		},
4758 		CLASSIC,
4759 		{ 0x00, 0x1b, 0x21, 0x3c, 0x9d, 0xf8,
4760 		  0x90, 0xe2, 0xba, 0x0a, 0x56, 0xb4,
4761 		  0x08, 0x00,
4762 		  0x45, 0x00, 0x00, 0x28, 0x00, 0x00,
4763 		  0x20, 0x00, 0x40, 0x11, 0x00, 0x00, /* IP header */
4764 		  0xc0, 0xa8, 0x33, 0x01,
4765 		  0xc0, 0xa8, 0x33, 0x02,
4766 		  0xbb, 0xb6,
4767 		  0xa9, 0xfa,
4768 		  0x00, 0x14, 0x00, 0x00,
4769 		  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4770 		  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4771 		  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4772 		  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4773 		  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4774 		  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4775 		  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4776 		  0xcc, 0xcc, 0xcc, 0xcc },
4777 		{ { 88, 0x001b } }
4778 	},
4779 	{
4780 		"check: RET X",
4781 		.u.insns = {
4782 			BPF_STMT(BPF_RET | BPF_X, 0),
4783 		},
4784 		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4785 		{ },
4786 		{ },
4787 		.fill_helper = NULL,
4788 		.expected_errcode = -EINVAL,
4789 	},
4790 	{
4791 		"check: LDX + RET X",
4792 		.u.insns = {
4793 			BPF_STMT(BPF_LDX | BPF_IMM, 42),
4794 			BPF_STMT(BPF_RET | BPF_X, 0),
4795 		},
4796 		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4797 		{ },
4798 		{ },
4799 		.fill_helper = NULL,
4800 		.expected_errcode = -EINVAL,
4801 	},
4802 	{	/* Mainly checking JIT here. */
4803 		"M[]: alt STX + LDX",
4804 		.u.insns = {
4805 			BPF_STMT(BPF_LDX | BPF_IMM, 100),
4806 			BPF_STMT(BPF_STX, 0),
4807 			BPF_STMT(BPF_LDX | BPF_MEM, 0),
4808 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4809 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4810 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4811 			BPF_STMT(BPF_STX, 1),
4812 			BPF_STMT(BPF_LDX | BPF_MEM, 1),
4813 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4814 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4815 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4816 			BPF_STMT(BPF_STX, 2),
4817 			BPF_STMT(BPF_LDX | BPF_MEM, 2),
4818 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4819 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4820 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4821 			BPF_STMT(BPF_STX, 3),
4822 			BPF_STMT(BPF_LDX | BPF_MEM, 3),
4823 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4824 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4825 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4826 			BPF_STMT(BPF_STX, 4),
4827 			BPF_STMT(BPF_LDX | BPF_MEM, 4),
4828 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4829 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4830 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4831 			BPF_STMT(BPF_STX, 5),
4832 			BPF_STMT(BPF_LDX | BPF_MEM, 5),
4833 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4834 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4835 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4836 			BPF_STMT(BPF_STX, 6),
4837 			BPF_STMT(BPF_LDX | BPF_MEM, 6),
4838 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4839 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4840 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4841 			BPF_STMT(BPF_STX, 7),
4842 			BPF_STMT(BPF_LDX | BPF_MEM, 7),
4843 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4844 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4845 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4846 			BPF_STMT(BPF_STX, 8),
4847 			BPF_STMT(BPF_LDX | BPF_MEM, 8),
4848 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4849 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4850 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4851 			BPF_STMT(BPF_STX, 9),
4852 			BPF_STMT(BPF_LDX | BPF_MEM, 9),
4853 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4854 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4855 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4856 			BPF_STMT(BPF_STX, 10),
4857 			BPF_STMT(BPF_LDX | BPF_MEM, 10),
4858 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4859 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4860 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4861 			BPF_STMT(BPF_STX, 11),
4862 			BPF_STMT(BPF_LDX | BPF_MEM, 11),
4863 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4864 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4865 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4866 			BPF_STMT(BPF_STX, 12),
4867 			BPF_STMT(BPF_LDX | BPF_MEM, 12),
4868 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4869 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4870 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4871 			BPF_STMT(BPF_STX, 13),
4872 			BPF_STMT(BPF_LDX | BPF_MEM, 13),
4873 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4874 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4875 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4876 			BPF_STMT(BPF_STX, 14),
4877 			BPF_STMT(BPF_LDX | BPF_MEM, 14),
4878 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4879 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4880 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4881 			BPF_STMT(BPF_STX, 15),
4882 			BPF_STMT(BPF_LDX | BPF_MEM, 15),
4883 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4884 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4885 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4886 			BPF_STMT(BPF_RET | BPF_A, 0),
4887 		},
4888 		CLASSIC | FLAG_NO_DATA,
4889 		{ },
4890 		{ { 0, 116 } },
4891 	},
4892 	{	/* Mainly checking JIT here. */
4893 		"M[]: full STX + full LDX",
4894 		.u.insns = {
4895 			BPF_STMT(BPF_LDX | BPF_IMM, 0xbadfeedb),
4896 			BPF_STMT(BPF_STX, 0),
4897 			BPF_STMT(BPF_LDX | BPF_IMM, 0xecabedae),
4898 			BPF_STMT(BPF_STX, 1),
4899 			BPF_STMT(BPF_LDX | BPF_IMM, 0xafccfeaf),
4900 			BPF_STMT(BPF_STX, 2),
4901 			BPF_STMT(BPF_LDX | BPF_IMM, 0xbffdcedc),
4902 			BPF_STMT(BPF_STX, 3),
4903 			BPF_STMT(BPF_LDX | BPF_IMM, 0xfbbbdccb),
4904 			BPF_STMT(BPF_STX, 4),
4905 			BPF_STMT(BPF_LDX | BPF_IMM, 0xfbabcbda),
4906 			BPF_STMT(BPF_STX, 5),
4907 			BPF_STMT(BPF_LDX | BPF_IMM, 0xaedecbdb),
4908 			BPF_STMT(BPF_STX, 6),
4909 			BPF_STMT(BPF_LDX | BPF_IMM, 0xadebbade),
4910 			BPF_STMT(BPF_STX, 7),
4911 			BPF_STMT(BPF_LDX | BPF_IMM, 0xfcfcfaec),
4912 			BPF_STMT(BPF_STX, 8),
4913 			BPF_STMT(BPF_LDX | BPF_IMM, 0xbcdddbdc),
4914 			BPF_STMT(BPF_STX, 9),
4915 			BPF_STMT(BPF_LDX | BPF_IMM, 0xfeefdfac),
4916 			BPF_STMT(BPF_STX, 10),
4917 			BPF_STMT(BPF_LDX | BPF_IMM, 0xcddcdeea),
4918 			BPF_STMT(BPF_STX, 11),
4919 			BPF_STMT(BPF_LDX | BPF_IMM, 0xaccfaebb),
4920 			BPF_STMT(BPF_STX, 12),
4921 			BPF_STMT(BPF_LDX | BPF_IMM, 0xbdcccdcf),
4922 			BPF_STMT(BPF_STX, 13),
4923 			BPF_STMT(BPF_LDX | BPF_IMM, 0xaaedecde),
4924 			BPF_STMT(BPF_STX, 14),
4925 			BPF_STMT(BPF_LDX | BPF_IMM, 0xfaeacdad),
4926 			BPF_STMT(BPF_STX, 15),
4927 			BPF_STMT(BPF_LDX | BPF_MEM, 0),
4928 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4929 			BPF_STMT(BPF_LDX | BPF_MEM, 1),
4930 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4931 			BPF_STMT(BPF_LDX | BPF_MEM, 2),
4932 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4933 			BPF_STMT(BPF_LDX | BPF_MEM, 3),
4934 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4935 			BPF_STMT(BPF_LDX | BPF_MEM, 4),
4936 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4937 			BPF_STMT(BPF_LDX | BPF_MEM, 5),
4938 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4939 			BPF_STMT(BPF_LDX | BPF_MEM, 6),
4940 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4941 			BPF_STMT(BPF_LDX | BPF_MEM, 7),
4942 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4943 			BPF_STMT(BPF_LDX | BPF_MEM, 8),
4944 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4945 			BPF_STMT(BPF_LDX | BPF_MEM, 9),
4946 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4947 			BPF_STMT(BPF_LDX | BPF_MEM, 10),
4948 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4949 			BPF_STMT(BPF_LDX | BPF_MEM, 11),
4950 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4951 			BPF_STMT(BPF_LDX | BPF_MEM, 12),
4952 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4953 			BPF_STMT(BPF_LDX | BPF_MEM, 13),
4954 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4955 			BPF_STMT(BPF_LDX | BPF_MEM, 14),
4956 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4957 			BPF_STMT(BPF_LDX | BPF_MEM, 15),
4958 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4959 			BPF_STMT(BPF_RET | BPF_A, 0),
4960 		},
4961 		CLASSIC | FLAG_NO_DATA,
4962 		{ },
4963 		{ { 0, 0x2a5a5e5 } },
4964 	},
4965 	{
4966 		"check: SKF_AD_MAX",
4967 		.u.insns = {
4968 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
4969 				 SKF_AD_OFF + SKF_AD_MAX),
4970 			BPF_STMT(BPF_RET | BPF_A, 0),
4971 		},
4972 		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4973 		{ },
4974 		{ },
4975 		.fill_helper = NULL,
4976 		.expected_errcode = -EINVAL,
4977 	},
4978 	{	/* Passes checker but fails during runtime. */
4979 		"LD [SKF_AD_OFF-1]",
4980 		.u.insns = {
4981 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
4982 				 SKF_AD_OFF - 1),
4983 			BPF_STMT(BPF_RET | BPF_K, 1),
4984 		},
4985 		CLASSIC,
4986 		{ },
4987 		{ { 1, 0 } },
4988 	},
4989 	{
4990 		"load 64-bit immediate",
4991 		.u.insns_int = {
4992 			BPF_LD_IMM64(R1, 0x567800001234LL),
4993 			BPF_MOV64_REG(R2, R1),
4994 			BPF_MOV64_REG(R3, R2),
4995 			BPF_ALU64_IMM(BPF_RSH, R2, 32),
4996 			BPF_ALU64_IMM(BPF_LSH, R3, 32),
4997 			BPF_ALU64_IMM(BPF_RSH, R3, 32),
4998 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
4999 			BPF_JMP_IMM(BPF_JEQ, R2, 0x5678, 1),
5000 			BPF_EXIT_INSN(),
5001 			BPF_JMP_IMM(BPF_JEQ, R3, 0x1234, 1),
5002 			BPF_EXIT_INSN(),
5003 			BPF_LD_IMM64(R0, 0x1ffffffffLL),
5004 			BPF_ALU64_IMM(BPF_RSH, R0, 32), /* R0 = 1 */
5005 			BPF_EXIT_INSN(),
5006 		},
5007 		INTERNAL,
5008 		{ },
5009 		{ { 0, 1 } }
5010 	},
5011 	/* BPF_ALU | BPF_MOV | BPF_X */
5012 	{
5013 		"ALU_MOV_X: dst = 2",
5014 		.u.insns_int = {
5015 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
5016 			BPF_ALU32_REG(BPF_MOV, R0, R1),
5017 			BPF_EXIT_INSN(),
5018 		},
5019 		INTERNAL,
5020 		{ },
5021 		{ { 0, 2 } },
5022 	},
5023 	{
5024 		"ALU_MOV_X: dst = 4294967295",
5025 		.u.insns_int = {
5026 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
5027 			BPF_ALU32_REG(BPF_MOV, R0, R1),
5028 			BPF_EXIT_INSN(),
5029 		},
5030 		INTERNAL,
5031 		{ },
5032 		{ { 0, 4294967295U } },
5033 	},
5034 	{
5035 		"ALU64_MOV_X: dst = 2",
5036 		.u.insns_int = {
5037 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
5038 			BPF_ALU64_REG(BPF_MOV, R0, R1),
5039 			BPF_EXIT_INSN(),
5040 		},
5041 		INTERNAL,
5042 		{ },
5043 		{ { 0, 2 } },
5044 	},
5045 	{
5046 		"ALU64_MOV_X: dst = 4294967295",
5047 		.u.insns_int = {
5048 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
5049 			BPF_ALU64_REG(BPF_MOV, R0, R1),
5050 			BPF_EXIT_INSN(),
5051 		},
5052 		INTERNAL,
5053 		{ },
5054 		{ { 0, 4294967295U } },
5055 	},
5056 	/* BPF_ALU | BPF_MOV | BPF_K */
5057 	{
5058 		"ALU_MOV_K: dst = 2",
5059 		.u.insns_int = {
5060 			BPF_ALU32_IMM(BPF_MOV, R0, 2),
5061 			BPF_EXIT_INSN(),
5062 		},
5063 		INTERNAL,
5064 		{ },
5065 		{ { 0, 2 } },
5066 	},
5067 	{
5068 		"ALU_MOV_K: dst = 4294967295",
5069 		.u.insns_int = {
5070 			BPF_ALU32_IMM(BPF_MOV, R0, 4294967295U),
5071 			BPF_EXIT_INSN(),
5072 		},
5073 		INTERNAL,
5074 		{ },
5075 		{ { 0, 4294967295U } },
5076 	},
5077 	{
5078 		"ALU_MOV_K: 0x0000ffffffff0000 = 0x00000000ffffffff",
5079 		.u.insns_int = {
5080 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
5081 			BPF_LD_IMM64(R3, 0x00000000ffffffffLL),
5082 			BPF_ALU32_IMM(BPF_MOV, R2, 0xffffffff),
5083 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5084 			BPF_MOV32_IMM(R0, 2),
5085 			BPF_EXIT_INSN(),
5086 			BPF_MOV32_IMM(R0, 1),
5087 			BPF_EXIT_INSN(),
5088 		},
5089 		INTERNAL,
5090 		{ },
5091 		{ { 0, 0x1 } },
5092 	},
5093 	{
5094 		"ALU_MOV_K: small negative",
5095 		.u.insns_int = {
5096 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
5097 			BPF_EXIT_INSN(),
5098 		},
5099 		INTERNAL,
5100 		{ },
5101 		{ { 0, -123 } }
5102 	},
5103 	{
5104 		"ALU_MOV_K: small negative zero extension",
5105 		.u.insns_int = {
5106 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
5107 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
5108 			BPF_EXIT_INSN(),
5109 		},
5110 		INTERNAL,
5111 		{ },
5112 		{ { 0, 0 } }
5113 	},
5114 	{
5115 		"ALU_MOV_K: large negative",
5116 		.u.insns_int = {
5117 			BPF_ALU32_IMM(BPF_MOV, R0, -123456789),
5118 			BPF_EXIT_INSN(),
5119 		},
5120 		INTERNAL,
5121 		{ },
5122 		{ { 0, -123456789 } }
5123 	},
5124 	{
5125 		"ALU_MOV_K: large negative zero extension",
5126 		.u.insns_int = {
5127 			BPF_ALU32_IMM(BPF_MOV, R0, -123456789),
5128 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
5129 			BPF_EXIT_INSN(),
5130 		},
5131 		INTERNAL,
5132 		{ },
5133 		{ { 0, 0 } }
5134 	},
5135 	{
5136 		"ALU64_MOV_K: dst = 2",
5137 		.u.insns_int = {
5138 			BPF_ALU64_IMM(BPF_MOV, R0, 2),
5139 			BPF_EXIT_INSN(),
5140 		},
5141 		INTERNAL,
5142 		{ },
5143 		{ { 0, 2 } },
5144 	},
5145 	{
5146 		"ALU64_MOV_K: dst = 2147483647",
5147 		.u.insns_int = {
5148 			BPF_ALU64_IMM(BPF_MOV, R0, 2147483647),
5149 			BPF_EXIT_INSN(),
5150 		},
5151 		INTERNAL,
5152 		{ },
5153 		{ { 0, 2147483647 } },
5154 	},
5155 	{
5156 		"ALU64_OR_K: dst = 0x0",
5157 		.u.insns_int = {
5158 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
5159 			BPF_LD_IMM64(R3, 0x0),
5160 			BPF_ALU64_IMM(BPF_MOV, R2, 0x0),
5161 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5162 			BPF_MOV32_IMM(R0, 2),
5163 			BPF_EXIT_INSN(),
5164 			BPF_MOV32_IMM(R0, 1),
5165 			BPF_EXIT_INSN(),
5166 		},
5167 		INTERNAL,
5168 		{ },
5169 		{ { 0, 0x1 } },
5170 	},
5171 	{
5172 		"ALU64_MOV_K: dst = -1",
5173 		.u.insns_int = {
5174 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
5175 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
5176 			BPF_ALU64_IMM(BPF_MOV, R2, 0xffffffff),
5177 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5178 			BPF_MOV32_IMM(R0, 2),
5179 			BPF_EXIT_INSN(),
5180 			BPF_MOV32_IMM(R0, 1),
5181 			BPF_EXIT_INSN(),
5182 		},
5183 		INTERNAL,
5184 		{ },
5185 		{ { 0, 0x1 } },
5186 	},
5187 	{
5188 		"ALU64_MOV_K: small negative",
5189 		.u.insns_int = {
5190 			BPF_ALU64_IMM(BPF_MOV, R0, -123),
5191 			BPF_EXIT_INSN(),
5192 		},
5193 		INTERNAL,
5194 		{ },
5195 		{ { 0, -123 } }
5196 	},
5197 	{
5198 		"ALU64_MOV_K: small negative sign extension",
5199 		.u.insns_int = {
5200 			BPF_ALU64_IMM(BPF_MOV, R0, -123),
5201 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
5202 			BPF_EXIT_INSN(),
5203 		},
5204 		INTERNAL,
5205 		{ },
5206 		{ { 0, 0xffffffff } }
5207 	},
5208 	{
5209 		"ALU64_MOV_K: large negative",
5210 		.u.insns_int = {
5211 			BPF_ALU64_IMM(BPF_MOV, R0, -123456789),
5212 			BPF_EXIT_INSN(),
5213 		},
5214 		INTERNAL,
5215 		{ },
5216 		{ { 0, -123456789 } }
5217 	},
5218 	{
5219 		"ALU64_MOV_K: large negative sign extension",
5220 		.u.insns_int = {
5221 			BPF_ALU64_IMM(BPF_MOV, R0, -123456789),
5222 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
5223 			BPF_EXIT_INSN(),
5224 		},
5225 		INTERNAL,
5226 		{ },
5227 		{ { 0, 0xffffffff } }
5228 	},
5229 	/* MOVSX32 */
5230 	{
5231 		"ALU_MOVSX | BPF_B",
5232 		.u.insns_int = {
5233 			BPF_LD_IMM64(R2, 0x00000000ffffffefLL),
5234 			BPF_LD_IMM64(R3, 0xdeadbeefdeadbeefLL),
5235 			BPF_MOVSX32_REG(R1, R3, 8),
5236 			BPF_JMP_REG(BPF_JEQ, R2, R1, 2),
5237 			BPF_MOV32_IMM(R0, 2),
5238 			BPF_EXIT_INSN(),
5239 			BPF_MOV32_IMM(R0, 1),
5240 			BPF_EXIT_INSN(),
5241 		},
5242 		INTERNAL,
5243 		{ },
5244 		{ { 0, 0x1 } },
5245 	},
5246 	{
5247 		"ALU_MOVSX | BPF_H",
5248 		.u.insns_int = {
5249 			BPF_LD_IMM64(R2, 0x00000000ffffbeefLL),
5250 			BPF_LD_IMM64(R3, 0xdeadbeefdeadbeefLL),
5251 			BPF_MOVSX32_REG(R1, R3, 16),
5252 			BPF_JMP_REG(BPF_JEQ, R2, R1, 2),
5253 			BPF_MOV32_IMM(R0, 2),
5254 			BPF_EXIT_INSN(),
5255 			BPF_MOV32_IMM(R0, 1),
5256 			BPF_EXIT_INSN(),
5257 		},
5258 		INTERNAL,
5259 		{ },
5260 		{ { 0, 0x1 } },
5261 	},
5262 	/* MOVSX64 REG */
5263 	{
5264 		"ALU64_MOVSX | BPF_B",
5265 		.u.insns_int = {
5266 			BPF_LD_IMM64(R2, 0xffffffffffffffefLL),
5267 			BPF_LD_IMM64(R3, 0xdeadbeefdeadbeefLL),
5268 			BPF_MOVSX64_REG(R1, R3, 8),
5269 			BPF_JMP_REG(BPF_JEQ, R2, R1, 2),
5270 			BPF_MOV32_IMM(R0, 2),
5271 			BPF_EXIT_INSN(),
5272 			BPF_MOV32_IMM(R0, 1),
5273 			BPF_EXIT_INSN(),
5274 		},
5275 		INTERNAL,
5276 		{ },
5277 		{ { 0, 0x1 } },
5278 	},
5279 	{
5280 		"ALU64_MOVSX | BPF_H",
5281 		.u.insns_int = {
5282 			BPF_LD_IMM64(R2, 0xffffffffffffbeefLL),
5283 			BPF_LD_IMM64(R3, 0xdeadbeefdeadbeefLL),
5284 			BPF_MOVSX64_REG(R1, R3, 16),
5285 			BPF_JMP_REG(BPF_JEQ, R2, R1, 2),
5286 			BPF_MOV32_IMM(R0, 2),
5287 			BPF_EXIT_INSN(),
5288 			BPF_MOV32_IMM(R0, 1),
5289 			BPF_EXIT_INSN(),
5290 		},
5291 		INTERNAL,
5292 		{ },
5293 		{ { 0, 0x1 } },
5294 	},
5295 	{
5296 		"ALU64_MOVSX | BPF_W",
5297 		.u.insns_int = {
5298 			BPF_LD_IMM64(R2, 0xffffffffdeadbeefLL),
5299 			BPF_LD_IMM64(R3, 0xdeadbeefdeadbeefLL),
5300 			BPF_MOVSX64_REG(R1, R3, 32),
5301 			BPF_JMP_REG(BPF_JEQ, R2, R1, 2),
5302 			BPF_MOV32_IMM(R0, 2),
5303 			BPF_EXIT_INSN(),
5304 			BPF_MOV32_IMM(R0, 1),
5305 			BPF_EXIT_INSN(),
5306 		},
5307 		INTERNAL,
5308 		{ },
5309 		{ { 0, 0x1 } },
5310 	},
5311 	/* BPF_ALU | BPF_ADD | BPF_X */
5312 	{
5313 		"ALU_ADD_X: 1 + 2 = 3",
5314 		.u.insns_int = {
5315 			BPF_LD_IMM64(R0, 1),
5316 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
5317 			BPF_ALU32_REG(BPF_ADD, R0, R1),
5318 			BPF_EXIT_INSN(),
5319 		},
5320 		INTERNAL,
5321 		{ },
5322 		{ { 0, 3 } },
5323 	},
5324 	{
5325 		"ALU_ADD_X: 1 + 4294967294 = 4294967295",
5326 		.u.insns_int = {
5327 			BPF_LD_IMM64(R0, 1),
5328 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
5329 			BPF_ALU32_REG(BPF_ADD, R0, R1),
5330 			BPF_EXIT_INSN(),
5331 		},
5332 		INTERNAL,
5333 		{ },
5334 		{ { 0, 4294967295U } },
5335 	},
5336 	{
5337 		"ALU_ADD_X: 2 + 4294967294 = 0",
5338 		.u.insns_int = {
5339 			BPF_LD_IMM64(R0, 2),
5340 			BPF_LD_IMM64(R1, 4294967294U),
5341 			BPF_ALU32_REG(BPF_ADD, R0, R1),
5342 			BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
5343 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
5344 			BPF_EXIT_INSN(),
5345 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
5346 			BPF_EXIT_INSN(),
5347 		},
5348 		INTERNAL,
5349 		{ },
5350 		{ { 0, 1 } },
5351 	},
5352 	{
5353 		"ALU64_ADD_X: 1 + 2 = 3",
5354 		.u.insns_int = {
5355 			BPF_LD_IMM64(R0, 1),
5356 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
5357 			BPF_ALU64_REG(BPF_ADD, R0, R1),
5358 			BPF_EXIT_INSN(),
5359 		},
5360 		INTERNAL,
5361 		{ },
5362 		{ { 0, 3 } },
5363 	},
5364 	{
5365 		"ALU64_ADD_X: 1 + 4294967294 = 4294967295",
5366 		.u.insns_int = {
5367 			BPF_LD_IMM64(R0, 1),
5368 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
5369 			BPF_ALU64_REG(BPF_ADD, R0, R1),
5370 			BPF_EXIT_INSN(),
5371 		},
5372 		INTERNAL,
5373 		{ },
5374 		{ { 0, 4294967295U } },
5375 	},
5376 	{
5377 		"ALU64_ADD_X: 2 + 4294967294 = 4294967296",
5378 		.u.insns_int = {
5379 			BPF_LD_IMM64(R0, 2),
5380 			BPF_LD_IMM64(R1, 4294967294U),
5381 			BPF_LD_IMM64(R2, 4294967296ULL),
5382 			BPF_ALU64_REG(BPF_ADD, R0, R1),
5383 			BPF_JMP_REG(BPF_JEQ, R0, R2, 2),
5384 			BPF_MOV32_IMM(R0, 0),
5385 			BPF_EXIT_INSN(),
5386 			BPF_MOV32_IMM(R0, 1),
5387 			BPF_EXIT_INSN(),
5388 		},
5389 		INTERNAL,
5390 		{ },
5391 		{ { 0, 1 } },
5392 	},
5393 	/* BPF_ALU | BPF_ADD | BPF_K */
5394 	{
5395 		"ALU_ADD_K: 1 + 2 = 3",
5396 		.u.insns_int = {
5397 			BPF_LD_IMM64(R0, 1),
5398 			BPF_ALU32_IMM(BPF_ADD, R0, 2),
5399 			BPF_EXIT_INSN(),
5400 		},
5401 		INTERNAL,
5402 		{ },
5403 		{ { 0, 3 } },
5404 	},
5405 	{
5406 		"ALU_ADD_K: 3 + 0 = 3",
5407 		.u.insns_int = {
5408 			BPF_LD_IMM64(R0, 3),
5409 			BPF_ALU32_IMM(BPF_ADD, R0, 0),
5410 			BPF_EXIT_INSN(),
5411 		},
5412 		INTERNAL,
5413 		{ },
5414 		{ { 0, 3 } },
5415 	},
5416 	{
5417 		"ALU_ADD_K: 1 + 4294967294 = 4294967295",
5418 		.u.insns_int = {
5419 			BPF_LD_IMM64(R0, 1),
5420 			BPF_ALU32_IMM(BPF_ADD, R0, 4294967294U),
5421 			BPF_EXIT_INSN(),
5422 		},
5423 		INTERNAL,
5424 		{ },
5425 		{ { 0, 4294967295U } },
5426 	},
5427 	{
5428 		"ALU_ADD_K: 4294967294 + 2 = 0",
5429 		.u.insns_int = {
5430 			BPF_LD_IMM64(R0, 4294967294U),
5431 			BPF_ALU32_IMM(BPF_ADD, R0, 2),
5432 			BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
5433 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
5434 			BPF_EXIT_INSN(),
5435 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
5436 			BPF_EXIT_INSN(),
5437 		},
5438 		INTERNAL,
5439 		{ },
5440 		{ { 0, 1 } },
5441 	},
5442 	{
5443 		"ALU_ADD_K: 0 + (-1) = 0x00000000ffffffff",
5444 		.u.insns_int = {
5445 			BPF_LD_IMM64(R2, 0x0),
5446 			BPF_LD_IMM64(R3, 0x00000000ffffffff),
5447 			BPF_ALU32_IMM(BPF_ADD, R2, 0xffffffff),
5448 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5449 			BPF_MOV32_IMM(R0, 2),
5450 			BPF_EXIT_INSN(),
5451 			BPF_MOV32_IMM(R0, 1),
5452 			BPF_EXIT_INSN(),
5453 		},
5454 		INTERNAL,
5455 		{ },
5456 		{ { 0, 0x1 } },
5457 	},
5458 	{
5459 		"ALU_ADD_K: 0 + 0xffff = 0xffff",
5460 		.u.insns_int = {
5461 			BPF_LD_IMM64(R2, 0x0),
5462 			BPF_LD_IMM64(R3, 0xffff),
5463 			BPF_ALU32_IMM(BPF_ADD, R2, 0xffff),
5464 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5465 			BPF_MOV32_IMM(R0, 2),
5466 			BPF_EXIT_INSN(),
5467 			BPF_MOV32_IMM(R0, 1),
5468 			BPF_EXIT_INSN(),
5469 		},
5470 		INTERNAL,
5471 		{ },
5472 		{ { 0, 0x1 } },
5473 	},
5474 	{
5475 		"ALU_ADD_K: 0 + 0x7fffffff = 0x7fffffff",
5476 		.u.insns_int = {
5477 			BPF_LD_IMM64(R2, 0x0),
5478 			BPF_LD_IMM64(R3, 0x7fffffff),
5479 			BPF_ALU32_IMM(BPF_ADD, R2, 0x7fffffff),
5480 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5481 			BPF_MOV32_IMM(R0, 2),
5482 			BPF_EXIT_INSN(),
5483 			BPF_MOV32_IMM(R0, 1),
5484 			BPF_EXIT_INSN(),
5485 		},
5486 		INTERNAL,
5487 		{ },
5488 		{ { 0, 0x1 } },
5489 	},
5490 	{
5491 		"ALU_ADD_K: 0 + 0x80000000 = 0x80000000",
5492 		.u.insns_int = {
5493 			BPF_LD_IMM64(R2, 0x0),
5494 			BPF_LD_IMM64(R3, 0x80000000),
5495 			BPF_ALU32_IMM(BPF_ADD, R2, 0x80000000),
5496 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5497 			BPF_MOV32_IMM(R0, 2),
5498 			BPF_EXIT_INSN(),
5499 			BPF_MOV32_IMM(R0, 1),
5500 			BPF_EXIT_INSN(),
5501 		},
5502 		INTERNAL,
5503 		{ },
5504 		{ { 0, 0x1 } },
5505 	},
5506 	{
5507 		"ALU_ADD_K: 0 + 0x80008000 = 0x80008000",
5508 		.u.insns_int = {
5509 			BPF_LD_IMM64(R2, 0x0),
5510 			BPF_LD_IMM64(R3, 0x80008000),
5511 			BPF_ALU32_IMM(BPF_ADD, R2, 0x80008000),
5512 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5513 			BPF_MOV32_IMM(R0, 2),
5514 			BPF_EXIT_INSN(),
5515 			BPF_MOV32_IMM(R0, 1),
5516 			BPF_EXIT_INSN(),
5517 		},
5518 		INTERNAL,
5519 		{ },
5520 		{ { 0, 0x1 } },
5521 	},
5522 	{
5523 		"ALU64_ADD_K: 1 + 2 = 3",
5524 		.u.insns_int = {
5525 			BPF_LD_IMM64(R0, 1),
5526 			BPF_ALU64_IMM(BPF_ADD, R0, 2),
5527 			BPF_EXIT_INSN(),
5528 		},
5529 		INTERNAL,
5530 		{ },
5531 		{ { 0, 3 } },
5532 	},
5533 	{
5534 		"ALU64_ADD_K: 3 + 0 = 3",
5535 		.u.insns_int = {
5536 			BPF_LD_IMM64(R0, 3),
5537 			BPF_ALU64_IMM(BPF_ADD, R0, 0),
5538 			BPF_EXIT_INSN(),
5539 		},
5540 		INTERNAL,
5541 		{ },
5542 		{ { 0, 3 } },
5543 	},
5544 	{
5545 		"ALU64_ADD_K: 1 + 2147483646 = 2147483647",
5546 		.u.insns_int = {
5547 			BPF_LD_IMM64(R0, 1),
5548 			BPF_ALU64_IMM(BPF_ADD, R0, 2147483646),
5549 			BPF_EXIT_INSN(),
5550 		},
5551 		INTERNAL,
5552 		{ },
5553 		{ { 0, 2147483647 } },
5554 	},
5555 	{
5556 		"ALU64_ADD_K: 4294967294 + 2 = 4294967296",
5557 		.u.insns_int = {
5558 			BPF_LD_IMM64(R0, 4294967294U),
5559 			BPF_LD_IMM64(R1, 4294967296ULL),
5560 			BPF_ALU64_IMM(BPF_ADD, R0, 2),
5561 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
5562 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
5563 			BPF_EXIT_INSN(),
5564 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
5565 			BPF_EXIT_INSN(),
5566 		},
5567 		INTERNAL,
5568 		{ },
5569 		{ { 0, 1 } },
5570 	},
5571 	{
5572 		"ALU64_ADD_K: 2147483646 + -2147483647 = -1",
5573 		.u.insns_int = {
5574 			BPF_LD_IMM64(R0, 2147483646),
5575 			BPF_ALU64_IMM(BPF_ADD, R0, -2147483647),
5576 			BPF_EXIT_INSN(),
5577 		},
5578 		INTERNAL,
5579 		{ },
5580 		{ { 0, -1 } },
5581 	},
5582 	{
5583 		"ALU64_ADD_K: 1 + 0 = 1",
5584 		.u.insns_int = {
5585 			BPF_LD_IMM64(R2, 0x1),
5586 			BPF_LD_IMM64(R3, 0x1),
5587 			BPF_ALU64_IMM(BPF_ADD, R2, 0x0),
5588 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5589 			BPF_MOV32_IMM(R0, 2),
5590 			BPF_EXIT_INSN(),
5591 			BPF_MOV32_IMM(R0, 1),
5592 			BPF_EXIT_INSN(),
5593 		},
5594 		INTERNAL,
5595 		{ },
5596 		{ { 0, 0x1 } },
5597 	},
5598 	{
5599 		"ALU64_ADD_K: 0 + (-1) = 0xffffffffffffffff",
5600 		.u.insns_int = {
5601 			BPF_LD_IMM64(R2, 0x0),
5602 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
5603 			BPF_ALU64_IMM(BPF_ADD, R2, 0xffffffff),
5604 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5605 			BPF_MOV32_IMM(R0, 2),
5606 			BPF_EXIT_INSN(),
5607 			BPF_MOV32_IMM(R0, 1),
5608 			BPF_EXIT_INSN(),
5609 		},
5610 		INTERNAL,
5611 		{ },
5612 		{ { 0, 0x1 } },
5613 	},
5614 	{
5615 		"ALU64_ADD_K: 0 + 0xffff = 0xffff",
5616 		.u.insns_int = {
5617 			BPF_LD_IMM64(R2, 0x0),
5618 			BPF_LD_IMM64(R3, 0xffff),
5619 			BPF_ALU64_IMM(BPF_ADD, R2, 0xffff),
5620 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5621 			BPF_MOV32_IMM(R0, 2),
5622 			BPF_EXIT_INSN(),
5623 			BPF_MOV32_IMM(R0, 1),
5624 			BPF_EXIT_INSN(),
5625 		},
5626 		INTERNAL,
5627 		{ },
5628 		{ { 0, 0x1 } },
5629 	},
5630 	{
5631 		"ALU64_ADD_K: 0 + 0x7fffffff = 0x7fffffff",
5632 		.u.insns_int = {
5633 			BPF_LD_IMM64(R2, 0x0),
5634 			BPF_LD_IMM64(R3, 0x7fffffff),
5635 			BPF_ALU64_IMM(BPF_ADD, R2, 0x7fffffff),
5636 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5637 			BPF_MOV32_IMM(R0, 2),
5638 			BPF_EXIT_INSN(),
5639 			BPF_MOV32_IMM(R0, 1),
5640 			BPF_EXIT_INSN(),
5641 		},
5642 		INTERNAL,
5643 		{ },
5644 		{ { 0, 0x1 } },
5645 	},
5646 	{
5647 		"ALU64_ADD_K: 0 + 0x80000000 = 0xffffffff80000000",
5648 		.u.insns_int = {
5649 			BPF_LD_IMM64(R2, 0x0),
5650 			BPF_LD_IMM64(R3, 0xffffffff80000000LL),
5651 			BPF_ALU64_IMM(BPF_ADD, R2, 0x80000000),
5652 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5653 			BPF_MOV32_IMM(R0, 2),
5654 			BPF_EXIT_INSN(),
5655 			BPF_MOV32_IMM(R0, 1),
5656 			BPF_EXIT_INSN(),
5657 		},
5658 		INTERNAL,
5659 		{ },
5660 		{ { 0, 0x1 } },
5661 	},
5662 	{
5663 		"ALU_ADD_K: 0 + 0x80008000 = 0xffffffff80008000",
5664 		.u.insns_int = {
5665 			BPF_LD_IMM64(R2, 0x0),
5666 			BPF_LD_IMM64(R3, 0xffffffff80008000LL),
5667 			BPF_ALU64_IMM(BPF_ADD, R2, 0x80008000),
5668 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5669 			BPF_MOV32_IMM(R0, 2),
5670 			BPF_EXIT_INSN(),
5671 			BPF_MOV32_IMM(R0, 1),
5672 			BPF_EXIT_INSN(),
5673 		},
5674 		INTERNAL,
5675 		{ },
5676 		{ { 0, 0x1 } },
5677 	},
5678 	/* BPF_ALU | BPF_SUB | BPF_X */
5679 	{
5680 		"ALU_SUB_X: 3 - 1 = 2",
5681 		.u.insns_int = {
5682 			BPF_LD_IMM64(R0, 3),
5683 			BPF_ALU32_IMM(BPF_MOV, R1, 1),
5684 			BPF_ALU32_REG(BPF_SUB, R0, R1),
5685 			BPF_EXIT_INSN(),
5686 		},
5687 		INTERNAL,
5688 		{ },
5689 		{ { 0, 2 } },
5690 	},
5691 	{
5692 		"ALU_SUB_X: 4294967295 - 4294967294 = 1",
5693 		.u.insns_int = {
5694 			BPF_LD_IMM64(R0, 4294967295U),
5695 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
5696 			BPF_ALU32_REG(BPF_SUB, R0, R1),
5697 			BPF_EXIT_INSN(),
5698 		},
5699 		INTERNAL,
5700 		{ },
5701 		{ { 0, 1 } },
5702 	},
5703 	{
5704 		"ALU64_SUB_X: 3 - 1 = 2",
5705 		.u.insns_int = {
5706 			BPF_LD_IMM64(R0, 3),
5707 			BPF_ALU32_IMM(BPF_MOV, R1, 1),
5708 			BPF_ALU64_REG(BPF_SUB, R0, R1),
5709 			BPF_EXIT_INSN(),
5710 		},
5711 		INTERNAL,
5712 		{ },
5713 		{ { 0, 2 } },
5714 	},
5715 	{
5716 		"ALU64_SUB_X: 4294967295 - 4294967294 = 1",
5717 		.u.insns_int = {
5718 			BPF_LD_IMM64(R0, 4294967295U),
5719 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
5720 			BPF_ALU64_REG(BPF_SUB, R0, R1),
5721 			BPF_EXIT_INSN(),
5722 		},
5723 		INTERNAL,
5724 		{ },
5725 		{ { 0, 1 } },
5726 	},
5727 	/* BPF_ALU | BPF_SUB | BPF_K */
5728 	{
5729 		"ALU_SUB_K: 3 - 1 = 2",
5730 		.u.insns_int = {
5731 			BPF_LD_IMM64(R0, 3),
5732 			BPF_ALU32_IMM(BPF_SUB, R0, 1),
5733 			BPF_EXIT_INSN(),
5734 		},
5735 		INTERNAL,
5736 		{ },
5737 		{ { 0, 2 } },
5738 	},
5739 	{
5740 		"ALU_SUB_K: 3 - 0 = 3",
5741 		.u.insns_int = {
5742 			BPF_LD_IMM64(R0, 3),
5743 			BPF_ALU32_IMM(BPF_SUB, R0, 0),
5744 			BPF_EXIT_INSN(),
5745 		},
5746 		INTERNAL,
5747 		{ },
5748 		{ { 0, 3 } },
5749 	},
5750 	{
5751 		"ALU_SUB_K: 4294967295 - 4294967294 = 1",
5752 		.u.insns_int = {
5753 			BPF_LD_IMM64(R0, 4294967295U),
5754 			BPF_ALU32_IMM(BPF_SUB, R0, 4294967294U),
5755 			BPF_EXIT_INSN(),
5756 		},
5757 		INTERNAL,
5758 		{ },
5759 		{ { 0, 1 } },
5760 	},
5761 	{
5762 		"ALU64_SUB_K: 3 - 1 = 2",
5763 		.u.insns_int = {
5764 			BPF_LD_IMM64(R0, 3),
5765 			BPF_ALU64_IMM(BPF_SUB, R0, 1),
5766 			BPF_EXIT_INSN(),
5767 		},
5768 		INTERNAL,
5769 		{ },
5770 		{ { 0, 2 } },
5771 	},
5772 	{
5773 		"ALU64_SUB_K: 3 - 0 = 3",
5774 		.u.insns_int = {
5775 			BPF_LD_IMM64(R0, 3),
5776 			BPF_ALU64_IMM(BPF_SUB, R0, 0),
5777 			BPF_EXIT_INSN(),
5778 		},
5779 		INTERNAL,
5780 		{ },
5781 		{ { 0, 3 } },
5782 	},
5783 	{
5784 		"ALU64_SUB_K: 4294967294 - 4294967295 = -1",
5785 		.u.insns_int = {
5786 			BPF_LD_IMM64(R0, 4294967294U),
5787 			BPF_ALU64_IMM(BPF_SUB, R0, 4294967295U),
5788 			BPF_EXIT_INSN(),
5789 		},
5790 		INTERNAL,
5791 		{ },
5792 		{ { 0, -1 } },
5793 	},
5794 	{
5795 		"ALU64_ADD_K: 2147483646 - 2147483647 = -1",
5796 		.u.insns_int = {
5797 			BPF_LD_IMM64(R0, 2147483646),
5798 			BPF_ALU64_IMM(BPF_SUB, R0, 2147483647),
5799 			BPF_EXIT_INSN(),
5800 		},
5801 		INTERNAL,
5802 		{ },
5803 		{ { 0, -1 } },
5804 	},
5805 	/* BPF_ALU | BPF_MUL | BPF_X */
5806 	{
5807 		"ALU_MUL_X: 2 * 3 = 6",
5808 		.u.insns_int = {
5809 			BPF_LD_IMM64(R0, 2),
5810 			BPF_ALU32_IMM(BPF_MOV, R1, 3),
5811 			BPF_ALU32_REG(BPF_MUL, R0, R1),
5812 			BPF_EXIT_INSN(),
5813 		},
5814 		INTERNAL,
5815 		{ },
5816 		{ { 0, 6 } },
5817 	},
5818 	{
5819 		"ALU_MUL_X: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
5820 		.u.insns_int = {
5821 			BPF_LD_IMM64(R0, 2),
5822 			BPF_ALU32_IMM(BPF_MOV, R1, 0x7FFFFFF8),
5823 			BPF_ALU32_REG(BPF_MUL, R0, R1),
5824 			BPF_EXIT_INSN(),
5825 		},
5826 		INTERNAL,
5827 		{ },
5828 		{ { 0, 0xFFFFFFF0 } },
5829 	},
5830 	{
5831 		"ALU_MUL_X: -1 * -1 = 1",
5832 		.u.insns_int = {
5833 			BPF_LD_IMM64(R0, -1),
5834 			BPF_ALU32_IMM(BPF_MOV, R1, -1),
5835 			BPF_ALU32_REG(BPF_MUL, R0, R1),
5836 			BPF_EXIT_INSN(),
5837 		},
5838 		INTERNAL,
5839 		{ },
5840 		{ { 0, 1 } },
5841 	},
5842 	{
5843 		"ALU64_MUL_X: 2 * 3 = 6",
5844 		.u.insns_int = {
5845 			BPF_LD_IMM64(R0, 2),
5846 			BPF_ALU32_IMM(BPF_MOV, R1, 3),
5847 			BPF_ALU64_REG(BPF_MUL, R0, R1),
5848 			BPF_EXIT_INSN(),
5849 		},
5850 		INTERNAL,
5851 		{ },
5852 		{ { 0, 6 } },
5853 	},
5854 	{
5855 		"ALU64_MUL_X: 1 * 2147483647 = 2147483647",
5856 		.u.insns_int = {
5857 			BPF_LD_IMM64(R0, 1),
5858 			BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
5859 			BPF_ALU64_REG(BPF_MUL, R0, R1),
5860 			BPF_EXIT_INSN(),
5861 		},
5862 		INTERNAL,
5863 		{ },
5864 		{ { 0, 2147483647 } },
5865 	},
5866 	{
5867 		"ALU64_MUL_X: 64x64 multiply, low word",
5868 		.u.insns_int = {
5869 			BPF_LD_IMM64(R0, 0x0fedcba987654321LL),
5870 			BPF_LD_IMM64(R1, 0x123456789abcdef0LL),
5871 			BPF_ALU64_REG(BPF_MUL, R0, R1),
5872 			BPF_EXIT_INSN(),
5873 		},
5874 		INTERNAL,
5875 		{ },
5876 		{ { 0, 0xe5618cf0 } }
5877 	},
5878 	{
5879 		"ALU64_MUL_X: 64x64 multiply, high word",
5880 		.u.insns_int = {
5881 			BPF_LD_IMM64(R0, 0x0fedcba987654321LL),
5882 			BPF_LD_IMM64(R1, 0x123456789abcdef0LL),
5883 			BPF_ALU64_REG(BPF_MUL, R0, R1),
5884 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
5885 			BPF_EXIT_INSN(),
5886 		},
5887 		INTERNAL,
5888 		{ },
5889 		{ { 0, 0x2236d88f } }
5890 	},
5891 	/* BPF_ALU | BPF_MUL | BPF_K */
5892 	{
5893 		"ALU_MUL_K: 2 * 3 = 6",
5894 		.u.insns_int = {
5895 			BPF_LD_IMM64(R0, 2),
5896 			BPF_ALU32_IMM(BPF_MUL, R0, 3),
5897 			BPF_EXIT_INSN(),
5898 		},
5899 		INTERNAL,
5900 		{ },
5901 		{ { 0, 6 } },
5902 	},
5903 	{
5904 		"ALU_MUL_K: 3 * 1 = 3",
5905 		.u.insns_int = {
5906 			BPF_LD_IMM64(R0, 3),
5907 			BPF_ALU32_IMM(BPF_MUL, R0, 1),
5908 			BPF_EXIT_INSN(),
5909 		},
5910 		INTERNAL,
5911 		{ },
5912 		{ { 0, 3 } },
5913 	},
5914 	{
5915 		"ALU_MUL_K: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
5916 		.u.insns_int = {
5917 			BPF_LD_IMM64(R0, 2),
5918 			BPF_ALU32_IMM(BPF_MUL, R0, 0x7FFFFFF8),
5919 			BPF_EXIT_INSN(),
5920 		},
5921 		INTERNAL,
5922 		{ },
5923 		{ { 0, 0xFFFFFFF0 } },
5924 	},
5925 	{
5926 		"ALU_MUL_K: 1 * (-1) = 0x00000000ffffffff",
5927 		.u.insns_int = {
5928 			BPF_LD_IMM64(R2, 0x1),
5929 			BPF_LD_IMM64(R3, 0x00000000ffffffff),
5930 			BPF_ALU32_IMM(BPF_MUL, R2, 0xffffffff),
5931 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5932 			BPF_MOV32_IMM(R0, 2),
5933 			BPF_EXIT_INSN(),
5934 			BPF_MOV32_IMM(R0, 1),
5935 			BPF_EXIT_INSN(),
5936 		},
5937 		INTERNAL,
5938 		{ },
5939 		{ { 0, 0x1 } },
5940 	},
5941 	{
5942 		"ALU64_MUL_K: 2 * 3 = 6",
5943 		.u.insns_int = {
5944 			BPF_LD_IMM64(R0, 2),
5945 			BPF_ALU64_IMM(BPF_MUL, R0, 3),
5946 			BPF_EXIT_INSN(),
5947 		},
5948 		INTERNAL,
5949 		{ },
5950 		{ { 0, 6 } },
5951 	},
5952 	{
5953 		"ALU64_MUL_K: 3 * 1 = 3",
5954 		.u.insns_int = {
5955 			BPF_LD_IMM64(R0, 3),
5956 			BPF_ALU64_IMM(BPF_MUL, R0, 1),
5957 			BPF_EXIT_INSN(),
5958 		},
5959 		INTERNAL,
5960 		{ },
5961 		{ { 0, 3 } },
5962 	},
5963 	{
5964 		"ALU64_MUL_K: 1 * 2147483647 = 2147483647",
5965 		.u.insns_int = {
5966 			BPF_LD_IMM64(R0, 1),
5967 			BPF_ALU64_IMM(BPF_MUL, R0, 2147483647),
5968 			BPF_EXIT_INSN(),
5969 		},
5970 		INTERNAL,
5971 		{ },
5972 		{ { 0, 2147483647 } },
5973 	},
5974 	{
5975 		"ALU64_MUL_K: 1 * -2147483647 = -2147483647",
5976 		.u.insns_int = {
5977 			BPF_LD_IMM64(R0, 1),
5978 			BPF_ALU64_IMM(BPF_MUL, R0, -2147483647),
5979 			BPF_EXIT_INSN(),
5980 		},
5981 		INTERNAL,
5982 		{ },
5983 		{ { 0, -2147483647 } },
5984 	},
5985 	{
5986 		"ALU64_MUL_K: 1 * (-1) = 0xffffffffffffffff",
5987 		.u.insns_int = {
5988 			BPF_LD_IMM64(R2, 0x1),
5989 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
5990 			BPF_ALU64_IMM(BPF_MUL, R2, 0xffffffff),
5991 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5992 			BPF_MOV32_IMM(R0, 2),
5993 			BPF_EXIT_INSN(),
5994 			BPF_MOV32_IMM(R0, 1),
5995 			BPF_EXIT_INSN(),
5996 		},
5997 		INTERNAL,
5998 		{ },
5999 		{ { 0, 0x1 } },
6000 	},
6001 	{
6002 		"ALU64_MUL_K: 64x32 multiply, low word",
6003 		.u.insns_int = {
6004 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6005 			BPF_ALU64_IMM(BPF_MUL, R0, 0x12345678),
6006 			BPF_EXIT_INSN(),
6007 		},
6008 		INTERNAL,
6009 		{ },
6010 		{ { 0, 0xe242d208 } }
6011 	},
6012 	{
6013 		"ALU64_MUL_K: 64x32 multiply, high word",
6014 		.u.insns_int = {
6015 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6016 			BPF_ALU64_IMM(BPF_MUL, R0, 0x12345678),
6017 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6018 			BPF_EXIT_INSN(),
6019 		},
6020 		INTERNAL,
6021 		{ },
6022 		{ { 0, 0xc28f5c28 } }
6023 	},
6024 	/* BPF_ALU | BPF_DIV | BPF_X */
6025 	{
6026 		"ALU_DIV_X: 6 / 2 = 3",
6027 		.u.insns_int = {
6028 			BPF_LD_IMM64(R0, 6),
6029 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
6030 			BPF_ALU32_REG(BPF_DIV, R0, R1),
6031 			BPF_EXIT_INSN(),
6032 		},
6033 		INTERNAL,
6034 		{ },
6035 		{ { 0, 3 } },
6036 	},
6037 	{
6038 		"ALU_DIV_X: 4294967295 / 4294967295 = 1",
6039 		.u.insns_int = {
6040 			BPF_LD_IMM64(R0, 4294967295U),
6041 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
6042 			BPF_ALU32_REG(BPF_DIV, R0, R1),
6043 			BPF_EXIT_INSN(),
6044 		},
6045 		INTERNAL,
6046 		{ },
6047 		{ { 0, 1 } },
6048 	},
6049 	{
6050 		"ALU64_DIV_X: 6 / 2 = 3",
6051 		.u.insns_int = {
6052 			BPF_LD_IMM64(R0, 6),
6053 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
6054 			BPF_ALU64_REG(BPF_DIV, R0, R1),
6055 			BPF_EXIT_INSN(),
6056 		},
6057 		INTERNAL,
6058 		{ },
6059 		{ { 0, 3 } },
6060 	},
6061 	{
6062 		"ALU64_DIV_X: 2147483647 / 2147483647 = 1",
6063 		.u.insns_int = {
6064 			BPF_LD_IMM64(R0, 2147483647),
6065 			BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
6066 			BPF_ALU64_REG(BPF_DIV, R0, R1),
6067 			BPF_EXIT_INSN(),
6068 		},
6069 		INTERNAL,
6070 		{ },
6071 		{ { 0, 1 } },
6072 	},
6073 	{
6074 		"ALU64_DIV_X: 0xffffffffffffffff / (-1) = 0x0000000000000001",
6075 		.u.insns_int = {
6076 			BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
6077 			BPF_LD_IMM64(R4, 0xffffffffffffffffLL),
6078 			BPF_LD_IMM64(R3, 0x0000000000000001LL),
6079 			BPF_ALU64_REG(BPF_DIV, R2, R4),
6080 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6081 			BPF_MOV32_IMM(R0, 2),
6082 			BPF_EXIT_INSN(),
6083 			BPF_MOV32_IMM(R0, 1),
6084 			BPF_EXIT_INSN(),
6085 		},
6086 		INTERNAL,
6087 		{ },
6088 		{ { 0, 0x1 } },
6089 	},
6090 	/* BPF_ALU | BPF_DIV | BPF_K */
6091 	{
6092 		"ALU_DIV_K: 6 / 2 = 3",
6093 		.u.insns_int = {
6094 			BPF_LD_IMM64(R0, 6),
6095 			BPF_ALU32_IMM(BPF_DIV, R0, 2),
6096 			BPF_EXIT_INSN(),
6097 		},
6098 		INTERNAL,
6099 		{ },
6100 		{ { 0, 3 } },
6101 	},
6102 	{
6103 		"ALU_DIV_K: 3 / 1 = 3",
6104 		.u.insns_int = {
6105 			BPF_LD_IMM64(R0, 3),
6106 			BPF_ALU32_IMM(BPF_DIV, R0, 1),
6107 			BPF_EXIT_INSN(),
6108 		},
6109 		INTERNAL,
6110 		{ },
6111 		{ { 0, 3 } },
6112 	},
6113 	{
6114 		"ALU_DIV_K: 4294967295 / 4294967295 = 1",
6115 		.u.insns_int = {
6116 			BPF_LD_IMM64(R0, 4294967295U),
6117 			BPF_ALU32_IMM(BPF_DIV, R0, 4294967295U),
6118 			BPF_EXIT_INSN(),
6119 		},
6120 		INTERNAL,
6121 		{ },
6122 		{ { 0, 1 } },
6123 	},
6124 	{
6125 		"ALU_DIV_K: 0xffffffffffffffff / (-1) = 0x1",
6126 		.u.insns_int = {
6127 			BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
6128 			BPF_LD_IMM64(R3, 0x1UL),
6129 			BPF_ALU32_IMM(BPF_DIV, R2, 0xffffffff),
6130 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6131 			BPF_MOV32_IMM(R0, 2),
6132 			BPF_EXIT_INSN(),
6133 			BPF_MOV32_IMM(R0, 1),
6134 			BPF_EXIT_INSN(),
6135 		},
6136 		INTERNAL,
6137 		{ },
6138 		{ { 0, 0x1 } },
6139 	},
6140 	{
6141 		"ALU64_DIV_K: 6 / 2 = 3",
6142 		.u.insns_int = {
6143 			BPF_LD_IMM64(R0, 6),
6144 			BPF_ALU64_IMM(BPF_DIV, R0, 2),
6145 			BPF_EXIT_INSN(),
6146 		},
6147 		INTERNAL,
6148 		{ },
6149 		{ { 0, 3 } },
6150 	},
6151 	{
6152 		"ALU64_DIV_K: 3 / 1 = 3",
6153 		.u.insns_int = {
6154 			BPF_LD_IMM64(R0, 3),
6155 			BPF_ALU64_IMM(BPF_DIV, R0, 1),
6156 			BPF_EXIT_INSN(),
6157 		},
6158 		INTERNAL,
6159 		{ },
6160 		{ { 0, 3 } },
6161 	},
6162 	{
6163 		"ALU64_DIV_K: 2147483647 / 2147483647 = 1",
6164 		.u.insns_int = {
6165 			BPF_LD_IMM64(R0, 2147483647),
6166 			BPF_ALU64_IMM(BPF_DIV, R0, 2147483647),
6167 			BPF_EXIT_INSN(),
6168 		},
6169 		INTERNAL,
6170 		{ },
6171 		{ { 0, 1 } },
6172 	},
6173 	{
6174 		"ALU64_DIV_K: 0xffffffffffffffff / (-1) = 0x0000000000000001",
6175 		.u.insns_int = {
6176 			BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
6177 			BPF_LD_IMM64(R3, 0x0000000000000001LL),
6178 			BPF_ALU64_IMM(BPF_DIV, R2, 0xffffffff),
6179 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6180 			BPF_MOV32_IMM(R0, 2),
6181 			BPF_EXIT_INSN(),
6182 			BPF_MOV32_IMM(R0, 1),
6183 			BPF_EXIT_INSN(),
6184 		},
6185 		INTERNAL,
6186 		{ },
6187 		{ { 0, 0x1 } },
6188 	},
6189 	/* BPF_ALU | BPF_MOD | BPF_X */
6190 	{
6191 		"ALU_MOD_X: 3 % 2 = 1",
6192 		.u.insns_int = {
6193 			BPF_LD_IMM64(R0, 3),
6194 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
6195 			BPF_ALU32_REG(BPF_MOD, R0, R1),
6196 			BPF_EXIT_INSN(),
6197 		},
6198 		INTERNAL,
6199 		{ },
6200 		{ { 0, 1 } },
6201 	},
6202 	{
6203 		"ALU_MOD_X: 4294967295 % 4294967293 = 2",
6204 		.u.insns_int = {
6205 			BPF_LD_IMM64(R0, 4294967295U),
6206 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967293U),
6207 			BPF_ALU32_REG(BPF_MOD, R0, R1),
6208 			BPF_EXIT_INSN(),
6209 		},
6210 		INTERNAL,
6211 		{ },
6212 		{ { 0, 2 } },
6213 	},
6214 	{
6215 		"ALU64_MOD_X: 3 % 2 = 1",
6216 		.u.insns_int = {
6217 			BPF_LD_IMM64(R0, 3),
6218 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
6219 			BPF_ALU64_REG(BPF_MOD, R0, R1),
6220 			BPF_EXIT_INSN(),
6221 		},
6222 		INTERNAL,
6223 		{ },
6224 		{ { 0, 1 } },
6225 	},
6226 	{
6227 		"ALU64_MOD_X: 2147483647 % 2147483645 = 2",
6228 		.u.insns_int = {
6229 			BPF_LD_IMM64(R0, 2147483647),
6230 			BPF_ALU32_IMM(BPF_MOV, R1, 2147483645),
6231 			BPF_ALU64_REG(BPF_MOD, R0, R1),
6232 			BPF_EXIT_INSN(),
6233 		},
6234 		INTERNAL,
6235 		{ },
6236 		{ { 0, 2 } },
6237 	},
6238 	/* BPF_ALU | BPF_MOD | BPF_K */
6239 	{
6240 		"ALU_MOD_K: 3 % 2 = 1",
6241 		.u.insns_int = {
6242 			BPF_LD_IMM64(R0, 3),
6243 			BPF_ALU32_IMM(BPF_MOD, R0, 2),
6244 			BPF_EXIT_INSN(),
6245 		},
6246 		INTERNAL,
6247 		{ },
6248 		{ { 0, 1 } },
6249 	},
6250 	{
6251 		"ALU_MOD_K: 3 % 1 = 0",
6252 		.u.insns_int = {
6253 			BPF_LD_IMM64(R0, 3),
6254 			BPF_ALU32_IMM(BPF_MOD, R0, 1),
6255 			BPF_EXIT_INSN(),
6256 		},
6257 		INTERNAL,
6258 		{ },
6259 		{ { 0, 0 } },
6260 	},
6261 	{
6262 		"ALU_MOD_K: 4294967295 % 4294967293 = 2",
6263 		.u.insns_int = {
6264 			BPF_LD_IMM64(R0, 4294967295U),
6265 			BPF_ALU32_IMM(BPF_MOD, R0, 4294967293U),
6266 			BPF_EXIT_INSN(),
6267 		},
6268 		INTERNAL,
6269 		{ },
6270 		{ { 0, 2 } },
6271 	},
6272 	{
6273 		"ALU64_MOD_K: 3 % 2 = 1",
6274 		.u.insns_int = {
6275 			BPF_LD_IMM64(R0, 3),
6276 			BPF_ALU64_IMM(BPF_MOD, R0, 2),
6277 			BPF_EXIT_INSN(),
6278 		},
6279 		INTERNAL,
6280 		{ },
6281 		{ { 0, 1 } },
6282 	},
6283 	{
6284 		"ALU64_MOD_K: 3 % 1 = 0",
6285 		.u.insns_int = {
6286 			BPF_LD_IMM64(R0, 3),
6287 			BPF_ALU64_IMM(BPF_MOD, R0, 1),
6288 			BPF_EXIT_INSN(),
6289 		},
6290 		INTERNAL,
6291 		{ },
6292 		{ { 0, 0 } },
6293 	},
6294 	{
6295 		"ALU64_MOD_K: 2147483647 % 2147483645 = 2",
6296 		.u.insns_int = {
6297 			BPF_LD_IMM64(R0, 2147483647),
6298 			BPF_ALU64_IMM(BPF_MOD, R0, 2147483645),
6299 			BPF_EXIT_INSN(),
6300 		},
6301 		INTERNAL,
6302 		{ },
6303 		{ { 0, 2 } },
6304 	},
6305 	/* BPF_ALU | BPF_DIV | BPF_X off=1 (SDIV) */
6306 	{
6307 		"ALU_SDIV_X: -6 / 2 = -3",
6308 		.u.insns_int = {
6309 			BPF_LD_IMM64(R0, -6),
6310 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
6311 			BPF_ALU32_REG_OFF(BPF_DIV, R0, R1, 1),
6312 			BPF_EXIT_INSN(),
6313 		},
6314 		INTERNAL,
6315 		{ },
6316 		{ { 0, -3 } },
6317 	},
6318 	/* BPF_ALU | BPF_DIV | BPF_K off=1 (SDIV) */
6319 	{
6320 		"ALU_SDIV_K: -6 / 2 = -3",
6321 		.u.insns_int = {
6322 			BPF_LD_IMM64(R0, -6),
6323 			BPF_ALU32_IMM_OFF(BPF_DIV, R0, 2, 1),
6324 			BPF_EXIT_INSN(),
6325 		},
6326 		INTERNAL,
6327 		{ },
6328 		{ { 0, -3 } },
6329 	},
6330 	/* BPF_ALU64 | BPF_DIV | BPF_X off=1 (SDIV64) */
6331 	{
6332 		"ALU64_SDIV_X: -6 / 2 = -3",
6333 		.u.insns_int = {
6334 			BPF_LD_IMM64(R0, -6),
6335 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
6336 			BPF_ALU64_REG_OFF(BPF_DIV, R0, R1, 1),
6337 			BPF_EXIT_INSN(),
6338 		},
6339 		INTERNAL,
6340 		{ },
6341 		{ { 0, -3 } },
6342 	},
6343 	/* BPF_ALU64 | BPF_DIV | BPF_K off=1 (SDIV64) */
6344 	{
6345 		"ALU64_SDIV_K: -6 / 2 = -3",
6346 		.u.insns_int = {
6347 			BPF_LD_IMM64(R0, -6),
6348 			BPF_ALU64_IMM_OFF(BPF_DIV, R0, 2, 1),
6349 			BPF_EXIT_INSN(),
6350 		},
6351 		INTERNAL,
6352 		{ },
6353 		{ { 0, -3 } },
6354 	},
6355 	/* BPF_ALU | BPF_MOD | BPF_X off=1 (SMOD) */
6356 	{
6357 		"ALU_SMOD_X: -7 % 2 = -1",
6358 		.u.insns_int = {
6359 			BPF_LD_IMM64(R0, -7),
6360 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
6361 			BPF_ALU32_REG_OFF(BPF_MOD, R0, R1, 1),
6362 			BPF_EXIT_INSN(),
6363 		},
6364 		INTERNAL,
6365 		{ },
6366 		{ { 0, -1 } },
6367 	},
6368 	/* BPF_ALU | BPF_MOD | BPF_K off=1 (SMOD) */
6369 	{
6370 		"ALU_SMOD_K: -7 % 2 = -1",
6371 		.u.insns_int = {
6372 			BPF_LD_IMM64(R0, -7),
6373 			BPF_ALU32_IMM_OFF(BPF_MOD, R0, 2, 1),
6374 			BPF_EXIT_INSN(),
6375 		},
6376 		INTERNAL,
6377 		{ },
6378 		{ { 0, -1 } },
6379 	},
6380 	/* BPF_ALU64 | BPF_MOD | BPF_X off=1 (SMOD64) */
6381 	{
6382 		"ALU64_SMOD_X: -7 % 2 = -1",
6383 		.u.insns_int = {
6384 			BPF_LD_IMM64(R0, -7),
6385 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
6386 			BPF_ALU64_REG_OFF(BPF_MOD, R0, R1, 1),
6387 			BPF_EXIT_INSN(),
6388 		},
6389 		INTERNAL,
6390 		{ },
6391 		{ { 0, -1 } },
6392 	},
6393 	/* BPF_ALU64 | BPF_MOD | BPF_K off=1 (SMOD64) */
6394 	{
6395 		"ALU64_SMOD_K: -7 % 2 = -1",
6396 		.u.insns_int = {
6397 			BPF_LD_IMM64(R0, -7),
6398 			BPF_ALU64_IMM_OFF(BPF_MOD, R0, 2, 1),
6399 			BPF_EXIT_INSN(),
6400 		},
6401 		INTERNAL,
6402 		{ },
6403 		{ { 0, -1 } },
6404 	},
6405 	/* BPF_ALU | BPF_AND | BPF_X */
6406 	{
6407 		"ALU_AND_X: 3 & 2 = 2",
6408 		.u.insns_int = {
6409 			BPF_LD_IMM64(R0, 3),
6410 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
6411 			BPF_ALU32_REG(BPF_AND, R0, R1),
6412 			BPF_EXIT_INSN(),
6413 		},
6414 		INTERNAL,
6415 		{ },
6416 		{ { 0, 2 } },
6417 	},
6418 	{
6419 		"ALU_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
6420 		.u.insns_int = {
6421 			BPF_LD_IMM64(R0, 0xffffffff),
6422 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6423 			BPF_ALU32_REG(BPF_AND, R0, R1),
6424 			BPF_EXIT_INSN(),
6425 		},
6426 		INTERNAL,
6427 		{ },
6428 		{ { 0, 0xffffffff } },
6429 	},
6430 	{
6431 		"ALU64_AND_X: 3 & 2 = 2",
6432 		.u.insns_int = {
6433 			BPF_LD_IMM64(R0, 3),
6434 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
6435 			BPF_ALU64_REG(BPF_AND, R0, R1),
6436 			BPF_EXIT_INSN(),
6437 		},
6438 		INTERNAL,
6439 		{ },
6440 		{ { 0, 2 } },
6441 	},
6442 	{
6443 		"ALU64_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
6444 		.u.insns_int = {
6445 			BPF_LD_IMM64(R0, 0xffffffff),
6446 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6447 			BPF_ALU64_REG(BPF_AND, R0, R1),
6448 			BPF_EXIT_INSN(),
6449 		},
6450 		INTERNAL,
6451 		{ },
6452 		{ { 0, 0xffffffff } },
6453 	},
6454 	/* BPF_ALU | BPF_AND | BPF_K */
6455 	{
6456 		"ALU_AND_K: 3 & 2 = 2",
6457 		.u.insns_int = {
6458 			BPF_LD_IMM64(R0, 3),
6459 			BPF_ALU32_IMM(BPF_AND, R0, 2),
6460 			BPF_EXIT_INSN(),
6461 		},
6462 		INTERNAL,
6463 		{ },
6464 		{ { 0, 2 } },
6465 	},
6466 	{
6467 		"ALU_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
6468 		.u.insns_int = {
6469 			BPF_LD_IMM64(R0, 0xffffffff),
6470 			BPF_ALU32_IMM(BPF_AND, R0, 0xffffffff),
6471 			BPF_EXIT_INSN(),
6472 		},
6473 		INTERNAL,
6474 		{ },
6475 		{ { 0, 0xffffffff } },
6476 	},
6477 	{
6478 		"ALU_AND_K: Small immediate",
6479 		.u.insns_int = {
6480 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
6481 			BPF_ALU32_IMM(BPF_AND, R0, 15),
6482 			BPF_EXIT_INSN(),
6483 		},
6484 		INTERNAL,
6485 		{ },
6486 		{ { 0, 4 } }
6487 	},
6488 	{
6489 		"ALU_AND_K: Large immediate",
6490 		.u.insns_int = {
6491 			BPF_ALU32_IMM(BPF_MOV, R0, 0xf1f2f3f4),
6492 			BPF_ALU32_IMM(BPF_AND, R0, 0xafbfcfdf),
6493 			BPF_EXIT_INSN(),
6494 		},
6495 		INTERNAL,
6496 		{ },
6497 		{ { 0, 0xa1b2c3d4 } }
6498 	},
6499 	{
6500 		"ALU_AND_K: Zero extension",
6501 		.u.insns_int = {
6502 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6503 			BPF_LD_IMM64(R1, 0x0000000080a0c0e0LL),
6504 			BPF_ALU32_IMM(BPF_AND, R0, 0xf0f0f0f0),
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_AND_K: 3 & 2 = 2",
6517 		.u.insns_int = {
6518 			BPF_LD_IMM64(R0, 3),
6519 			BPF_ALU64_IMM(BPF_AND, R0, 2),
6520 			BPF_EXIT_INSN(),
6521 		},
6522 		INTERNAL,
6523 		{ },
6524 		{ { 0, 2 } },
6525 	},
6526 	{
6527 		"ALU64_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
6528 		.u.insns_int = {
6529 			BPF_LD_IMM64(R0, 0xffffffff),
6530 			BPF_ALU64_IMM(BPF_AND, R0, 0xffffffff),
6531 			BPF_EXIT_INSN(),
6532 		},
6533 		INTERNAL,
6534 		{ },
6535 		{ { 0, 0xffffffff } },
6536 	},
6537 	{
6538 		"ALU64_AND_K: 0x0000ffffffff0000 & 0x0 = 0x0000000000000000",
6539 		.u.insns_int = {
6540 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6541 			BPF_LD_IMM64(R3, 0x0000000000000000LL),
6542 			BPF_ALU64_IMM(BPF_AND, R2, 0x0),
6543 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6544 			BPF_MOV32_IMM(R0, 2),
6545 			BPF_EXIT_INSN(),
6546 			BPF_MOV32_IMM(R0, 1),
6547 			BPF_EXIT_INSN(),
6548 		},
6549 		INTERNAL,
6550 		{ },
6551 		{ { 0, 0x1 } },
6552 	},
6553 	{
6554 		"ALU64_AND_K: 0x0000ffffffff0000 & -1 = 0x0000ffffffff0000",
6555 		.u.insns_int = {
6556 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6557 			BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
6558 			BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
6559 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6560 			BPF_MOV32_IMM(R0, 2),
6561 			BPF_EXIT_INSN(),
6562 			BPF_MOV32_IMM(R0, 1),
6563 			BPF_EXIT_INSN(),
6564 		},
6565 		INTERNAL,
6566 		{ },
6567 		{ { 0, 0x1 } },
6568 	},
6569 	{
6570 		"ALU64_AND_K: 0xffffffffffffffff & -1 = 0xffffffffffffffff",
6571 		.u.insns_int = {
6572 			BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
6573 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
6574 			BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
6575 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6576 			BPF_MOV32_IMM(R0, 2),
6577 			BPF_EXIT_INSN(),
6578 			BPF_MOV32_IMM(R0, 1),
6579 			BPF_EXIT_INSN(),
6580 		},
6581 		INTERNAL,
6582 		{ },
6583 		{ { 0, 0x1 } },
6584 	},
6585 	{
6586 		"ALU64_AND_K: Sign extension 1",
6587 		.u.insns_int = {
6588 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6589 			BPF_LD_IMM64(R1, 0x00000000090b0d0fLL),
6590 			BPF_ALU64_IMM(BPF_AND, R0, 0x0f0f0f0f),
6591 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6592 			BPF_MOV32_IMM(R0, 2),
6593 			BPF_EXIT_INSN(),
6594 			BPF_MOV32_IMM(R0, 1),
6595 			BPF_EXIT_INSN(),
6596 		},
6597 		INTERNAL,
6598 		{ },
6599 		{ { 0, 1 } }
6600 	},
6601 	{
6602 		"ALU64_AND_K: Sign extension 2",
6603 		.u.insns_int = {
6604 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6605 			BPF_LD_IMM64(R1, 0x0123456780a0c0e0LL),
6606 			BPF_ALU64_IMM(BPF_AND, R0, 0xf0f0f0f0),
6607 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6608 			BPF_MOV32_IMM(R0, 2),
6609 			BPF_EXIT_INSN(),
6610 			BPF_MOV32_IMM(R0, 1),
6611 			BPF_EXIT_INSN(),
6612 		},
6613 		INTERNAL,
6614 		{ },
6615 		{ { 0, 1 } }
6616 	},
6617 	/* BPF_ALU | BPF_OR | BPF_X */
6618 	{
6619 		"ALU_OR_X: 1 | 2 = 3",
6620 		.u.insns_int = {
6621 			BPF_LD_IMM64(R0, 1),
6622 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
6623 			BPF_ALU32_REG(BPF_OR, R0, R1),
6624 			BPF_EXIT_INSN(),
6625 		},
6626 		INTERNAL,
6627 		{ },
6628 		{ { 0, 3 } },
6629 	},
6630 	{
6631 		"ALU_OR_X: 0x0 | 0xffffffff = 0xffffffff",
6632 		.u.insns_int = {
6633 			BPF_LD_IMM64(R0, 0),
6634 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6635 			BPF_ALU32_REG(BPF_OR, R0, R1),
6636 			BPF_EXIT_INSN(),
6637 		},
6638 		INTERNAL,
6639 		{ },
6640 		{ { 0, 0xffffffff } },
6641 	},
6642 	{
6643 		"ALU64_OR_X: 1 | 2 = 3",
6644 		.u.insns_int = {
6645 			BPF_LD_IMM64(R0, 1),
6646 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
6647 			BPF_ALU64_REG(BPF_OR, R0, R1),
6648 			BPF_EXIT_INSN(),
6649 		},
6650 		INTERNAL,
6651 		{ },
6652 		{ { 0, 3 } },
6653 	},
6654 	{
6655 		"ALU64_OR_X: 0 | 0xffffffff = 0xffffffff",
6656 		.u.insns_int = {
6657 			BPF_LD_IMM64(R0, 0),
6658 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6659 			BPF_ALU64_REG(BPF_OR, R0, R1),
6660 			BPF_EXIT_INSN(),
6661 		},
6662 		INTERNAL,
6663 		{ },
6664 		{ { 0, 0xffffffff } },
6665 	},
6666 	/* BPF_ALU | BPF_OR | BPF_K */
6667 	{
6668 		"ALU_OR_K: 1 | 2 = 3",
6669 		.u.insns_int = {
6670 			BPF_LD_IMM64(R0, 1),
6671 			BPF_ALU32_IMM(BPF_OR, R0, 2),
6672 			BPF_EXIT_INSN(),
6673 		},
6674 		INTERNAL,
6675 		{ },
6676 		{ { 0, 3 } },
6677 	},
6678 	{
6679 		"ALU_OR_K: 0 & 0xffffffff = 0xffffffff",
6680 		.u.insns_int = {
6681 			BPF_LD_IMM64(R0, 0),
6682 			BPF_ALU32_IMM(BPF_OR, R0, 0xffffffff),
6683 			BPF_EXIT_INSN(),
6684 		},
6685 		INTERNAL,
6686 		{ },
6687 		{ { 0, 0xffffffff } },
6688 	},
6689 	{
6690 		"ALU_OR_K: Small immediate",
6691 		.u.insns_int = {
6692 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
6693 			BPF_ALU32_IMM(BPF_OR, R0, 1),
6694 			BPF_EXIT_INSN(),
6695 		},
6696 		INTERNAL,
6697 		{ },
6698 		{ { 0, 0x01020305 } }
6699 	},
6700 	{
6701 		"ALU_OR_K: Large immediate",
6702 		.u.insns_int = {
6703 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
6704 			BPF_ALU32_IMM(BPF_OR, R0, 0xa0b0c0d0),
6705 			BPF_EXIT_INSN(),
6706 		},
6707 		INTERNAL,
6708 		{ },
6709 		{ { 0, 0xa1b2c3d4 } }
6710 	},
6711 	{
6712 		"ALU_OR_K: Zero extension",
6713 		.u.insns_int = {
6714 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6715 			BPF_LD_IMM64(R1, 0x00000000f9fbfdffLL),
6716 			BPF_ALU32_IMM(BPF_OR, R0, 0xf0f0f0f0),
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_OR_K: 1 | 2 = 3",
6729 		.u.insns_int = {
6730 			BPF_LD_IMM64(R0, 1),
6731 			BPF_ALU64_IMM(BPF_OR, R0, 2),
6732 			BPF_EXIT_INSN(),
6733 		},
6734 		INTERNAL,
6735 		{ },
6736 		{ { 0, 3 } },
6737 	},
6738 	{
6739 		"ALU64_OR_K: 0 & 0xffffffff = 0xffffffff",
6740 		.u.insns_int = {
6741 			BPF_LD_IMM64(R0, 0),
6742 			BPF_ALU64_IMM(BPF_OR, R0, 0xffffffff),
6743 			BPF_EXIT_INSN(),
6744 		},
6745 		INTERNAL,
6746 		{ },
6747 		{ { 0, 0xffffffff } },
6748 	},
6749 	{
6750 		"ALU64_OR_K: 0x0000ffffffff0000 | 0x0 = 0x0000ffffffff0000",
6751 		.u.insns_int = {
6752 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6753 			BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
6754 			BPF_ALU64_IMM(BPF_OR, R2, 0x0),
6755 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6756 			BPF_MOV32_IMM(R0, 2),
6757 			BPF_EXIT_INSN(),
6758 			BPF_MOV32_IMM(R0, 1),
6759 			BPF_EXIT_INSN(),
6760 		},
6761 		INTERNAL,
6762 		{ },
6763 		{ { 0, 0x1 } },
6764 	},
6765 	{
6766 		"ALU64_OR_K: 0x0000ffffffff0000 | -1 = 0xffffffffffffffff",
6767 		.u.insns_int = {
6768 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6769 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
6770 			BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
6771 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6772 			BPF_MOV32_IMM(R0, 2),
6773 			BPF_EXIT_INSN(),
6774 			BPF_MOV32_IMM(R0, 1),
6775 			BPF_EXIT_INSN(),
6776 		},
6777 		INTERNAL,
6778 		{ },
6779 		{ { 0, 0x1 } },
6780 	},
6781 	{
6782 		"ALU64_OR_K: 0x000000000000000 | -1 = 0xffffffffffffffff",
6783 		.u.insns_int = {
6784 			BPF_LD_IMM64(R2, 0x0000000000000000LL),
6785 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
6786 			BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
6787 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6788 			BPF_MOV32_IMM(R0, 2),
6789 			BPF_EXIT_INSN(),
6790 			BPF_MOV32_IMM(R0, 1),
6791 			BPF_EXIT_INSN(),
6792 		},
6793 		INTERNAL,
6794 		{ },
6795 		{ { 0, 0x1 } },
6796 	},
6797 	{
6798 		"ALU64_OR_K: Sign extension 1",
6799 		.u.insns_int = {
6800 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6801 			BPF_LD_IMM64(R1, 0x012345678fafcfefLL),
6802 			BPF_ALU64_IMM(BPF_OR, R0, 0x0f0f0f0f),
6803 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6804 			BPF_MOV32_IMM(R0, 2),
6805 			BPF_EXIT_INSN(),
6806 			BPF_MOV32_IMM(R0, 1),
6807 			BPF_EXIT_INSN(),
6808 		},
6809 		INTERNAL,
6810 		{ },
6811 		{ { 0, 1 } }
6812 	},
6813 	{
6814 		"ALU64_OR_K: Sign extension 2",
6815 		.u.insns_int = {
6816 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6817 			BPF_LD_IMM64(R1, 0xfffffffff9fbfdffLL),
6818 			BPF_ALU64_IMM(BPF_OR, R0, 0xf0f0f0f0),
6819 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6820 			BPF_MOV32_IMM(R0, 2),
6821 			BPF_EXIT_INSN(),
6822 			BPF_MOV32_IMM(R0, 1),
6823 			BPF_EXIT_INSN(),
6824 		},
6825 		INTERNAL,
6826 		{ },
6827 		{ { 0, 1 } }
6828 	},
6829 	/* BPF_ALU | BPF_XOR | BPF_X */
6830 	{
6831 		"ALU_XOR_X: 5 ^ 6 = 3",
6832 		.u.insns_int = {
6833 			BPF_LD_IMM64(R0, 5),
6834 			BPF_ALU32_IMM(BPF_MOV, R1, 6),
6835 			BPF_ALU32_REG(BPF_XOR, R0, R1),
6836 			BPF_EXIT_INSN(),
6837 		},
6838 		INTERNAL,
6839 		{ },
6840 		{ { 0, 3 } },
6841 	},
6842 	{
6843 		"ALU_XOR_X: 0x1 ^ 0xffffffff = 0xfffffffe",
6844 		.u.insns_int = {
6845 			BPF_LD_IMM64(R0, 1),
6846 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6847 			BPF_ALU32_REG(BPF_XOR, R0, R1),
6848 			BPF_EXIT_INSN(),
6849 		},
6850 		INTERNAL,
6851 		{ },
6852 		{ { 0, 0xfffffffe } },
6853 	},
6854 	{
6855 		"ALU64_XOR_X: 5 ^ 6 = 3",
6856 		.u.insns_int = {
6857 			BPF_LD_IMM64(R0, 5),
6858 			BPF_ALU32_IMM(BPF_MOV, R1, 6),
6859 			BPF_ALU64_REG(BPF_XOR, R0, R1),
6860 			BPF_EXIT_INSN(),
6861 		},
6862 		INTERNAL,
6863 		{ },
6864 		{ { 0, 3 } },
6865 	},
6866 	{
6867 		"ALU64_XOR_X: 1 ^ 0xffffffff = 0xfffffffe",
6868 		.u.insns_int = {
6869 			BPF_LD_IMM64(R0, 1),
6870 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6871 			BPF_ALU64_REG(BPF_XOR, R0, R1),
6872 			BPF_EXIT_INSN(),
6873 		},
6874 		INTERNAL,
6875 		{ },
6876 		{ { 0, 0xfffffffe } },
6877 	},
6878 	/* BPF_ALU | BPF_XOR | BPF_K */
6879 	{
6880 		"ALU_XOR_K: 5 ^ 6 = 3",
6881 		.u.insns_int = {
6882 			BPF_LD_IMM64(R0, 5),
6883 			BPF_ALU32_IMM(BPF_XOR, R0, 6),
6884 			BPF_EXIT_INSN(),
6885 		},
6886 		INTERNAL,
6887 		{ },
6888 		{ { 0, 3 } },
6889 	},
6890 	{
6891 		"ALU_XOR_K: 1 ^ 0xffffffff = 0xfffffffe",
6892 		.u.insns_int = {
6893 			BPF_LD_IMM64(R0, 1),
6894 			BPF_ALU32_IMM(BPF_XOR, R0, 0xffffffff),
6895 			BPF_EXIT_INSN(),
6896 		},
6897 		INTERNAL,
6898 		{ },
6899 		{ { 0, 0xfffffffe } },
6900 	},
6901 	{
6902 		"ALU_XOR_K: Small immediate",
6903 		.u.insns_int = {
6904 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
6905 			BPF_ALU32_IMM(BPF_XOR, R0, 15),
6906 			BPF_EXIT_INSN(),
6907 		},
6908 		INTERNAL,
6909 		{ },
6910 		{ { 0, 0x0102030b } }
6911 	},
6912 	{
6913 		"ALU_XOR_K: Large immediate",
6914 		.u.insns_int = {
6915 			BPF_ALU32_IMM(BPF_MOV, R0, 0xf1f2f3f4),
6916 			BPF_ALU32_IMM(BPF_XOR, R0, 0xafbfcfdf),
6917 			BPF_EXIT_INSN(),
6918 		},
6919 		INTERNAL,
6920 		{ },
6921 		{ { 0, 0x5e4d3c2b } }
6922 	},
6923 	{
6924 		"ALU_XOR_K: Zero extension",
6925 		.u.insns_int = {
6926 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6927 			BPF_LD_IMM64(R1, 0x00000000795b3d1fLL),
6928 			BPF_ALU32_IMM(BPF_XOR, R0, 0xf0f0f0f0),
6929 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6930 			BPF_MOV32_IMM(R0, 2),
6931 			BPF_EXIT_INSN(),
6932 			BPF_MOV32_IMM(R0, 1),
6933 			BPF_EXIT_INSN(),
6934 		},
6935 		INTERNAL,
6936 		{ },
6937 		{ { 0, 1 } }
6938 	},
6939 	{
6940 		"ALU64_XOR_K: 5 ^ 6 = 3",
6941 		.u.insns_int = {
6942 			BPF_LD_IMM64(R0, 5),
6943 			BPF_ALU64_IMM(BPF_XOR, R0, 6),
6944 			BPF_EXIT_INSN(),
6945 		},
6946 		INTERNAL,
6947 		{ },
6948 		{ { 0, 3 } },
6949 	},
6950 	{
6951 		"ALU64_XOR_K: 1 ^ 0xffffffff = 0xfffffffe",
6952 		.u.insns_int = {
6953 			BPF_LD_IMM64(R0, 1),
6954 			BPF_ALU64_IMM(BPF_XOR, R0, 0xffffffff),
6955 			BPF_EXIT_INSN(),
6956 		},
6957 		INTERNAL,
6958 		{ },
6959 		{ { 0, 0xfffffffe } },
6960 	},
6961 	{
6962 		"ALU64_XOR_K: 0x0000ffffffff0000 ^ 0x0 = 0x0000ffffffff0000",
6963 		.u.insns_int = {
6964 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6965 			BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
6966 			BPF_ALU64_IMM(BPF_XOR, R2, 0x0),
6967 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6968 			BPF_MOV32_IMM(R0, 2),
6969 			BPF_EXIT_INSN(),
6970 			BPF_MOV32_IMM(R0, 1),
6971 			BPF_EXIT_INSN(),
6972 		},
6973 		INTERNAL,
6974 		{ },
6975 		{ { 0, 0x1 } },
6976 	},
6977 	{
6978 		"ALU64_XOR_K: 0x0000ffffffff0000 ^ -1 = 0xffff00000000ffff",
6979 		.u.insns_int = {
6980 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6981 			BPF_LD_IMM64(R3, 0xffff00000000ffffLL),
6982 			BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
6983 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6984 			BPF_MOV32_IMM(R0, 2),
6985 			BPF_EXIT_INSN(),
6986 			BPF_MOV32_IMM(R0, 1),
6987 			BPF_EXIT_INSN(),
6988 		},
6989 		INTERNAL,
6990 		{ },
6991 		{ { 0, 0x1 } },
6992 	},
6993 	{
6994 		"ALU64_XOR_K: 0x000000000000000 ^ -1 = 0xffffffffffffffff",
6995 		.u.insns_int = {
6996 			BPF_LD_IMM64(R2, 0x0000000000000000LL),
6997 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
6998 			BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
6999 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
7000 			BPF_MOV32_IMM(R0, 2),
7001 			BPF_EXIT_INSN(),
7002 			BPF_MOV32_IMM(R0, 1),
7003 			BPF_EXIT_INSN(),
7004 		},
7005 		INTERNAL,
7006 		{ },
7007 		{ { 0, 0x1 } },
7008 	},
7009 	{
7010 		"ALU64_XOR_K: Sign extension 1",
7011 		.u.insns_int = {
7012 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7013 			BPF_LD_IMM64(R1, 0x0123456786a4c2e0LL),
7014 			BPF_ALU64_IMM(BPF_XOR, R0, 0x0f0f0f0f),
7015 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
7016 			BPF_MOV32_IMM(R0, 2),
7017 			BPF_EXIT_INSN(),
7018 			BPF_MOV32_IMM(R0, 1),
7019 			BPF_EXIT_INSN(),
7020 		},
7021 		INTERNAL,
7022 		{ },
7023 		{ { 0, 1 } }
7024 	},
7025 	{
7026 		"ALU64_XOR_K: Sign extension 2",
7027 		.u.insns_int = {
7028 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7029 			BPF_LD_IMM64(R1, 0xfedcba98795b3d1fLL),
7030 			BPF_ALU64_IMM(BPF_XOR, R0, 0xf0f0f0f0),
7031 			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
7032 			BPF_MOV32_IMM(R0, 2),
7033 			BPF_EXIT_INSN(),
7034 			BPF_MOV32_IMM(R0, 1),
7035 			BPF_EXIT_INSN(),
7036 		},
7037 		INTERNAL,
7038 		{ },
7039 		{ { 0, 1 } }
7040 	},
7041 	/* BPF_ALU | BPF_LSH | BPF_X */
7042 	{
7043 		"ALU_LSH_X: 1 << 1 = 2",
7044 		.u.insns_int = {
7045 			BPF_LD_IMM64(R0, 1),
7046 			BPF_ALU32_IMM(BPF_MOV, R1, 1),
7047 			BPF_ALU32_REG(BPF_LSH, R0, R1),
7048 			BPF_EXIT_INSN(),
7049 		},
7050 		INTERNAL,
7051 		{ },
7052 		{ { 0, 2 } },
7053 	},
7054 	{
7055 		"ALU_LSH_X: 1 << 31 = 0x80000000",
7056 		.u.insns_int = {
7057 			BPF_LD_IMM64(R0, 1),
7058 			BPF_ALU32_IMM(BPF_MOV, R1, 31),
7059 			BPF_ALU32_REG(BPF_LSH, R0, R1),
7060 			BPF_EXIT_INSN(),
7061 		},
7062 		INTERNAL,
7063 		{ },
7064 		{ { 0, 0x80000000 } },
7065 	},
7066 	{
7067 		"ALU_LSH_X: 0x12345678 << 12 = 0x45678000",
7068 		.u.insns_int = {
7069 			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
7070 			BPF_ALU32_IMM(BPF_MOV, R1, 12),
7071 			BPF_ALU32_REG(BPF_LSH, R0, R1),
7072 			BPF_EXIT_INSN(),
7073 		},
7074 		INTERNAL,
7075 		{ },
7076 		{ { 0, 0x45678000 } }
7077 	},
7078 	{
7079 		"ALU64_LSH_X: 1 << 1 = 2",
7080 		.u.insns_int = {
7081 			BPF_LD_IMM64(R0, 1),
7082 			BPF_ALU32_IMM(BPF_MOV, R1, 1),
7083 			BPF_ALU64_REG(BPF_LSH, R0, R1),
7084 			BPF_EXIT_INSN(),
7085 		},
7086 		INTERNAL,
7087 		{ },
7088 		{ { 0, 2 } },
7089 	},
7090 	{
7091 		"ALU64_LSH_X: 1 << 31 = 0x80000000",
7092 		.u.insns_int = {
7093 			BPF_LD_IMM64(R0, 1),
7094 			BPF_ALU32_IMM(BPF_MOV, R1, 31),
7095 			BPF_ALU64_REG(BPF_LSH, R0, R1),
7096 			BPF_EXIT_INSN(),
7097 		},
7098 		INTERNAL,
7099 		{ },
7100 		{ { 0, 0x80000000 } },
7101 	},
7102 	{
7103 		"ALU64_LSH_X: Shift < 32, low word",
7104 		.u.insns_int = {
7105 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7106 			BPF_ALU32_IMM(BPF_MOV, R1, 12),
7107 			BPF_ALU64_REG(BPF_LSH, R0, R1),
7108 			BPF_EXIT_INSN(),
7109 		},
7110 		INTERNAL,
7111 		{ },
7112 		{ { 0, 0xbcdef000 } }
7113 	},
7114 	{
7115 		"ALU64_LSH_X: Shift < 32, high word",
7116 		.u.insns_int = {
7117 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7118 			BPF_ALU32_IMM(BPF_MOV, R1, 12),
7119 			BPF_ALU64_REG(BPF_LSH, R0, R1),
7120 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7121 			BPF_EXIT_INSN(),
7122 		},
7123 		INTERNAL,
7124 		{ },
7125 		{ { 0, 0x3456789a } }
7126 	},
7127 	{
7128 		"ALU64_LSH_X: Shift > 32, low word",
7129 		.u.insns_int = {
7130 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7131 			BPF_ALU32_IMM(BPF_MOV, R1, 36),
7132 			BPF_ALU64_REG(BPF_LSH, R0, R1),
7133 			BPF_EXIT_INSN(),
7134 		},
7135 		INTERNAL,
7136 		{ },
7137 		{ { 0, 0 } }
7138 	},
7139 	{
7140 		"ALU64_LSH_X: Shift > 32, high word",
7141 		.u.insns_int = {
7142 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7143 			BPF_ALU32_IMM(BPF_MOV, R1, 36),
7144 			BPF_ALU64_REG(BPF_LSH, R0, R1),
7145 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7146 			BPF_EXIT_INSN(),
7147 		},
7148 		INTERNAL,
7149 		{ },
7150 		{ { 0, 0x9abcdef0 } }
7151 	},
7152 	{
7153 		"ALU64_LSH_X: Shift == 32, low word",
7154 		.u.insns_int = {
7155 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7156 			BPF_ALU32_IMM(BPF_MOV, R1, 32),
7157 			BPF_ALU64_REG(BPF_LSH, R0, R1),
7158 			BPF_EXIT_INSN(),
7159 		},
7160 		INTERNAL,
7161 		{ },
7162 		{ { 0, 0 } }
7163 	},
7164 	{
7165 		"ALU64_LSH_X: Shift == 32, high word",
7166 		.u.insns_int = {
7167 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7168 			BPF_ALU32_IMM(BPF_MOV, R1, 32),
7169 			BPF_ALU64_REG(BPF_LSH, R0, R1),
7170 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7171 			BPF_EXIT_INSN(),
7172 		},
7173 		INTERNAL,
7174 		{ },
7175 		{ { 0, 0x89abcdef } }
7176 	},
7177 	{
7178 		"ALU64_LSH_X: Zero shift, low word",
7179 		.u.insns_int = {
7180 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7181 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
7182 			BPF_ALU64_REG(BPF_LSH, R0, R1),
7183 			BPF_EXIT_INSN(),
7184 		},
7185 		INTERNAL,
7186 		{ },
7187 		{ { 0, 0x89abcdef } }
7188 	},
7189 	{
7190 		"ALU64_LSH_X: Zero shift, high word",
7191 		.u.insns_int = {
7192 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7193 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
7194 			BPF_ALU64_REG(BPF_LSH, R0, R1),
7195 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7196 			BPF_EXIT_INSN(),
7197 		},
7198 		INTERNAL,
7199 		{ },
7200 		{ { 0, 0x01234567 } }
7201 	},
7202 	/* BPF_ALU | BPF_LSH | BPF_K */
7203 	{
7204 		"ALU_LSH_K: 1 << 1 = 2",
7205 		.u.insns_int = {
7206 			BPF_LD_IMM64(R0, 1),
7207 			BPF_ALU32_IMM(BPF_LSH, R0, 1),
7208 			BPF_EXIT_INSN(),
7209 		},
7210 		INTERNAL,
7211 		{ },
7212 		{ { 0, 2 } },
7213 	},
7214 	{
7215 		"ALU_LSH_K: 1 << 31 = 0x80000000",
7216 		.u.insns_int = {
7217 			BPF_LD_IMM64(R0, 1),
7218 			BPF_ALU32_IMM(BPF_LSH, R0, 31),
7219 			BPF_EXIT_INSN(),
7220 		},
7221 		INTERNAL,
7222 		{ },
7223 		{ { 0, 0x80000000 } },
7224 	},
7225 	{
7226 		"ALU_LSH_K: 0x12345678 << 12 = 0x45678000",
7227 		.u.insns_int = {
7228 			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
7229 			BPF_ALU32_IMM(BPF_LSH, R0, 12),
7230 			BPF_EXIT_INSN(),
7231 		},
7232 		INTERNAL,
7233 		{ },
7234 		{ { 0, 0x45678000 } }
7235 	},
7236 	{
7237 		"ALU_LSH_K: 0x12345678 << 0 = 0x12345678",
7238 		.u.insns_int = {
7239 			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
7240 			BPF_ALU32_IMM(BPF_LSH, R0, 0),
7241 			BPF_EXIT_INSN(),
7242 		},
7243 		INTERNAL,
7244 		{ },
7245 		{ { 0, 0x12345678 } }
7246 	},
7247 	{
7248 		"ALU64_LSH_K: 1 << 1 = 2",
7249 		.u.insns_int = {
7250 			BPF_LD_IMM64(R0, 1),
7251 			BPF_ALU64_IMM(BPF_LSH, R0, 1),
7252 			BPF_EXIT_INSN(),
7253 		},
7254 		INTERNAL,
7255 		{ },
7256 		{ { 0, 2 } },
7257 	},
7258 	{
7259 		"ALU64_LSH_K: 1 << 31 = 0x80000000",
7260 		.u.insns_int = {
7261 			BPF_LD_IMM64(R0, 1),
7262 			BPF_ALU64_IMM(BPF_LSH, R0, 31),
7263 			BPF_EXIT_INSN(),
7264 		},
7265 		INTERNAL,
7266 		{ },
7267 		{ { 0, 0x80000000 } },
7268 	},
7269 	{
7270 		"ALU64_LSH_K: Shift < 32, low word",
7271 		.u.insns_int = {
7272 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7273 			BPF_ALU64_IMM(BPF_LSH, R0, 12),
7274 			BPF_EXIT_INSN(),
7275 		},
7276 		INTERNAL,
7277 		{ },
7278 		{ { 0, 0xbcdef000 } }
7279 	},
7280 	{
7281 		"ALU64_LSH_K: Shift < 32, high word",
7282 		.u.insns_int = {
7283 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7284 			BPF_ALU64_IMM(BPF_LSH, R0, 12),
7285 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7286 			BPF_EXIT_INSN(),
7287 		},
7288 		INTERNAL,
7289 		{ },
7290 		{ { 0, 0x3456789a } }
7291 	},
7292 	{
7293 		"ALU64_LSH_K: Shift > 32, low word",
7294 		.u.insns_int = {
7295 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7296 			BPF_ALU64_IMM(BPF_LSH, R0, 36),
7297 			BPF_EXIT_INSN(),
7298 		},
7299 		INTERNAL,
7300 		{ },
7301 		{ { 0, 0 } }
7302 	},
7303 	{
7304 		"ALU64_LSH_K: Shift > 32, high word",
7305 		.u.insns_int = {
7306 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7307 			BPF_ALU64_IMM(BPF_LSH, R0, 36),
7308 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7309 			BPF_EXIT_INSN(),
7310 		},
7311 		INTERNAL,
7312 		{ },
7313 		{ { 0, 0x9abcdef0 } }
7314 	},
7315 	{
7316 		"ALU64_LSH_K: Shift == 32, low word",
7317 		.u.insns_int = {
7318 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7319 			BPF_ALU64_IMM(BPF_LSH, R0, 32),
7320 			BPF_EXIT_INSN(),
7321 		},
7322 		INTERNAL,
7323 		{ },
7324 		{ { 0, 0 } }
7325 	},
7326 	{
7327 		"ALU64_LSH_K: Shift == 32, high word",
7328 		.u.insns_int = {
7329 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7330 			BPF_ALU64_IMM(BPF_LSH, R0, 32),
7331 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7332 			BPF_EXIT_INSN(),
7333 		},
7334 		INTERNAL,
7335 		{ },
7336 		{ { 0, 0x89abcdef } }
7337 	},
7338 	{
7339 		"ALU64_LSH_K: Zero shift",
7340 		.u.insns_int = {
7341 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7342 			BPF_ALU64_IMM(BPF_LSH, R0, 0),
7343 			BPF_EXIT_INSN(),
7344 		},
7345 		INTERNAL,
7346 		{ },
7347 		{ { 0, 0x89abcdef } }
7348 	},
7349 	/* BPF_ALU | BPF_RSH | BPF_X */
7350 	{
7351 		"ALU_RSH_X: 2 >> 1 = 1",
7352 		.u.insns_int = {
7353 			BPF_LD_IMM64(R0, 2),
7354 			BPF_ALU32_IMM(BPF_MOV, R1, 1),
7355 			BPF_ALU32_REG(BPF_RSH, R0, R1),
7356 			BPF_EXIT_INSN(),
7357 		},
7358 		INTERNAL,
7359 		{ },
7360 		{ { 0, 1 } },
7361 	},
7362 	{
7363 		"ALU_RSH_X: 0x80000000 >> 31 = 1",
7364 		.u.insns_int = {
7365 			BPF_LD_IMM64(R0, 0x80000000),
7366 			BPF_ALU32_IMM(BPF_MOV, R1, 31),
7367 			BPF_ALU32_REG(BPF_RSH, R0, R1),
7368 			BPF_EXIT_INSN(),
7369 		},
7370 		INTERNAL,
7371 		{ },
7372 		{ { 0, 1 } },
7373 	},
7374 	{
7375 		"ALU_RSH_X: 0x12345678 >> 20 = 0x123",
7376 		.u.insns_int = {
7377 			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
7378 			BPF_ALU32_IMM(BPF_MOV, R1, 20),
7379 			BPF_ALU32_REG(BPF_RSH, R0, R1),
7380 			BPF_EXIT_INSN(),
7381 		},
7382 		INTERNAL,
7383 		{ },
7384 		{ { 0, 0x123 } }
7385 	},
7386 	{
7387 		"ALU64_RSH_X: 2 >> 1 = 1",
7388 		.u.insns_int = {
7389 			BPF_LD_IMM64(R0, 2),
7390 			BPF_ALU32_IMM(BPF_MOV, R1, 1),
7391 			BPF_ALU64_REG(BPF_RSH, R0, R1),
7392 			BPF_EXIT_INSN(),
7393 		},
7394 		INTERNAL,
7395 		{ },
7396 		{ { 0, 1 } },
7397 	},
7398 	{
7399 		"ALU64_RSH_X: 0x80000000 >> 31 = 1",
7400 		.u.insns_int = {
7401 			BPF_LD_IMM64(R0, 0x80000000),
7402 			BPF_ALU32_IMM(BPF_MOV, R1, 31),
7403 			BPF_ALU64_REG(BPF_RSH, R0, R1),
7404 			BPF_EXIT_INSN(),
7405 		},
7406 		INTERNAL,
7407 		{ },
7408 		{ { 0, 1 } },
7409 	},
7410 	{
7411 		"ALU64_RSH_X: Shift < 32, low word",
7412 		.u.insns_int = {
7413 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7414 			BPF_ALU32_IMM(BPF_MOV, R1, 12),
7415 			BPF_ALU64_REG(BPF_RSH, R0, R1),
7416 			BPF_EXIT_INSN(),
7417 		},
7418 		INTERNAL,
7419 		{ },
7420 		{ { 0, 0x56789abc } }
7421 	},
7422 	{
7423 		"ALU64_RSH_X: Shift < 32, high word",
7424 		.u.insns_int = {
7425 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7426 			BPF_ALU32_IMM(BPF_MOV, R1, 12),
7427 			BPF_ALU64_REG(BPF_RSH, R0, R1),
7428 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7429 			BPF_EXIT_INSN(),
7430 		},
7431 		INTERNAL,
7432 		{ },
7433 		{ { 0, 0x00081234 } }
7434 	},
7435 	{
7436 		"ALU64_RSH_X: Shift > 32, low word",
7437 		.u.insns_int = {
7438 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7439 			BPF_ALU32_IMM(BPF_MOV, R1, 36),
7440 			BPF_ALU64_REG(BPF_RSH, R0, R1),
7441 			BPF_EXIT_INSN(),
7442 		},
7443 		INTERNAL,
7444 		{ },
7445 		{ { 0, 0x08123456 } }
7446 	},
7447 	{
7448 		"ALU64_RSH_X: Shift > 32, high word",
7449 		.u.insns_int = {
7450 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7451 			BPF_ALU32_IMM(BPF_MOV, R1, 36),
7452 			BPF_ALU64_REG(BPF_RSH, R0, R1),
7453 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7454 			BPF_EXIT_INSN(),
7455 		},
7456 		INTERNAL,
7457 		{ },
7458 		{ { 0, 0 } }
7459 	},
7460 	{
7461 		"ALU64_RSH_X: Shift == 32, low word",
7462 		.u.insns_int = {
7463 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7464 			BPF_ALU32_IMM(BPF_MOV, R1, 32),
7465 			BPF_ALU64_REG(BPF_RSH, R0, R1),
7466 			BPF_EXIT_INSN(),
7467 		},
7468 		INTERNAL,
7469 		{ },
7470 		{ { 0, 0x81234567 } }
7471 	},
7472 	{
7473 		"ALU64_RSH_X: Shift == 32, high word",
7474 		.u.insns_int = {
7475 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7476 			BPF_ALU32_IMM(BPF_MOV, R1, 32),
7477 			BPF_ALU64_REG(BPF_RSH, R0, R1),
7478 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7479 			BPF_EXIT_INSN(),
7480 		},
7481 		INTERNAL,
7482 		{ },
7483 		{ { 0, 0 } }
7484 	},
7485 	{
7486 		"ALU64_RSH_X: Zero shift, low word",
7487 		.u.insns_int = {
7488 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7489 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
7490 			BPF_ALU64_REG(BPF_RSH, R0, R1),
7491 			BPF_EXIT_INSN(),
7492 		},
7493 		INTERNAL,
7494 		{ },
7495 		{ { 0, 0x89abcdef } }
7496 	},
7497 	{
7498 		"ALU64_RSH_X: Zero shift, high word",
7499 		.u.insns_int = {
7500 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7501 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
7502 			BPF_ALU64_REG(BPF_RSH, R0, R1),
7503 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7504 			BPF_EXIT_INSN(),
7505 		},
7506 		INTERNAL,
7507 		{ },
7508 		{ { 0, 0x81234567 } }
7509 	},
7510 	/* BPF_ALU | BPF_RSH | BPF_K */
7511 	{
7512 		"ALU_RSH_K: 2 >> 1 = 1",
7513 		.u.insns_int = {
7514 			BPF_LD_IMM64(R0, 2),
7515 			BPF_ALU32_IMM(BPF_RSH, R0, 1),
7516 			BPF_EXIT_INSN(),
7517 		},
7518 		INTERNAL,
7519 		{ },
7520 		{ { 0, 1 } },
7521 	},
7522 	{
7523 		"ALU_RSH_K: 0x80000000 >> 31 = 1",
7524 		.u.insns_int = {
7525 			BPF_LD_IMM64(R0, 0x80000000),
7526 			BPF_ALU32_IMM(BPF_RSH, R0, 31),
7527 			BPF_EXIT_INSN(),
7528 		},
7529 		INTERNAL,
7530 		{ },
7531 		{ { 0, 1 } },
7532 	},
7533 	{
7534 		"ALU_RSH_K: 0x12345678 >> 20 = 0x123",
7535 		.u.insns_int = {
7536 			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
7537 			BPF_ALU32_IMM(BPF_RSH, R0, 20),
7538 			BPF_EXIT_INSN(),
7539 		},
7540 		INTERNAL,
7541 		{ },
7542 		{ { 0, 0x123 } }
7543 	},
7544 	{
7545 		"ALU_RSH_K: 0x12345678 >> 0 = 0x12345678",
7546 		.u.insns_int = {
7547 			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
7548 			BPF_ALU32_IMM(BPF_RSH, R0, 0),
7549 			BPF_EXIT_INSN(),
7550 		},
7551 		INTERNAL,
7552 		{ },
7553 		{ { 0, 0x12345678 } }
7554 	},
7555 	{
7556 		"ALU64_RSH_K: 2 >> 1 = 1",
7557 		.u.insns_int = {
7558 			BPF_LD_IMM64(R0, 2),
7559 			BPF_ALU64_IMM(BPF_RSH, R0, 1),
7560 			BPF_EXIT_INSN(),
7561 		},
7562 		INTERNAL,
7563 		{ },
7564 		{ { 0, 1 } },
7565 	},
7566 	{
7567 		"ALU64_RSH_K: 0x80000000 >> 31 = 1",
7568 		.u.insns_int = {
7569 			BPF_LD_IMM64(R0, 0x80000000),
7570 			BPF_ALU64_IMM(BPF_RSH, R0, 31),
7571 			BPF_EXIT_INSN(),
7572 		},
7573 		INTERNAL,
7574 		{ },
7575 		{ { 0, 1 } },
7576 	},
7577 	{
7578 		"ALU64_RSH_K: Shift < 32, low word",
7579 		.u.insns_int = {
7580 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7581 			BPF_ALU64_IMM(BPF_RSH, R0, 12),
7582 			BPF_EXIT_INSN(),
7583 		},
7584 		INTERNAL,
7585 		{ },
7586 		{ { 0, 0x56789abc } }
7587 	},
7588 	{
7589 		"ALU64_RSH_K: Shift < 32, high word",
7590 		.u.insns_int = {
7591 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7592 			BPF_ALU64_IMM(BPF_RSH, R0, 12),
7593 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7594 			BPF_EXIT_INSN(),
7595 		},
7596 		INTERNAL,
7597 		{ },
7598 		{ { 0, 0x00081234 } }
7599 	},
7600 	{
7601 		"ALU64_RSH_K: Shift > 32, low word",
7602 		.u.insns_int = {
7603 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7604 			BPF_ALU64_IMM(BPF_RSH, R0, 36),
7605 			BPF_EXIT_INSN(),
7606 		},
7607 		INTERNAL,
7608 		{ },
7609 		{ { 0, 0x08123456 } }
7610 	},
7611 	{
7612 		"ALU64_RSH_K: Shift > 32, high word",
7613 		.u.insns_int = {
7614 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7615 			BPF_ALU64_IMM(BPF_RSH, R0, 36),
7616 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7617 			BPF_EXIT_INSN(),
7618 		},
7619 		INTERNAL,
7620 		{ },
7621 		{ { 0, 0 } }
7622 	},
7623 	{
7624 		"ALU64_RSH_K: Shift == 32, low word",
7625 		.u.insns_int = {
7626 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7627 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7628 			BPF_EXIT_INSN(),
7629 		},
7630 		INTERNAL,
7631 		{ },
7632 		{ { 0, 0x81234567 } }
7633 	},
7634 	{
7635 		"ALU64_RSH_K: Shift == 32, high word",
7636 		.u.insns_int = {
7637 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7638 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7639 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7640 			BPF_EXIT_INSN(),
7641 		},
7642 		INTERNAL,
7643 		{ },
7644 		{ { 0, 0 } }
7645 	},
7646 	{
7647 		"ALU64_RSH_K: Zero shift",
7648 		.u.insns_int = {
7649 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7650 			BPF_ALU64_IMM(BPF_RSH, R0, 0),
7651 			BPF_EXIT_INSN(),
7652 		},
7653 		INTERNAL,
7654 		{ },
7655 		{ { 0, 0x89abcdef } }
7656 	},
7657 	/* BPF_ALU | BPF_ARSH | BPF_X */
7658 	{
7659 		"ALU32_ARSH_X: -1234 >> 7 = -10",
7660 		.u.insns_int = {
7661 			BPF_ALU32_IMM(BPF_MOV, R0, -1234),
7662 			BPF_ALU32_IMM(BPF_MOV, R1, 7),
7663 			BPF_ALU32_REG(BPF_ARSH, R0, R1),
7664 			BPF_EXIT_INSN(),
7665 		},
7666 		INTERNAL,
7667 		{ },
7668 		{ { 0, -10 } }
7669 	},
7670 	{
7671 		"ALU64_ARSH_X: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
7672 		.u.insns_int = {
7673 			BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
7674 			BPF_ALU32_IMM(BPF_MOV, R1, 40),
7675 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
7676 			BPF_EXIT_INSN(),
7677 		},
7678 		INTERNAL,
7679 		{ },
7680 		{ { 0, 0xffff00ff } },
7681 	},
7682 	{
7683 		"ALU64_ARSH_X: Shift < 32, low word",
7684 		.u.insns_int = {
7685 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7686 			BPF_ALU32_IMM(BPF_MOV, R1, 12),
7687 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
7688 			BPF_EXIT_INSN(),
7689 		},
7690 		INTERNAL,
7691 		{ },
7692 		{ { 0, 0x56789abc } }
7693 	},
7694 	{
7695 		"ALU64_ARSH_X: Shift < 32, high word",
7696 		.u.insns_int = {
7697 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7698 			BPF_ALU32_IMM(BPF_MOV, R1, 12),
7699 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
7700 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7701 			BPF_EXIT_INSN(),
7702 		},
7703 		INTERNAL,
7704 		{ },
7705 		{ { 0, 0xfff81234 } }
7706 	},
7707 	{
7708 		"ALU64_ARSH_X: Shift > 32, low word",
7709 		.u.insns_int = {
7710 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7711 			BPF_ALU32_IMM(BPF_MOV, R1, 36),
7712 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
7713 			BPF_EXIT_INSN(),
7714 		},
7715 		INTERNAL,
7716 		{ },
7717 		{ { 0, 0xf8123456 } }
7718 	},
7719 	{
7720 		"ALU64_ARSH_X: Shift > 32, high word",
7721 		.u.insns_int = {
7722 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7723 			BPF_ALU32_IMM(BPF_MOV, R1, 36),
7724 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
7725 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7726 			BPF_EXIT_INSN(),
7727 		},
7728 		INTERNAL,
7729 		{ },
7730 		{ { 0, -1 } }
7731 	},
7732 	{
7733 		"ALU64_ARSH_X: Shift == 32, low word",
7734 		.u.insns_int = {
7735 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7736 			BPF_ALU32_IMM(BPF_MOV, R1, 32),
7737 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
7738 			BPF_EXIT_INSN(),
7739 		},
7740 		INTERNAL,
7741 		{ },
7742 		{ { 0, 0x81234567 } }
7743 	},
7744 	{
7745 		"ALU64_ARSH_X: Shift == 32, high word",
7746 		.u.insns_int = {
7747 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7748 			BPF_ALU32_IMM(BPF_MOV, R1, 32),
7749 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
7750 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7751 			BPF_EXIT_INSN(),
7752 		},
7753 		INTERNAL,
7754 		{ },
7755 		{ { 0, -1 } }
7756 	},
7757 	{
7758 		"ALU64_ARSH_X: Zero shift, low word",
7759 		.u.insns_int = {
7760 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7761 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
7762 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
7763 			BPF_EXIT_INSN(),
7764 		},
7765 		INTERNAL,
7766 		{ },
7767 		{ { 0, 0x89abcdef } }
7768 	},
7769 	{
7770 		"ALU64_ARSH_X: Zero shift, high word",
7771 		.u.insns_int = {
7772 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7773 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
7774 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
7775 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7776 			BPF_EXIT_INSN(),
7777 		},
7778 		INTERNAL,
7779 		{ },
7780 		{ { 0, 0x81234567 } }
7781 	},
7782 	/* BPF_ALU | BPF_ARSH | BPF_K */
7783 	{
7784 		"ALU32_ARSH_K: -1234 >> 7 = -10",
7785 		.u.insns_int = {
7786 			BPF_ALU32_IMM(BPF_MOV, R0, -1234),
7787 			BPF_ALU32_IMM(BPF_ARSH, R0, 7),
7788 			BPF_EXIT_INSN(),
7789 		},
7790 		INTERNAL,
7791 		{ },
7792 		{ { 0, -10 } }
7793 	},
7794 	{
7795 		"ALU32_ARSH_K: -1234 >> 0 = -1234",
7796 		.u.insns_int = {
7797 			BPF_ALU32_IMM(BPF_MOV, R0, -1234),
7798 			BPF_ALU32_IMM(BPF_ARSH, R0, 0),
7799 			BPF_EXIT_INSN(),
7800 		},
7801 		INTERNAL,
7802 		{ },
7803 		{ { 0, -1234 } }
7804 	},
7805 	{
7806 		"ALU64_ARSH_K: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
7807 		.u.insns_int = {
7808 			BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
7809 			BPF_ALU64_IMM(BPF_ARSH, R0, 40),
7810 			BPF_EXIT_INSN(),
7811 		},
7812 		INTERNAL,
7813 		{ },
7814 		{ { 0, 0xffff00ff } },
7815 	},
7816 	{
7817 		"ALU64_ARSH_K: Shift < 32, low word",
7818 		.u.insns_int = {
7819 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7820 			BPF_ALU64_IMM(BPF_RSH, R0, 12),
7821 			BPF_EXIT_INSN(),
7822 		},
7823 		INTERNAL,
7824 		{ },
7825 		{ { 0, 0x56789abc } }
7826 	},
7827 	{
7828 		"ALU64_ARSH_K: Shift < 32, high word",
7829 		.u.insns_int = {
7830 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7831 			BPF_ALU64_IMM(BPF_ARSH, R0, 12),
7832 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7833 			BPF_EXIT_INSN(),
7834 		},
7835 		INTERNAL,
7836 		{ },
7837 		{ { 0, 0xfff81234 } }
7838 	},
7839 	{
7840 		"ALU64_ARSH_K: Shift > 32, low word",
7841 		.u.insns_int = {
7842 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7843 			BPF_ALU64_IMM(BPF_ARSH, R0, 36),
7844 			BPF_EXIT_INSN(),
7845 		},
7846 		INTERNAL,
7847 		{ },
7848 		{ { 0, 0xf8123456 } }
7849 	},
7850 	{
7851 		"ALU64_ARSH_K: Shift > 32, high word",
7852 		.u.insns_int = {
7853 			BPF_LD_IMM64(R0, 0xf123456789abcdefLL),
7854 			BPF_ALU64_IMM(BPF_ARSH, R0, 36),
7855 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7856 			BPF_EXIT_INSN(),
7857 		},
7858 		INTERNAL,
7859 		{ },
7860 		{ { 0, -1 } }
7861 	},
7862 	{
7863 		"ALU64_ARSH_K: Shift == 32, low word",
7864 		.u.insns_int = {
7865 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7866 			BPF_ALU64_IMM(BPF_ARSH, R0, 32),
7867 			BPF_EXIT_INSN(),
7868 		},
7869 		INTERNAL,
7870 		{ },
7871 		{ { 0, 0x81234567 } }
7872 	},
7873 	{
7874 		"ALU64_ARSH_K: Shift == 32, high word",
7875 		.u.insns_int = {
7876 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7877 			BPF_ALU64_IMM(BPF_ARSH, R0, 32),
7878 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7879 			BPF_EXIT_INSN(),
7880 		},
7881 		INTERNAL,
7882 		{ },
7883 		{ { 0, -1 } }
7884 	},
7885 	{
7886 		"ALU64_ARSH_K: Zero shift",
7887 		.u.insns_int = {
7888 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7889 			BPF_ALU64_IMM(BPF_ARSH, R0, 0),
7890 			BPF_EXIT_INSN(),
7891 		},
7892 		INTERNAL,
7893 		{ },
7894 		{ { 0, 0x89abcdef } }
7895 	},
7896 	/* BPF_ALU | BPF_NEG */
7897 	{
7898 		"ALU_NEG: -(3) = -3",
7899 		.u.insns_int = {
7900 			BPF_ALU32_IMM(BPF_MOV, R0, 3),
7901 			BPF_ALU32_IMM(BPF_NEG, R0, 0),
7902 			BPF_EXIT_INSN(),
7903 		},
7904 		INTERNAL,
7905 		{ },
7906 		{ { 0, -3 } },
7907 	},
7908 	{
7909 		"ALU_NEG: -(-3) = 3",
7910 		.u.insns_int = {
7911 			BPF_ALU32_IMM(BPF_MOV, R0, -3),
7912 			BPF_ALU32_IMM(BPF_NEG, R0, 0),
7913 			BPF_EXIT_INSN(),
7914 		},
7915 		INTERNAL,
7916 		{ },
7917 		{ { 0, 3 } },
7918 	},
7919 	{
7920 		"ALU64_NEG: -(3) = -3",
7921 		.u.insns_int = {
7922 			BPF_LD_IMM64(R0, 3),
7923 			BPF_ALU64_IMM(BPF_NEG, R0, 0),
7924 			BPF_EXIT_INSN(),
7925 		},
7926 		INTERNAL,
7927 		{ },
7928 		{ { 0, -3 } },
7929 	},
7930 	{
7931 		"ALU64_NEG: -(-3) = 3",
7932 		.u.insns_int = {
7933 			BPF_LD_IMM64(R0, -3),
7934 			BPF_ALU64_IMM(BPF_NEG, R0, 0),
7935 			BPF_EXIT_INSN(),
7936 		},
7937 		INTERNAL,
7938 		{ },
7939 		{ { 0, 3 } },
7940 	},
7941 	/* BPF_ALU | BPF_END | BPF_FROM_BE */
7942 	{
7943 		"ALU_END_FROM_BE 16: 0x0123456789abcdef -> 0xcdef",
7944 		.u.insns_int = {
7945 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7946 			BPF_ENDIAN(BPF_FROM_BE, R0, 16),
7947 			BPF_EXIT_INSN(),
7948 		},
7949 		INTERNAL,
7950 		{ },
7951 		{ { 0,  cpu_to_be16(0xcdef) } },
7952 	},
7953 	{
7954 		"ALU_END_FROM_BE 32: 0x0123456789abcdef -> 0x89abcdef",
7955 		.u.insns_int = {
7956 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7957 			BPF_ENDIAN(BPF_FROM_BE, R0, 32),
7958 			BPF_ALU64_REG(BPF_MOV, R1, R0),
7959 			BPF_ALU64_IMM(BPF_RSH, R1, 32),
7960 			BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
7961 			BPF_EXIT_INSN(),
7962 		},
7963 		INTERNAL,
7964 		{ },
7965 		{ { 0, cpu_to_be32(0x89abcdef) } },
7966 	},
7967 	{
7968 		"ALU_END_FROM_BE 64: 0x0123456789abcdef -> 0x89abcdef",
7969 		.u.insns_int = {
7970 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7971 			BPF_ENDIAN(BPF_FROM_BE, R0, 64),
7972 			BPF_EXIT_INSN(),
7973 		},
7974 		INTERNAL,
7975 		{ },
7976 		{ { 0, (u32) cpu_to_be64(0x0123456789abcdefLL) } },
7977 	},
7978 	{
7979 		"ALU_END_FROM_BE 64: 0x0123456789abcdef >> 32 -> 0x01234567",
7980 		.u.insns_int = {
7981 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7982 			BPF_ENDIAN(BPF_FROM_BE, R0, 64),
7983 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7984 			BPF_EXIT_INSN(),
7985 		},
7986 		INTERNAL,
7987 		{ },
7988 		{ { 0, (u32) (cpu_to_be64(0x0123456789abcdefLL) >> 32) } },
7989 	},
7990 	/* BPF_ALU | BPF_END | BPF_FROM_BE, reversed */
7991 	{
7992 		"ALU_END_FROM_BE 16: 0xfedcba9876543210 -> 0x3210",
7993 		.u.insns_int = {
7994 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7995 			BPF_ENDIAN(BPF_FROM_BE, R0, 16),
7996 			BPF_EXIT_INSN(),
7997 		},
7998 		INTERNAL,
7999 		{ },
8000 		{ { 0,  cpu_to_be16(0x3210) } },
8001 	},
8002 	{
8003 		"ALU_END_FROM_BE 32: 0xfedcba9876543210 -> 0x76543210",
8004 		.u.insns_int = {
8005 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
8006 			BPF_ENDIAN(BPF_FROM_BE, R0, 32),
8007 			BPF_ALU64_REG(BPF_MOV, R1, R0),
8008 			BPF_ALU64_IMM(BPF_RSH, R1, 32),
8009 			BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
8010 			BPF_EXIT_INSN(),
8011 		},
8012 		INTERNAL,
8013 		{ },
8014 		{ { 0, cpu_to_be32(0x76543210) } },
8015 	},
8016 	{
8017 		"ALU_END_FROM_BE 64: 0xfedcba9876543210 -> 0x76543210",
8018 		.u.insns_int = {
8019 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
8020 			BPF_ENDIAN(BPF_FROM_BE, R0, 64),
8021 			BPF_EXIT_INSN(),
8022 		},
8023 		INTERNAL,
8024 		{ },
8025 		{ { 0, (u32) cpu_to_be64(0xfedcba9876543210ULL) } },
8026 	},
8027 	{
8028 		"ALU_END_FROM_BE 64: 0xfedcba9876543210 >> 32 -> 0xfedcba98",
8029 		.u.insns_int = {
8030 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
8031 			BPF_ENDIAN(BPF_FROM_BE, R0, 64),
8032 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
8033 			BPF_EXIT_INSN(),
8034 		},
8035 		INTERNAL,
8036 		{ },
8037 		{ { 0, (u32) (cpu_to_be64(0xfedcba9876543210ULL) >> 32) } },
8038 	},
8039 	/* BPF_ALU | BPF_END | BPF_FROM_LE */
8040 	{
8041 		"ALU_END_FROM_LE 16: 0x0123456789abcdef -> 0xefcd",
8042 		.u.insns_int = {
8043 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
8044 			BPF_ENDIAN(BPF_FROM_LE, R0, 16),
8045 			BPF_EXIT_INSN(),
8046 		},
8047 		INTERNAL,
8048 		{ },
8049 		{ { 0, cpu_to_le16(0xcdef) } },
8050 	},
8051 	{
8052 		"ALU_END_FROM_LE 32: 0x0123456789abcdef -> 0xefcdab89",
8053 		.u.insns_int = {
8054 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
8055 			BPF_ENDIAN(BPF_FROM_LE, R0, 32),
8056 			BPF_ALU64_REG(BPF_MOV, R1, R0),
8057 			BPF_ALU64_IMM(BPF_RSH, R1, 32),
8058 			BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
8059 			BPF_EXIT_INSN(),
8060 		},
8061 		INTERNAL,
8062 		{ },
8063 		{ { 0, cpu_to_le32(0x89abcdef) } },
8064 	},
8065 	{
8066 		"ALU_END_FROM_LE 64: 0x0123456789abcdef -> 0x67452301",
8067 		.u.insns_int = {
8068 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
8069 			BPF_ENDIAN(BPF_FROM_LE, R0, 64),
8070 			BPF_EXIT_INSN(),
8071 		},
8072 		INTERNAL,
8073 		{ },
8074 		{ { 0, (u32) cpu_to_le64(0x0123456789abcdefLL) } },
8075 	},
8076 	{
8077 		"ALU_END_FROM_LE 64: 0x0123456789abcdef >> 32 -> 0xefcdab89",
8078 		.u.insns_int = {
8079 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
8080 			BPF_ENDIAN(BPF_FROM_LE, R0, 64),
8081 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
8082 			BPF_EXIT_INSN(),
8083 		},
8084 		INTERNAL,
8085 		{ },
8086 		{ { 0, (u32) (cpu_to_le64(0x0123456789abcdefLL) >> 32) } },
8087 	},
8088 	/* BPF_ALU | BPF_END | BPF_FROM_LE, reversed */
8089 	{
8090 		"ALU_END_FROM_LE 16: 0xfedcba9876543210 -> 0x1032",
8091 		.u.insns_int = {
8092 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
8093 			BPF_ENDIAN(BPF_FROM_LE, R0, 16),
8094 			BPF_EXIT_INSN(),
8095 		},
8096 		INTERNAL,
8097 		{ },
8098 		{ { 0,  cpu_to_le16(0x3210) } },
8099 	},
8100 	{
8101 		"ALU_END_FROM_LE 32: 0xfedcba9876543210 -> 0x10325476",
8102 		.u.insns_int = {
8103 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
8104 			BPF_ENDIAN(BPF_FROM_LE, R0, 32),
8105 			BPF_ALU64_REG(BPF_MOV, R1, R0),
8106 			BPF_ALU64_IMM(BPF_RSH, R1, 32),
8107 			BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
8108 			BPF_EXIT_INSN(),
8109 		},
8110 		INTERNAL,
8111 		{ },
8112 		{ { 0, cpu_to_le32(0x76543210) } },
8113 	},
8114 	{
8115 		"ALU_END_FROM_LE 64: 0xfedcba9876543210 -> 0x10325476",
8116 		.u.insns_int = {
8117 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
8118 			BPF_ENDIAN(BPF_FROM_LE, R0, 64),
8119 			BPF_EXIT_INSN(),
8120 		},
8121 		INTERNAL,
8122 		{ },
8123 		{ { 0, (u32) cpu_to_le64(0xfedcba9876543210ULL) } },
8124 	},
8125 	{
8126 		"ALU_END_FROM_LE 64: 0xfedcba9876543210 >> 32 -> 0x98badcfe",
8127 		.u.insns_int = {
8128 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
8129 			BPF_ENDIAN(BPF_FROM_LE, R0, 64),
8130 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
8131 			BPF_EXIT_INSN(),
8132 		},
8133 		INTERNAL,
8134 		{ },
8135 		{ { 0, (u32) (cpu_to_le64(0xfedcba9876543210ULL) >> 32) } },
8136 	},
8137 	/* BSWAP */
8138 	{
8139 		"BSWAP 16: 0x0123456789abcdef -> 0xefcd",
8140 		.u.insns_int = {
8141 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
8142 			BPF_BSWAP(R0, 16),
8143 			BPF_EXIT_INSN(),
8144 		},
8145 		INTERNAL,
8146 		{ },
8147 		{ { 0, 0xefcd } },
8148 	},
8149 	{
8150 		"BSWAP 32: 0x0123456789abcdef -> 0xefcdab89",
8151 		.u.insns_int = {
8152 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
8153 			BPF_BSWAP(R0, 32),
8154 			BPF_ALU64_REG(BPF_MOV, R1, R0),
8155 			BPF_ALU64_IMM(BPF_RSH, R1, 32),
8156 			BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
8157 			BPF_EXIT_INSN(),
8158 		},
8159 		INTERNAL,
8160 		{ },
8161 		{ { 0, 0xefcdab89 } },
8162 	},
8163 	{
8164 		"BSWAP 64: 0x0123456789abcdef -> 0x67452301",
8165 		.u.insns_int = {
8166 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
8167 			BPF_BSWAP(R0, 64),
8168 			BPF_EXIT_INSN(),
8169 		},
8170 		INTERNAL,
8171 		{ },
8172 		{ { 0, 0x67452301 } },
8173 	},
8174 	{
8175 		"BSWAP 64: 0x0123456789abcdef >> 32 -> 0xefcdab89",
8176 		.u.insns_int = {
8177 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
8178 			BPF_BSWAP(R0, 64),
8179 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
8180 			BPF_EXIT_INSN(),
8181 		},
8182 		INTERNAL,
8183 		{ },
8184 		{ { 0, 0xefcdab89 } },
8185 	},
8186 	/* BSWAP, reversed */
8187 	{
8188 		"BSWAP 16: 0xfedcba9876543210 -> 0x1032",
8189 		.u.insns_int = {
8190 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
8191 			BPF_BSWAP(R0, 16),
8192 			BPF_EXIT_INSN(),
8193 		},
8194 		INTERNAL,
8195 		{ },
8196 		{ { 0, 0x1032 } },
8197 	},
8198 	{
8199 		"BSWAP 32: 0xfedcba9876543210 -> 0x10325476",
8200 		.u.insns_int = {
8201 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
8202 			BPF_BSWAP(R0, 32),
8203 			BPF_ALU64_REG(BPF_MOV, R1, R0),
8204 			BPF_ALU64_IMM(BPF_RSH, R1, 32),
8205 			BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
8206 			BPF_EXIT_INSN(),
8207 		},
8208 		INTERNAL,
8209 		{ },
8210 		{ { 0, 0x10325476 } },
8211 	},
8212 	{
8213 		"BSWAP 64: 0xfedcba9876543210 -> 0x98badcfe",
8214 		.u.insns_int = {
8215 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
8216 			BPF_BSWAP(R0, 64),
8217 			BPF_EXIT_INSN(),
8218 		},
8219 		INTERNAL,
8220 		{ },
8221 		{ { 0, 0x98badcfe } },
8222 	},
8223 	{
8224 		"BSWAP 64: 0xfedcba9876543210 >> 32 -> 0x10325476",
8225 		.u.insns_int = {
8226 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
8227 			BPF_BSWAP(R0, 64),
8228 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
8229 			BPF_EXIT_INSN(),
8230 		},
8231 		INTERNAL,
8232 		{ },
8233 		{ { 0, 0x10325476 } },
8234 	},
8235 	/* BPF_LDX_MEM B/H/W/DW */
8236 	{
8237 		"BPF_LDX_MEM | BPF_B, base",
8238 		.u.insns_int = {
8239 			BPF_LD_IMM64(R1, 0x0102030405060708ULL),
8240 			BPF_LD_IMM64(R2, 0x0000000000000008ULL),
8241 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
8242 #ifdef __BIG_ENDIAN
8243 			BPF_LDX_MEM(BPF_B, R0, R10, -1),
8244 #else
8245 			BPF_LDX_MEM(BPF_B, R0, R10, -8),
8246 #endif
8247 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8248 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8249 			BPF_EXIT_INSN(),
8250 		},
8251 		INTERNAL,
8252 		{ },
8253 		{ { 0, 0 } },
8254 		.stack_depth = 8,
8255 	},
8256 	{
8257 		"BPF_LDX_MEM | BPF_B, MSB set",
8258 		.u.insns_int = {
8259 			BPF_LD_IMM64(R1, 0x8182838485868788ULL),
8260 			BPF_LD_IMM64(R2, 0x0000000000000088ULL),
8261 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
8262 #ifdef __BIG_ENDIAN
8263 			BPF_LDX_MEM(BPF_B, R0, R10, -1),
8264 #else
8265 			BPF_LDX_MEM(BPF_B, R0, R10, -8),
8266 #endif
8267 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8268 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8269 			BPF_EXIT_INSN(),
8270 		},
8271 		INTERNAL,
8272 		{ },
8273 		{ { 0, 0 } },
8274 		.stack_depth = 8,
8275 	},
8276 	{
8277 		"BPF_LDX_MEM | BPF_B, negative offset",
8278 		.u.insns_int = {
8279 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8280 			BPF_LD_IMM64(R3, 0x0000000000000088ULL),
8281 			BPF_ALU64_IMM(BPF_ADD, R1, 512),
8282 			BPF_STX_MEM(BPF_B, R1, R2, -256),
8283 			BPF_LDX_MEM(BPF_B, R0, R1, -256),
8284 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8285 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8286 			BPF_EXIT_INSN(),
8287 		},
8288 		INTERNAL | FLAG_LARGE_MEM,
8289 		{ },
8290 		{ { 512, 0 } },
8291 		.stack_depth = 0,
8292 	},
8293 	{
8294 		"BPF_LDX_MEM | BPF_B, small positive offset",
8295 		.u.insns_int = {
8296 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8297 			BPF_LD_IMM64(R3, 0x0000000000000088ULL),
8298 			BPF_STX_MEM(BPF_B, R1, R2, 256),
8299 			BPF_LDX_MEM(BPF_B, R0, R1, 256),
8300 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8301 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8302 			BPF_EXIT_INSN(),
8303 		},
8304 		INTERNAL | FLAG_LARGE_MEM,
8305 		{ },
8306 		{ { 512, 0 } },
8307 		.stack_depth = 0,
8308 	},
8309 	{
8310 		"BPF_LDX_MEM | BPF_B, large positive offset",
8311 		.u.insns_int = {
8312 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8313 			BPF_LD_IMM64(R3, 0x0000000000000088ULL),
8314 			BPF_STX_MEM(BPF_B, R1, R2, 4096),
8315 			BPF_LDX_MEM(BPF_B, R0, R1, 4096),
8316 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8317 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8318 			BPF_EXIT_INSN(),
8319 		},
8320 		INTERNAL | FLAG_LARGE_MEM,
8321 		{ },
8322 		{ { 4096 + 16, 0 } },
8323 		.stack_depth = 0,
8324 	},
8325 	{
8326 		"BPF_LDX_MEM | BPF_H, base",
8327 		.u.insns_int = {
8328 			BPF_LD_IMM64(R1, 0x0102030405060708ULL),
8329 			BPF_LD_IMM64(R2, 0x0000000000000708ULL),
8330 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
8331 #ifdef __BIG_ENDIAN
8332 			BPF_LDX_MEM(BPF_H, R0, R10, -2),
8333 #else
8334 			BPF_LDX_MEM(BPF_H, R0, R10, -8),
8335 #endif
8336 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8337 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8338 			BPF_EXIT_INSN(),
8339 		},
8340 		INTERNAL,
8341 		{ },
8342 		{ { 0, 0 } },
8343 		.stack_depth = 8,
8344 	},
8345 	{
8346 		"BPF_LDX_MEM | BPF_H, MSB set",
8347 		.u.insns_int = {
8348 			BPF_LD_IMM64(R1, 0x8182838485868788ULL),
8349 			BPF_LD_IMM64(R2, 0x0000000000008788ULL),
8350 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
8351 #ifdef __BIG_ENDIAN
8352 			BPF_LDX_MEM(BPF_H, R0, R10, -2),
8353 #else
8354 			BPF_LDX_MEM(BPF_H, R0, R10, -8),
8355 #endif
8356 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8357 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8358 			BPF_EXIT_INSN(),
8359 		},
8360 		INTERNAL,
8361 		{ },
8362 		{ { 0, 0 } },
8363 		.stack_depth = 8,
8364 	},
8365 	{
8366 		"BPF_LDX_MEM | BPF_H, negative offset",
8367 		.u.insns_int = {
8368 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8369 			BPF_LD_IMM64(R3, 0x0000000000008788ULL),
8370 			BPF_ALU64_IMM(BPF_ADD, R1, 512),
8371 			BPF_STX_MEM(BPF_H, R1, R2, -256),
8372 			BPF_LDX_MEM(BPF_H, R0, R1, -256),
8373 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8374 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8375 			BPF_EXIT_INSN(),
8376 		},
8377 		INTERNAL | FLAG_LARGE_MEM,
8378 		{ },
8379 		{ { 512, 0 } },
8380 		.stack_depth = 0,
8381 	},
8382 	{
8383 		"BPF_LDX_MEM | BPF_H, small positive offset",
8384 		.u.insns_int = {
8385 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8386 			BPF_LD_IMM64(R3, 0x0000000000008788ULL),
8387 			BPF_STX_MEM(BPF_H, R1, R2, 256),
8388 			BPF_LDX_MEM(BPF_H, R0, R1, 256),
8389 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8390 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8391 			BPF_EXIT_INSN(),
8392 		},
8393 		INTERNAL | FLAG_LARGE_MEM,
8394 		{ },
8395 		{ { 512, 0 } },
8396 		.stack_depth = 0,
8397 	},
8398 	{
8399 		"BPF_LDX_MEM | BPF_H, large positive offset",
8400 		.u.insns_int = {
8401 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8402 			BPF_LD_IMM64(R3, 0x0000000000008788ULL),
8403 			BPF_STX_MEM(BPF_H, R1, R2, 8192),
8404 			BPF_LDX_MEM(BPF_H, R0, R1, 8192),
8405 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8406 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8407 			BPF_EXIT_INSN(),
8408 		},
8409 		INTERNAL | FLAG_LARGE_MEM,
8410 		{ },
8411 		{ { 8192 + 16, 0 } },
8412 		.stack_depth = 0,
8413 	},
8414 	{
8415 		"BPF_LDX_MEM | BPF_H, unaligned positive offset",
8416 		.u.insns_int = {
8417 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8418 			BPF_LD_IMM64(R3, 0x0000000000008788ULL),
8419 			BPF_STX_MEM(BPF_H, R1, R2, 13),
8420 			BPF_LDX_MEM(BPF_H, R0, R1, 13),
8421 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8422 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8423 			BPF_EXIT_INSN(),
8424 		},
8425 		INTERNAL | FLAG_LARGE_MEM,
8426 		{ },
8427 		{ { 32, 0 } },
8428 		.stack_depth = 0,
8429 	},
8430 	{
8431 		"BPF_LDX_MEM | BPF_W, base",
8432 		.u.insns_int = {
8433 			BPF_LD_IMM64(R1, 0x0102030405060708ULL),
8434 			BPF_LD_IMM64(R2, 0x0000000005060708ULL),
8435 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
8436 #ifdef __BIG_ENDIAN
8437 			BPF_LDX_MEM(BPF_W, R0, R10, -4),
8438 #else
8439 			BPF_LDX_MEM(BPF_W, R0, R10, -8),
8440 #endif
8441 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8442 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8443 			BPF_EXIT_INSN(),
8444 		},
8445 		INTERNAL,
8446 		{ },
8447 		{ { 0, 0 } },
8448 		.stack_depth = 8,
8449 	},
8450 	{
8451 		"BPF_LDX_MEM | BPF_W, MSB set",
8452 		.u.insns_int = {
8453 			BPF_LD_IMM64(R1, 0x8182838485868788ULL),
8454 			BPF_LD_IMM64(R2, 0x0000000085868788ULL),
8455 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
8456 #ifdef __BIG_ENDIAN
8457 			BPF_LDX_MEM(BPF_W, R0, R10, -4),
8458 #else
8459 			BPF_LDX_MEM(BPF_W, R0, R10, -8),
8460 #endif
8461 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8462 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8463 			BPF_EXIT_INSN(),
8464 		},
8465 		INTERNAL,
8466 		{ },
8467 		{ { 0, 0 } },
8468 		.stack_depth = 8,
8469 	},
8470 	{
8471 		"BPF_LDX_MEM | BPF_W, negative offset",
8472 		.u.insns_int = {
8473 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8474 			BPF_LD_IMM64(R3, 0x0000000085868788ULL),
8475 			BPF_ALU64_IMM(BPF_ADD, R1, 512),
8476 			BPF_STX_MEM(BPF_W, R1, R2, -256),
8477 			BPF_LDX_MEM(BPF_W, R0, R1, -256),
8478 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8479 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8480 			BPF_EXIT_INSN(),
8481 		},
8482 		INTERNAL | FLAG_LARGE_MEM,
8483 		{ },
8484 		{ { 512, 0 } },
8485 		.stack_depth = 0,
8486 	},
8487 	{
8488 		"BPF_LDX_MEM | BPF_W, small positive offset",
8489 		.u.insns_int = {
8490 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8491 			BPF_LD_IMM64(R3, 0x0000000085868788ULL),
8492 			BPF_STX_MEM(BPF_W, R1, R2, 256),
8493 			BPF_LDX_MEM(BPF_W, R0, R1, 256),
8494 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8495 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8496 			BPF_EXIT_INSN(),
8497 		},
8498 		INTERNAL | FLAG_LARGE_MEM,
8499 		{ },
8500 		{ { 512, 0 } },
8501 		.stack_depth = 0,
8502 	},
8503 	{
8504 		"BPF_LDX_MEM | BPF_W, large positive offset",
8505 		.u.insns_int = {
8506 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8507 			BPF_LD_IMM64(R3, 0x0000000085868788ULL),
8508 			BPF_STX_MEM(BPF_W, R1, R2, 16384),
8509 			BPF_LDX_MEM(BPF_W, R0, R1, 16384),
8510 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8511 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8512 			BPF_EXIT_INSN(),
8513 		},
8514 		INTERNAL | FLAG_LARGE_MEM,
8515 		{ },
8516 		{ { 16384 + 16, 0 } },
8517 		.stack_depth = 0,
8518 	},
8519 	{
8520 		"BPF_LDX_MEM | BPF_W, unaligned positive offset",
8521 		.u.insns_int = {
8522 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8523 			BPF_LD_IMM64(R3, 0x0000000085868788ULL),
8524 			BPF_STX_MEM(BPF_W, R1, R2, 13),
8525 			BPF_LDX_MEM(BPF_W, R0, R1, 13),
8526 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8527 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8528 			BPF_EXIT_INSN(),
8529 		},
8530 		INTERNAL | FLAG_LARGE_MEM,
8531 		{ },
8532 		{ { 32, 0 } },
8533 		.stack_depth = 0,
8534 	},
8535 	{
8536 		"BPF_LDX_MEM | BPF_DW, base",
8537 		.u.insns_int = {
8538 			BPF_LD_IMM64(R1, 0x0102030405060708ULL),
8539 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
8540 			BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8541 			BPF_JMP_REG(BPF_JNE, R0, R1, 1),
8542 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8543 			BPF_EXIT_INSN(),
8544 		},
8545 		INTERNAL,
8546 		{ },
8547 		{ { 0, 0 } },
8548 		.stack_depth = 8,
8549 	},
8550 	{
8551 		"BPF_LDX_MEM | BPF_DW, MSB set",
8552 		.u.insns_int = {
8553 			BPF_LD_IMM64(R1, 0x8182838485868788ULL),
8554 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
8555 			BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8556 			BPF_JMP_REG(BPF_JNE, R0, R1, 1),
8557 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8558 			BPF_EXIT_INSN(),
8559 		},
8560 		INTERNAL,
8561 		{ },
8562 		{ { 0, 0 } },
8563 		.stack_depth = 8,
8564 	},
8565 	{
8566 		"BPF_LDX_MEM | BPF_DW, negative offset",
8567 		.u.insns_int = {
8568 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8569 			BPF_ALU64_IMM(BPF_ADD, R1, 512),
8570 			BPF_STX_MEM(BPF_DW, R1, R2, -256),
8571 			BPF_LDX_MEM(BPF_DW, R0, R1, -256),
8572 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8573 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8574 			BPF_EXIT_INSN(),
8575 		},
8576 		INTERNAL | FLAG_LARGE_MEM,
8577 		{ },
8578 		{ { 512, 0 } },
8579 		.stack_depth = 0,
8580 	},
8581 	{
8582 		"BPF_LDX_MEM | BPF_DW, small positive offset",
8583 		.u.insns_int = {
8584 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8585 			BPF_STX_MEM(BPF_DW, R1, R2, 256),
8586 			BPF_LDX_MEM(BPF_DW, R0, R1, 256),
8587 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8588 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8589 			BPF_EXIT_INSN(),
8590 		},
8591 		INTERNAL | FLAG_LARGE_MEM,
8592 		{ },
8593 		{ { 512, 0 } },
8594 		.stack_depth = 8,
8595 	},
8596 	{
8597 		"BPF_LDX_MEM | BPF_DW, large positive offset",
8598 		.u.insns_int = {
8599 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8600 			BPF_STX_MEM(BPF_DW, R1, R2, 32760),
8601 			BPF_LDX_MEM(BPF_DW, R0, R1, 32760),
8602 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8603 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8604 			BPF_EXIT_INSN(),
8605 		},
8606 		INTERNAL | FLAG_LARGE_MEM,
8607 		{ },
8608 		{ { 32768, 0 } },
8609 		.stack_depth = 0,
8610 	},
8611 	{
8612 		"BPF_LDX_MEM | BPF_DW, unaligned positive offset",
8613 		.u.insns_int = {
8614 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8615 			BPF_STX_MEM(BPF_DW, R1, R2, 13),
8616 			BPF_LDX_MEM(BPF_DW, R0, R1, 13),
8617 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8618 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8619 			BPF_EXIT_INSN(),
8620 		},
8621 		INTERNAL | FLAG_LARGE_MEM,
8622 		{ },
8623 		{ { 32, 0 } },
8624 		.stack_depth = 0,
8625 	},
8626 	/* BPF_LDX_MEMSX B/H/W */
8627 	{
8628 		"BPF_LDX_MEMSX | BPF_B",
8629 		.u.insns_int = {
8630 			BPF_LD_IMM64(R1, 0xdead0000000000f0ULL),
8631 			BPF_LD_IMM64(R2, 0xfffffffffffffff0ULL),
8632 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
8633 #ifdef __BIG_ENDIAN
8634 			BPF_LDX_MEMSX(BPF_B, R0, R10, -1),
8635 #else
8636 			BPF_LDX_MEMSX(BPF_B, R0, R10, -8),
8637 #endif
8638 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8639 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8640 			BPF_EXIT_INSN(),
8641 		},
8642 		INTERNAL,
8643 		{ },
8644 		{ { 0, 0 } },
8645 		.stack_depth = 8,
8646 	},
8647 	{
8648 		"BPF_LDX_MEMSX | BPF_H",
8649 		.u.insns_int = {
8650 			BPF_LD_IMM64(R1, 0xdead00000000f123ULL),
8651 			BPF_LD_IMM64(R2, 0xfffffffffffff123ULL),
8652 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
8653 #ifdef __BIG_ENDIAN
8654 			BPF_LDX_MEMSX(BPF_H, R0, R10, -2),
8655 #else
8656 			BPF_LDX_MEMSX(BPF_H, R0, R10, -8),
8657 #endif
8658 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8659 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8660 			BPF_EXIT_INSN(),
8661 		},
8662 		INTERNAL,
8663 		{ },
8664 		{ { 0, 0 } },
8665 		.stack_depth = 8,
8666 	},
8667 	{
8668 		"BPF_LDX_MEMSX | BPF_W",
8669 		.u.insns_int = {
8670 			BPF_LD_IMM64(R1, 0x00000000deadbeefULL),
8671 			BPF_LD_IMM64(R2, 0xffffffffdeadbeefULL),
8672 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
8673 #ifdef __BIG_ENDIAN
8674 			BPF_LDX_MEMSX(BPF_W, R0, R10, -4),
8675 #else
8676 			BPF_LDX_MEMSX(BPF_W, R0, R10, -8),
8677 #endif
8678 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8679 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8680 			BPF_EXIT_INSN(),
8681 		},
8682 		INTERNAL,
8683 		{ },
8684 		{ { 0, 0 } },
8685 		.stack_depth = 8,
8686 	},
8687 	/* BPF_STX_MEM B/H/W/DW */
8688 	{
8689 		"BPF_STX_MEM | BPF_B",
8690 		.u.insns_int = {
8691 			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8692 			BPF_LD_IMM64(R2, 0x0102030405060708ULL),
8693 			BPF_LD_IMM64(R3, 0x8090a0b0c0d0e008ULL),
8694 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
8695 #ifdef __BIG_ENDIAN
8696 			BPF_STX_MEM(BPF_B, R10, R2, -1),
8697 #else
8698 			BPF_STX_MEM(BPF_B, R10, R2, -8),
8699 #endif
8700 			BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8701 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8702 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8703 			BPF_EXIT_INSN(),
8704 		},
8705 		INTERNAL,
8706 		{ },
8707 		{ { 0, 0 } },
8708 		.stack_depth = 8,
8709 	},
8710 	{
8711 		"BPF_STX_MEM | BPF_B, MSB set",
8712 		.u.insns_int = {
8713 			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8714 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8715 			BPF_LD_IMM64(R3, 0x8090a0b0c0d0e088ULL),
8716 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
8717 #ifdef __BIG_ENDIAN
8718 			BPF_STX_MEM(BPF_B, R10, R2, -1),
8719 #else
8720 			BPF_STX_MEM(BPF_B, R10, R2, -8),
8721 #endif
8722 			BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8723 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8724 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8725 			BPF_EXIT_INSN(),
8726 		},
8727 		INTERNAL,
8728 		{ },
8729 		{ { 0, 0 } },
8730 		.stack_depth = 8,
8731 	},
8732 	{
8733 		"BPF_STX_MEM | BPF_H",
8734 		.u.insns_int = {
8735 			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8736 			BPF_LD_IMM64(R2, 0x0102030405060708ULL),
8737 			BPF_LD_IMM64(R3, 0x8090a0b0c0d00708ULL),
8738 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
8739 #ifdef __BIG_ENDIAN
8740 			BPF_STX_MEM(BPF_H, R10, R2, -2),
8741 #else
8742 			BPF_STX_MEM(BPF_H, R10, R2, -8),
8743 #endif
8744 			BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8745 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8746 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8747 			BPF_EXIT_INSN(),
8748 		},
8749 		INTERNAL,
8750 		{ },
8751 		{ { 0, 0 } },
8752 		.stack_depth = 8,
8753 	},
8754 	{
8755 		"BPF_STX_MEM | BPF_H, MSB set",
8756 		.u.insns_int = {
8757 			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8758 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8759 			BPF_LD_IMM64(R3, 0x8090a0b0c0d08788ULL),
8760 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
8761 #ifdef __BIG_ENDIAN
8762 			BPF_STX_MEM(BPF_H, R10, R2, -2),
8763 #else
8764 			BPF_STX_MEM(BPF_H, R10, R2, -8),
8765 #endif
8766 			BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8767 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8768 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8769 			BPF_EXIT_INSN(),
8770 		},
8771 		INTERNAL,
8772 		{ },
8773 		{ { 0, 0 } },
8774 		.stack_depth = 8,
8775 	},
8776 	{
8777 		"BPF_STX_MEM | BPF_W",
8778 		.u.insns_int = {
8779 			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8780 			BPF_LD_IMM64(R2, 0x0102030405060708ULL),
8781 			BPF_LD_IMM64(R3, 0x8090a0b005060708ULL),
8782 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
8783 #ifdef __BIG_ENDIAN
8784 			BPF_STX_MEM(BPF_W, R10, R2, -4),
8785 #else
8786 			BPF_STX_MEM(BPF_W, R10, R2, -8),
8787 #endif
8788 			BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8789 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8790 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8791 			BPF_EXIT_INSN(),
8792 		},
8793 		INTERNAL,
8794 		{ },
8795 		{ { 0, 0 } },
8796 		.stack_depth = 8,
8797 	},
8798 	{
8799 		"BPF_STX_MEM | BPF_W, MSB set",
8800 		.u.insns_int = {
8801 			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8802 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8803 			BPF_LD_IMM64(R3, 0x8090a0b085868788ULL),
8804 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
8805 #ifdef __BIG_ENDIAN
8806 			BPF_STX_MEM(BPF_W, R10, R2, -4),
8807 #else
8808 			BPF_STX_MEM(BPF_W, R10, R2, -8),
8809 #endif
8810 			BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8811 			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8812 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8813 			BPF_EXIT_INSN(),
8814 		},
8815 		INTERNAL,
8816 		{ },
8817 		{ { 0, 0 } },
8818 		.stack_depth = 8,
8819 	},
8820 	/* BPF_ST(X) | BPF_MEM | BPF_B/H/W/DW */
8821 	{
8822 		"ST_MEM_B: Store/Load byte: max negative",
8823 		.u.insns_int = {
8824 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8825 			BPF_ST_MEM(BPF_B, R10, -40, 0xff),
8826 			BPF_LDX_MEM(BPF_B, R0, R10, -40),
8827 			BPF_EXIT_INSN(),
8828 		},
8829 		INTERNAL,
8830 		{ },
8831 		{ { 0, 0xff } },
8832 		.stack_depth = 40,
8833 	},
8834 	{
8835 		"ST_MEM_B: Store/Load byte: max positive",
8836 		.u.insns_int = {
8837 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8838 			BPF_ST_MEM(BPF_H, R10, -40, 0x7f),
8839 			BPF_LDX_MEM(BPF_H, R0, R10, -40),
8840 			BPF_EXIT_INSN(),
8841 		},
8842 		INTERNAL,
8843 		{ },
8844 		{ { 0, 0x7f } },
8845 		.stack_depth = 40,
8846 	},
8847 	{
8848 		"STX_MEM_B: Store/Load byte: max negative",
8849 		.u.insns_int = {
8850 			BPF_LD_IMM64(R0, 0),
8851 			BPF_LD_IMM64(R1, 0xffLL),
8852 			BPF_STX_MEM(BPF_B, R10, R1, -40),
8853 			BPF_LDX_MEM(BPF_B, R0, R10, -40),
8854 			BPF_EXIT_INSN(),
8855 		},
8856 		INTERNAL,
8857 		{ },
8858 		{ { 0, 0xff } },
8859 		.stack_depth = 40,
8860 	},
8861 	{
8862 		"ST_MEM_H: Store/Load half word: max negative",
8863 		.u.insns_int = {
8864 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8865 			BPF_ST_MEM(BPF_H, R10, -40, 0xffff),
8866 			BPF_LDX_MEM(BPF_H, R0, R10, -40),
8867 			BPF_EXIT_INSN(),
8868 		},
8869 		INTERNAL,
8870 		{ },
8871 		{ { 0, 0xffff } },
8872 		.stack_depth = 40,
8873 	},
8874 	{
8875 		"ST_MEM_H: Store/Load half word: max positive",
8876 		.u.insns_int = {
8877 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8878 			BPF_ST_MEM(BPF_H, R10, -40, 0x7fff),
8879 			BPF_LDX_MEM(BPF_H, R0, R10, -40),
8880 			BPF_EXIT_INSN(),
8881 		},
8882 		INTERNAL,
8883 		{ },
8884 		{ { 0, 0x7fff } },
8885 		.stack_depth = 40,
8886 	},
8887 	{
8888 		"STX_MEM_H: Store/Load half word: max negative",
8889 		.u.insns_int = {
8890 			BPF_LD_IMM64(R0, 0),
8891 			BPF_LD_IMM64(R1, 0xffffLL),
8892 			BPF_STX_MEM(BPF_H, R10, R1, -40),
8893 			BPF_LDX_MEM(BPF_H, R0, R10, -40),
8894 			BPF_EXIT_INSN(),
8895 		},
8896 		INTERNAL,
8897 		{ },
8898 		{ { 0, 0xffff } },
8899 		.stack_depth = 40,
8900 	},
8901 	{
8902 		"ST_MEM_W: Store/Load word: max negative",
8903 		.u.insns_int = {
8904 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8905 			BPF_ST_MEM(BPF_W, R10, -40, 0xffffffff),
8906 			BPF_LDX_MEM(BPF_W, R0, R10, -40),
8907 			BPF_EXIT_INSN(),
8908 		},
8909 		INTERNAL,
8910 		{ },
8911 		{ { 0, 0xffffffff } },
8912 		.stack_depth = 40,
8913 	},
8914 	{
8915 		"ST_MEM_W: Store/Load word: max positive",
8916 		.u.insns_int = {
8917 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8918 			BPF_ST_MEM(BPF_W, R10, -40, 0x7fffffff),
8919 			BPF_LDX_MEM(BPF_W, R0, R10, -40),
8920 			BPF_EXIT_INSN(),
8921 		},
8922 		INTERNAL,
8923 		{ },
8924 		{ { 0, 0x7fffffff } },
8925 		.stack_depth = 40,
8926 	},
8927 	{
8928 		"STX_MEM_W: Store/Load word: max negative",
8929 		.u.insns_int = {
8930 			BPF_LD_IMM64(R0, 0),
8931 			BPF_LD_IMM64(R1, 0xffffffffLL),
8932 			BPF_STX_MEM(BPF_W, R10, R1, -40),
8933 			BPF_LDX_MEM(BPF_W, R0, R10, -40),
8934 			BPF_EXIT_INSN(),
8935 		},
8936 		INTERNAL,
8937 		{ },
8938 		{ { 0, 0xffffffff } },
8939 		.stack_depth = 40,
8940 	},
8941 	{
8942 		"ST_MEM_DW: Store/Load double word: max negative",
8943 		.u.insns_int = {
8944 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8945 			BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
8946 			BPF_LDX_MEM(BPF_DW, R0, R10, -40),
8947 			BPF_EXIT_INSN(),
8948 		},
8949 		INTERNAL,
8950 		{ },
8951 		{ { 0, 0xffffffff } },
8952 		.stack_depth = 40,
8953 	},
8954 	{
8955 		"ST_MEM_DW: Store/Load double word: max negative 2",
8956 		.u.insns_int = {
8957 			BPF_LD_IMM64(R2, 0xffff00000000ffffLL),
8958 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
8959 			BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
8960 			BPF_LDX_MEM(BPF_DW, R2, R10, -40),
8961 			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
8962 			BPF_MOV32_IMM(R0, 2),
8963 			BPF_EXIT_INSN(),
8964 			BPF_MOV32_IMM(R0, 1),
8965 			BPF_EXIT_INSN(),
8966 		},
8967 		INTERNAL,
8968 		{ },
8969 		{ { 0, 0x1 } },
8970 		.stack_depth = 40,
8971 	},
8972 	{
8973 		"ST_MEM_DW: Store/Load double word: max positive",
8974 		.u.insns_int = {
8975 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8976 			BPF_ST_MEM(BPF_DW, R10, -40, 0x7fffffff),
8977 			BPF_LDX_MEM(BPF_DW, R0, R10, -40),
8978 			BPF_EXIT_INSN(),
8979 		},
8980 		INTERNAL,
8981 		{ },
8982 		{ { 0, 0x7fffffff } },
8983 		.stack_depth = 40,
8984 	},
8985 	{
8986 		"STX_MEM_DW: Store/Load double word: max negative",
8987 		.u.insns_int = {
8988 			BPF_LD_IMM64(R0, 0),
8989 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
8990 			BPF_STX_MEM(BPF_DW, R10, R1, -40),
8991 			BPF_LDX_MEM(BPF_DW, R0, R10, -40),
8992 			BPF_EXIT_INSN(),
8993 		},
8994 		INTERNAL,
8995 		{ },
8996 		{ { 0, 0xffffffff } },
8997 		.stack_depth = 40,
8998 	},
8999 	{
9000 		"STX_MEM_DW: Store double word: first word in memory",
9001 		.u.insns_int = {
9002 			BPF_LD_IMM64(R0, 0),
9003 			BPF_LD_IMM64(R1, 0x0123456789abcdefLL),
9004 			BPF_STX_MEM(BPF_DW, R10, R1, -40),
9005 			BPF_LDX_MEM(BPF_W, R0, R10, -40),
9006 			BPF_EXIT_INSN(),
9007 		},
9008 		INTERNAL,
9009 		{ },
9010 #ifdef __BIG_ENDIAN
9011 		{ { 0, 0x01234567 } },
9012 #else
9013 		{ { 0, 0x89abcdef } },
9014 #endif
9015 		.stack_depth = 40,
9016 	},
9017 	{
9018 		"STX_MEM_DW: Store double word: second word in memory",
9019 		.u.insns_int = {
9020 			BPF_LD_IMM64(R0, 0),
9021 			BPF_LD_IMM64(R1, 0x0123456789abcdefLL),
9022 			BPF_STX_MEM(BPF_DW, R10, R1, -40),
9023 			BPF_LDX_MEM(BPF_W, R0, R10, -36),
9024 			BPF_EXIT_INSN(),
9025 		},
9026 		INTERNAL,
9027 		{ },
9028 #ifdef __BIG_ENDIAN
9029 		{ { 0, 0x89abcdef } },
9030 #else
9031 		{ { 0, 0x01234567 } },
9032 #endif
9033 		.stack_depth = 40,
9034 	},
9035 	/* BPF_STX | BPF_ATOMIC | BPF_W/DW */
9036 	{
9037 		"STX_XADD_W: X + 1 + 1 + 1 + ...",
9038 		{ },
9039 		INTERNAL,
9040 		{ },
9041 		{ { 0, 4134 } },
9042 		.fill_helper = bpf_fill_stxw,
9043 	},
9044 	{
9045 		"STX_XADD_DW: X + 1 + 1 + 1 + ...",
9046 		{ },
9047 		INTERNAL,
9048 		{ },
9049 		{ { 0, 4134 } },
9050 		.fill_helper = bpf_fill_stxdw,
9051 	},
9052 	/*
9053 	 * Exhaustive tests of atomic operation variants.
9054 	 * Individual tests are expanded from template macros for all
9055 	 * combinations of ALU operation, word size and fetching.
9056 	 */
9057 #define BPF_ATOMIC_POISON(width) ((width) == BPF_W ? (0xbaadf00dULL << 32) : 0)
9058 
9059 #define BPF_ATOMIC_OP_TEST1(width, op, logic, old, update, result)	\
9060 {									\
9061 	"BPF_ATOMIC | " #width ", " #op ": Test: "			\
9062 		#old " " #logic " " #update " = " #result,		\
9063 	.u.insns_int = {						\
9064 		BPF_LD_IMM64(R5, (update) | BPF_ATOMIC_POISON(width)),	\
9065 		BPF_ST_MEM(width, R10, -40, old),			\
9066 		BPF_ATOMIC_OP(width, op, R10, R5, -40),			\
9067 		BPF_LDX_MEM(width, R0, R10, -40),			\
9068 		BPF_ALU64_REG(BPF_MOV, R1, R0),				\
9069 		BPF_ALU64_IMM(BPF_RSH, R1, 32),				\
9070 		BPF_ALU64_REG(BPF_OR, R0, R1),				\
9071 		BPF_EXIT_INSN(),					\
9072 	},								\
9073 	INTERNAL,							\
9074 	{ },								\
9075 	{ { 0, result } },						\
9076 	.stack_depth = 40,						\
9077 }
9078 #define BPF_ATOMIC_OP_TEST2(width, op, logic, old, update, result)	\
9079 {									\
9080 	"BPF_ATOMIC | " #width ", " #op ": Test side effects, r10: "	\
9081 		#old " " #logic " " #update " = " #result,		\
9082 	.u.insns_int = {						\
9083 		BPF_ALU64_REG(BPF_MOV, R1, R10),			\
9084 		BPF_LD_IMM64(R0, (update) | BPF_ATOMIC_POISON(width)),	\
9085 		BPF_ST_MEM(BPF_W, R10, -40, old),			\
9086 		BPF_ATOMIC_OP(width, op, R10, R0, -40),			\
9087 		BPF_ALU64_REG(BPF_MOV, R0, R10),			\
9088 		BPF_ALU64_REG(BPF_SUB, R0, R1),				\
9089 		BPF_ALU64_REG(BPF_MOV, R1, R0),				\
9090 		BPF_ALU64_IMM(BPF_RSH, R1, 32),				\
9091 		BPF_ALU64_REG(BPF_OR, R0, R1),				\
9092 		BPF_EXIT_INSN(),					\
9093 	},								\
9094 	INTERNAL,							\
9095 	{ },								\
9096 	{ { 0, 0 } },							\
9097 	.stack_depth = 40,						\
9098 }
9099 #define BPF_ATOMIC_OP_TEST3(width, op, logic, old, update, result)	\
9100 {									\
9101 	"BPF_ATOMIC | " #width ", " #op ": Test side effects, r0: "	\
9102 		#old " " #logic " " #update " = " #result,		\
9103 	.u.insns_int = {						\
9104 		BPF_ALU64_REG(BPF_MOV, R0, R10),			\
9105 		BPF_LD_IMM64(R1, (update) | BPF_ATOMIC_POISON(width)),	\
9106 		BPF_ST_MEM(width, R10, -40, old),			\
9107 		BPF_ATOMIC_OP(width, op, R10, R1, -40),			\
9108 		BPF_ALU64_REG(BPF_SUB, R0, R10),			\
9109 		BPF_ALU64_REG(BPF_MOV, R1, R0),				\
9110 		BPF_ALU64_IMM(BPF_RSH, R1, 32),				\
9111 		BPF_ALU64_REG(BPF_OR, R0, R1),				\
9112 		BPF_EXIT_INSN(),					\
9113 	},								\
9114 	INTERNAL,                                                       \
9115 	{ },                                                            \
9116 	{ { 0, 0 } },                                                   \
9117 	.stack_depth = 40,                                              \
9118 }
9119 #define BPF_ATOMIC_OP_TEST4(width, op, logic, old, update, result)	\
9120 {									\
9121 	"BPF_ATOMIC | " #width ", " #op ": Test fetch: "		\
9122 		#old " " #logic " " #update " = " #result,		\
9123 	.u.insns_int = {						\
9124 		BPF_LD_IMM64(R3, (update) | BPF_ATOMIC_POISON(width)),	\
9125 		BPF_ST_MEM(width, R10, -40, old),			\
9126 		BPF_ATOMIC_OP(width, op, R10, R3, -40),			\
9127 		BPF_ALU32_REG(BPF_MOV, R0, R3),                         \
9128 		BPF_EXIT_INSN(),					\
9129 	},								\
9130 	INTERNAL,                                                       \
9131 	{ },                                                            \
9132 	{ { 0, (op) & BPF_FETCH ? old : update } },			\
9133 	.stack_depth = 40,                                              \
9134 }
9135 	/* BPF_ATOMIC | BPF_W: BPF_ADD */
9136 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
9137 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
9138 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
9139 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
9140 	/* BPF_ATOMIC | BPF_W: BPF_ADD | BPF_FETCH */
9141 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
9142 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
9143 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
9144 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
9145 	/* BPF_ATOMIC | BPF_DW: BPF_ADD */
9146 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
9147 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
9148 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
9149 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
9150 	/* BPF_ATOMIC | BPF_DW: BPF_ADD | BPF_FETCH */
9151 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
9152 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
9153 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
9154 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
9155 	/* BPF_ATOMIC | BPF_W: BPF_AND */
9156 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
9157 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
9158 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
9159 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
9160 	/* BPF_ATOMIC | BPF_W: BPF_AND | BPF_FETCH */
9161 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
9162 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
9163 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
9164 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
9165 	/* BPF_ATOMIC | BPF_DW: BPF_AND */
9166 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
9167 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
9168 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
9169 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
9170 	/* BPF_ATOMIC | BPF_DW: BPF_AND | BPF_FETCH */
9171 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
9172 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
9173 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
9174 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
9175 	/* BPF_ATOMIC | BPF_W: BPF_OR */
9176 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
9177 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
9178 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
9179 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
9180 	/* BPF_ATOMIC | BPF_W: BPF_OR | BPF_FETCH */
9181 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
9182 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
9183 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
9184 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
9185 	/* BPF_ATOMIC | BPF_DW: BPF_OR */
9186 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
9187 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
9188 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
9189 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
9190 	/* BPF_ATOMIC | BPF_DW: BPF_OR | BPF_FETCH */
9191 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
9192 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
9193 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
9194 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
9195 	/* BPF_ATOMIC | BPF_W: BPF_XOR */
9196 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
9197 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
9198 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
9199 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
9200 	/* BPF_ATOMIC | BPF_W: BPF_XOR | BPF_FETCH */
9201 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
9202 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
9203 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
9204 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
9205 	/* BPF_ATOMIC | BPF_DW: BPF_XOR */
9206 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
9207 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
9208 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
9209 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
9210 	/* BPF_ATOMIC | BPF_DW: BPF_XOR | BPF_FETCH */
9211 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
9212 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
9213 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
9214 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
9215 	/* BPF_ATOMIC | BPF_W: BPF_XCHG */
9216 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
9217 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
9218 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
9219 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
9220 	/* BPF_ATOMIC | BPF_DW: BPF_XCHG */
9221 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
9222 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
9223 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
9224 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
9225 #undef BPF_ATOMIC_POISON
9226 #undef BPF_ATOMIC_OP_TEST1
9227 #undef BPF_ATOMIC_OP_TEST2
9228 #undef BPF_ATOMIC_OP_TEST3
9229 #undef BPF_ATOMIC_OP_TEST4
9230 	/* BPF_ATOMIC | BPF_W, BPF_CMPXCHG */
9231 	{
9232 		"BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test successful return",
9233 		.u.insns_int = {
9234 			BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
9235 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
9236 			BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
9237 			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
9238 			BPF_EXIT_INSN(),
9239 		},
9240 		INTERNAL,
9241 		{ },
9242 		{ { 0, 0x01234567 } },
9243 		.stack_depth = 40,
9244 	},
9245 	{
9246 		"BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test successful store",
9247 		.u.insns_int = {
9248 			BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
9249 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
9250 			BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
9251 			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
9252 			BPF_LDX_MEM(BPF_W, R0, R10, -40),
9253 			BPF_EXIT_INSN(),
9254 		},
9255 		INTERNAL,
9256 		{ },
9257 		{ { 0, 0x89abcdef } },
9258 		.stack_depth = 40,
9259 	},
9260 	{
9261 		"BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test failure return",
9262 		.u.insns_int = {
9263 			BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
9264 			BPF_ALU32_IMM(BPF_MOV, R0, 0x76543210),
9265 			BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
9266 			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
9267 			BPF_EXIT_INSN(),
9268 		},
9269 		INTERNAL,
9270 		{ },
9271 		{ { 0, 0x01234567 } },
9272 		.stack_depth = 40,
9273 	},
9274 	{
9275 		"BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test failure store",
9276 		.u.insns_int = {
9277 			BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
9278 			BPF_ALU32_IMM(BPF_MOV, R0, 0x76543210),
9279 			BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
9280 			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
9281 			BPF_LDX_MEM(BPF_W, R0, R10, -40),
9282 			BPF_EXIT_INSN(),
9283 		},
9284 		INTERNAL,
9285 		{ },
9286 		{ { 0, 0x01234567 } },
9287 		.stack_depth = 40,
9288 	},
9289 	{
9290 		"BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test side effects",
9291 		.u.insns_int = {
9292 			BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
9293 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
9294 			BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
9295 			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
9296 			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
9297 			BPF_ALU32_REG(BPF_MOV, R0, R3),
9298 			BPF_EXIT_INSN(),
9299 		},
9300 		INTERNAL,
9301 		{ },
9302 		{ { 0, 0x89abcdef } },
9303 		.stack_depth = 40,
9304 	},
9305 	/* BPF_ATOMIC | BPF_DW, BPF_CMPXCHG */
9306 	{
9307 		"BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test successful return",
9308 		.u.insns_int = {
9309 			BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
9310 			BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
9311 			BPF_ALU64_REG(BPF_MOV, R0, R1),
9312 			BPF_STX_MEM(BPF_DW, R10, R1, -40),
9313 			BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
9314 			BPF_JMP_REG(BPF_JNE, R0, R1, 1),
9315 			BPF_ALU64_REG(BPF_SUB, R0, R1),
9316 			BPF_EXIT_INSN(),
9317 		},
9318 		INTERNAL,
9319 		{ },
9320 		{ { 0, 0 } },
9321 		.stack_depth = 40,
9322 	},
9323 	{
9324 		"BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test successful store",
9325 		.u.insns_int = {
9326 			BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
9327 			BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
9328 			BPF_ALU64_REG(BPF_MOV, R0, R1),
9329 			BPF_STX_MEM(BPF_DW, R10, R0, -40),
9330 			BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
9331 			BPF_LDX_MEM(BPF_DW, R0, R10, -40),
9332 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
9333 			BPF_ALU64_REG(BPF_SUB, R0, R2),
9334 			BPF_EXIT_INSN(),
9335 		},
9336 		INTERNAL,
9337 		{ },
9338 		{ { 0, 0 } },
9339 		.stack_depth = 40,
9340 	},
9341 	{
9342 		"BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test failure return",
9343 		.u.insns_int = {
9344 			BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
9345 			BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
9346 			BPF_ALU64_REG(BPF_MOV, R0, R1),
9347 			BPF_ALU64_IMM(BPF_ADD, R0, 1),
9348 			BPF_STX_MEM(BPF_DW, R10, R1, -40),
9349 			BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
9350 			BPF_JMP_REG(BPF_JNE, R0, R1, 1),
9351 			BPF_ALU64_REG(BPF_SUB, R0, R1),
9352 			BPF_EXIT_INSN(),
9353 		},
9354 		INTERNAL,
9355 		{ },
9356 		{ { 0, 0 } },
9357 		.stack_depth = 40,
9358 	},
9359 	{
9360 		"BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test failure store",
9361 		.u.insns_int = {
9362 			BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
9363 			BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
9364 			BPF_ALU64_REG(BPF_MOV, R0, R1),
9365 			BPF_ALU64_IMM(BPF_ADD, R0, 1),
9366 			BPF_STX_MEM(BPF_DW, R10, R1, -40),
9367 			BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
9368 			BPF_LDX_MEM(BPF_DW, R0, R10, -40),
9369 			BPF_JMP_REG(BPF_JNE, R0, R1, 1),
9370 			BPF_ALU64_REG(BPF_SUB, R0, R1),
9371 			BPF_EXIT_INSN(),
9372 		},
9373 		INTERNAL,
9374 		{ },
9375 		{ { 0, 0 } },
9376 		.stack_depth = 40,
9377 	},
9378 	{
9379 		"BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test side effects",
9380 		.u.insns_int = {
9381 			BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
9382 			BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
9383 			BPF_ALU64_REG(BPF_MOV, R0, R1),
9384 			BPF_STX_MEM(BPF_DW, R10, R1, -40),
9385 			BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
9386 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
9387 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
9388 			BPF_ALU64_REG(BPF_SUB, R0, R2),
9389 			BPF_EXIT_INSN(),
9390 		},
9391 		INTERNAL,
9392 		{ },
9393 		{ { 0, 0 } },
9394 		.stack_depth = 40,
9395 	},
9396 	/* BPF_JMP32 | BPF_JEQ | BPF_K */
9397 	{
9398 		"JMP32_JEQ_K: Small immediate",
9399 		.u.insns_int = {
9400 			BPF_ALU32_IMM(BPF_MOV, R0, 123),
9401 			BPF_JMP32_IMM(BPF_JEQ, R0, 321, 1),
9402 			BPF_JMP32_IMM(BPF_JEQ, R0, 123, 1),
9403 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9404 			BPF_EXIT_INSN(),
9405 		},
9406 		INTERNAL,
9407 		{ },
9408 		{ { 0, 123 } }
9409 	},
9410 	{
9411 		"JMP32_JEQ_K: Large immediate",
9412 		.u.insns_int = {
9413 			BPF_ALU32_IMM(BPF_MOV, R0, 12345678),
9414 			BPF_JMP32_IMM(BPF_JEQ, R0, 12345678 & 0xffff, 1),
9415 			BPF_JMP32_IMM(BPF_JEQ, R0, 12345678, 1),
9416 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9417 			BPF_EXIT_INSN(),
9418 		},
9419 		INTERNAL,
9420 		{ },
9421 		{ { 0, 12345678 } }
9422 	},
9423 	{
9424 		"JMP32_JEQ_K: negative immediate",
9425 		.u.insns_int = {
9426 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
9427 			BPF_JMP32_IMM(BPF_JEQ, R0,  123, 1),
9428 			BPF_JMP32_IMM(BPF_JEQ, R0, -123, 1),
9429 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9430 			BPF_EXIT_INSN(),
9431 		},
9432 		INTERNAL,
9433 		{ },
9434 		{ { 0, -123 } }
9435 	},
9436 	/* BPF_JMP32 | BPF_JEQ | BPF_X */
9437 	{
9438 		"JMP32_JEQ_X",
9439 		.u.insns_int = {
9440 			BPF_ALU32_IMM(BPF_MOV, R0, 1234),
9441 			BPF_ALU32_IMM(BPF_MOV, R1, 4321),
9442 			BPF_JMP32_REG(BPF_JEQ, R0, R1, 2),
9443 			BPF_ALU32_IMM(BPF_MOV, R1, 1234),
9444 			BPF_JMP32_REG(BPF_JEQ, R0, R1, 1),
9445 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9446 			BPF_EXIT_INSN(),
9447 		},
9448 		INTERNAL,
9449 		{ },
9450 		{ { 0, 1234 } }
9451 	},
9452 	/* BPF_JMP32 | BPF_JNE | BPF_K */
9453 	{
9454 		"JMP32_JNE_K: Small immediate",
9455 		.u.insns_int = {
9456 			BPF_ALU32_IMM(BPF_MOV, R0, 123),
9457 			BPF_JMP32_IMM(BPF_JNE, R0, 123, 1),
9458 			BPF_JMP32_IMM(BPF_JNE, R0, 321, 1),
9459 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9460 			BPF_EXIT_INSN(),
9461 		},
9462 		INTERNAL,
9463 		{ },
9464 		{ { 0, 123 } }
9465 	},
9466 	{
9467 		"JMP32_JNE_K: Large immediate",
9468 		.u.insns_int = {
9469 			BPF_ALU32_IMM(BPF_MOV, R0, 12345678),
9470 			BPF_JMP32_IMM(BPF_JNE, R0, 12345678, 1),
9471 			BPF_JMP32_IMM(BPF_JNE, R0, 12345678 & 0xffff, 1),
9472 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9473 			BPF_EXIT_INSN(),
9474 		},
9475 		INTERNAL,
9476 		{ },
9477 		{ { 0, 12345678 } }
9478 	},
9479 	{
9480 		"JMP32_JNE_K: negative immediate",
9481 		.u.insns_int = {
9482 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
9483 			BPF_JMP32_IMM(BPF_JNE, R0, -123, 1),
9484 			BPF_JMP32_IMM(BPF_JNE, R0,  123, 1),
9485 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9486 			BPF_EXIT_INSN(),
9487 		},
9488 		INTERNAL,
9489 		{ },
9490 		{ { 0, -123 } }
9491 	},
9492 	/* BPF_JMP32 | BPF_JNE | BPF_X */
9493 	{
9494 		"JMP32_JNE_X",
9495 		.u.insns_int = {
9496 			BPF_ALU32_IMM(BPF_MOV, R0, 1234),
9497 			BPF_ALU32_IMM(BPF_MOV, R1, 1234),
9498 			BPF_JMP32_REG(BPF_JNE, R0, R1, 2),
9499 			BPF_ALU32_IMM(BPF_MOV, R1, 4321),
9500 			BPF_JMP32_REG(BPF_JNE, R0, R1, 1),
9501 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9502 			BPF_EXIT_INSN(),
9503 		},
9504 		INTERNAL,
9505 		{ },
9506 		{ { 0, 1234 } }
9507 	},
9508 	/* BPF_JMP32 | BPF_JSET | BPF_K */
9509 	{
9510 		"JMP32_JSET_K: Small immediate",
9511 		.u.insns_int = {
9512 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9513 			BPF_JMP32_IMM(BPF_JSET, R0, 2, 1),
9514 			BPF_JMP32_IMM(BPF_JSET, R0, 3, 1),
9515 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9516 			BPF_EXIT_INSN(),
9517 		},
9518 		INTERNAL,
9519 		{ },
9520 		{ { 0, 1 } }
9521 	},
9522 	{
9523 		"JMP32_JSET_K: Large immediate",
9524 		.u.insns_int = {
9525 			BPF_ALU32_IMM(BPF_MOV, R0, 0x40000000),
9526 			BPF_JMP32_IMM(BPF_JSET, R0, 0x3fffffff, 1),
9527 			BPF_JMP32_IMM(BPF_JSET, R0, 0x60000000, 1),
9528 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9529 			BPF_EXIT_INSN(),
9530 		},
9531 		INTERNAL,
9532 		{ },
9533 		{ { 0, 0x40000000 } }
9534 	},
9535 	{
9536 		"JMP32_JSET_K: negative immediate",
9537 		.u.insns_int = {
9538 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
9539 			BPF_JMP32_IMM(BPF_JSET, R0, -1, 1),
9540 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9541 			BPF_EXIT_INSN(),
9542 		},
9543 		INTERNAL,
9544 		{ },
9545 		{ { 0, -123 } }
9546 	},
9547 	/* BPF_JMP32 | BPF_JSET | BPF_X */
9548 	{
9549 		"JMP32_JSET_X",
9550 		.u.insns_int = {
9551 			BPF_ALU32_IMM(BPF_MOV, R0, 8),
9552 			BPF_ALU32_IMM(BPF_MOV, R1, 7),
9553 			BPF_JMP32_REG(BPF_JSET, R0, R1, 2),
9554 			BPF_ALU32_IMM(BPF_MOV, R1, 8 | 2),
9555 			BPF_JMP32_REG(BPF_JNE, R0, R1, 1),
9556 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9557 			BPF_EXIT_INSN(),
9558 		},
9559 		INTERNAL,
9560 		{ },
9561 		{ { 0, 8 } }
9562 	},
9563 	/* BPF_JMP32 | BPF_JGT | BPF_K */
9564 	{
9565 		"JMP32_JGT_K: Small immediate",
9566 		.u.insns_int = {
9567 			BPF_ALU32_IMM(BPF_MOV, R0, 123),
9568 			BPF_JMP32_IMM(BPF_JGT, R0, 123, 1),
9569 			BPF_JMP32_IMM(BPF_JGT, R0, 122, 1),
9570 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9571 			BPF_EXIT_INSN(),
9572 		},
9573 		INTERNAL,
9574 		{ },
9575 		{ { 0, 123 } }
9576 	},
9577 	{
9578 		"JMP32_JGT_K: Large immediate",
9579 		.u.insns_int = {
9580 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9581 			BPF_JMP32_IMM(BPF_JGT, R0, 0xffffffff, 1),
9582 			BPF_JMP32_IMM(BPF_JGT, R0, 0xfffffffd, 1),
9583 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9584 			BPF_EXIT_INSN(),
9585 		},
9586 		INTERNAL,
9587 		{ },
9588 		{ { 0, 0xfffffffe } }
9589 	},
9590 	/* BPF_JMP32 | BPF_JGT | BPF_X */
9591 	{
9592 		"JMP32_JGT_X",
9593 		.u.insns_int = {
9594 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9595 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
9596 			BPF_JMP32_REG(BPF_JGT, R0, R1, 2),
9597 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
9598 			BPF_JMP32_REG(BPF_JGT, R0, R1, 1),
9599 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9600 			BPF_EXIT_INSN(),
9601 		},
9602 		INTERNAL,
9603 		{ },
9604 		{ { 0, 0xfffffffe } }
9605 	},
9606 	/* BPF_JMP32 | BPF_JGE | BPF_K */
9607 	{
9608 		"JMP32_JGE_K: Small immediate",
9609 		.u.insns_int = {
9610 			BPF_ALU32_IMM(BPF_MOV, R0, 123),
9611 			BPF_JMP32_IMM(BPF_JGE, R0, 124, 1),
9612 			BPF_JMP32_IMM(BPF_JGE, R0, 123, 1),
9613 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9614 			BPF_EXIT_INSN(),
9615 		},
9616 		INTERNAL,
9617 		{ },
9618 		{ { 0, 123 } }
9619 	},
9620 	{
9621 		"JMP32_JGE_K: Large immediate",
9622 		.u.insns_int = {
9623 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9624 			BPF_JMP32_IMM(BPF_JGE, R0, 0xffffffff, 1),
9625 			BPF_JMP32_IMM(BPF_JGE, R0, 0xfffffffe, 1),
9626 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9627 			BPF_EXIT_INSN(),
9628 		},
9629 		INTERNAL,
9630 		{ },
9631 		{ { 0, 0xfffffffe } }
9632 	},
9633 	/* BPF_JMP32 | BPF_JGE | BPF_X */
9634 	{
9635 		"JMP32_JGE_X",
9636 		.u.insns_int = {
9637 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9638 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
9639 			BPF_JMP32_REG(BPF_JGE, R0, R1, 2),
9640 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffe),
9641 			BPF_JMP32_REG(BPF_JGE, R0, R1, 1),
9642 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9643 			BPF_EXIT_INSN(),
9644 		},
9645 		INTERNAL,
9646 		{ },
9647 		{ { 0, 0xfffffffe } }
9648 	},
9649 	/* BPF_JMP32 | BPF_JLT | BPF_K */
9650 	{
9651 		"JMP32_JLT_K: Small immediate",
9652 		.u.insns_int = {
9653 			BPF_ALU32_IMM(BPF_MOV, R0, 123),
9654 			BPF_JMP32_IMM(BPF_JLT, R0, 123, 1),
9655 			BPF_JMP32_IMM(BPF_JLT, R0, 124, 1),
9656 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9657 			BPF_EXIT_INSN(),
9658 		},
9659 		INTERNAL,
9660 		{ },
9661 		{ { 0, 123 } }
9662 	},
9663 	{
9664 		"JMP32_JLT_K: Large immediate",
9665 		.u.insns_int = {
9666 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9667 			BPF_JMP32_IMM(BPF_JLT, R0, 0xfffffffd, 1),
9668 			BPF_JMP32_IMM(BPF_JLT, R0, 0xffffffff, 1),
9669 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9670 			BPF_EXIT_INSN(),
9671 		},
9672 		INTERNAL,
9673 		{ },
9674 		{ { 0, 0xfffffffe } }
9675 	},
9676 	/* BPF_JMP32 | BPF_JLT | BPF_X */
9677 	{
9678 		"JMP32_JLT_X",
9679 		.u.insns_int = {
9680 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9681 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
9682 			BPF_JMP32_REG(BPF_JLT, R0, R1, 2),
9683 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
9684 			BPF_JMP32_REG(BPF_JLT, R0, R1, 1),
9685 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9686 			BPF_EXIT_INSN(),
9687 		},
9688 		INTERNAL,
9689 		{ },
9690 		{ { 0, 0xfffffffe } }
9691 	},
9692 	/* BPF_JMP32 | BPF_JLE | BPF_K */
9693 	{
9694 		"JMP32_JLE_K: Small immediate",
9695 		.u.insns_int = {
9696 			BPF_ALU32_IMM(BPF_MOV, R0, 123),
9697 			BPF_JMP32_IMM(BPF_JLE, R0, 122, 1),
9698 			BPF_JMP32_IMM(BPF_JLE, R0, 123, 1),
9699 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9700 			BPF_EXIT_INSN(),
9701 		},
9702 		INTERNAL,
9703 		{ },
9704 		{ { 0, 123 } }
9705 	},
9706 	{
9707 		"JMP32_JLE_K: Large immediate",
9708 		.u.insns_int = {
9709 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9710 			BPF_JMP32_IMM(BPF_JLE, R0, 0xfffffffd, 1),
9711 			BPF_JMP32_IMM(BPF_JLE, R0, 0xfffffffe, 1),
9712 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9713 			BPF_EXIT_INSN(),
9714 		},
9715 		INTERNAL,
9716 		{ },
9717 		{ { 0, 0xfffffffe } }
9718 	},
9719 	/* BPF_JMP32 | BPF_JLE | BPF_X */
9720 	{
9721 		"JMP32_JLE_X",
9722 		.u.insns_int = {
9723 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9724 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
9725 			BPF_JMP32_REG(BPF_JLE, R0, R1, 2),
9726 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffe),
9727 			BPF_JMP32_REG(BPF_JLE, R0, R1, 1),
9728 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9729 			BPF_EXIT_INSN(),
9730 		},
9731 		INTERNAL,
9732 		{ },
9733 		{ { 0, 0xfffffffe } }
9734 	},
9735 	/* BPF_JMP32 | BPF_JSGT | BPF_K */
9736 	{
9737 		"JMP32_JSGT_K: Small immediate",
9738 		.u.insns_int = {
9739 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
9740 			BPF_JMP32_IMM(BPF_JSGT, R0, -123, 1),
9741 			BPF_JMP32_IMM(BPF_JSGT, R0, -124, 1),
9742 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9743 			BPF_EXIT_INSN(),
9744 		},
9745 		INTERNAL,
9746 		{ },
9747 		{ { 0, -123 } }
9748 	},
9749 	{
9750 		"JMP32_JSGT_K: Large immediate",
9751 		.u.insns_int = {
9752 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9753 			BPF_JMP32_IMM(BPF_JSGT, R0, -12345678, 1),
9754 			BPF_JMP32_IMM(BPF_JSGT, R0, -12345679, 1),
9755 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9756 			BPF_EXIT_INSN(),
9757 		},
9758 		INTERNAL,
9759 		{ },
9760 		{ { 0, -12345678 } }
9761 	},
9762 	/* BPF_JMP32 | BPF_JSGT | BPF_X */
9763 	{
9764 		"JMP32_JSGT_X",
9765 		.u.insns_int = {
9766 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9767 			BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
9768 			BPF_JMP32_REG(BPF_JSGT, R0, R1, 2),
9769 			BPF_ALU32_IMM(BPF_MOV, R1, -12345679),
9770 			BPF_JMP32_REG(BPF_JSGT, R0, R1, 1),
9771 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9772 			BPF_EXIT_INSN(),
9773 		},
9774 		INTERNAL,
9775 		{ },
9776 		{ { 0, -12345678 } }
9777 	},
9778 	/* BPF_JMP32 | BPF_JSGE | BPF_K */
9779 	{
9780 		"JMP32_JSGE_K: Small immediate",
9781 		.u.insns_int = {
9782 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
9783 			BPF_JMP32_IMM(BPF_JSGE, R0, -122, 1),
9784 			BPF_JMP32_IMM(BPF_JSGE, R0, -123, 1),
9785 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9786 			BPF_EXIT_INSN(),
9787 		},
9788 		INTERNAL,
9789 		{ },
9790 		{ { 0, -123 } }
9791 	},
9792 	{
9793 		"JMP32_JSGE_K: Large immediate",
9794 		.u.insns_int = {
9795 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9796 			BPF_JMP32_IMM(BPF_JSGE, R0, -12345677, 1),
9797 			BPF_JMP32_IMM(BPF_JSGE, R0, -12345678, 1),
9798 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9799 			BPF_EXIT_INSN(),
9800 		},
9801 		INTERNAL,
9802 		{ },
9803 		{ { 0, -12345678 } }
9804 	},
9805 	/* BPF_JMP32 | BPF_JSGE | BPF_X */
9806 	{
9807 		"JMP32_JSGE_X",
9808 		.u.insns_int = {
9809 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9810 			BPF_ALU32_IMM(BPF_MOV, R1, -12345677),
9811 			BPF_JMP32_REG(BPF_JSGE, R0, R1, 2),
9812 			BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
9813 			BPF_JMP32_REG(BPF_JSGE, R0, R1, 1),
9814 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9815 			BPF_EXIT_INSN(),
9816 		},
9817 		INTERNAL,
9818 		{ },
9819 		{ { 0, -12345678 } }
9820 	},
9821 	/* BPF_JMP32 | BPF_JSLT | BPF_K */
9822 	{
9823 		"JMP32_JSLT_K: Small immediate",
9824 		.u.insns_int = {
9825 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
9826 			BPF_JMP32_IMM(BPF_JSLT, R0, -123, 1),
9827 			BPF_JMP32_IMM(BPF_JSLT, R0, -122, 1),
9828 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9829 			BPF_EXIT_INSN(),
9830 		},
9831 		INTERNAL,
9832 		{ },
9833 		{ { 0, -123 } }
9834 	},
9835 	{
9836 		"JMP32_JSLT_K: Large immediate",
9837 		.u.insns_int = {
9838 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9839 			BPF_JMP32_IMM(BPF_JSLT, R0, -12345678, 1),
9840 			BPF_JMP32_IMM(BPF_JSLT, R0, -12345677, 1),
9841 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9842 			BPF_EXIT_INSN(),
9843 		},
9844 		INTERNAL,
9845 		{ },
9846 		{ { 0, -12345678 } }
9847 	},
9848 	/* BPF_JMP32 | BPF_JSLT | BPF_X */
9849 	{
9850 		"JMP32_JSLT_X",
9851 		.u.insns_int = {
9852 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9853 			BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
9854 			BPF_JMP32_REG(BPF_JSLT, R0, R1, 2),
9855 			BPF_ALU32_IMM(BPF_MOV, R1, -12345677),
9856 			BPF_JMP32_REG(BPF_JSLT, R0, R1, 1),
9857 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9858 			BPF_EXIT_INSN(),
9859 		},
9860 		INTERNAL,
9861 		{ },
9862 		{ { 0, -12345678 } }
9863 	},
9864 	/* BPF_JMP32 | BPF_JSLE | BPF_K */
9865 	{
9866 		"JMP32_JSLE_K: Small immediate",
9867 		.u.insns_int = {
9868 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
9869 			BPF_JMP32_IMM(BPF_JSLE, R0, -124, 1),
9870 			BPF_JMP32_IMM(BPF_JSLE, R0, -123, 1),
9871 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9872 			BPF_EXIT_INSN(),
9873 		},
9874 		INTERNAL,
9875 		{ },
9876 		{ { 0, -123 } }
9877 	},
9878 	{
9879 		"JMP32_JSLE_K: Large immediate",
9880 		.u.insns_int = {
9881 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9882 			BPF_JMP32_IMM(BPF_JSLE, R0, -12345679, 1),
9883 			BPF_JMP32_IMM(BPF_JSLE, R0, -12345678, 1),
9884 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9885 			BPF_EXIT_INSN(),
9886 		},
9887 		INTERNAL,
9888 		{ },
9889 		{ { 0, -12345678 } }
9890 	},
9891 	/* BPF_JMP32 | BPF_JSLE | BPF_K */
9892 	{
9893 		"JMP32_JSLE_X",
9894 		.u.insns_int = {
9895 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9896 			BPF_ALU32_IMM(BPF_MOV, R1, -12345679),
9897 			BPF_JMP32_REG(BPF_JSLE, R0, R1, 2),
9898 			BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
9899 			BPF_JMP32_REG(BPF_JSLE, R0, R1, 1),
9900 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9901 			BPF_EXIT_INSN(),
9902 		},
9903 		INTERNAL,
9904 		{ },
9905 		{ { 0, -12345678 } }
9906 	},
9907 	/* BPF_JMP | BPF_EXIT */
9908 	{
9909 		"JMP_EXIT",
9910 		.u.insns_int = {
9911 			BPF_ALU32_IMM(BPF_MOV, R0, 0x4711),
9912 			BPF_EXIT_INSN(),
9913 			BPF_ALU32_IMM(BPF_MOV, R0, 0x4712),
9914 		},
9915 		INTERNAL,
9916 		{ },
9917 		{ { 0, 0x4711 } },
9918 	},
9919 	/* BPF_JMP | BPF_JA */
9920 	{
9921 		"JMP_JA: Unconditional jump: if (true) return 1",
9922 		.u.insns_int = {
9923 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9924 			BPF_JMP_IMM(BPF_JA, 0, 0, 1),
9925 			BPF_EXIT_INSN(),
9926 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9927 			BPF_EXIT_INSN(),
9928 		},
9929 		INTERNAL,
9930 		{ },
9931 		{ { 0, 1 } },
9932 	},
9933 	/* BPF_JMP32 | BPF_JA */
9934 	{
9935 		"JMP32_JA: Unconditional jump: if (true) return 1",
9936 		.u.insns_int = {
9937 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9938 			BPF_JMP32_IMM(BPF_JA, 0, 1, 0),
9939 			BPF_EXIT_INSN(),
9940 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9941 			BPF_EXIT_INSN(),
9942 		},
9943 		INTERNAL,
9944 		{ },
9945 		{ { 0, 1 } },
9946 	},
9947 	/* BPF_JMP | BPF_JSLT | BPF_K */
9948 	{
9949 		"JMP_JSLT_K: Signed jump: if (-2 < -1) return 1",
9950 		.u.insns_int = {
9951 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9952 			BPF_LD_IMM64(R1, 0xfffffffffffffffeLL),
9953 			BPF_JMP_IMM(BPF_JSLT, R1, -1, 1),
9954 			BPF_EXIT_INSN(),
9955 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9956 			BPF_EXIT_INSN(),
9957 		},
9958 		INTERNAL,
9959 		{ },
9960 		{ { 0, 1 } },
9961 	},
9962 	{
9963 		"JMP_JSLT_K: Signed jump: if (-1 < -1) return 0",
9964 		.u.insns_int = {
9965 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9966 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9967 			BPF_JMP_IMM(BPF_JSLT, R1, -1, 1),
9968 			BPF_EXIT_INSN(),
9969 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9970 			BPF_EXIT_INSN(),
9971 		},
9972 		INTERNAL,
9973 		{ },
9974 		{ { 0, 1 } },
9975 	},
9976 	/* BPF_JMP | BPF_JSGT | BPF_K */
9977 	{
9978 		"JMP_JSGT_K: Signed jump: if (-1 > -2) return 1",
9979 		.u.insns_int = {
9980 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9981 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9982 			BPF_JMP_IMM(BPF_JSGT, R1, -2, 1),
9983 			BPF_EXIT_INSN(),
9984 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9985 			BPF_EXIT_INSN(),
9986 		},
9987 		INTERNAL,
9988 		{ },
9989 		{ { 0, 1 } },
9990 	},
9991 	{
9992 		"JMP_JSGT_K: Signed jump: if (-1 > -1) return 0",
9993 		.u.insns_int = {
9994 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9995 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9996 			BPF_JMP_IMM(BPF_JSGT, R1, -1, 1),
9997 			BPF_EXIT_INSN(),
9998 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9999 			BPF_EXIT_INSN(),
10000 		},
10001 		INTERNAL,
10002 		{ },
10003 		{ { 0, 1 } },
10004 	},
10005 	/* BPF_JMP | BPF_JSLE | BPF_K */
10006 	{
10007 		"JMP_JSLE_K: Signed jump: if (-2 <= -1) return 1",
10008 		.u.insns_int = {
10009 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10010 			BPF_LD_IMM64(R1, 0xfffffffffffffffeLL),
10011 			BPF_JMP_IMM(BPF_JSLE, R1, -1, 1),
10012 			BPF_EXIT_INSN(),
10013 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10014 			BPF_EXIT_INSN(),
10015 		},
10016 		INTERNAL,
10017 		{ },
10018 		{ { 0, 1 } },
10019 	},
10020 	{
10021 		"JMP_JSLE_K: Signed jump: if (-1 <= -1) return 1",
10022 		.u.insns_int = {
10023 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10024 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
10025 			BPF_JMP_IMM(BPF_JSLE, R1, -1, 1),
10026 			BPF_EXIT_INSN(),
10027 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10028 			BPF_EXIT_INSN(),
10029 		},
10030 		INTERNAL,
10031 		{ },
10032 		{ { 0, 1 } },
10033 	},
10034 	{
10035 		"JMP_JSLE_K: Signed jump: value walk 1",
10036 		.u.insns_int = {
10037 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10038 			BPF_LD_IMM64(R1, 3),
10039 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 6),
10040 			BPF_ALU64_IMM(BPF_SUB, R1, 1),
10041 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 4),
10042 			BPF_ALU64_IMM(BPF_SUB, R1, 1),
10043 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 2),
10044 			BPF_ALU64_IMM(BPF_SUB, R1, 1),
10045 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 1),
10046 			BPF_EXIT_INSN(),		/* bad exit */
10047 			BPF_ALU32_IMM(BPF_MOV, R0, 1),	/* good exit */
10048 			BPF_EXIT_INSN(),
10049 		},
10050 		INTERNAL,
10051 		{ },
10052 		{ { 0, 1 } },
10053 	},
10054 	{
10055 		"JMP_JSLE_K: Signed jump: value walk 2",
10056 		.u.insns_int = {
10057 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10058 			BPF_LD_IMM64(R1, 3),
10059 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 4),
10060 			BPF_ALU64_IMM(BPF_SUB, R1, 2),
10061 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 2),
10062 			BPF_ALU64_IMM(BPF_SUB, R1, 2),
10063 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 1),
10064 			BPF_EXIT_INSN(),		/* bad exit */
10065 			BPF_ALU32_IMM(BPF_MOV, R0, 1),	/* good exit */
10066 			BPF_EXIT_INSN(),
10067 		},
10068 		INTERNAL,
10069 		{ },
10070 		{ { 0, 1 } },
10071 	},
10072 	/* BPF_JMP | BPF_JSGE | BPF_K */
10073 	{
10074 		"JMP_JSGE_K: Signed jump: if (-1 >= -2) return 1",
10075 		.u.insns_int = {
10076 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10077 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
10078 			BPF_JMP_IMM(BPF_JSGE, R1, -2, 1),
10079 			BPF_EXIT_INSN(),
10080 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10081 			BPF_EXIT_INSN(),
10082 		},
10083 		INTERNAL,
10084 		{ },
10085 		{ { 0, 1 } },
10086 	},
10087 	{
10088 		"JMP_JSGE_K: Signed jump: if (-1 >= -1) return 1",
10089 		.u.insns_int = {
10090 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10091 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
10092 			BPF_JMP_IMM(BPF_JSGE, R1, -1, 1),
10093 			BPF_EXIT_INSN(),
10094 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10095 			BPF_EXIT_INSN(),
10096 		},
10097 		INTERNAL,
10098 		{ },
10099 		{ { 0, 1 } },
10100 	},
10101 	{
10102 		"JMP_JSGE_K: Signed jump: value walk 1",
10103 		.u.insns_int = {
10104 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10105 			BPF_LD_IMM64(R1, -3),
10106 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 6),
10107 			BPF_ALU64_IMM(BPF_ADD, R1, 1),
10108 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 4),
10109 			BPF_ALU64_IMM(BPF_ADD, R1, 1),
10110 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 2),
10111 			BPF_ALU64_IMM(BPF_ADD, R1, 1),
10112 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 1),
10113 			BPF_EXIT_INSN(),		/* bad exit */
10114 			BPF_ALU32_IMM(BPF_MOV, R0, 1),	/* good exit */
10115 			BPF_EXIT_INSN(),
10116 		},
10117 		INTERNAL,
10118 		{ },
10119 		{ { 0, 1 } },
10120 	},
10121 	{
10122 		"JMP_JSGE_K: Signed jump: value walk 2",
10123 		.u.insns_int = {
10124 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10125 			BPF_LD_IMM64(R1, -3),
10126 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 4),
10127 			BPF_ALU64_IMM(BPF_ADD, R1, 2),
10128 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 2),
10129 			BPF_ALU64_IMM(BPF_ADD, R1, 2),
10130 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 1),
10131 			BPF_EXIT_INSN(),		/* bad exit */
10132 			BPF_ALU32_IMM(BPF_MOV, R0, 1),	/* good exit */
10133 			BPF_EXIT_INSN(),
10134 		},
10135 		INTERNAL,
10136 		{ },
10137 		{ { 0, 1 } },
10138 	},
10139 	/* BPF_JMP | BPF_JGT | BPF_K */
10140 	{
10141 		"JMP_JGT_K: if (3 > 2) return 1",
10142 		.u.insns_int = {
10143 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10144 			BPF_LD_IMM64(R1, 3),
10145 			BPF_JMP_IMM(BPF_JGT, R1, 2, 1),
10146 			BPF_EXIT_INSN(),
10147 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10148 			BPF_EXIT_INSN(),
10149 		},
10150 		INTERNAL,
10151 		{ },
10152 		{ { 0, 1 } },
10153 	},
10154 	{
10155 		"JMP_JGT_K: Unsigned jump: if (-1 > 1) return 1",
10156 		.u.insns_int = {
10157 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10158 			BPF_LD_IMM64(R1, -1),
10159 			BPF_JMP_IMM(BPF_JGT, R1, 1, 1),
10160 			BPF_EXIT_INSN(),
10161 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10162 			BPF_EXIT_INSN(),
10163 		},
10164 		INTERNAL,
10165 		{ },
10166 		{ { 0, 1 } },
10167 	},
10168 	/* BPF_JMP | BPF_JLT | BPF_K */
10169 	{
10170 		"JMP_JLT_K: if (2 < 3) return 1",
10171 		.u.insns_int = {
10172 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10173 			BPF_LD_IMM64(R1, 2),
10174 			BPF_JMP_IMM(BPF_JLT, R1, 3, 1),
10175 			BPF_EXIT_INSN(),
10176 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10177 			BPF_EXIT_INSN(),
10178 		},
10179 		INTERNAL,
10180 		{ },
10181 		{ { 0, 1 } },
10182 	},
10183 	{
10184 		"JMP_JGT_K: Unsigned jump: if (1 < -1) return 1",
10185 		.u.insns_int = {
10186 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10187 			BPF_LD_IMM64(R1, 1),
10188 			BPF_JMP_IMM(BPF_JLT, R1, -1, 1),
10189 			BPF_EXIT_INSN(),
10190 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10191 			BPF_EXIT_INSN(),
10192 		},
10193 		INTERNAL,
10194 		{ },
10195 		{ { 0, 1 } },
10196 	},
10197 	/* BPF_JMP | BPF_JGE | BPF_K */
10198 	{
10199 		"JMP_JGE_K: if (3 >= 2) return 1",
10200 		.u.insns_int = {
10201 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10202 			BPF_LD_IMM64(R1, 3),
10203 			BPF_JMP_IMM(BPF_JGE, R1, 2, 1),
10204 			BPF_EXIT_INSN(),
10205 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10206 			BPF_EXIT_INSN(),
10207 		},
10208 		INTERNAL,
10209 		{ },
10210 		{ { 0, 1 } },
10211 	},
10212 	/* BPF_JMP | BPF_JLE | BPF_K */
10213 	{
10214 		"JMP_JLE_K: if (2 <= 3) return 1",
10215 		.u.insns_int = {
10216 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10217 			BPF_LD_IMM64(R1, 2),
10218 			BPF_JMP_IMM(BPF_JLE, R1, 3, 1),
10219 			BPF_EXIT_INSN(),
10220 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10221 			BPF_EXIT_INSN(),
10222 		},
10223 		INTERNAL,
10224 		{ },
10225 		{ { 0, 1 } },
10226 	},
10227 	/* BPF_JMP | BPF_JGT | BPF_K jump backwards */
10228 	{
10229 		"JMP_JGT_K: if (3 > 2) return 1 (jump backwards)",
10230 		.u.insns_int = {
10231 			BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
10232 			BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */
10233 			BPF_EXIT_INSN(),
10234 			BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
10235 			BPF_LD_IMM64(R1, 3), /* note: this takes 2 insns */
10236 			BPF_JMP_IMM(BPF_JGT, R1, 2, -6), /* goto out */
10237 			BPF_EXIT_INSN(),
10238 		},
10239 		INTERNAL,
10240 		{ },
10241 		{ { 0, 1 } },
10242 	},
10243 	{
10244 		"JMP_JGE_K: if (3 >= 3) return 1",
10245 		.u.insns_int = {
10246 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10247 			BPF_LD_IMM64(R1, 3),
10248 			BPF_JMP_IMM(BPF_JGE, R1, 3, 1),
10249 			BPF_EXIT_INSN(),
10250 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10251 			BPF_EXIT_INSN(),
10252 		},
10253 		INTERNAL,
10254 		{ },
10255 		{ { 0, 1 } },
10256 	},
10257 	/* BPF_JMP | BPF_JLT | BPF_K jump backwards */
10258 	{
10259 		"JMP_JGT_K: if (2 < 3) return 1 (jump backwards)",
10260 		.u.insns_int = {
10261 			BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
10262 			BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */
10263 			BPF_EXIT_INSN(),
10264 			BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
10265 			BPF_LD_IMM64(R1, 2), /* note: this takes 2 insns */
10266 			BPF_JMP_IMM(BPF_JLT, R1, 3, -6), /* goto out */
10267 			BPF_EXIT_INSN(),
10268 		},
10269 		INTERNAL,
10270 		{ },
10271 		{ { 0, 1 } },
10272 	},
10273 	{
10274 		"JMP_JLE_K: if (3 <= 3) return 1",
10275 		.u.insns_int = {
10276 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10277 			BPF_LD_IMM64(R1, 3),
10278 			BPF_JMP_IMM(BPF_JLE, R1, 3, 1),
10279 			BPF_EXIT_INSN(),
10280 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10281 			BPF_EXIT_INSN(),
10282 		},
10283 		INTERNAL,
10284 		{ },
10285 		{ { 0, 1 } },
10286 	},
10287 	/* BPF_JMP | BPF_JNE | BPF_K */
10288 	{
10289 		"JMP_JNE_K: if (3 != 2) return 1",
10290 		.u.insns_int = {
10291 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10292 			BPF_LD_IMM64(R1, 3),
10293 			BPF_JMP_IMM(BPF_JNE, R1, 2, 1),
10294 			BPF_EXIT_INSN(),
10295 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10296 			BPF_EXIT_INSN(),
10297 		},
10298 		INTERNAL,
10299 		{ },
10300 		{ { 0, 1 } },
10301 	},
10302 	/* BPF_JMP | BPF_JEQ | BPF_K */
10303 	{
10304 		"JMP_JEQ_K: if (3 == 3) return 1",
10305 		.u.insns_int = {
10306 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10307 			BPF_LD_IMM64(R1, 3),
10308 			BPF_JMP_IMM(BPF_JEQ, R1, 3, 1),
10309 			BPF_EXIT_INSN(),
10310 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10311 			BPF_EXIT_INSN(),
10312 		},
10313 		INTERNAL,
10314 		{ },
10315 		{ { 0, 1 } },
10316 	},
10317 	/* BPF_JMP | BPF_JSET | BPF_K */
10318 	{
10319 		"JMP_JSET_K: if (0x3 & 0x2) return 1",
10320 		.u.insns_int = {
10321 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10322 			BPF_LD_IMM64(R1, 3),
10323 			BPF_JMP_IMM(BPF_JSET, R1, 2, 1),
10324 			BPF_EXIT_INSN(),
10325 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10326 			BPF_EXIT_INSN(),
10327 		},
10328 		INTERNAL,
10329 		{ },
10330 		{ { 0, 1 } },
10331 	},
10332 	{
10333 		"JMP_JSET_K: if (0x3 & 0xffffffff) return 1",
10334 		.u.insns_int = {
10335 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10336 			BPF_LD_IMM64(R1, 3),
10337 			BPF_JMP_IMM(BPF_JSET, R1, 0xffffffff, 1),
10338 			BPF_EXIT_INSN(),
10339 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10340 			BPF_EXIT_INSN(),
10341 		},
10342 		INTERNAL,
10343 		{ },
10344 		{ { 0, 1 } },
10345 	},
10346 	/* BPF_JMP | BPF_JSGT | BPF_X */
10347 	{
10348 		"JMP_JSGT_X: Signed jump: if (-1 > -2) return 1",
10349 		.u.insns_int = {
10350 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10351 			BPF_LD_IMM64(R1, -1),
10352 			BPF_LD_IMM64(R2, -2),
10353 			BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
10354 			BPF_EXIT_INSN(),
10355 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10356 			BPF_EXIT_INSN(),
10357 		},
10358 		INTERNAL,
10359 		{ },
10360 		{ { 0, 1 } },
10361 	},
10362 	{
10363 		"JMP_JSGT_X: Signed jump: if (-1 > -1) return 0",
10364 		.u.insns_int = {
10365 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10366 			BPF_LD_IMM64(R1, -1),
10367 			BPF_LD_IMM64(R2, -1),
10368 			BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
10369 			BPF_EXIT_INSN(),
10370 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10371 			BPF_EXIT_INSN(),
10372 		},
10373 		INTERNAL,
10374 		{ },
10375 		{ { 0, 1 } },
10376 	},
10377 	/* BPF_JMP | BPF_JSLT | BPF_X */
10378 	{
10379 		"JMP_JSLT_X: Signed jump: if (-2 < -1) return 1",
10380 		.u.insns_int = {
10381 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10382 			BPF_LD_IMM64(R1, -1),
10383 			BPF_LD_IMM64(R2, -2),
10384 			BPF_JMP_REG(BPF_JSLT, R2, R1, 1),
10385 			BPF_EXIT_INSN(),
10386 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10387 			BPF_EXIT_INSN(),
10388 		},
10389 		INTERNAL,
10390 		{ },
10391 		{ { 0, 1 } },
10392 	},
10393 	{
10394 		"JMP_JSLT_X: Signed jump: if (-1 < -1) return 0",
10395 		.u.insns_int = {
10396 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10397 			BPF_LD_IMM64(R1, -1),
10398 			BPF_LD_IMM64(R2, -1),
10399 			BPF_JMP_REG(BPF_JSLT, R1, R2, 1),
10400 			BPF_EXIT_INSN(),
10401 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10402 			BPF_EXIT_INSN(),
10403 		},
10404 		INTERNAL,
10405 		{ },
10406 		{ { 0, 1 } },
10407 	},
10408 	/* BPF_JMP | BPF_JSGE | BPF_X */
10409 	{
10410 		"JMP_JSGE_X: Signed jump: if (-1 >= -2) return 1",
10411 		.u.insns_int = {
10412 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10413 			BPF_LD_IMM64(R1, -1),
10414 			BPF_LD_IMM64(R2, -2),
10415 			BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
10416 			BPF_EXIT_INSN(),
10417 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10418 			BPF_EXIT_INSN(),
10419 		},
10420 		INTERNAL,
10421 		{ },
10422 		{ { 0, 1 } },
10423 	},
10424 	{
10425 		"JMP_JSGE_X: Signed jump: if (-1 >= -1) return 1",
10426 		.u.insns_int = {
10427 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10428 			BPF_LD_IMM64(R1, -1),
10429 			BPF_LD_IMM64(R2, -1),
10430 			BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
10431 			BPF_EXIT_INSN(),
10432 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10433 			BPF_EXIT_INSN(),
10434 		},
10435 		INTERNAL,
10436 		{ },
10437 		{ { 0, 1 } },
10438 	},
10439 	/* BPF_JMP | BPF_JSLE | BPF_X */
10440 	{
10441 		"JMP_JSLE_X: Signed jump: if (-2 <= -1) return 1",
10442 		.u.insns_int = {
10443 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10444 			BPF_LD_IMM64(R1, -1),
10445 			BPF_LD_IMM64(R2, -2),
10446 			BPF_JMP_REG(BPF_JSLE, R2, R1, 1),
10447 			BPF_EXIT_INSN(),
10448 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10449 			BPF_EXIT_INSN(),
10450 		},
10451 		INTERNAL,
10452 		{ },
10453 		{ { 0, 1 } },
10454 	},
10455 	{
10456 		"JMP_JSLE_X: Signed jump: if (-1 <= -1) return 1",
10457 		.u.insns_int = {
10458 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10459 			BPF_LD_IMM64(R1, -1),
10460 			BPF_LD_IMM64(R2, -1),
10461 			BPF_JMP_REG(BPF_JSLE, R1, R2, 1),
10462 			BPF_EXIT_INSN(),
10463 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10464 			BPF_EXIT_INSN(),
10465 		},
10466 		INTERNAL,
10467 		{ },
10468 		{ { 0, 1 } },
10469 	},
10470 	/* BPF_JMP | BPF_JGT | BPF_X */
10471 	{
10472 		"JMP_JGT_X: if (3 > 2) return 1",
10473 		.u.insns_int = {
10474 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10475 			BPF_LD_IMM64(R1, 3),
10476 			BPF_LD_IMM64(R2, 2),
10477 			BPF_JMP_REG(BPF_JGT, R1, R2, 1),
10478 			BPF_EXIT_INSN(),
10479 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10480 			BPF_EXIT_INSN(),
10481 		},
10482 		INTERNAL,
10483 		{ },
10484 		{ { 0, 1 } },
10485 	},
10486 	{
10487 		"JMP_JGT_X: Unsigned jump: if (-1 > 1) return 1",
10488 		.u.insns_int = {
10489 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10490 			BPF_LD_IMM64(R1, -1),
10491 			BPF_LD_IMM64(R2, 1),
10492 			BPF_JMP_REG(BPF_JGT, R1, R2, 1),
10493 			BPF_EXIT_INSN(),
10494 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10495 			BPF_EXIT_INSN(),
10496 		},
10497 		INTERNAL,
10498 		{ },
10499 		{ { 0, 1 } },
10500 	},
10501 	/* BPF_JMP | BPF_JLT | BPF_X */
10502 	{
10503 		"JMP_JLT_X: if (2 < 3) return 1",
10504 		.u.insns_int = {
10505 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10506 			BPF_LD_IMM64(R1, 3),
10507 			BPF_LD_IMM64(R2, 2),
10508 			BPF_JMP_REG(BPF_JLT, R2, R1, 1),
10509 			BPF_EXIT_INSN(),
10510 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10511 			BPF_EXIT_INSN(),
10512 		},
10513 		INTERNAL,
10514 		{ },
10515 		{ { 0, 1 } },
10516 	},
10517 	{
10518 		"JMP_JLT_X: Unsigned jump: if (1 < -1) return 1",
10519 		.u.insns_int = {
10520 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10521 			BPF_LD_IMM64(R1, -1),
10522 			BPF_LD_IMM64(R2, 1),
10523 			BPF_JMP_REG(BPF_JLT, R2, R1, 1),
10524 			BPF_EXIT_INSN(),
10525 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10526 			BPF_EXIT_INSN(),
10527 		},
10528 		INTERNAL,
10529 		{ },
10530 		{ { 0, 1 } },
10531 	},
10532 	/* BPF_JMP | BPF_JGE | BPF_X */
10533 	{
10534 		"JMP_JGE_X: if (3 >= 2) return 1",
10535 		.u.insns_int = {
10536 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10537 			BPF_LD_IMM64(R1, 3),
10538 			BPF_LD_IMM64(R2, 2),
10539 			BPF_JMP_REG(BPF_JGE, R1, R2, 1),
10540 			BPF_EXIT_INSN(),
10541 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10542 			BPF_EXIT_INSN(),
10543 		},
10544 		INTERNAL,
10545 		{ },
10546 		{ { 0, 1 } },
10547 	},
10548 	{
10549 		"JMP_JGE_X: if (3 >= 3) return 1",
10550 		.u.insns_int = {
10551 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10552 			BPF_LD_IMM64(R1, 3),
10553 			BPF_LD_IMM64(R2, 3),
10554 			BPF_JMP_REG(BPF_JGE, R1, R2, 1),
10555 			BPF_EXIT_INSN(),
10556 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10557 			BPF_EXIT_INSN(),
10558 		},
10559 		INTERNAL,
10560 		{ },
10561 		{ { 0, 1 } },
10562 	},
10563 	/* BPF_JMP | BPF_JLE | BPF_X */
10564 	{
10565 		"JMP_JLE_X: if (2 <= 3) return 1",
10566 		.u.insns_int = {
10567 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10568 			BPF_LD_IMM64(R1, 3),
10569 			BPF_LD_IMM64(R2, 2),
10570 			BPF_JMP_REG(BPF_JLE, R2, R1, 1),
10571 			BPF_EXIT_INSN(),
10572 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10573 			BPF_EXIT_INSN(),
10574 		},
10575 		INTERNAL,
10576 		{ },
10577 		{ { 0, 1 } },
10578 	},
10579 	{
10580 		"JMP_JLE_X: if (3 <= 3) return 1",
10581 		.u.insns_int = {
10582 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10583 			BPF_LD_IMM64(R1, 3),
10584 			BPF_LD_IMM64(R2, 3),
10585 			BPF_JMP_REG(BPF_JLE, R1, R2, 1),
10586 			BPF_EXIT_INSN(),
10587 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10588 			BPF_EXIT_INSN(),
10589 		},
10590 		INTERNAL,
10591 		{ },
10592 		{ { 0, 1 } },
10593 	},
10594 	{
10595 		/* Mainly testing JIT + imm64 here. */
10596 		"JMP_JGE_X: ldimm64 test 1",
10597 		.u.insns_int = {
10598 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10599 			BPF_LD_IMM64(R1, 3),
10600 			BPF_LD_IMM64(R2, 2),
10601 			BPF_JMP_REG(BPF_JGE, R1, R2, 2),
10602 			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
10603 			BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
10604 			BPF_EXIT_INSN(),
10605 		},
10606 		INTERNAL,
10607 		{ },
10608 		{ { 0, 0xeeeeeeeeU } },
10609 	},
10610 	{
10611 		"JMP_JGE_X: ldimm64 test 2",
10612 		.u.insns_int = {
10613 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10614 			BPF_LD_IMM64(R1, 3),
10615 			BPF_LD_IMM64(R2, 2),
10616 			BPF_JMP_REG(BPF_JGE, R1, R2, 0),
10617 			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
10618 			BPF_EXIT_INSN(),
10619 		},
10620 		INTERNAL,
10621 		{ },
10622 		{ { 0, 0xffffffffU } },
10623 	},
10624 	{
10625 		"JMP_JGE_X: ldimm64 test 3",
10626 		.u.insns_int = {
10627 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10628 			BPF_LD_IMM64(R1, 3),
10629 			BPF_LD_IMM64(R2, 2),
10630 			BPF_JMP_REG(BPF_JGE, R1, R2, 4),
10631 			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
10632 			BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
10633 			BPF_EXIT_INSN(),
10634 		},
10635 		INTERNAL,
10636 		{ },
10637 		{ { 0, 1 } },
10638 	},
10639 	{
10640 		"JMP_JLE_X: ldimm64 test 1",
10641 		.u.insns_int = {
10642 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10643 			BPF_LD_IMM64(R1, 3),
10644 			BPF_LD_IMM64(R2, 2),
10645 			BPF_JMP_REG(BPF_JLE, R2, R1, 2),
10646 			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
10647 			BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
10648 			BPF_EXIT_INSN(),
10649 		},
10650 		INTERNAL,
10651 		{ },
10652 		{ { 0, 0xeeeeeeeeU } },
10653 	},
10654 	{
10655 		"JMP_JLE_X: ldimm64 test 2",
10656 		.u.insns_int = {
10657 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10658 			BPF_LD_IMM64(R1, 3),
10659 			BPF_LD_IMM64(R2, 2),
10660 			BPF_JMP_REG(BPF_JLE, R2, R1, 0),
10661 			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
10662 			BPF_EXIT_INSN(),
10663 		},
10664 		INTERNAL,
10665 		{ },
10666 		{ { 0, 0xffffffffU } },
10667 	},
10668 	{
10669 		"JMP_JLE_X: ldimm64 test 3",
10670 		.u.insns_int = {
10671 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10672 			BPF_LD_IMM64(R1, 3),
10673 			BPF_LD_IMM64(R2, 2),
10674 			BPF_JMP_REG(BPF_JLE, R2, R1, 4),
10675 			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
10676 			BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
10677 			BPF_EXIT_INSN(),
10678 		},
10679 		INTERNAL,
10680 		{ },
10681 		{ { 0, 1 } },
10682 	},
10683 	/* BPF_JMP | BPF_JNE | BPF_X */
10684 	{
10685 		"JMP_JNE_X: if (3 != 2) return 1",
10686 		.u.insns_int = {
10687 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10688 			BPF_LD_IMM64(R1, 3),
10689 			BPF_LD_IMM64(R2, 2),
10690 			BPF_JMP_REG(BPF_JNE, R1, R2, 1),
10691 			BPF_EXIT_INSN(),
10692 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10693 			BPF_EXIT_INSN(),
10694 		},
10695 		INTERNAL,
10696 		{ },
10697 		{ { 0, 1 } },
10698 	},
10699 	/* BPF_JMP | BPF_JEQ | BPF_X */
10700 	{
10701 		"JMP_JEQ_X: if (3 == 3) return 1",
10702 		.u.insns_int = {
10703 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10704 			BPF_LD_IMM64(R1, 3),
10705 			BPF_LD_IMM64(R2, 3),
10706 			BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
10707 			BPF_EXIT_INSN(),
10708 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10709 			BPF_EXIT_INSN(),
10710 		},
10711 		INTERNAL,
10712 		{ },
10713 		{ { 0, 1 } },
10714 	},
10715 	/* BPF_JMP | BPF_JSET | BPF_X */
10716 	{
10717 		"JMP_JSET_X: if (0x3 & 0x2) return 1",
10718 		.u.insns_int = {
10719 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10720 			BPF_LD_IMM64(R1, 3),
10721 			BPF_LD_IMM64(R2, 2),
10722 			BPF_JMP_REG(BPF_JSET, R1, R2, 1),
10723 			BPF_EXIT_INSN(),
10724 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10725 			BPF_EXIT_INSN(),
10726 		},
10727 		INTERNAL,
10728 		{ },
10729 		{ { 0, 1 } },
10730 	},
10731 	{
10732 		"JMP_JSET_X: if (0x3 & 0xffffffff) return 1",
10733 		.u.insns_int = {
10734 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10735 			BPF_LD_IMM64(R1, 3),
10736 			BPF_LD_IMM64(R2, 0xffffffff),
10737 			BPF_JMP_REG(BPF_JSET, R1, R2, 1),
10738 			BPF_EXIT_INSN(),
10739 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
10740 			BPF_EXIT_INSN(),
10741 		},
10742 		INTERNAL,
10743 		{ },
10744 		{ { 0, 1 } },
10745 	},
10746 	{
10747 		"JMP_JA: Jump, gap, jump, ...",
10748 		{ },
10749 		CLASSIC | FLAG_NO_DATA,
10750 		{ },
10751 		{ { 0, 0xababcbac } },
10752 		.fill_helper = bpf_fill_ja,
10753 	},
10754 	{	/* Mainly checking JIT here. */
10755 		"BPF_MAXINSNS: Maximum possible literals",
10756 		{ },
10757 		CLASSIC | FLAG_NO_DATA,
10758 		{ },
10759 		{ { 0, 0xffffffff } },
10760 		.fill_helper = bpf_fill_maxinsns1,
10761 	},
10762 	{	/* Mainly checking JIT here. */
10763 		"BPF_MAXINSNS: Single literal",
10764 		{ },
10765 		CLASSIC | FLAG_NO_DATA,
10766 		{ },
10767 		{ { 0, 0xfefefefe } },
10768 		.fill_helper = bpf_fill_maxinsns2,
10769 	},
10770 	{	/* Mainly checking JIT here. */
10771 		"BPF_MAXINSNS: Run/add until end",
10772 		{ },
10773 		CLASSIC | FLAG_NO_DATA,
10774 		{ },
10775 		{ { 0, 0x947bf368 } },
10776 		.fill_helper = bpf_fill_maxinsns3,
10777 	},
10778 	{
10779 		"BPF_MAXINSNS: Too many instructions",
10780 		{ },
10781 		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
10782 		{ },
10783 		{ },
10784 		.fill_helper = bpf_fill_maxinsns4,
10785 		.expected_errcode = -EINVAL,
10786 	},
10787 	{	/* Mainly checking JIT here. */
10788 		"BPF_MAXINSNS: Very long jump",
10789 		{ },
10790 		CLASSIC | FLAG_NO_DATA,
10791 		{ },
10792 		{ { 0, 0xabababab } },
10793 		.fill_helper = bpf_fill_maxinsns5,
10794 	},
10795 	{	/* Mainly checking JIT here. */
10796 		"BPF_MAXINSNS: Ctx heavy transformations",
10797 		{ },
10798 		CLASSIC,
10799 		{ },
10800 		{
10801 			{  1, SKB_VLAN_PRESENT },
10802 			{ 10, SKB_VLAN_PRESENT }
10803 		},
10804 		.fill_helper = bpf_fill_maxinsns6,
10805 	},
10806 	{	/* Mainly checking JIT here. */
10807 		"BPF_MAXINSNS: Call heavy transformations",
10808 		{ },
10809 		CLASSIC | FLAG_NO_DATA,
10810 		{ },
10811 		{ { 1, 0 }, { 10, 0 } },
10812 		.fill_helper = bpf_fill_maxinsns7,
10813 	},
10814 	{	/* Mainly checking JIT here. */
10815 		"BPF_MAXINSNS: Jump heavy test",
10816 		{ },
10817 		CLASSIC | FLAG_NO_DATA,
10818 		{ },
10819 		{ { 0, 0xffffffff } },
10820 		.fill_helper = bpf_fill_maxinsns8,
10821 	},
10822 	{	/* Mainly checking JIT here. */
10823 		"BPF_MAXINSNS: Very long jump backwards",
10824 		{ },
10825 		INTERNAL | FLAG_NO_DATA,
10826 		{ },
10827 		{ { 0, 0xcbababab } },
10828 		.fill_helper = bpf_fill_maxinsns9,
10829 	},
10830 	{	/* Mainly checking JIT here. */
10831 		"BPF_MAXINSNS: Edge hopping nuthouse",
10832 		{ },
10833 		INTERNAL | FLAG_NO_DATA,
10834 		{ },
10835 		{ { 0, 0xabababac } },
10836 		.fill_helper = bpf_fill_maxinsns10,
10837 	},
10838 	{
10839 		"BPF_MAXINSNS: Jump, gap, jump, ...",
10840 		{ },
10841 		CLASSIC | FLAG_NO_DATA,
10842 		{ },
10843 		{ { 0, 0xababcbac } },
10844 		.fill_helper = bpf_fill_maxinsns11,
10845 	},
10846 	{
10847 		"BPF_MAXINSNS: jump over MSH",
10848 		{ },
10849 		CLASSIC | FLAG_EXPECTED_FAIL,
10850 		{ 0xfa, 0xfb, 0xfc, 0xfd, },
10851 		{ { 4, 0xabababab } },
10852 		.fill_helper = bpf_fill_maxinsns12,
10853 		.expected_errcode = -EINVAL,
10854 	},
10855 	{
10856 		"BPF_MAXINSNS: exec all MSH",
10857 		{ },
10858 		CLASSIC,
10859 		{ 0xfa, 0xfb, 0xfc, 0xfd, },
10860 		{ { 4, 0xababab83 } },
10861 		.fill_helper = bpf_fill_maxinsns13,
10862 	},
10863 	{
10864 		"BPF_MAXINSNS: ld_abs+get_processor_id",
10865 		{ },
10866 		CLASSIC,
10867 		{ },
10868 		{ { 1, 0xbee } },
10869 		.fill_helper = bpf_fill_ld_abs_get_processor_id,
10870 	},
10871 	/*
10872 	 * LD_IND / LD_ABS on fragmented SKBs
10873 	 */
10874 	{
10875 		"LD_IND byte frag",
10876 		.u.insns = {
10877 			BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
10878 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x0),
10879 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10880 		},
10881 		CLASSIC | FLAG_SKB_FRAG,
10882 		{ },
10883 		{ {0x40, 0x42} },
10884 		.frag_data = {
10885 			0x42, 0x00, 0x00, 0x00,
10886 			0x43, 0x44, 0x00, 0x00,
10887 			0x21, 0x07, 0x19, 0x83,
10888 		},
10889 	},
10890 	{
10891 		"LD_IND halfword frag",
10892 		.u.insns = {
10893 			BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
10894 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x4),
10895 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10896 		},
10897 		CLASSIC | FLAG_SKB_FRAG,
10898 		{ },
10899 		{ {0x40, 0x4344} },
10900 		.frag_data = {
10901 			0x42, 0x00, 0x00, 0x00,
10902 			0x43, 0x44, 0x00, 0x00,
10903 			0x21, 0x07, 0x19, 0x83,
10904 		},
10905 	},
10906 	{
10907 		"LD_IND word frag",
10908 		.u.insns = {
10909 			BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
10910 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x8),
10911 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10912 		},
10913 		CLASSIC | FLAG_SKB_FRAG,
10914 		{ },
10915 		{ {0x40, 0x21071983} },
10916 		.frag_data = {
10917 			0x42, 0x00, 0x00, 0x00,
10918 			0x43, 0x44, 0x00, 0x00,
10919 			0x21, 0x07, 0x19, 0x83,
10920 		},
10921 	},
10922 	{
10923 		"LD_IND halfword mixed head/frag",
10924 		.u.insns = {
10925 			BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
10926 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
10927 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10928 		},
10929 		CLASSIC | FLAG_SKB_FRAG,
10930 		{ [0x3e] = 0x25, [0x3f] = 0x05, },
10931 		{ {0x40, 0x0519} },
10932 		.frag_data = { 0x19, 0x82 },
10933 	},
10934 	{
10935 		"LD_IND word mixed head/frag",
10936 		.u.insns = {
10937 			BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
10938 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
10939 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10940 		},
10941 		CLASSIC | FLAG_SKB_FRAG,
10942 		{ [0x3e] = 0x25, [0x3f] = 0x05, },
10943 		{ {0x40, 0x25051982} },
10944 		.frag_data = { 0x19, 0x82 },
10945 	},
10946 	{
10947 		"LD_ABS byte frag",
10948 		.u.insns = {
10949 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x40),
10950 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10951 		},
10952 		CLASSIC | FLAG_SKB_FRAG,
10953 		{ },
10954 		{ {0x40, 0x42} },
10955 		.frag_data = {
10956 			0x42, 0x00, 0x00, 0x00,
10957 			0x43, 0x44, 0x00, 0x00,
10958 			0x21, 0x07, 0x19, 0x83,
10959 		},
10960 	},
10961 	{
10962 		"LD_ABS halfword frag",
10963 		.u.insns = {
10964 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x44),
10965 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10966 		},
10967 		CLASSIC | FLAG_SKB_FRAG,
10968 		{ },
10969 		{ {0x40, 0x4344} },
10970 		.frag_data = {
10971 			0x42, 0x00, 0x00, 0x00,
10972 			0x43, 0x44, 0x00, 0x00,
10973 			0x21, 0x07, 0x19, 0x83,
10974 		},
10975 	},
10976 	{
10977 		"LD_ABS word frag",
10978 		.u.insns = {
10979 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x48),
10980 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10981 		},
10982 		CLASSIC | FLAG_SKB_FRAG,
10983 		{ },
10984 		{ {0x40, 0x21071983} },
10985 		.frag_data = {
10986 			0x42, 0x00, 0x00, 0x00,
10987 			0x43, 0x44, 0x00, 0x00,
10988 			0x21, 0x07, 0x19, 0x83,
10989 		},
10990 	},
10991 	{
10992 		"LD_ABS halfword mixed head/frag",
10993 		.u.insns = {
10994 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f),
10995 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10996 		},
10997 		CLASSIC | FLAG_SKB_FRAG,
10998 		{ [0x3e] = 0x25, [0x3f] = 0x05, },
10999 		{ {0x40, 0x0519} },
11000 		.frag_data = { 0x19, 0x82 },
11001 	},
11002 	{
11003 		"LD_ABS word mixed head/frag",
11004 		.u.insns = {
11005 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3e),
11006 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11007 		},
11008 		CLASSIC | FLAG_SKB_FRAG,
11009 		{ [0x3e] = 0x25, [0x3f] = 0x05, },
11010 		{ {0x40, 0x25051982} },
11011 		.frag_data = { 0x19, 0x82 },
11012 	},
11013 	/*
11014 	 * LD_IND / LD_ABS on non fragmented SKBs
11015 	 */
11016 	{
11017 		/*
11018 		 * this tests that the JIT/interpreter correctly resets X
11019 		 * before using it in an LD_IND instruction.
11020 		 */
11021 		"LD_IND byte default X",
11022 		.u.insns = {
11023 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
11024 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11025 		},
11026 		CLASSIC,
11027 		{ [0x1] = 0x42 },
11028 		{ {0x40, 0x42 } },
11029 	},
11030 	{
11031 		"LD_IND byte positive offset",
11032 		.u.insns = {
11033 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
11034 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
11035 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11036 		},
11037 		CLASSIC,
11038 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11039 		{ {0x40, 0x82 } },
11040 	},
11041 	{
11042 		"LD_IND byte negative offset",
11043 		.u.insns = {
11044 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
11045 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x1),
11046 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11047 		},
11048 		CLASSIC,
11049 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11050 		{ {0x40, 0x05 } },
11051 	},
11052 	{
11053 		"LD_IND byte positive offset, all ff",
11054 		.u.insns = {
11055 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
11056 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
11057 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11058 		},
11059 		CLASSIC,
11060 		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
11061 		{ {0x40, 0xff } },
11062 	},
11063 	{
11064 		"LD_IND byte positive offset, out of bounds",
11065 		.u.insns = {
11066 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
11067 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
11068 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11069 		},
11070 		CLASSIC,
11071 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11072 		{ {0x3f, 0 }, },
11073 	},
11074 	{
11075 		"LD_IND byte negative offset, out of bounds",
11076 		.u.insns = {
11077 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
11078 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x3f),
11079 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11080 		},
11081 		CLASSIC,
11082 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11083 		{ {0x3f, 0 } },
11084 	},
11085 	{
11086 		"LD_IND byte negative offset, multiple calls",
11087 		.u.insns = {
11088 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3b),
11089 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 1),
11090 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 2),
11091 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 3),
11092 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 4),
11093 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11094 		},
11095 		CLASSIC,
11096 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11097 		{ {0x40, 0x82 }, },
11098 	},
11099 	{
11100 		"LD_IND halfword positive offset",
11101 		.u.insns = {
11102 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
11103 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x2),
11104 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11105 		},
11106 		CLASSIC,
11107 		{
11108 			[0x1c] = 0xaa, [0x1d] = 0x55,
11109 			[0x1e] = 0xbb, [0x1f] = 0x66,
11110 			[0x20] = 0xcc, [0x21] = 0x77,
11111 			[0x22] = 0xdd, [0x23] = 0x88,
11112 		},
11113 		{ {0x40, 0xdd88 } },
11114 	},
11115 	{
11116 		"LD_IND halfword negative offset",
11117 		.u.insns = {
11118 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
11119 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x2),
11120 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11121 		},
11122 		CLASSIC,
11123 		{
11124 			[0x1c] = 0xaa, [0x1d] = 0x55,
11125 			[0x1e] = 0xbb, [0x1f] = 0x66,
11126 			[0x20] = 0xcc, [0x21] = 0x77,
11127 			[0x22] = 0xdd, [0x23] = 0x88,
11128 		},
11129 		{ {0x40, 0xbb66 } },
11130 	},
11131 	{
11132 		"LD_IND halfword unaligned",
11133 		.u.insns = {
11134 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
11135 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
11136 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11137 		},
11138 		CLASSIC,
11139 		{
11140 			[0x1c] = 0xaa, [0x1d] = 0x55,
11141 			[0x1e] = 0xbb, [0x1f] = 0x66,
11142 			[0x20] = 0xcc, [0x21] = 0x77,
11143 			[0x22] = 0xdd, [0x23] = 0x88,
11144 		},
11145 		{ {0x40, 0x66cc } },
11146 	},
11147 	{
11148 		"LD_IND halfword positive offset, all ff",
11149 		.u.insns = {
11150 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3d),
11151 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1),
11152 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11153 		},
11154 		CLASSIC,
11155 		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
11156 		{ {0x40, 0xffff } },
11157 	},
11158 	{
11159 		"LD_IND halfword positive offset, out of bounds",
11160 		.u.insns = {
11161 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
11162 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1),
11163 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11164 		},
11165 		CLASSIC,
11166 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11167 		{ {0x3f, 0 }, },
11168 	},
11169 	{
11170 		"LD_IND halfword negative offset, out of bounds",
11171 		.u.insns = {
11172 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
11173 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x3f),
11174 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11175 		},
11176 		CLASSIC,
11177 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11178 		{ {0x3f, 0 } },
11179 	},
11180 	{
11181 		"LD_IND word positive offset",
11182 		.u.insns = {
11183 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
11184 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x4),
11185 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11186 		},
11187 		CLASSIC,
11188 		{
11189 			[0x1c] = 0xaa, [0x1d] = 0x55,
11190 			[0x1e] = 0xbb, [0x1f] = 0x66,
11191 			[0x20] = 0xcc, [0x21] = 0x77,
11192 			[0x22] = 0xdd, [0x23] = 0x88,
11193 			[0x24] = 0xee, [0x25] = 0x99,
11194 			[0x26] = 0xff, [0x27] = 0xaa,
11195 		},
11196 		{ {0x40, 0xee99ffaa } },
11197 	},
11198 	{
11199 		"LD_IND word negative offset",
11200 		.u.insns = {
11201 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
11202 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x4),
11203 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11204 		},
11205 		CLASSIC,
11206 		{
11207 			[0x1c] = 0xaa, [0x1d] = 0x55,
11208 			[0x1e] = 0xbb, [0x1f] = 0x66,
11209 			[0x20] = 0xcc, [0x21] = 0x77,
11210 			[0x22] = 0xdd, [0x23] = 0x88,
11211 			[0x24] = 0xee, [0x25] = 0x99,
11212 			[0x26] = 0xff, [0x27] = 0xaa,
11213 		},
11214 		{ {0x40, 0xaa55bb66 } },
11215 	},
11216 	{
11217 		"LD_IND word unaligned (addr & 3 == 2)",
11218 		.u.insns = {
11219 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
11220 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
11221 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11222 		},
11223 		CLASSIC,
11224 		{
11225 			[0x1c] = 0xaa, [0x1d] = 0x55,
11226 			[0x1e] = 0xbb, [0x1f] = 0x66,
11227 			[0x20] = 0xcc, [0x21] = 0x77,
11228 			[0x22] = 0xdd, [0x23] = 0x88,
11229 			[0x24] = 0xee, [0x25] = 0x99,
11230 			[0x26] = 0xff, [0x27] = 0xaa,
11231 		},
11232 		{ {0x40, 0xbb66cc77 } },
11233 	},
11234 	{
11235 		"LD_IND word unaligned (addr & 3 == 1)",
11236 		.u.insns = {
11237 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
11238 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3),
11239 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11240 		},
11241 		CLASSIC,
11242 		{
11243 			[0x1c] = 0xaa, [0x1d] = 0x55,
11244 			[0x1e] = 0xbb, [0x1f] = 0x66,
11245 			[0x20] = 0xcc, [0x21] = 0x77,
11246 			[0x22] = 0xdd, [0x23] = 0x88,
11247 			[0x24] = 0xee, [0x25] = 0x99,
11248 			[0x26] = 0xff, [0x27] = 0xaa,
11249 		},
11250 		{ {0x40, 0x55bb66cc } },
11251 	},
11252 	{
11253 		"LD_IND word unaligned (addr & 3 == 3)",
11254 		.u.insns = {
11255 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
11256 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x1),
11257 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11258 		},
11259 		CLASSIC,
11260 		{
11261 			[0x1c] = 0xaa, [0x1d] = 0x55,
11262 			[0x1e] = 0xbb, [0x1f] = 0x66,
11263 			[0x20] = 0xcc, [0x21] = 0x77,
11264 			[0x22] = 0xdd, [0x23] = 0x88,
11265 			[0x24] = 0xee, [0x25] = 0x99,
11266 			[0x26] = 0xff, [0x27] = 0xaa,
11267 		},
11268 		{ {0x40, 0x66cc77dd } },
11269 	},
11270 	{
11271 		"LD_IND word positive offset, all ff",
11272 		.u.insns = {
11273 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3b),
11274 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1),
11275 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11276 		},
11277 		CLASSIC,
11278 		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
11279 		{ {0x40, 0xffffffff } },
11280 	},
11281 	{
11282 		"LD_IND word positive offset, out of bounds",
11283 		.u.insns = {
11284 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
11285 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1),
11286 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11287 		},
11288 		CLASSIC,
11289 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11290 		{ {0x3f, 0 }, },
11291 	},
11292 	{
11293 		"LD_IND word negative offset, out of bounds",
11294 		.u.insns = {
11295 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
11296 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3f),
11297 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11298 		},
11299 		CLASSIC,
11300 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11301 		{ {0x3f, 0 } },
11302 	},
11303 	{
11304 		"LD_ABS byte",
11305 		.u.insns = {
11306 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x20),
11307 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11308 		},
11309 		CLASSIC,
11310 		{
11311 			[0x1c] = 0xaa, [0x1d] = 0x55,
11312 			[0x1e] = 0xbb, [0x1f] = 0x66,
11313 			[0x20] = 0xcc, [0x21] = 0x77,
11314 			[0x22] = 0xdd, [0x23] = 0x88,
11315 			[0x24] = 0xee, [0x25] = 0x99,
11316 			[0x26] = 0xff, [0x27] = 0xaa,
11317 		},
11318 		{ {0x40, 0xcc } },
11319 	},
11320 	{
11321 		"LD_ABS byte positive offset, all ff",
11322 		.u.insns = {
11323 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f),
11324 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11325 		},
11326 		CLASSIC,
11327 		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
11328 		{ {0x40, 0xff } },
11329 	},
11330 	{
11331 		"LD_ABS byte positive offset, out of bounds",
11332 		.u.insns = {
11333 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f),
11334 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11335 		},
11336 		CLASSIC,
11337 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11338 		{ {0x3f, 0 }, },
11339 	},
11340 	{
11341 		"LD_ABS byte negative offset, out of bounds load",
11342 		.u.insns = {
11343 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, -1),
11344 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11345 		},
11346 		CLASSIC | FLAG_EXPECTED_FAIL,
11347 		.expected_errcode = -EINVAL,
11348 	},
11349 	{
11350 		"LD_ABS byte negative offset, in bounds",
11351 		.u.insns = {
11352 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
11353 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11354 		},
11355 		CLASSIC,
11356 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11357 		{ {0x40, 0x82 }, },
11358 	},
11359 	{
11360 		"LD_ABS byte negative offset, out of bounds",
11361 		.u.insns = {
11362 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
11363 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11364 		},
11365 		CLASSIC,
11366 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11367 		{ {0x3f, 0 }, },
11368 	},
11369 	{
11370 		"LD_ABS byte negative offset, multiple calls",
11371 		.u.insns = {
11372 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3c),
11373 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3d),
11374 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3e),
11375 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
11376 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11377 		},
11378 		CLASSIC,
11379 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11380 		{ {0x40, 0x82 }, },
11381 	},
11382 	{
11383 		"LD_ABS halfword",
11384 		.u.insns = {
11385 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x22),
11386 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11387 		},
11388 		CLASSIC,
11389 		{
11390 			[0x1c] = 0xaa, [0x1d] = 0x55,
11391 			[0x1e] = 0xbb, [0x1f] = 0x66,
11392 			[0x20] = 0xcc, [0x21] = 0x77,
11393 			[0x22] = 0xdd, [0x23] = 0x88,
11394 			[0x24] = 0xee, [0x25] = 0x99,
11395 			[0x26] = 0xff, [0x27] = 0xaa,
11396 		},
11397 		{ {0x40, 0xdd88 } },
11398 	},
11399 	{
11400 		"LD_ABS halfword unaligned",
11401 		.u.insns = {
11402 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x25),
11403 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11404 		},
11405 		CLASSIC,
11406 		{
11407 			[0x1c] = 0xaa, [0x1d] = 0x55,
11408 			[0x1e] = 0xbb, [0x1f] = 0x66,
11409 			[0x20] = 0xcc, [0x21] = 0x77,
11410 			[0x22] = 0xdd, [0x23] = 0x88,
11411 			[0x24] = 0xee, [0x25] = 0x99,
11412 			[0x26] = 0xff, [0x27] = 0xaa,
11413 		},
11414 		{ {0x40, 0x99ff } },
11415 	},
11416 	{
11417 		"LD_ABS halfword positive offset, all ff",
11418 		.u.insns = {
11419 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3e),
11420 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11421 		},
11422 		CLASSIC,
11423 		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
11424 		{ {0x40, 0xffff } },
11425 	},
11426 	{
11427 		"LD_ABS halfword positive offset, out of bounds",
11428 		.u.insns = {
11429 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f),
11430 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11431 		},
11432 		CLASSIC,
11433 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11434 		{ {0x3f, 0 }, },
11435 	},
11436 	{
11437 		"LD_ABS halfword negative offset, out of bounds load",
11438 		.u.insns = {
11439 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, -1),
11440 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11441 		},
11442 		CLASSIC | FLAG_EXPECTED_FAIL,
11443 		.expected_errcode = -EINVAL,
11444 	},
11445 	{
11446 		"LD_ABS halfword negative offset, in bounds",
11447 		.u.insns = {
11448 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e),
11449 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11450 		},
11451 		CLASSIC,
11452 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11453 		{ {0x40, 0x1982 }, },
11454 	},
11455 	{
11456 		"LD_ABS halfword negative offset, out of bounds",
11457 		.u.insns = {
11458 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e),
11459 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11460 		},
11461 		CLASSIC,
11462 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11463 		{ {0x3f, 0 }, },
11464 	},
11465 	{
11466 		"LD_ABS word",
11467 		.u.insns = {
11468 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x1c),
11469 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11470 		},
11471 		CLASSIC,
11472 		{
11473 			[0x1c] = 0xaa, [0x1d] = 0x55,
11474 			[0x1e] = 0xbb, [0x1f] = 0x66,
11475 			[0x20] = 0xcc, [0x21] = 0x77,
11476 			[0x22] = 0xdd, [0x23] = 0x88,
11477 			[0x24] = 0xee, [0x25] = 0x99,
11478 			[0x26] = 0xff, [0x27] = 0xaa,
11479 		},
11480 		{ {0x40, 0xaa55bb66 } },
11481 	},
11482 	{
11483 		"LD_ABS word unaligned (addr & 3 == 2)",
11484 		.u.insns = {
11485 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x22),
11486 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11487 		},
11488 		CLASSIC,
11489 		{
11490 			[0x1c] = 0xaa, [0x1d] = 0x55,
11491 			[0x1e] = 0xbb, [0x1f] = 0x66,
11492 			[0x20] = 0xcc, [0x21] = 0x77,
11493 			[0x22] = 0xdd, [0x23] = 0x88,
11494 			[0x24] = 0xee, [0x25] = 0x99,
11495 			[0x26] = 0xff, [0x27] = 0xaa,
11496 		},
11497 		{ {0x40, 0xdd88ee99 } },
11498 	},
11499 	{
11500 		"LD_ABS word unaligned (addr & 3 == 1)",
11501 		.u.insns = {
11502 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x21),
11503 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11504 		},
11505 		CLASSIC,
11506 		{
11507 			[0x1c] = 0xaa, [0x1d] = 0x55,
11508 			[0x1e] = 0xbb, [0x1f] = 0x66,
11509 			[0x20] = 0xcc, [0x21] = 0x77,
11510 			[0x22] = 0xdd, [0x23] = 0x88,
11511 			[0x24] = 0xee, [0x25] = 0x99,
11512 			[0x26] = 0xff, [0x27] = 0xaa,
11513 		},
11514 		{ {0x40, 0x77dd88ee } },
11515 	},
11516 	{
11517 		"LD_ABS word unaligned (addr & 3 == 3)",
11518 		.u.insns = {
11519 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x23),
11520 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11521 		},
11522 		CLASSIC,
11523 		{
11524 			[0x1c] = 0xaa, [0x1d] = 0x55,
11525 			[0x1e] = 0xbb, [0x1f] = 0x66,
11526 			[0x20] = 0xcc, [0x21] = 0x77,
11527 			[0x22] = 0xdd, [0x23] = 0x88,
11528 			[0x24] = 0xee, [0x25] = 0x99,
11529 			[0x26] = 0xff, [0x27] = 0xaa,
11530 		},
11531 		{ {0x40, 0x88ee99ff } },
11532 	},
11533 	{
11534 		"LD_ABS word positive offset, all ff",
11535 		.u.insns = {
11536 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3c),
11537 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11538 		},
11539 		CLASSIC,
11540 		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
11541 		{ {0x40, 0xffffffff } },
11542 	},
11543 	{
11544 		"LD_ABS word positive offset, out of bounds",
11545 		.u.insns = {
11546 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3f),
11547 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11548 		},
11549 		CLASSIC,
11550 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11551 		{ {0x3f, 0 }, },
11552 	},
11553 	{
11554 		"LD_ABS word negative offset, out of bounds load",
11555 		.u.insns = {
11556 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, -1),
11557 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11558 		},
11559 		CLASSIC | FLAG_EXPECTED_FAIL,
11560 		.expected_errcode = -EINVAL,
11561 	},
11562 	{
11563 		"LD_ABS word negative offset, in bounds",
11564 		.u.insns = {
11565 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c),
11566 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11567 		},
11568 		CLASSIC,
11569 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11570 		{ {0x40, 0x25051982 }, },
11571 	},
11572 	{
11573 		"LD_ABS word negative offset, out of bounds",
11574 		.u.insns = {
11575 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c),
11576 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11577 		},
11578 		CLASSIC,
11579 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11580 		{ {0x3f, 0 }, },
11581 	},
11582 	{
11583 		"LDX_MSH standalone, preserved A",
11584 		.u.insns = {
11585 			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
11586 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
11587 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11588 		},
11589 		CLASSIC,
11590 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11591 		{ {0x40, 0xffeebbaa }, },
11592 	},
11593 	{
11594 		"LDX_MSH standalone, preserved A 2",
11595 		.u.insns = {
11596 			BPF_STMT(BPF_LD | BPF_IMM, 0x175e9d63),
11597 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
11598 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3d),
11599 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e),
11600 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3f),
11601 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11602 		},
11603 		CLASSIC,
11604 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11605 		{ {0x40, 0x175e9d63 }, },
11606 	},
11607 	{
11608 		"LDX_MSH standalone, test result 1",
11609 		.u.insns = {
11610 			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
11611 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
11612 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
11613 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11614 		},
11615 		CLASSIC,
11616 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11617 		{ {0x40, 0x14 }, },
11618 	},
11619 	{
11620 		"LDX_MSH standalone, test result 2",
11621 		.u.insns = {
11622 			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
11623 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e),
11624 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
11625 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11626 		},
11627 		CLASSIC,
11628 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11629 		{ {0x40, 0x24 }, },
11630 	},
11631 	{
11632 		"LDX_MSH standalone, negative offset",
11633 		.u.insns = {
11634 			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
11635 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, -1),
11636 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
11637 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11638 		},
11639 		CLASSIC,
11640 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11641 		{ {0x40, 0 }, },
11642 	},
11643 	{
11644 		"LDX_MSH standalone, negative offset 2",
11645 		.u.insns = {
11646 			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
11647 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, SKF_LL_OFF + 0x3e),
11648 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
11649 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11650 		},
11651 		CLASSIC,
11652 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11653 		{ {0x40, 0x24 }, },
11654 	},
11655 	{
11656 		"LDX_MSH standalone, out of bounds",
11657 		.u.insns = {
11658 			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
11659 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x40),
11660 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
11661 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11662 		},
11663 		CLASSIC,
11664 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11665 		{ {0x40, 0 }, },
11666 	},
11667 	/*
11668 	 * verify that the interpreter or JIT correctly sets A and X
11669 	 * to 0.
11670 	 */
11671 	{
11672 		"ADD default X",
11673 		.u.insns = {
11674 			/*
11675 			 * A = 0x42
11676 			 * A = A + X
11677 			 * ret A
11678 			 */
11679 			BPF_STMT(BPF_LD | BPF_IMM, 0x42),
11680 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
11681 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11682 		},
11683 		CLASSIC | FLAG_NO_DATA,
11684 		{},
11685 		{ {0x1, 0x42 } },
11686 	},
11687 	{
11688 		"ADD default A",
11689 		.u.insns = {
11690 			/*
11691 			 * A = A + 0x42
11692 			 * ret A
11693 			 */
11694 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0x42),
11695 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11696 		},
11697 		CLASSIC | FLAG_NO_DATA,
11698 		{},
11699 		{ {0x1, 0x42 } },
11700 	},
11701 	{
11702 		"SUB default X",
11703 		.u.insns = {
11704 			/*
11705 			 * A = 0x66
11706 			 * A = A - X
11707 			 * ret A
11708 			 */
11709 			BPF_STMT(BPF_LD | BPF_IMM, 0x66),
11710 			BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
11711 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11712 		},
11713 		CLASSIC | FLAG_NO_DATA,
11714 		{},
11715 		{ {0x1, 0x66 } },
11716 	},
11717 	{
11718 		"SUB default A",
11719 		.u.insns = {
11720 			/*
11721 			 * A = A - -0x66
11722 			 * ret A
11723 			 */
11724 			BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, -0x66),
11725 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11726 		},
11727 		CLASSIC | FLAG_NO_DATA,
11728 		{},
11729 		{ {0x1, 0x66 } },
11730 	},
11731 	{
11732 		"MUL default X",
11733 		.u.insns = {
11734 			/*
11735 			 * A = 0x42
11736 			 * A = A * X
11737 			 * ret A
11738 			 */
11739 			BPF_STMT(BPF_LD | BPF_IMM, 0x42),
11740 			BPF_STMT(BPF_ALU | BPF_MUL | BPF_X, 0),
11741 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11742 		},
11743 		CLASSIC | FLAG_NO_DATA,
11744 		{},
11745 		{ {0x1, 0x0 } },
11746 	},
11747 	{
11748 		"MUL default A",
11749 		.u.insns = {
11750 			/*
11751 			 * A = A * 0x66
11752 			 * ret A
11753 			 */
11754 			BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 0x66),
11755 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11756 		},
11757 		CLASSIC | FLAG_NO_DATA,
11758 		{},
11759 		{ {0x1, 0x0 } },
11760 	},
11761 	{
11762 		"DIV default X",
11763 		.u.insns = {
11764 			/*
11765 			 * A = 0x42
11766 			 * A = A / X ; this halt the filter execution if X is 0
11767 			 * ret 0x42
11768 			 */
11769 			BPF_STMT(BPF_LD | BPF_IMM, 0x42),
11770 			BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
11771 			BPF_STMT(BPF_RET | BPF_K, 0x42),
11772 		},
11773 		CLASSIC | FLAG_NO_DATA,
11774 		{},
11775 		{ {0x1, 0x0 } },
11776 	},
11777 	{
11778 		"DIV default A",
11779 		.u.insns = {
11780 			/*
11781 			 * A = A / 1
11782 			 * ret A
11783 			 */
11784 			BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x1),
11785 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11786 		},
11787 		CLASSIC | FLAG_NO_DATA,
11788 		{},
11789 		{ {0x1, 0x0 } },
11790 	},
11791 	{
11792 		"MOD default X",
11793 		.u.insns = {
11794 			/*
11795 			 * A = 0x42
11796 			 * A = A mod X ; this halt the filter execution if X is 0
11797 			 * ret 0x42
11798 			 */
11799 			BPF_STMT(BPF_LD | BPF_IMM, 0x42),
11800 			BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
11801 			BPF_STMT(BPF_RET | BPF_K, 0x42),
11802 		},
11803 		CLASSIC | FLAG_NO_DATA,
11804 		{},
11805 		{ {0x1, 0x0 } },
11806 	},
11807 	{
11808 		"MOD default A",
11809 		.u.insns = {
11810 			/*
11811 			 * A = A mod 1
11812 			 * ret A
11813 			 */
11814 			BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x1),
11815 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11816 		},
11817 		CLASSIC | FLAG_NO_DATA,
11818 		{},
11819 		{ {0x1, 0x0 } },
11820 	},
11821 	{
11822 		"JMP EQ default A",
11823 		.u.insns = {
11824 			/*
11825 			 * cmp A, 0x0, 0, 1
11826 			 * ret 0x42
11827 			 * ret 0x66
11828 			 */
11829 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0, 0, 1),
11830 			BPF_STMT(BPF_RET | BPF_K, 0x42),
11831 			BPF_STMT(BPF_RET | BPF_K, 0x66),
11832 		},
11833 		CLASSIC | FLAG_NO_DATA,
11834 		{},
11835 		{ {0x1, 0x42 } },
11836 	},
11837 	{
11838 		"JMP EQ default X",
11839 		.u.insns = {
11840 			/*
11841 			 * A = 0x0
11842 			 * cmp A, X, 0, 1
11843 			 * ret 0x42
11844 			 * ret 0x66
11845 			 */
11846 			BPF_STMT(BPF_LD | BPF_IMM, 0x0),
11847 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0x0, 0, 1),
11848 			BPF_STMT(BPF_RET | BPF_K, 0x42),
11849 			BPF_STMT(BPF_RET | BPF_K, 0x66),
11850 		},
11851 		CLASSIC | FLAG_NO_DATA,
11852 		{},
11853 		{ {0x1, 0x42 } },
11854 	},
11855 	/* Checking interpreter vs JIT wrt signed extended imms. */
11856 	{
11857 		"JNE signed compare, test 1",
11858 		.u.insns_int = {
11859 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
11860 			BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
11861 			BPF_MOV64_REG(R2, R1),
11862 			BPF_ALU64_REG(BPF_AND, R2, R3),
11863 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
11864 			BPF_JMP_IMM(BPF_JNE, R2, -17104896, 1),
11865 			BPF_ALU32_IMM(BPF_MOV, R0, 2),
11866 			BPF_EXIT_INSN(),
11867 		},
11868 		INTERNAL,
11869 		{ },
11870 		{ { 0, 1 } },
11871 	},
11872 	{
11873 		"JNE signed compare, test 2",
11874 		.u.insns_int = {
11875 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
11876 			BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
11877 			BPF_MOV64_REG(R2, R1),
11878 			BPF_ALU64_REG(BPF_AND, R2, R3),
11879 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
11880 			BPF_JMP_IMM(BPF_JNE, R2, 0xfefb0000, 1),
11881 			BPF_ALU32_IMM(BPF_MOV, R0, 2),
11882 			BPF_EXIT_INSN(),
11883 		},
11884 		INTERNAL,
11885 		{ },
11886 		{ { 0, 1 } },
11887 	},
11888 	{
11889 		"JNE signed compare, test 3",
11890 		.u.insns_int = {
11891 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
11892 			BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
11893 			BPF_ALU32_IMM(BPF_MOV, R4, 0xfefb0000),
11894 			BPF_MOV64_REG(R2, R1),
11895 			BPF_ALU64_REG(BPF_AND, R2, R3),
11896 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
11897 			BPF_JMP_REG(BPF_JNE, R2, R4, 1),
11898 			BPF_ALU32_IMM(BPF_MOV, R0, 2),
11899 			BPF_EXIT_INSN(),
11900 		},
11901 		INTERNAL,
11902 		{ },
11903 		{ { 0, 2 } },
11904 	},
11905 	{
11906 		"JNE signed compare, test 4",
11907 		.u.insns_int = {
11908 			BPF_LD_IMM64(R1, -17104896),
11909 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
11910 			BPF_JMP_IMM(BPF_JNE, R1, -17104896, 1),
11911 			BPF_ALU32_IMM(BPF_MOV, R0, 2),
11912 			BPF_EXIT_INSN(),
11913 		},
11914 		INTERNAL,
11915 		{ },
11916 		{ { 0, 2 } },
11917 	},
11918 	{
11919 		"JNE signed compare, test 5",
11920 		.u.insns_int = {
11921 			BPF_LD_IMM64(R1, 0xfefb0000),
11922 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
11923 			BPF_JMP_IMM(BPF_JNE, R1, 0xfefb0000, 1),
11924 			BPF_ALU32_IMM(BPF_MOV, R0, 2),
11925 			BPF_EXIT_INSN(),
11926 		},
11927 		INTERNAL,
11928 		{ },
11929 		{ { 0, 1 } },
11930 	},
11931 	{
11932 		"JNE signed compare, test 6",
11933 		.u.insns_int = {
11934 			BPF_LD_IMM64(R1, 0x7efb0000),
11935 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
11936 			BPF_JMP_IMM(BPF_JNE, R1, 0x7efb0000, 1),
11937 			BPF_ALU32_IMM(BPF_MOV, R0, 2),
11938 			BPF_EXIT_INSN(),
11939 		},
11940 		INTERNAL,
11941 		{ },
11942 		{ { 0, 2 } },
11943 	},
11944 	{
11945 		"JNE signed compare, test 7",
11946 		.u.insns = {
11947 			BPF_STMT(BPF_LD | BPF_IMM, 0xffff0000),
11948 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
11949 			BPF_STMT(BPF_LD | BPF_IMM, 0xfefbbc12),
11950 			BPF_STMT(BPF_ALU | BPF_AND | BPF_X, 0),
11951 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0xfefb0000, 1, 0),
11952 			BPF_STMT(BPF_RET | BPF_K, 1),
11953 			BPF_STMT(BPF_RET | BPF_K, 2),
11954 		},
11955 		CLASSIC | FLAG_NO_DATA,
11956 		{},
11957 		{ { 0, 2 } },
11958 	},
11959 	/* BPF_LDX_MEM with operand aliasing */
11960 	{
11961 		"LDX_MEM_B: operand register aliasing",
11962 		.u.insns_int = {
11963 			BPF_ST_MEM(BPF_B, R10, -8, 123),
11964 			BPF_MOV64_REG(R0, R10),
11965 			BPF_LDX_MEM(BPF_B, R0, R0, -8),
11966 			BPF_EXIT_INSN(),
11967 		},
11968 		INTERNAL,
11969 		{ },
11970 		{ { 0, 123 } },
11971 		.stack_depth = 8,
11972 	},
11973 	{
11974 		"LDX_MEM_H: operand register aliasing",
11975 		.u.insns_int = {
11976 			BPF_ST_MEM(BPF_H, R10, -8, 12345),
11977 			BPF_MOV64_REG(R0, R10),
11978 			BPF_LDX_MEM(BPF_H, R0, R0, -8),
11979 			BPF_EXIT_INSN(),
11980 		},
11981 		INTERNAL,
11982 		{ },
11983 		{ { 0, 12345 } },
11984 		.stack_depth = 8,
11985 	},
11986 	{
11987 		"LDX_MEM_W: operand register aliasing",
11988 		.u.insns_int = {
11989 			BPF_ST_MEM(BPF_W, R10, -8, 123456789),
11990 			BPF_MOV64_REG(R0, R10),
11991 			BPF_LDX_MEM(BPF_W, R0, R0, -8),
11992 			BPF_EXIT_INSN(),
11993 		},
11994 		INTERNAL,
11995 		{ },
11996 		{ { 0, 123456789 } },
11997 		.stack_depth = 8,
11998 	},
11999 	{
12000 		"LDX_MEM_DW: operand register aliasing",
12001 		.u.insns_int = {
12002 			BPF_LD_IMM64(R1, 0x123456789abcdefULL),
12003 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
12004 			BPF_MOV64_REG(R0, R10),
12005 			BPF_LDX_MEM(BPF_DW, R0, R0, -8),
12006 			BPF_ALU64_REG(BPF_SUB, R0, R1),
12007 			BPF_MOV64_REG(R1, R0),
12008 			BPF_ALU64_IMM(BPF_RSH, R1, 32),
12009 			BPF_ALU64_REG(BPF_OR, R0, R1),
12010 			BPF_EXIT_INSN(),
12011 		},
12012 		INTERNAL,
12013 		{ },
12014 		{ { 0, 0 } },
12015 		.stack_depth = 8,
12016 	},
12017 	/*
12018 	 * Register (non-)clobbering tests for the case where a JIT implements
12019 	 * complex ALU or ATOMIC operations via function calls. If so, the
12020 	 * function call must be transparent to the eBPF registers. The JIT
12021 	 * must therefore save and restore relevant registers across the call.
12022 	 * The following tests check that the eBPF registers retain their
12023 	 * values after such an operation. Mainly intended for complex ALU
12024 	 * and atomic operation, but we run it for all. You never know...
12025 	 *
12026 	 * Note that each operations should be tested twice with different
12027 	 * destinations, to check preservation for all registers.
12028 	 */
12029 #define BPF_TEST_CLOBBER_ALU(alu, op, dst, src)			\
12030 	{							\
12031 		#alu "_" #op " to " #dst ": no clobbering",	\
12032 		.u.insns_int = {				\
12033 			BPF_ALU64_IMM(BPF_MOV, R0, R0),		\
12034 			BPF_ALU64_IMM(BPF_MOV, R1, R1),		\
12035 			BPF_ALU64_IMM(BPF_MOV, R2, R2),		\
12036 			BPF_ALU64_IMM(BPF_MOV, R3, R3),		\
12037 			BPF_ALU64_IMM(BPF_MOV, R4, R4),		\
12038 			BPF_ALU64_IMM(BPF_MOV, R5, R5),		\
12039 			BPF_ALU64_IMM(BPF_MOV, R6, R6),		\
12040 			BPF_ALU64_IMM(BPF_MOV, R7, R7),		\
12041 			BPF_ALU64_IMM(BPF_MOV, R8, R8),		\
12042 			BPF_ALU64_IMM(BPF_MOV, R9, R9),		\
12043 			BPF_##alu(BPF_ ##op, dst, src),		\
12044 			BPF_ALU32_IMM(BPF_MOV, dst, dst),	\
12045 			BPF_JMP_IMM(BPF_JNE, R0, R0, 10),	\
12046 			BPF_JMP_IMM(BPF_JNE, R1, R1, 9),	\
12047 			BPF_JMP_IMM(BPF_JNE, R2, R2, 8),	\
12048 			BPF_JMP_IMM(BPF_JNE, R3, R3, 7),	\
12049 			BPF_JMP_IMM(BPF_JNE, R4, R4, 6),	\
12050 			BPF_JMP_IMM(BPF_JNE, R5, R5, 5),	\
12051 			BPF_JMP_IMM(BPF_JNE, R6, R6, 4),	\
12052 			BPF_JMP_IMM(BPF_JNE, R7, R7, 3),	\
12053 			BPF_JMP_IMM(BPF_JNE, R8, R8, 2),	\
12054 			BPF_JMP_IMM(BPF_JNE, R9, R9, 1),	\
12055 			BPF_ALU64_IMM(BPF_MOV, R0, 1),		\
12056 			BPF_EXIT_INSN(),			\
12057 		},						\
12058 		INTERNAL,					\
12059 		{ },						\
12060 		{ { 0, 1 } }					\
12061 	}
12062 	/* ALU64 operations, register clobbering */
12063 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, AND, R8, 123456789),
12064 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, AND, R9, 123456789),
12065 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, OR, R8, 123456789),
12066 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, OR, R9, 123456789),
12067 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, XOR, R8, 123456789),
12068 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, XOR, R9, 123456789),
12069 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, LSH, R8, 12),
12070 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, LSH, R9, 12),
12071 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, RSH, R8, 12),
12072 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, RSH, R9, 12),
12073 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, ARSH, R8, 12),
12074 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, ARSH, R9, 12),
12075 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, ADD, R8, 123456789),
12076 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, ADD, R9, 123456789),
12077 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, SUB, R8, 123456789),
12078 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, SUB, R9, 123456789),
12079 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, MUL, R8, 123456789),
12080 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, MUL, R9, 123456789),
12081 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, DIV, R8, 123456789),
12082 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, DIV, R9, 123456789),
12083 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, MOD, R8, 123456789),
12084 	BPF_TEST_CLOBBER_ALU(ALU64_IMM, MOD, R9, 123456789),
12085 	/* ALU32 immediate operations, register clobbering */
12086 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, AND, R8, 123456789),
12087 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, AND, R9, 123456789),
12088 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, OR, R8, 123456789),
12089 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, OR, R9, 123456789),
12090 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, XOR, R8, 123456789),
12091 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, XOR, R9, 123456789),
12092 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, LSH, R8, 12),
12093 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, LSH, R9, 12),
12094 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, RSH, R8, 12),
12095 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, RSH, R9, 12),
12096 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, ARSH, R8, 12),
12097 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, ARSH, R9, 12),
12098 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, ADD, R8, 123456789),
12099 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, ADD, R9, 123456789),
12100 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, SUB, R8, 123456789),
12101 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, SUB, R9, 123456789),
12102 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, MUL, R8, 123456789),
12103 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, MUL, R9, 123456789),
12104 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, DIV, R8, 123456789),
12105 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, DIV, R9, 123456789),
12106 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, MOD, R8, 123456789),
12107 	BPF_TEST_CLOBBER_ALU(ALU32_IMM, MOD, R9, 123456789),
12108 	/* ALU64 register operations, register clobbering */
12109 	BPF_TEST_CLOBBER_ALU(ALU64_REG, AND, R8, R1),
12110 	BPF_TEST_CLOBBER_ALU(ALU64_REG, AND, R9, R1),
12111 	BPF_TEST_CLOBBER_ALU(ALU64_REG, OR, R8, R1),
12112 	BPF_TEST_CLOBBER_ALU(ALU64_REG, OR, R9, R1),
12113 	BPF_TEST_CLOBBER_ALU(ALU64_REG, XOR, R8, R1),
12114 	BPF_TEST_CLOBBER_ALU(ALU64_REG, XOR, R9, R1),
12115 	BPF_TEST_CLOBBER_ALU(ALU64_REG, LSH, R8, R1),
12116 	BPF_TEST_CLOBBER_ALU(ALU64_REG, LSH, R9, R1),
12117 	BPF_TEST_CLOBBER_ALU(ALU64_REG, RSH, R8, R1),
12118 	BPF_TEST_CLOBBER_ALU(ALU64_REG, RSH, R9, R1),
12119 	BPF_TEST_CLOBBER_ALU(ALU64_REG, ARSH, R8, R1),
12120 	BPF_TEST_CLOBBER_ALU(ALU64_REG, ARSH, R9, R1),
12121 	BPF_TEST_CLOBBER_ALU(ALU64_REG, ADD, R8, R1),
12122 	BPF_TEST_CLOBBER_ALU(ALU64_REG, ADD, R9, R1),
12123 	BPF_TEST_CLOBBER_ALU(ALU64_REG, SUB, R8, R1),
12124 	BPF_TEST_CLOBBER_ALU(ALU64_REG, SUB, R9, R1),
12125 	BPF_TEST_CLOBBER_ALU(ALU64_REG, MUL, R8, R1),
12126 	BPF_TEST_CLOBBER_ALU(ALU64_REG, MUL, R9, R1),
12127 	BPF_TEST_CLOBBER_ALU(ALU64_REG, DIV, R8, R1),
12128 	BPF_TEST_CLOBBER_ALU(ALU64_REG, DIV, R9, R1),
12129 	BPF_TEST_CLOBBER_ALU(ALU64_REG, MOD, R8, R1),
12130 	BPF_TEST_CLOBBER_ALU(ALU64_REG, MOD, R9, R1),
12131 	/* ALU32 register operations, register clobbering */
12132 	BPF_TEST_CLOBBER_ALU(ALU32_REG, AND, R8, R1),
12133 	BPF_TEST_CLOBBER_ALU(ALU32_REG, AND, R9, R1),
12134 	BPF_TEST_CLOBBER_ALU(ALU32_REG, OR, R8, R1),
12135 	BPF_TEST_CLOBBER_ALU(ALU32_REG, OR, R9, R1),
12136 	BPF_TEST_CLOBBER_ALU(ALU32_REG, XOR, R8, R1),
12137 	BPF_TEST_CLOBBER_ALU(ALU32_REG, XOR, R9, R1),
12138 	BPF_TEST_CLOBBER_ALU(ALU32_REG, LSH, R8, R1),
12139 	BPF_TEST_CLOBBER_ALU(ALU32_REG, LSH, R9, R1),
12140 	BPF_TEST_CLOBBER_ALU(ALU32_REG, RSH, R8, R1),
12141 	BPF_TEST_CLOBBER_ALU(ALU32_REG, RSH, R9, R1),
12142 	BPF_TEST_CLOBBER_ALU(ALU32_REG, ARSH, R8, R1),
12143 	BPF_TEST_CLOBBER_ALU(ALU32_REG, ARSH, R9, R1),
12144 	BPF_TEST_CLOBBER_ALU(ALU32_REG, ADD, R8, R1),
12145 	BPF_TEST_CLOBBER_ALU(ALU32_REG, ADD, R9, R1),
12146 	BPF_TEST_CLOBBER_ALU(ALU32_REG, SUB, R8, R1),
12147 	BPF_TEST_CLOBBER_ALU(ALU32_REG, SUB, R9, R1),
12148 	BPF_TEST_CLOBBER_ALU(ALU32_REG, MUL, R8, R1),
12149 	BPF_TEST_CLOBBER_ALU(ALU32_REG, MUL, R9, R1),
12150 	BPF_TEST_CLOBBER_ALU(ALU32_REG, DIV, R8, R1),
12151 	BPF_TEST_CLOBBER_ALU(ALU32_REG, DIV, R9, R1),
12152 	BPF_TEST_CLOBBER_ALU(ALU32_REG, MOD, R8, R1),
12153 	BPF_TEST_CLOBBER_ALU(ALU32_REG, MOD, R9, R1),
12154 #undef BPF_TEST_CLOBBER_ALU
12155 #define BPF_TEST_CLOBBER_ATOMIC(width, op)			\
12156 	{							\
12157 		"Atomic_" #width " " #op ": no clobbering",	\
12158 		.u.insns_int = {				\
12159 			BPF_ALU64_IMM(BPF_MOV, R0, 0),		\
12160 			BPF_ALU64_IMM(BPF_MOV, R1, 1),		\
12161 			BPF_ALU64_IMM(BPF_MOV, R2, 2),		\
12162 			BPF_ALU64_IMM(BPF_MOV, R3, 3),		\
12163 			BPF_ALU64_IMM(BPF_MOV, R4, 4),		\
12164 			BPF_ALU64_IMM(BPF_MOV, R5, 5),		\
12165 			BPF_ALU64_IMM(BPF_MOV, R6, 6),		\
12166 			BPF_ALU64_IMM(BPF_MOV, R7, 7),		\
12167 			BPF_ALU64_IMM(BPF_MOV, R8, 8),		\
12168 			BPF_ALU64_IMM(BPF_MOV, R9, 9),		\
12169 			BPF_ST_MEM(width, R10, -8,		\
12170 				   (op) == BPF_CMPXCHG ? 0 :	\
12171 				   (op) & BPF_FETCH ? 1 : 0),	\
12172 			BPF_ATOMIC_OP(width, op, R10, R1, -8),	\
12173 			BPF_JMP_IMM(BPF_JNE, R0, 0, 10),	\
12174 			BPF_JMP_IMM(BPF_JNE, R1, 1, 9),		\
12175 			BPF_JMP_IMM(BPF_JNE, R2, 2, 8),		\
12176 			BPF_JMP_IMM(BPF_JNE, R3, 3, 7),		\
12177 			BPF_JMP_IMM(BPF_JNE, R4, 4, 6),		\
12178 			BPF_JMP_IMM(BPF_JNE, R5, 5, 5),		\
12179 			BPF_JMP_IMM(BPF_JNE, R6, 6, 4),		\
12180 			BPF_JMP_IMM(BPF_JNE, R7, 7, 3),		\
12181 			BPF_JMP_IMM(BPF_JNE, R8, 8, 2),		\
12182 			BPF_JMP_IMM(BPF_JNE, R9, 9, 1),		\
12183 			BPF_ALU64_IMM(BPF_MOV, R0, 1),		\
12184 			BPF_EXIT_INSN(),			\
12185 		},						\
12186 		INTERNAL,					\
12187 		{ },						\
12188 		{ { 0, 1 } },					\
12189 		.stack_depth = 8,				\
12190 	}
12191 	/* 64-bit atomic operations, register clobbering */
12192 	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_ADD),
12193 	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_AND),
12194 	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_OR),
12195 	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_XOR),
12196 	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_ADD | BPF_FETCH),
12197 	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_AND | BPF_FETCH),
12198 	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_OR | BPF_FETCH),
12199 	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_XOR | BPF_FETCH),
12200 	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_XCHG),
12201 	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_CMPXCHG),
12202 	/* 32-bit atomic operations, register clobbering */
12203 	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_ADD),
12204 	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_AND),
12205 	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_OR),
12206 	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_XOR),
12207 	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_ADD | BPF_FETCH),
12208 	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_AND | BPF_FETCH),
12209 	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_OR | BPF_FETCH),
12210 	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_XOR | BPF_FETCH),
12211 	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_XCHG),
12212 	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_CMPXCHG),
12213 #undef BPF_TEST_CLOBBER_ATOMIC
12214 	/* Checking that ALU32 src is not zero extended in place */
12215 #define BPF_ALU32_SRC_ZEXT(op)					\
12216 	{							\
12217 		"ALU32_" #op "_X: src preserved in zext",	\
12218 		.u.insns_int = {				\
12219 			BPF_LD_IMM64(R1, 0x0123456789acbdefULL),\
12220 			BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),\
12221 			BPF_ALU64_REG(BPF_MOV, R0, R1),		\
12222 			BPF_ALU32_REG(BPF_##op, R2, R1),	\
12223 			BPF_ALU64_REG(BPF_SUB, R0, R1),		\
12224 			BPF_ALU64_REG(BPF_MOV, R1, R0),		\
12225 			BPF_ALU64_IMM(BPF_RSH, R1, 32),		\
12226 			BPF_ALU64_REG(BPF_OR, R0, R1),		\
12227 			BPF_EXIT_INSN(),			\
12228 		},						\
12229 		INTERNAL,					\
12230 		{ },						\
12231 		{ { 0, 0 } },					\
12232 	}
12233 	BPF_ALU32_SRC_ZEXT(MOV),
12234 	BPF_ALU32_SRC_ZEXT(AND),
12235 	BPF_ALU32_SRC_ZEXT(OR),
12236 	BPF_ALU32_SRC_ZEXT(XOR),
12237 	BPF_ALU32_SRC_ZEXT(ADD),
12238 	BPF_ALU32_SRC_ZEXT(SUB),
12239 	BPF_ALU32_SRC_ZEXT(MUL),
12240 	BPF_ALU32_SRC_ZEXT(DIV),
12241 	BPF_ALU32_SRC_ZEXT(MOD),
12242 #undef BPF_ALU32_SRC_ZEXT
12243 	/* Checking that ATOMIC32 src is not zero extended in place */
12244 #define BPF_ATOMIC32_SRC_ZEXT(op)					\
12245 	{								\
12246 		"ATOMIC_W_" #op ": src preserved in zext",		\
12247 		.u.insns_int = {					\
12248 			BPF_LD_IMM64(R0, 0x0123456789acbdefULL),	\
12249 			BPF_ALU64_REG(BPF_MOV, R1, R0),			\
12250 			BPF_ST_MEM(BPF_W, R10, -4, 0),			\
12251 			BPF_ATOMIC_OP(BPF_W, BPF_##op, R10, R1, -4),	\
12252 			BPF_ALU64_REG(BPF_SUB, R0, R1),			\
12253 			BPF_ALU64_REG(BPF_MOV, R1, R0),			\
12254 			BPF_ALU64_IMM(BPF_RSH, R1, 32),			\
12255 			BPF_ALU64_REG(BPF_OR, R0, R1),			\
12256 			BPF_EXIT_INSN(),				\
12257 		},							\
12258 		INTERNAL,						\
12259 		{ },							\
12260 		{ { 0, 0 } },						\
12261 		.stack_depth = 8,					\
12262 	}
12263 	BPF_ATOMIC32_SRC_ZEXT(ADD),
12264 	BPF_ATOMIC32_SRC_ZEXT(AND),
12265 	BPF_ATOMIC32_SRC_ZEXT(OR),
12266 	BPF_ATOMIC32_SRC_ZEXT(XOR),
12267 #undef BPF_ATOMIC32_SRC_ZEXT
12268 	/* Checking that CMPXCHG32 src is not zero extended in place */
12269 	{
12270 		"ATOMIC_W_CMPXCHG: src preserved in zext",
12271 		.u.insns_int = {
12272 			BPF_LD_IMM64(R1, 0x0123456789acbdefULL),
12273 			BPF_ALU64_REG(BPF_MOV, R2, R1),
12274 			BPF_ALU64_REG(BPF_MOV, R0, 0),
12275 			BPF_ST_MEM(BPF_W, R10, -4, 0),
12276 			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R1, -4),
12277 			BPF_ALU64_REG(BPF_SUB, R1, R2),
12278 			BPF_ALU64_REG(BPF_MOV, R2, R1),
12279 			BPF_ALU64_IMM(BPF_RSH, R2, 32),
12280 			BPF_ALU64_REG(BPF_OR, R1, R2),
12281 			BPF_ALU64_REG(BPF_MOV, R0, R1),
12282 			BPF_EXIT_INSN(),
12283 		},
12284 		INTERNAL,
12285 		{ },
12286 		{ { 0, 0 } },
12287 		.stack_depth = 8,
12288 	},
12289 	/* Checking that JMP32 immediate src is not zero extended in place */
12290 #define BPF_JMP32_IMM_ZEXT(op)					\
12291 	{							\
12292 		"JMP32_" #op "_K: operand preserved in zext",	\
12293 		.u.insns_int = {				\
12294 			BPF_LD_IMM64(R0, 0x0123456789acbdefULL),\
12295 			BPF_ALU64_REG(BPF_MOV, R1, R0),		\
12296 			BPF_JMP32_IMM(BPF_##op, R0, 1234, 1),	\
12297 			BPF_JMP_A(0), /* Nop */			\
12298 			BPF_ALU64_REG(BPF_SUB, R0, R1),		\
12299 			BPF_ALU64_REG(BPF_MOV, R1, R0),		\
12300 			BPF_ALU64_IMM(BPF_RSH, R1, 32),		\
12301 			BPF_ALU64_REG(BPF_OR, R0, R1),		\
12302 			BPF_EXIT_INSN(),			\
12303 		},						\
12304 		INTERNAL,					\
12305 		{ },						\
12306 		{ { 0, 0 } },					\
12307 	}
12308 	BPF_JMP32_IMM_ZEXT(JEQ),
12309 	BPF_JMP32_IMM_ZEXT(JNE),
12310 	BPF_JMP32_IMM_ZEXT(JSET),
12311 	BPF_JMP32_IMM_ZEXT(JGT),
12312 	BPF_JMP32_IMM_ZEXT(JGE),
12313 	BPF_JMP32_IMM_ZEXT(JLT),
12314 	BPF_JMP32_IMM_ZEXT(JLE),
12315 	BPF_JMP32_IMM_ZEXT(JSGT),
12316 	BPF_JMP32_IMM_ZEXT(JSGE),
12317 	BPF_JMP32_IMM_ZEXT(JSLT),
12318 	BPF_JMP32_IMM_ZEXT(JSLE),
12319 #undef BPF_JMP2_IMM_ZEXT
12320 	/* Checking that JMP32 dst & src are not zero extended in place */
12321 #define BPF_JMP32_REG_ZEXT(op)					\
12322 	{							\
12323 		"JMP32_" #op "_X: operands preserved in zext",	\
12324 		.u.insns_int = {				\
12325 			BPF_LD_IMM64(R0, 0x0123456789acbdefULL),\
12326 			BPF_LD_IMM64(R1, 0xfedcba9876543210ULL),\
12327 			BPF_ALU64_REG(BPF_MOV, R2, R0),		\
12328 			BPF_ALU64_REG(BPF_MOV, R3, R1),		\
12329 			BPF_JMP32_IMM(BPF_##op, R0, R1, 1),	\
12330 			BPF_JMP_A(0), /* Nop */			\
12331 			BPF_ALU64_REG(BPF_SUB, R0, R2),		\
12332 			BPF_ALU64_REG(BPF_SUB, R1, R3),		\
12333 			BPF_ALU64_REG(BPF_OR, R0, R1),		\
12334 			BPF_ALU64_REG(BPF_MOV, R1, R0),		\
12335 			BPF_ALU64_IMM(BPF_RSH, R1, 32),		\
12336 			BPF_ALU64_REG(BPF_OR, R0, R1),		\
12337 			BPF_EXIT_INSN(),			\
12338 		},						\
12339 		INTERNAL,					\
12340 		{ },						\
12341 		{ { 0, 0 } },					\
12342 	}
12343 	BPF_JMP32_REG_ZEXT(JEQ),
12344 	BPF_JMP32_REG_ZEXT(JNE),
12345 	BPF_JMP32_REG_ZEXT(JSET),
12346 	BPF_JMP32_REG_ZEXT(JGT),
12347 	BPF_JMP32_REG_ZEXT(JGE),
12348 	BPF_JMP32_REG_ZEXT(JLT),
12349 	BPF_JMP32_REG_ZEXT(JLE),
12350 	BPF_JMP32_REG_ZEXT(JSGT),
12351 	BPF_JMP32_REG_ZEXT(JSGE),
12352 	BPF_JMP32_REG_ZEXT(JSLT),
12353 	BPF_JMP32_REG_ZEXT(JSLE),
12354 #undef BPF_JMP2_REG_ZEXT
12355 	/* ALU64 K register combinations */
12356 	{
12357 		"ALU64_MOV_K: registers",
12358 		{ },
12359 		INTERNAL,
12360 		{ },
12361 		{ { 0, 1 } },
12362 		.fill_helper = bpf_fill_alu64_mov_imm_regs,
12363 	},
12364 	{
12365 		"ALU64_AND_K: registers",
12366 		{ },
12367 		INTERNAL,
12368 		{ },
12369 		{ { 0, 1 } },
12370 		.fill_helper = bpf_fill_alu64_and_imm_regs,
12371 	},
12372 	{
12373 		"ALU64_OR_K: registers",
12374 		{ },
12375 		INTERNAL,
12376 		{ },
12377 		{ { 0, 1 } },
12378 		.fill_helper = bpf_fill_alu64_or_imm_regs,
12379 	},
12380 	{
12381 		"ALU64_XOR_K: registers",
12382 		{ },
12383 		INTERNAL,
12384 		{ },
12385 		{ { 0, 1 } },
12386 		.fill_helper = bpf_fill_alu64_xor_imm_regs,
12387 	},
12388 	{
12389 		"ALU64_LSH_K: registers",
12390 		{ },
12391 		INTERNAL,
12392 		{ },
12393 		{ { 0, 1 } },
12394 		.fill_helper = bpf_fill_alu64_lsh_imm_regs,
12395 	},
12396 	{
12397 		"ALU64_RSH_K: registers",
12398 		{ },
12399 		INTERNAL,
12400 		{ },
12401 		{ { 0, 1 } },
12402 		.fill_helper = bpf_fill_alu64_rsh_imm_regs,
12403 	},
12404 	{
12405 		"ALU64_ARSH_K: registers",
12406 		{ },
12407 		INTERNAL,
12408 		{ },
12409 		{ { 0, 1 } },
12410 		.fill_helper = bpf_fill_alu64_arsh_imm_regs,
12411 	},
12412 	{
12413 		"ALU64_ADD_K: registers",
12414 		{ },
12415 		INTERNAL,
12416 		{ },
12417 		{ { 0, 1 } },
12418 		.fill_helper = bpf_fill_alu64_add_imm_regs,
12419 	},
12420 	{
12421 		"ALU64_SUB_K: registers",
12422 		{ },
12423 		INTERNAL,
12424 		{ },
12425 		{ { 0, 1 } },
12426 		.fill_helper = bpf_fill_alu64_sub_imm_regs,
12427 	},
12428 	{
12429 		"ALU64_MUL_K: registers",
12430 		{ },
12431 		INTERNAL,
12432 		{ },
12433 		{ { 0, 1 } },
12434 		.fill_helper = bpf_fill_alu64_mul_imm_regs,
12435 	},
12436 	{
12437 		"ALU64_DIV_K: registers",
12438 		{ },
12439 		INTERNAL,
12440 		{ },
12441 		{ { 0, 1 } },
12442 		.fill_helper = bpf_fill_alu64_div_imm_regs,
12443 	},
12444 	{
12445 		"ALU64_MOD_K: registers",
12446 		{ },
12447 		INTERNAL,
12448 		{ },
12449 		{ { 0, 1 } },
12450 		.fill_helper = bpf_fill_alu64_mod_imm_regs,
12451 	},
12452 	{
12453 		"ALU64_SDIV_K: registers",
12454 		{ },
12455 		INTERNAL,
12456 		{ },
12457 		{ { 0, 1 } },
12458 		.fill_helper = bpf_fill_alu64_sdiv_imm_regs,
12459 	},
12460 	{
12461 		"ALU64_SMOD_K: registers",
12462 		{ },
12463 		INTERNAL,
12464 		{ },
12465 		{ { 0, 1 } },
12466 		.fill_helper = bpf_fill_alu64_smod_imm_regs,
12467 	},
12468 	/* ALU32 K registers */
12469 	{
12470 		"ALU32_MOV_K: registers",
12471 		{ },
12472 		INTERNAL,
12473 		{ },
12474 		{ { 0, 1 } },
12475 		.fill_helper = bpf_fill_alu32_mov_imm_regs,
12476 	},
12477 	{
12478 		"ALU32_AND_K: registers",
12479 		{ },
12480 		INTERNAL,
12481 		{ },
12482 		{ { 0, 1 } },
12483 		.fill_helper = bpf_fill_alu32_and_imm_regs,
12484 	},
12485 	{
12486 		"ALU32_OR_K: registers",
12487 		{ },
12488 		INTERNAL,
12489 		{ },
12490 		{ { 0, 1 } },
12491 		.fill_helper = bpf_fill_alu32_or_imm_regs,
12492 	},
12493 	{
12494 		"ALU32_XOR_K: registers",
12495 		{ },
12496 		INTERNAL,
12497 		{ },
12498 		{ { 0, 1 } },
12499 		.fill_helper = bpf_fill_alu32_xor_imm_regs,
12500 	},
12501 	{
12502 		"ALU32_LSH_K: registers",
12503 		{ },
12504 		INTERNAL,
12505 		{ },
12506 		{ { 0, 1 } },
12507 		.fill_helper = bpf_fill_alu32_lsh_imm_regs,
12508 	},
12509 	{
12510 		"ALU32_RSH_K: registers",
12511 		{ },
12512 		INTERNAL,
12513 		{ },
12514 		{ { 0, 1 } },
12515 		.fill_helper = bpf_fill_alu32_rsh_imm_regs,
12516 	},
12517 	{
12518 		"ALU32_ARSH_K: registers",
12519 		{ },
12520 		INTERNAL,
12521 		{ },
12522 		{ { 0, 1 } },
12523 		.fill_helper = bpf_fill_alu32_arsh_imm_regs,
12524 	},
12525 	{
12526 		"ALU32_ADD_K: registers",
12527 		{ },
12528 		INTERNAL,
12529 		{ },
12530 		{ { 0, 1 } },
12531 		.fill_helper = bpf_fill_alu32_add_imm_regs,
12532 	},
12533 	{
12534 		"ALU32_SUB_K: registers",
12535 		{ },
12536 		INTERNAL,
12537 		{ },
12538 		{ { 0, 1 } },
12539 		.fill_helper = bpf_fill_alu32_sub_imm_regs,
12540 	},
12541 	{
12542 		"ALU32_MUL_K: registers",
12543 		{ },
12544 		INTERNAL,
12545 		{ },
12546 		{ { 0, 1 } },
12547 		.fill_helper = bpf_fill_alu32_mul_imm_regs,
12548 	},
12549 	{
12550 		"ALU32_DIV_K: registers",
12551 		{ },
12552 		INTERNAL,
12553 		{ },
12554 		{ { 0, 1 } },
12555 		.fill_helper = bpf_fill_alu32_div_imm_regs,
12556 	},
12557 	{
12558 		"ALU32_MOD_K: registers",
12559 		{ },
12560 		INTERNAL,
12561 		{ },
12562 		{ { 0, 1 } },
12563 		.fill_helper = bpf_fill_alu32_mod_imm_regs,
12564 	},
12565 	{
12566 		"ALU32_SDIV_K: registers",
12567 		{ },
12568 		INTERNAL,
12569 		{ },
12570 		{ { 0, 1 } },
12571 		.fill_helper = bpf_fill_alu32_sdiv_imm_regs,
12572 	},
12573 	{
12574 		"ALU32_SMOD_K: registers",
12575 		{ },
12576 		INTERNAL,
12577 		{ },
12578 		{ { 0, 1 } },
12579 		.fill_helper = bpf_fill_alu32_smod_imm_regs,
12580 	},
12581 	/* ALU64 X register combinations */
12582 	{
12583 		"ALU64_MOV_X: register combinations",
12584 		{ },
12585 		INTERNAL,
12586 		{ },
12587 		{ { 0, 1 } },
12588 		.fill_helper = bpf_fill_alu64_mov_reg_pairs,
12589 	},
12590 	{
12591 		"ALU64_AND_X: register combinations",
12592 		{ },
12593 		INTERNAL,
12594 		{ },
12595 		{ { 0, 1 } },
12596 		.fill_helper = bpf_fill_alu64_and_reg_pairs,
12597 	},
12598 	{
12599 		"ALU64_OR_X: register combinations",
12600 		{ },
12601 		INTERNAL,
12602 		{ },
12603 		{ { 0, 1 } },
12604 		.fill_helper = bpf_fill_alu64_or_reg_pairs,
12605 	},
12606 	{
12607 		"ALU64_XOR_X: register combinations",
12608 		{ },
12609 		INTERNAL,
12610 		{ },
12611 		{ { 0, 1 } },
12612 		.fill_helper = bpf_fill_alu64_xor_reg_pairs,
12613 	},
12614 	{
12615 		"ALU64_LSH_X: register combinations",
12616 		{ },
12617 		INTERNAL,
12618 		{ },
12619 		{ { 0, 1 } },
12620 		.fill_helper = bpf_fill_alu64_lsh_reg_pairs,
12621 	},
12622 	{
12623 		"ALU64_RSH_X: register combinations",
12624 		{ },
12625 		INTERNAL,
12626 		{ },
12627 		{ { 0, 1 } },
12628 		.fill_helper = bpf_fill_alu64_rsh_reg_pairs,
12629 	},
12630 	{
12631 		"ALU64_ARSH_X: register combinations",
12632 		{ },
12633 		INTERNAL,
12634 		{ },
12635 		{ { 0, 1 } },
12636 		.fill_helper = bpf_fill_alu64_arsh_reg_pairs,
12637 	},
12638 	{
12639 		"ALU64_ADD_X: register combinations",
12640 		{ },
12641 		INTERNAL,
12642 		{ },
12643 		{ { 0, 1 } },
12644 		.fill_helper = bpf_fill_alu64_add_reg_pairs,
12645 	},
12646 	{
12647 		"ALU64_SUB_X: register combinations",
12648 		{ },
12649 		INTERNAL,
12650 		{ },
12651 		{ { 0, 1 } },
12652 		.fill_helper = bpf_fill_alu64_sub_reg_pairs,
12653 	},
12654 	{
12655 		"ALU64_MUL_X: register combinations",
12656 		{ },
12657 		INTERNAL,
12658 		{ },
12659 		{ { 0, 1 } },
12660 		.fill_helper = bpf_fill_alu64_mul_reg_pairs,
12661 	},
12662 	{
12663 		"ALU64_DIV_X: register combinations",
12664 		{ },
12665 		INTERNAL,
12666 		{ },
12667 		{ { 0, 1 } },
12668 		.fill_helper = bpf_fill_alu64_div_reg_pairs,
12669 	},
12670 	{
12671 		"ALU64_MOD_X: register combinations",
12672 		{ },
12673 		INTERNAL,
12674 		{ },
12675 		{ { 0, 1 } },
12676 		.fill_helper = bpf_fill_alu64_mod_reg_pairs,
12677 	},
12678 	/* ALU32 X register combinations */
12679 	{
12680 		"ALU32_MOV_X: register combinations",
12681 		{ },
12682 		INTERNAL,
12683 		{ },
12684 		{ { 0, 1 } },
12685 		.fill_helper = bpf_fill_alu32_mov_reg_pairs,
12686 	},
12687 	{
12688 		"ALU32_AND_X: register combinations",
12689 		{ },
12690 		INTERNAL,
12691 		{ },
12692 		{ { 0, 1 } },
12693 		.fill_helper = bpf_fill_alu32_and_reg_pairs,
12694 	},
12695 	{
12696 		"ALU32_OR_X: register combinations",
12697 		{ },
12698 		INTERNAL,
12699 		{ },
12700 		{ { 0, 1 } },
12701 		.fill_helper = bpf_fill_alu32_or_reg_pairs,
12702 	},
12703 	{
12704 		"ALU32_XOR_X: register combinations",
12705 		{ },
12706 		INTERNAL,
12707 		{ },
12708 		{ { 0, 1 } },
12709 		.fill_helper = bpf_fill_alu32_xor_reg_pairs,
12710 	},
12711 	{
12712 		"ALU32_LSH_X: register combinations",
12713 		{ },
12714 		INTERNAL,
12715 		{ },
12716 		{ { 0, 1 } },
12717 		.fill_helper = bpf_fill_alu32_lsh_reg_pairs,
12718 	},
12719 	{
12720 		"ALU32_RSH_X: register combinations",
12721 		{ },
12722 		INTERNAL,
12723 		{ },
12724 		{ { 0, 1 } },
12725 		.fill_helper = bpf_fill_alu32_rsh_reg_pairs,
12726 	},
12727 	{
12728 		"ALU32_ARSH_X: register combinations",
12729 		{ },
12730 		INTERNAL,
12731 		{ },
12732 		{ { 0, 1 } },
12733 		.fill_helper = bpf_fill_alu32_arsh_reg_pairs,
12734 	},
12735 	{
12736 		"ALU32_ADD_X: register combinations",
12737 		{ },
12738 		INTERNAL,
12739 		{ },
12740 		{ { 0, 1 } },
12741 		.fill_helper = bpf_fill_alu32_add_reg_pairs,
12742 	},
12743 	{
12744 		"ALU32_SUB_X: register combinations",
12745 		{ },
12746 		INTERNAL,
12747 		{ },
12748 		{ { 0, 1 } },
12749 		.fill_helper = bpf_fill_alu32_sub_reg_pairs,
12750 	},
12751 	{
12752 		"ALU32_MUL_X: register combinations",
12753 		{ },
12754 		INTERNAL,
12755 		{ },
12756 		{ { 0, 1 } },
12757 		.fill_helper = bpf_fill_alu32_mul_reg_pairs,
12758 	},
12759 	{
12760 		"ALU32_DIV_X: register combinations",
12761 		{ },
12762 		INTERNAL,
12763 		{ },
12764 		{ { 0, 1 } },
12765 		.fill_helper = bpf_fill_alu32_div_reg_pairs,
12766 	},
12767 	{
12768 		"ALU32_MOD_X register combinations",
12769 		{ },
12770 		INTERNAL,
12771 		{ },
12772 		{ { 0, 1 } },
12773 		.fill_helper = bpf_fill_alu32_mod_reg_pairs,
12774 	},
12775 	/* Exhaustive test of ALU64 shift operations */
12776 	{
12777 		"ALU64_LSH_K: all shift values",
12778 		{ },
12779 		INTERNAL | FLAG_NO_DATA,
12780 		{ },
12781 		{ { 0, 1 } },
12782 		.fill_helper = bpf_fill_alu64_lsh_imm,
12783 	},
12784 	{
12785 		"ALU64_RSH_K: all shift values",
12786 		{ },
12787 		INTERNAL | FLAG_NO_DATA,
12788 		{ },
12789 		{ { 0, 1 } },
12790 		.fill_helper = bpf_fill_alu64_rsh_imm,
12791 	},
12792 	{
12793 		"ALU64_ARSH_K: all shift values",
12794 		{ },
12795 		INTERNAL | FLAG_NO_DATA,
12796 		{ },
12797 		{ { 0, 1 } },
12798 		.fill_helper = bpf_fill_alu64_arsh_imm,
12799 	},
12800 	{
12801 		"ALU64_LSH_X: all shift values",
12802 		{ },
12803 		INTERNAL | FLAG_NO_DATA,
12804 		{ },
12805 		{ { 0, 1 } },
12806 		.fill_helper = bpf_fill_alu64_lsh_reg,
12807 	},
12808 	{
12809 		"ALU64_RSH_X: all shift values",
12810 		{ },
12811 		INTERNAL | FLAG_NO_DATA,
12812 		{ },
12813 		{ { 0, 1 } },
12814 		.fill_helper = bpf_fill_alu64_rsh_reg,
12815 	},
12816 	{
12817 		"ALU64_ARSH_X: all shift values",
12818 		{ },
12819 		INTERNAL | FLAG_NO_DATA,
12820 		{ },
12821 		{ { 0, 1 } },
12822 		.fill_helper = bpf_fill_alu64_arsh_reg,
12823 	},
12824 	/* Exhaustive test of ALU32 shift operations */
12825 	{
12826 		"ALU32_LSH_K: all shift values",
12827 		{ },
12828 		INTERNAL | FLAG_NO_DATA,
12829 		{ },
12830 		{ { 0, 1 } },
12831 		.fill_helper = bpf_fill_alu32_lsh_imm,
12832 	},
12833 	{
12834 		"ALU32_RSH_K: all shift values",
12835 		{ },
12836 		INTERNAL | FLAG_NO_DATA,
12837 		{ },
12838 		{ { 0, 1 } },
12839 		.fill_helper = bpf_fill_alu32_rsh_imm,
12840 	},
12841 	{
12842 		"ALU32_ARSH_K: all shift values",
12843 		{ },
12844 		INTERNAL | FLAG_NO_DATA,
12845 		{ },
12846 		{ { 0, 1 } },
12847 		.fill_helper = bpf_fill_alu32_arsh_imm,
12848 	},
12849 	{
12850 		"ALU32_LSH_X: all shift values",
12851 		{ },
12852 		INTERNAL | FLAG_NO_DATA,
12853 		{ },
12854 		{ { 0, 1 } },
12855 		.fill_helper = bpf_fill_alu32_lsh_reg,
12856 	},
12857 	{
12858 		"ALU32_RSH_X: all shift values",
12859 		{ },
12860 		INTERNAL | FLAG_NO_DATA,
12861 		{ },
12862 		{ { 0, 1 } },
12863 		.fill_helper = bpf_fill_alu32_rsh_reg,
12864 	},
12865 	{
12866 		"ALU32_ARSH_X: all shift values",
12867 		{ },
12868 		INTERNAL | FLAG_NO_DATA,
12869 		{ },
12870 		{ { 0, 1 } },
12871 		.fill_helper = bpf_fill_alu32_arsh_reg,
12872 	},
12873 	/*
12874 	 * Exhaustive test of ALU64 shift operations when
12875 	 * source and destination register are the same.
12876 	 */
12877 	{
12878 		"ALU64_LSH_X: all shift values with the same register",
12879 		{ },
12880 		INTERNAL | FLAG_NO_DATA,
12881 		{ },
12882 		{ { 0, 1 } },
12883 		.fill_helper = bpf_fill_alu64_lsh_same_reg,
12884 	},
12885 	{
12886 		"ALU64_RSH_X: all shift values with the same register",
12887 		{ },
12888 		INTERNAL | FLAG_NO_DATA,
12889 		{ },
12890 		{ { 0, 1 } },
12891 		.fill_helper = bpf_fill_alu64_rsh_same_reg,
12892 	},
12893 	{
12894 		"ALU64_ARSH_X: all shift values with the same register",
12895 		{ },
12896 		INTERNAL | FLAG_NO_DATA,
12897 		{ },
12898 		{ { 0, 1 } },
12899 		.fill_helper = bpf_fill_alu64_arsh_same_reg,
12900 	},
12901 	/*
12902 	 * Exhaustive test of ALU32 shift operations when
12903 	 * source and destination register are the same.
12904 	 */
12905 	{
12906 		"ALU32_LSH_X: all shift values with the same register",
12907 		{ },
12908 		INTERNAL | FLAG_NO_DATA,
12909 		{ },
12910 		{ { 0, 1 } },
12911 		.fill_helper = bpf_fill_alu32_lsh_same_reg,
12912 	},
12913 	{
12914 		"ALU32_RSH_X: all shift values with the same register",
12915 		{ },
12916 		INTERNAL | FLAG_NO_DATA,
12917 		{ },
12918 		{ { 0, 1 } },
12919 		.fill_helper = bpf_fill_alu32_rsh_same_reg,
12920 	},
12921 	{
12922 		"ALU32_ARSH_X: all shift values with the same register",
12923 		{ },
12924 		INTERNAL | FLAG_NO_DATA,
12925 		{ },
12926 		{ { 0, 1 } },
12927 		.fill_helper = bpf_fill_alu32_arsh_same_reg,
12928 	},
12929 	/* ALU64 immediate magnitudes */
12930 	{
12931 		"ALU64_MOV_K: all immediate value magnitudes",
12932 		{ },
12933 		INTERNAL | FLAG_NO_DATA,
12934 		{ },
12935 		{ { 0, 1 } },
12936 		.fill_helper = bpf_fill_alu64_mov_imm,
12937 		.nr_testruns = NR_PATTERN_RUNS,
12938 	},
12939 	{
12940 		"ALU64_AND_K: all immediate value magnitudes",
12941 		{ },
12942 		INTERNAL | FLAG_NO_DATA,
12943 		{ },
12944 		{ { 0, 1 } },
12945 		.fill_helper = bpf_fill_alu64_and_imm,
12946 		.nr_testruns = NR_PATTERN_RUNS,
12947 	},
12948 	{
12949 		"ALU64_OR_K: all immediate value magnitudes",
12950 		{ },
12951 		INTERNAL | FLAG_NO_DATA,
12952 		{ },
12953 		{ { 0, 1 } },
12954 		.fill_helper = bpf_fill_alu64_or_imm,
12955 		.nr_testruns = NR_PATTERN_RUNS,
12956 	},
12957 	{
12958 		"ALU64_XOR_K: all immediate value magnitudes",
12959 		{ },
12960 		INTERNAL | FLAG_NO_DATA,
12961 		{ },
12962 		{ { 0, 1 } },
12963 		.fill_helper = bpf_fill_alu64_xor_imm,
12964 		.nr_testruns = NR_PATTERN_RUNS,
12965 	},
12966 	{
12967 		"ALU64_ADD_K: all immediate value magnitudes",
12968 		{ },
12969 		INTERNAL | FLAG_NO_DATA,
12970 		{ },
12971 		{ { 0, 1 } },
12972 		.fill_helper = bpf_fill_alu64_add_imm,
12973 		.nr_testruns = NR_PATTERN_RUNS,
12974 	},
12975 	{
12976 		"ALU64_SUB_K: all immediate value magnitudes",
12977 		{ },
12978 		INTERNAL | FLAG_NO_DATA,
12979 		{ },
12980 		{ { 0, 1 } },
12981 		.fill_helper = bpf_fill_alu64_sub_imm,
12982 		.nr_testruns = NR_PATTERN_RUNS,
12983 	},
12984 	{
12985 		"ALU64_MUL_K: all immediate value magnitudes",
12986 		{ },
12987 		INTERNAL | FLAG_NO_DATA,
12988 		{ },
12989 		{ { 0, 1 } },
12990 		.fill_helper = bpf_fill_alu64_mul_imm,
12991 		.nr_testruns = NR_PATTERN_RUNS,
12992 	},
12993 	{
12994 		"ALU64_DIV_K: all immediate value magnitudes",
12995 		{ },
12996 		INTERNAL | FLAG_NO_DATA,
12997 		{ },
12998 		{ { 0, 1 } },
12999 		.fill_helper = bpf_fill_alu64_div_imm,
13000 		.nr_testruns = NR_PATTERN_RUNS,
13001 	},
13002 	{
13003 		"ALU64_MOD_K: all immediate value magnitudes",
13004 		{ },
13005 		INTERNAL | FLAG_NO_DATA,
13006 		{ },
13007 		{ { 0, 1 } },
13008 		.fill_helper = bpf_fill_alu64_mod_imm,
13009 		.nr_testruns = NR_PATTERN_RUNS,
13010 	},
13011 	{
13012 		"ALU64_SDIV_K: all immediate value magnitudes",
13013 		{ },
13014 		INTERNAL | FLAG_NO_DATA,
13015 		{ },
13016 		{ { 0, 1 } },
13017 		.fill_helper = bpf_fill_alu64_sdiv_imm,
13018 		.nr_testruns = NR_PATTERN_RUNS,
13019 	},
13020 	{
13021 		"ALU64_SMOD_K: all immediate value magnitudes",
13022 		{ },
13023 		INTERNAL | FLAG_NO_DATA,
13024 		{ },
13025 		{ { 0, 1 } },
13026 		.fill_helper = bpf_fill_alu64_smod_imm,
13027 		.nr_testruns = NR_PATTERN_RUNS,
13028 	},
13029 	/* ALU32 immediate magnitudes */
13030 	{
13031 		"ALU32_MOV_K: all immediate value magnitudes",
13032 		{ },
13033 		INTERNAL | FLAG_NO_DATA,
13034 		{ },
13035 		{ { 0, 1 } },
13036 		.fill_helper = bpf_fill_alu32_mov_imm,
13037 		.nr_testruns = NR_PATTERN_RUNS,
13038 	},
13039 	{
13040 		"ALU32_AND_K: all immediate value magnitudes",
13041 		{ },
13042 		INTERNAL | FLAG_NO_DATA,
13043 		{ },
13044 		{ { 0, 1 } },
13045 		.fill_helper = bpf_fill_alu32_and_imm,
13046 		.nr_testruns = NR_PATTERN_RUNS,
13047 	},
13048 	{
13049 		"ALU32_OR_K: all immediate value magnitudes",
13050 		{ },
13051 		INTERNAL | FLAG_NO_DATA,
13052 		{ },
13053 		{ { 0, 1 } },
13054 		.fill_helper = bpf_fill_alu32_or_imm,
13055 		.nr_testruns = NR_PATTERN_RUNS,
13056 	},
13057 	{
13058 		"ALU32_XOR_K: all immediate value magnitudes",
13059 		{ },
13060 		INTERNAL | FLAG_NO_DATA,
13061 		{ },
13062 		{ { 0, 1 } },
13063 		.fill_helper = bpf_fill_alu32_xor_imm,
13064 		.nr_testruns = NR_PATTERN_RUNS,
13065 	},
13066 	{
13067 		"ALU32_ADD_K: all immediate value magnitudes",
13068 		{ },
13069 		INTERNAL | FLAG_NO_DATA,
13070 		{ },
13071 		{ { 0, 1 } },
13072 		.fill_helper = bpf_fill_alu32_add_imm,
13073 		.nr_testruns = NR_PATTERN_RUNS,
13074 	},
13075 	{
13076 		"ALU32_SUB_K: all immediate value magnitudes",
13077 		{ },
13078 		INTERNAL | FLAG_NO_DATA,
13079 		{ },
13080 		{ { 0, 1 } },
13081 		.fill_helper = bpf_fill_alu32_sub_imm,
13082 		.nr_testruns = NR_PATTERN_RUNS,
13083 	},
13084 	{
13085 		"ALU32_MUL_K: all immediate value magnitudes",
13086 		{ },
13087 		INTERNAL | FLAG_NO_DATA,
13088 		{ },
13089 		{ { 0, 1 } },
13090 		.fill_helper = bpf_fill_alu32_mul_imm,
13091 		.nr_testruns = NR_PATTERN_RUNS,
13092 	},
13093 	{
13094 		"ALU32_DIV_K: all immediate value magnitudes",
13095 		{ },
13096 		INTERNAL | FLAG_NO_DATA,
13097 		{ },
13098 		{ { 0, 1 } },
13099 		.fill_helper = bpf_fill_alu32_div_imm,
13100 		.nr_testruns = NR_PATTERN_RUNS,
13101 	},
13102 	{
13103 		"ALU32_MOD_K: all immediate value magnitudes",
13104 		{ },
13105 		INTERNAL | FLAG_NO_DATA,
13106 		{ },
13107 		{ { 0, 1 } },
13108 		.fill_helper = bpf_fill_alu32_mod_imm,
13109 		.nr_testruns = NR_PATTERN_RUNS,
13110 	},
13111 	{
13112 		"ALU32_SDIV_K: all immediate value magnitudes",
13113 		{ },
13114 		INTERNAL | FLAG_NO_DATA,
13115 		{ },
13116 		{ { 0, 1 } },
13117 		.fill_helper = bpf_fill_alu32_sdiv_imm,
13118 		.nr_testruns = NR_PATTERN_RUNS,
13119 	},
13120 	{
13121 		"ALU32_SMOD_K: all immediate value magnitudes",
13122 		{ },
13123 		INTERNAL | FLAG_NO_DATA,
13124 		{ },
13125 		{ { 0, 1 } },
13126 		.fill_helper = bpf_fill_alu32_smod_imm,
13127 		.nr_testruns = NR_PATTERN_RUNS,
13128 	},
13129 	/* ALU64 register magnitudes */
13130 	{
13131 		"ALU64_MOV_X: all register value magnitudes",
13132 		{ },
13133 		INTERNAL | FLAG_NO_DATA,
13134 		{ },
13135 		{ { 0, 1 } },
13136 		.fill_helper = bpf_fill_alu64_mov_reg,
13137 		.nr_testruns = NR_PATTERN_RUNS,
13138 	},
13139 	{
13140 		"ALU64_AND_X: all register value magnitudes",
13141 		{ },
13142 		INTERNAL | FLAG_NO_DATA,
13143 		{ },
13144 		{ { 0, 1 } },
13145 		.fill_helper = bpf_fill_alu64_and_reg,
13146 		.nr_testruns = NR_PATTERN_RUNS,
13147 	},
13148 	{
13149 		"ALU64_OR_X: all register value magnitudes",
13150 		{ },
13151 		INTERNAL | FLAG_NO_DATA,
13152 		{ },
13153 		{ { 0, 1 } },
13154 		.fill_helper = bpf_fill_alu64_or_reg,
13155 		.nr_testruns = NR_PATTERN_RUNS,
13156 	},
13157 	{
13158 		"ALU64_XOR_X: all register value magnitudes",
13159 		{ },
13160 		INTERNAL | FLAG_NO_DATA,
13161 		{ },
13162 		{ { 0, 1 } },
13163 		.fill_helper = bpf_fill_alu64_xor_reg,
13164 		.nr_testruns = NR_PATTERN_RUNS,
13165 	},
13166 	{
13167 		"ALU64_ADD_X: all register value magnitudes",
13168 		{ },
13169 		INTERNAL | FLAG_NO_DATA,
13170 		{ },
13171 		{ { 0, 1 } },
13172 		.fill_helper = bpf_fill_alu64_add_reg,
13173 		.nr_testruns = NR_PATTERN_RUNS,
13174 	},
13175 	{
13176 		"ALU64_SUB_X: all register value magnitudes",
13177 		{ },
13178 		INTERNAL | FLAG_NO_DATA,
13179 		{ },
13180 		{ { 0, 1 } },
13181 		.fill_helper = bpf_fill_alu64_sub_reg,
13182 		.nr_testruns = NR_PATTERN_RUNS,
13183 	},
13184 	{
13185 		"ALU64_MUL_X: all register value magnitudes",
13186 		{ },
13187 		INTERNAL | FLAG_NO_DATA,
13188 		{ },
13189 		{ { 0, 1 } },
13190 		.fill_helper = bpf_fill_alu64_mul_reg,
13191 		.nr_testruns = NR_PATTERN_RUNS,
13192 	},
13193 	{
13194 		"ALU64_DIV_X: all register value magnitudes",
13195 		{ },
13196 		INTERNAL | FLAG_NO_DATA,
13197 		{ },
13198 		{ { 0, 1 } },
13199 		.fill_helper = bpf_fill_alu64_div_reg,
13200 		.nr_testruns = NR_PATTERN_RUNS,
13201 	},
13202 	{
13203 		"ALU64_MOD_X: all register value magnitudes",
13204 		{ },
13205 		INTERNAL | FLAG_NO_DATA,
13206 		{ },
13207 		{ { 0, 1 } },
13208 		.fill_helper = bpf_fill_alu64_mod_reg,
13209 		.nr_testruns = NR_PATTERN_RUNS,
13210 	},
13211 	/* ALU32 register magnitudes */
13212 	{
13213 		"ALU32_MOV_X: all register value magnitudes",
13214 		{ },
13215 		INTERNAL | FLAG_NO_DATA,
13216 		{ },
13217 		{ { 0, 1 } },
13218 		.fill_helper = bpf_fill_alu32_mov_reg,
13219 		.nr_testruns = NR_PATTERN_RUNS,
13220 	},
13221 	{
13222 		"ALU32_AND_X: all register value magnitudes",
13223 		{ },
13224 		INTERNAL | FLAG_NO_DATA,
13225 		{ },
13226 		{ { 0, 1 } },
13227 		.fill_helper = bpf_fill_alu32_and_reg,
13228 		.nr_testruns = NR_PATTERN_RUNS,
13229 	},
13230 	{
13231 		"ALU32_OR_X: all register value magnitudes",
13232 		{ },
13233 		INTERNAL | FLAG_NO_DATA,
13234 		{ },
13235 		{ { 0, 1 } },
13236 		.fill_helper = bpf_fill_alu32_or_reg,
13237 		.nr_testruns = NR_PATTERN_RUNS,
13238 	},
13239 	{
13240 		"ALU32_XOR_X: all register value magnitudes",
13241 		{ },
13242 		INTERNAL | FLAG_NO_DATA,
13243 		{ },
13244 		{ { 0, 1 } },
13245 		.fill_helper = bpf_fill_alu32_xor_reg,
13246 		.nr_testruns = NR_PATTERN_RUNS,
13247 	},
13248 	{
13249 		"ALU32_ADD_X: all register value magnitudes",
13250 		{ },
13251 		INTERNAL | FLAG_NO_DATA,
13252 		{ },
13253 		{ { 0, 1 } },
13254 		.fill_helper = bpf_fill_alu32_add_reg,
13255 		.nr_testruns = NR_PATTERN_RUNS,
13256 	},
13257 	{
13258 		"ALU32_SUB_X: all register value magnitudes",
13259 		{ },
13260 		INTERNAL | FLAG_NO_DATA,
13261 		{ },
13262 		{ { 0, 1 } },
13263 		.fill_helper = bpf_fill_alu32_sub_reg,
13264 		.nr_testruns = NR_PATTERN_RUNS,
13265 	},
13266 	{
13267 		"ALU32_MUL_X: all register value magnitudes",
13268 		{ },
13269 		INTERNAL | FLAG_NO_DATA,
13270 		{ },
13271 		{ { 0, 1 } },
13272 		.fill_helper = bpf_fill_alu32_mul_reg,
13273 		.nr_testruns = NR_PATTERN_RUNS,
13274 	},
13275 	{
13276 		"ALU32_DIV_X: all register value magnitudes",
13277 		{ },
13278 		INTERNAL | FLAG_NO_DATA,
13279 		{ },
13280 		{ { 0, 1 } },
13281 		.fill_helper = bpf_fill_alu32_div_reg,
13282 		.nr_testruns = NR_PATTERN_RUNS,
13283 	},
13284 	{
13285 		"ALU32_MOD_X: all register value magnitudes",
13286 		{ },
13287 		INTERNAL | FLAG_NO_DATA,
13288 		{ },
13289 		{ { 0, 1 } },
13290 		.fill_helper = bpf_fill_alu32_mod_reg,
13291 		.nr_testruns = NR_PATTERN_RUNS,
13292 	},
13293 	/* LD_IMM64 immediate magnitudes and byte patterns */
13294 	{
13295 		"LD_IMM64: all immediate value magnitudes",
13296 		{ },
13297 		INTERNAL | FLAG_NO_DATA,
13298 		{ },
13299 		{ { 0, 1 } },
13300 		.fill_helper = bpf_fill_ld_imm64_magn,
13301 	},
13302 	{
13303 		"LD_IMM64: checker byte patterns",
13304 		{ },
13305 		INTERNAL | FLAG_NO_DATA,
13306 		{ },
13307 		{ { 0, 1 } },
13308 		.fill_helper = bpf_fill_ld_imm64_checker,
13309 	},
13310 	{
13311 		"LD_IMM64: random positive and zero byte patterns",
13312 		{ },
13313 		INTERNAL | FLAG_NO_DATA,
13314 		{ },
13315 		{ { 0, 1 } },
13316 		.fill_helper = bpf_fill_ld_imm64_pos_zero,
13317 	},
13318 	{
13319 		"LD_IMM64: random negative and zero byte patterns",
13320 		{ },
13321 		INTERNAL | FLAG_NO_DATA,
13322 		{ },
13323 		{ { 0, 1 } },
13324 		.fill_helper = bpf_fill_ld_imm64_neg_zero,
13325 	},
13326 	{
13327 		"LD_IMM64: random positive and negative byte patterns",
13328 		{ },
13329 		INTERNAL | FLAG_NO_DATA,
13330 		{ },
13331 		{ { 0, 1 } },
13332 		.fill_helper = bpf_fill_ld_imm64_pos_neg,
13333 	},
13334 	/* 64-bit ATOMIC register combinations */
13335 	{
13336 		"ATOMIC_DW_ADD: register combinations",
13337 		{ },
13338 		INTERNAL,
13339 		{ },
13340 		{ { 0, 1 } },
13341 		.fill_helper = bpf_fill_atomic64_add_reg_pairs,
13342 		.stack_depth = 8,
13343 	},
13344 	{
13345 		"ATOMIC_DW_AND: register combinations",
13346 		{ },
13347 		INTERNAL,
13348 		{ },
13349 		{ { 0, 1 } },
13350 		.fill_helper = bpf_fill_atomic64_and_reg_pairs,
13351 		.stack_depth = 8,
13352 	},
13353 	{
13354 		"ATOMIC_DW_OR: register combinations",
13355 		{ },
13356 		INTERNAL,
13357 		{ },
13358 		{ { 0, 1 } },
13359 		.fill_helper = bpf_fill_atomic64_or_reg_pairs,
13360 		.stack_depth = 8,
13361 	},
13362 	{
13363 		"ATOMIC_DW_XOR: register combinations",
13364 		{ },
13365 		INTERNAL,
13366 		{ },
13367 		{ { 0, 1 } },
13368 		.fill_helper = bpf_fill_atomic64_xor_reg_pairs,
13369 		.stack_depth = 8,
13370 	},
13371 	{
13372 		"ATOMIC_DW_ADD_FETCH: register combinations",
13373 		{ },
13374 		INTERNAL,
13375 		{ },
13376 		{ { 0, 1 } },
13377 		.fill_helper = bpf_fill_atomic64_add_fetch_reg_pairs,
13378 		.stack_depth = 8,
13379 	},
13380 	{
13381 		"ATOMIC_DW_AND_FETCH: register combinations",
13382 		{ },
13383 		INTERNAL,
13384 		{ },
13385 		{ { 0, 1 } },
13386 		.fill_helper = bpf_fill_atomic64_and_fetch_reg_pairs,
13387 		.stack_depth = 8,
13388 	},
13389 	{
13390 		"ATOMIC_DW_OR_FETCH: register combinations",
13391 		{ },
13392 		INTERNAL,
13393 		{ },
13394 		{ { 0, 1 } },
13395 		.fill_helper = bpf_fill_atomic64_or_fetch_reg_pairs,
13396 		.stack_depth = 8,
13397 	},
13398 	{
13399 		"ATOMIC_DW_XOR_FETCH: register combinations",
13400 		{ },
13401 		INTERNAL,
13402 		{ },
13403 		{ { 0, 1 } },
13404 		.fill_helper = bpf_fill_atomic64_xor_fetch_reg_pairs,
13405 		.stack_depth = 8,
13406 	},
13407 	{
13408 		"ATOMIC_DW_XCHG: register combinations",
13409 		{ },
13410 		INTERNAL,
13411 		{ },
13412 		{ { 0, 1 } },
13413 		.fill_helper = bpf_fill_atomic64_xchg_reg_pairs,
13414 		.stack_depth = 8,
13415 	},
13416 	{
13417 		"ATOMIC_DW_CMPXCHG: register combinations",
13418 		{ },
13419 		INTERNAL,
13420 		{ },
13421 		{ { 0, 1 } },
13422 		.fill_helper = bpf_fill_atomic64_cmpxchg_reg_pairs,
13423 		.stack_depth = 8,
13424 	},
13425 	/* 32-bit ATOMIC register combinations */
13426 	{
13427 		"ATOMIC_W_ADD: register combinations",
13428 		{ },
13429 		INTERNAL,
13430 		{ },
13431 		{ { 0, 1 } },
13432 		.fill_helper = bpf_fill_atomic32_add_reg_pairs,
13433 		.stack_depth = 8,
13434 	},
13435 	{
13436 		"ATOMIC_W_AND: register combinations",
13437 		{ },
13438 		INTERNAL,
13439 		{ },
13440 		{ { 0, 1 } },
13441 		.fill_helper = bpf_fill_atomic32_and_reg_pairs,
13442 		.stack_depth = 8,
13443 	},
13444 	{
13445 		"ATOMIC_W_OR: register combinations",
13446 		{ },
13447 		INTERNAL,
13448 		{ },
13449 		{ { 0, 1 } },
13450 		.fill_helper = bpf_fill_atomic32_or_reg_pairs,
13451 		.stack_depth = 8,
13452 	},
13453 	{
13454 		"ATOMIC_W_XOR: register combinations",
13455 		{ },
13456 		INTERNAL,
13457 		{ },
13458 		{ { 0, 1 } },
13459 		.fill_helper = bpf_fill_atomic32_xor_reg_pairs,
13460 		.stack_depth = 8,
13461 	},
13462 	{
13463 		"ATOMIC_W_ADD_FETCH: register combinations",
13464 		{ },
13465 		INTERNAL,
13466 		{ },
13467 		{ { 0, 1 } },
13468 		.fill_helper = bpf_fill_atomic32_add_fetch_reg_pairs,
13469 		.stack_depth = 8,
13470 	},
13471 	{
13472 		"ATOMIC_W_AND_FETCH: register combinations",
13473 		{ },
13474 		INTERNAL,
13475 		{ },
13476 		{ { 0, 1 } },
13477 		.fill_helper = bpf_fill_atomic32_and_fetch_reg_pairs,
13478 		.stack_depth = 8,
13479 	},
13480 	{
13481 		"ATOMIC_W_OR_FETCH: register combinations",
13482 		{ },
13483 		INTERNAL,
13484 		{ },
13485 		{ { 0, 1 } },
13486 		.fill_helper = bpf_fill_atomic32_or_fetch_reg_pairs,
13487 		.stack_depth = 8,
13488 	},
13489 	{
13490 		"ATOMIC_W_XOR_FETCH: register combinations",
13491 		{ },
13492 		INTERNAL,
13493 		{ },
13494 		{ { 0, 1 } },
13495 		.fill_helper = bpf_fill_atomic32_xor_fetch_reg_pairs,
13496 		.stack_depth = 8,
13497 	},
13498 	{
13499 		"ATOMIC_W_XCHG: register combinations",
13500 		{ },
13501 		INTERNAL,
13502 		{ },
13503 		{ { 0, 1 } },
13504 		.fill_helper = bpf_fill_atomic32_xchg_reg_pairs,
13505 		.stack_depth = 8,
13506 	},
13507 	{
13508 		"ATOMIC_W_CMPXCHG: register combinations",
13509 		{ },
13510 		INTERNAL,
13511 		{ },
13512 		{ { 0, 1 } },
13513 		.fill_helper = bpf_fill_atomic32_cmpxchg_reg_pairs,
13514 		.stack_depth = 8,
13515 	},
13516 	/* 64-bit ATOMIC magnitudes */
13517 	{
13518 		"ATOMIC_DW_ADD: all operand magnitudes",
13519 		{ },
13520 		INTERNAL | FLAG_NO_DATA,
13521 		{ },
13522 		{ { 0, 1 } },
13523 		.fill_helper = bpf_fill_atomic64_add,
13524 		.stack_depth = 8,
13525 		.nr_testruns = NR_PATTERN_RUNS,
13526 	},
13527 	{
13528 		"ATOMIC_DW_AND: all operand magnitudes",
13529 		{ },
13530 		INTERNAL | FLAG_NO_DATA,
13531 		{ },
13532 		{ { 0, 1 } },
13533 		.fill_helper = bpf_fill_atomic64_and,
13534 		.stack_depth = 8,
13535 		.nr_testruns = NR_PATTERN_RUNS,
13536 	},
13537 	{
13538 		"ATOMIC_DW_OR: all operand magnitudes",
13539 		{ },
13540 		INTERNAL | FLAG_NO_DATA,
13541 		{ },
13542 		{ { 0, 1 } },
13543 		.fill_helper = bpf_fill_atomic64_or,
13544 		.stack_depth = 8,
13545 		.nr_testruns = NR_PATTERN_RUNS,
13546 	},
13547 	{
13548 		"ATOMIC_DW_XOR: all operand magnitudes",
13549 		{ },
13550 		INTERNAL | FLAG_NO_DATA,
13551 		{ },
13552 		{ { 0, 1 } },
13553 		.fill_helper = bpf_fill_atomic64_xor,
13554 		.stack_depth = 8,
13555 		.nr_testruns = NR_PATTERN_RUNS,
13556 	},
13557 	{
13558 		"ATOMIC_DW_ADD_FETCH: all operand magnitudes",
13559 		{ },
13560 		INTERNAL | FLAG_NO_DATA,
13561 		{ },
13562 		{ { 0, 1 } },
13563 		.fill_helper = bpf_fill_atomic64_add_fetch,
13564 		.stack_depth = 8,
13565 		.nr_testruns = NR_PATTERN_RUNS,
13566 	},
13567 	{
13568 		"ATOMIC_DW_AND_FETCH: all operand magnitudes",
13569 		{ },
13570 		INTERNAL | FLAG_NO_DATA,
13571 		{ },
13572 		{ { 0, 1 } },
13573 		.fill_helper = bpf_fill_atomic64_and_fetch,
13574 		.stack_depth = 8,
13575 		.nr_testruns = NR_PATTERN_RUNS,
13576 	},
13577 	{
13578 		"ATOMIC_DW_OR_FETCH: all operand magnitudes",
13579 		{ },
13580 		INTERNAL | FLAG_NO_DATA,
13581 		{ },
13582 		{ { 0, 1 } },
13583 		.fill_helper = bpf_fill_atomic64_or_fetch,
13584 		.stack_depth = 8,
13585 		.nr_testruns = NR_PATTERN_RUNS,
13586 	},
13587 	{
13588 		"ATOMIC_DW_XOR_FETCH: all operand magnitudes",
13589 		{ },
13590 		INTERNAL | FLAG_NO_DATA,
13591 		{ },
13592 		{ { 0, 1 } },
13593 		.fill_helper = bpf_fill_atomic64_xor_fetch,
13594 		.stack_depth = 8,
13595 		.nr_testruns = NR_PATTERN_RUNS,
13596 	},
13597 	{
13598 		"ATOMIC_DW_XCHG: all operand magnitudes",
13599 		{ },
13600 		INTERNAL | FLAG_NO_DATA,
13601 		{ },
13602 		{ { 0, 1 } },
13603 		.fill_helper = bpf_fill_atomic64_xchg,
13604 		.stack_depth = 8,
13605 		.nr_testruns = NR_PATTERN_RUNS,
13606 	},
13607 	{
13608 		"ATOMIC_DW_CMPXCHG: all operand magnitudes",
13609 		{ },
13610 		INTERNAL | FLAG_NO_DATA,
13611 		{ },
13612 		{ { 0, 1 } },
13613 		.fill_helper = bpf_fill_cmpxchg64,
13614 		.stack_depth = 8,
13615 		.nr_testruns = NR_PATTERN_RUNS,
13616 	},
13617 	/* 32-bit atomic magnitudes */
13618 	{
13619 		"ATOMIC_W_ADD: all operand magnitudes",
13620 		{ },
13621 		INTERNAL | FLAG_NO_DATA,
13622 		{ },
13623 		{ { 0, 1 } },
13624 		.fill_helper = bpf_fill_atomic32_add,
13625 		.stack_depth = 8,
13626 		.nr_testruns = NR_PATTERN_RUNS,
13627 	},
13628 	{
13629 		"ATOMIC_W_AND: all operand magnitudes",
13630 		{ },
13631 		INTERNAL | FLAG_NO_DATA,
13632 		{ },
13633 		{ { 0, 1 } },
13634 		.fill_helper = bpf_fill_atomic32_and,
13635 		.stack_depth = 8,
13636 		.nr_testruns = NR_PATTERN_RUNS,
13637 	},
13638 	{
13639 		"ATOMIC_W_OR: all operand magnitudes",
13640 		{ },
13641 		INTERNAL | FLAG_NO_DATA,
13642 		{ },
13643 		{ { 0, 1 } },
13644 		.fill_helper = bpf_fill_atomic32_or,
13645 		.stack_depth = 8,
13646 		.nr_testruns = NR_PATTERN_RUNS,
13647 	},
13648 	{
13649 		"ATOMIC_W_XOR: all operand magnitudes",
13650 		{ },
13651 		INTERNAL | FLAG_NO_DATA,
13652 		{ },
13653 		{ { 0, 1 } },
13654 		.fill_helper = bpf_fill_atomic32_xor,
13655 		.stack_depth = 8,
13656 		.nr_testruns = NR_PATTERN_RUNS,
13657 	},
13658 	{
13659 		"ATOMIC_W_ADD_FETCH: all operand magnitudes",
13660 		{ },
13661 		INTERNAL | FLAG_NO_DATA,
13662 		{ },
13663 		{ { 0, 1 } },
13664 		.fill_helper = bpf_fill_atomic32_add_fetch,
13665 		.stack_depth = 8,
13666 		.nr_testruns = NR_PATTERN_RUNS,
13667 	},
13668 	{
13669 		"ATOMIC_W_AND_FETCH: all operand magnitudes",
13670 		{ },
13671 		INTERNAL | FLAG_NO_DATA,
13672 		{ },
13673 		{ { 0, 1 } },
13674 		.fill_helper = bpf_fill_atomic32_and_fetch,
13675 		.stack_depth = 8,
13676 		.nr_testruns = NR_PATTERN_RUNS,
13677 	},
13678 	{
13679 		"ATOMIC_W_OR_FETCH: all operand magnitudes",
13680 		{ },
13681 		INTERNAL | FLAG_NO_DATA,
13682 		{ },
13683 		{ { 0, 1 } },
13684 		.fill_helper = bpf_fill_atomic32_or_fetch,
13685 		.stack_depth = 8,
13686 		.nr_testruns = NR_PATTERN_RUNS,
13687 	},
13688 	{
13689 		"ATOMIC_W_XOR_FETCH: all operand magnitudes",
13690 		{ },
13691 		INTERNAL | FLAG_NO_DATA,
13692 		{ },
13693 		{ { 0, 1 } },
13694 		.fill_helper = bpf_fill_atomic32_xor_fetch,
13695 		.stack_depth = 8,
13696 		.nr_testruns = NR_PATTERN_RUNS,
13697 	},
13698 	{
13699 		"ATOMIC_W_XCHG: all operand magnitudes",
13700 		{ },
13701 		INTERNAL | FLAG_NO_DATA,
13702 		{ },
13703 		{ { 0, 1 } },
13704 		.fill_helper = bpf_fill_atomic32_xchg,
13705 		.stack_depth = 8,
13706 		.nr_testruns = NR_PATTERN_RUNS,
13707 	},
13708 	{
13709 		"ATOMIC_W_CMPXCHG: all operand magnitudes",
13710 		{ },
13711 		INTERNAL | FLAG_NO_DATA,
13712 		{ },
13713 		{ { 0, 1 } },
13714 		.fill_helper = bpf_fill_cmpxchg32,
13715 		.stack_depth = 8,
13716 		.nr_testruns = NR_PATTERN_RUNS,
13717 	},
13718 	/* JMP immediate magnitudes */
13719 	{
13720 		"JMP_JSET_K: all immediate value magnitudes",
13721 		{ },
13722 		INTERNAL | FLAG_NO_DATA,
13723 		{ },
13724 		{ { 0, 1 } },
13725 		.fill_helper = bpf_fill_jmp_jset_imm,
13726 		.nr_testruns = NR_PATTERN_RUNS,
13727 	},
13728 	{
13729 		"JMP_JEQ_K: all immediate value magnitudes",
13730 		{ },
13731 		INTERNAL | FLAG_NO_DATA,
13732 		{ },
13733 		{ { 0, 1 } },
13734 		.fill_helper = bpf_fill_jmp_jeq_imm,
13735 		.nr_testruns = NR_PATTERN_RUNS,
13736 	},
13737 	{
13738 		"JMP_JNE_K: all immediate value magnitudes",
13739 		{ },
13740 		INTERNAL | FLAG_NO_DATA,
13741 		{ },
13742 		{ { 0, 1 } },
13743 		.fill_helper = bpf_fill_jmp_jne_imm,
13744 		.nr_testruns = NR_PATTERN_RUNS,
13745 	},
13746 	{
13747 		"JMP_JGT_K: all immediate value magnitudes",
13748 		{ },
13749 		INTERNAL | FLAG_NO_DATA,
13750 		{ },
13751 		{ { 0, 1 } },
13752 		.fill_helper = bpf_fill_jmp_jgt_imm,
13753 		.nr_testruns = NR_PATTERN_RUNS,
13754 	},
13755 	{
13756 		"JMP_JGE_K: all immediate value magnitudes",
13757 		{ },
13758 		INTERNAL | FLAG_NO_DATA,
13759 		{ },
13760 		{ { 0, 1 } },
13761 		.fill_helper = bpf_fill_jmp_jge_imm,
13762 		.nr_testruns = NR_PATTERN_RUNS,
13763 	},
13764 	{
13765 		"JMP_JLT_K: all immediate value magnitudes",
13766 		{ },
13767 		INTERNAL | FLAG_NO_DATA,
13768 		{ },
13769 		{ { 0, 1 } },
13770 		.fill_helper = bpf_fill_jmp_jlt_imm,
13771 		.nr_testruns = NR_PATTERN_RUNS,
13772 	},
13773 	{
13774 		"JMP_JLE_K: all immediate value magnitudes",
13775 		{ },
13776 		INTERNAL | FLAG_NO_DATA,
13777 		{ },
13778 		{ { 0, 1 } },
13779 		.fill_helper = bpf_fill_jmp_jle_imm,
13780 		.nr_testruns = NR_PATTERN_RUNS,
13781 	},
13782 	{
13783 		"JMP_JSGT_K: all immediate value magnitudes",
13784 		{ },
13785 		INTERNAL | FLAG_NO_DATA,
13786 		{ },
13787 		{ { 0, 1 } },
13788 		.fill_helper = bpf_fill_jmp_jsgt_imm,
13789 		.nr_testruns = NR_PATTERN_RUNS,
13790 	},
13791 	{
13792 		"JMP_JSGE_K: all immediate value magnitudes",
13793 		{ },
13794 		INTERNAL | FLAG_NO_DATA,
13795 		{ },
13796 		{ { 0, 1 } },
13797 		.fill_helper = bpf_fill_jmp_jsge_imm,
13798 		.nr_testruns = NR_PATTERN_RUNS,
13799 	},
13800 	{
13801 		"JMP_JSLT_K: all immediate value magnitudes",
13802 		{ },
13803 		INTERNAL | FLAG_NO_DATA,
13804 		{ },
13805 		{ { 0, 1 } },
13806 		.fill_helper = bpf_fill_jmp_jslt_imm,
13807 		.nr_testruns = NR_PATTERN_RUNS,
13808 	},
13809 	{
13810 		"JMP_JSLE_K: all immediate value magnitudes",
13811 		{ },
13812 		INTERNAL | FLAG_NO_DATA,
13813 		{ },
13814 		{ { 0, 1 } },
13815 		.fill_helper = bpf_fill_jmp_jsle_imm,
13816 		.nr_testruns = NR_PATTERN_RUNS,
13817 	},
13818 	/* JMP register magnitudes */
13819 	{
13820 		"JMP_JSET_X: all register value magnitudes",
13821 		{ },
13822 		INTERNAL | FLAG_NO_DATA,
13823 		{ },
13824 		{ { 0, 1 } },
13825 		.fill_helper = bpf_fill_jmp_jset_reg,
13826 		.nr_testruns = NR_PATTERN_RUNS,
13827 	},
13828 	{
13829 		"JMP_JEQ_X: all register value magnitudes",
13830 		{ },
13831 		INTERNAL | FLAG_NO_DATA,
13832 		{ },
13833 		{ { 0, 1 } },
13834 		.fill_helper = bpf_fill_jmp_jeq_reg,
13835 		.nr_testruns = NR_PATTERN_RUNS,
13836 	},
13837 	{
13838 		"JMP_JNE_X: all register value magnitudes",
13839 		{ },
13840 		INTERNAL | FLAG_NO_DATA,
13841 		{ },
13842 		{ { 0, 1 } },
13843 		.fill_helper = bpf_fill_jmp_jne_reg,
13844 		.nr_testruns = NR_PATTERN_RUNS,
13845 	},
13846 	{
13847 		"JMP_JGT_X: all register value magnitudes",
13848 		{ },
13849 		INTERNAL | FLAG_NO_DATA,
13850 		{ },
13851 		{ { 0, 1 } },
13852 		.fill_helper = bpf_fill_jmp_jgt_reg,
13853 		.nr_testruns = NR_PATTERN_RUNS,
13854 	},
13855 	{
13856 		"JMP_JGE_X: all register value magnitudes",
13857 		{ },
13858 		INTERNAL | FLAG_NO_DATA,
13859 		{ },
13860 		{ { 0, 1 } },
13861 		.fill_helper = bpf_fill_jmp_jge_reg,
13862 		.nr_testruns = NR_PATTERN_RUNS,
13863 	},
13864 	{
13865 		"JMP_JLT_X: all register value magnitudes",
13866 		{ },
13867 		INTERNAL | FLAG_NO_DATA,
13868 		{ },
13869 		{ { 0, 1 } },
13870 		.fill_helper = bpf_fill_jmp_jlt_reg,
13871 		.nr_testruns = NR_PATTERN_RUNS,
13872 	},
13873 	{
13874 		"JMP_JLE_X: all register value magnitudes",
13875 		{ },
13876 		INTERNAL | FLAG_NO_DATA,
13877 		{ },
13878 		{ { 0, 1 } },
13879 		.fill_helper = bpf_fill_jmp_jle_reg,
13880 		.nr_testruns = NR_PATTERN_RUNS,
13881 	},
13882 	{
13883 		"JMP_JSGT_X: all register value magnitudes",
13884 		{ },
13885 		INTERNAL | FLAG_NO_DATA,
13886 		{ },
13887 		{ { 0, 1 } },
13888 		.fill_helper = bpf_fill_jmp_jsgt_reg,
13889 		.nr_testruns = NR_PATTERN_RUNS,
13890 	},
13891 	{
13892 		"JMP_JSGE_X: all register value magnitudes",
13893 		{ },
13894 		INTERNAL | FLAG_NO_DATA,
13895 		{ },
13896 		{ { 0, 1 } },
13897 		.fill_helper = bpf_fill_jmp_jsge_reg,
13898 		.nr_testruns = NR_PATTERN_RUNS,
13899 	},
13900 	{
13901 		"JMP_JSLT_X: all register value magnitudes",
13902 		{ },
13903 		INTERNAL | FLAG_NO_DATA,
13904 		{ },
13905 		{ { 0, 1 } },
13906 		.fill_helper = bpf_fill_jmp_jslt_reg,
13907 		.nr_testruns = NR_PATTERN_RUNS,
13908 	},
13909 	{
13910 		"JMP_JSLE_X: all register value magnitudes",
13911 		{ },
13912 		INTERNAL | FLAG_NO_DATA,
13913 		{ },
13914 		{ { 0, 1 } },
13915 		.fill_helper = bpf_fill_jmp_jsle_reg,
13916 		.nr_testruns = NR_PATTERN_RUNS,
13917 	},
13918 	/* JMP32 immediate magnitudes */
13919 	{
13920 		"JMP32_JSET_K: all immediate value magnitudes",
13921 		{ },
13922 		INTERNAL | FLAG_NO_DATA,
13923 		{ },
13924 		{ { 0, 1 } },
13925 		.fill_helper = bpf_fill_jmp32_jset_imm,
13926 		.nr_testruns = NR_PATTERN_RUNS,
13927 	},
13928 	{
13929 		"JMP32_JEQ_K: all immediate value magnitudes",
13930 		{ },
13931 		INTERNAL | FLAG_NO_DATA,
13932 		{ },
13933 		{ { 0, 1 } },
13934 		.fill_helper = bpf_fill_jmp32_jeq_imm,
13935 		.nr_testruns = NR_PATTERN_RUNS,
13936 	},
13937 	{
13938 		"JMP32_JNE_K: all immediate value magnitudes",
13939 		{ },
13940 		INTERNAL | FLAG_NO_DATA,
13941 		{ },
13942 		{ { 0, 1 } },
13943 		.fill_helper = bpf_fill_jmp32_jne_imm,
13944 		.nr_testruns = NR_PATTERN_RUNS,
13945 	},
13946 	{
13947 		"JMP32_JGT_K: all immediate value magnitudes",
13948 		{ },
13949 		INTERNAL | FLAG_NO_DATA,
13950 		{ },
13951 		{ { 0, 1 } },
13952 		.fill_helper = bpf_fill_jmp32_jgt_imm,
13953 		.nr_testruns = NR_PATTERN_RUNS,
13954 	},
13955 	{
13956 		"JMP32_JGE_K: all immediate value magnitudes",
13957 		{ },
13958 		INTERNAL | FLAG_NO_DATA,
13959 		{ },
13960 		{ { 0, 1 } },
13961 		.fill_helper = bpf_fill_jmp32_jge_imm,
13962 		.nr_testruns = NR_PATTERN_RUNS,
13963 	},
13964 	{
13965 		"JMP32_JLT_K: all immediate value magnitudes",
13966 		{ },
13967 		INTERNAL | FLAG_NO_DATA,
13968 		{ },
13969 		{ { 0, 1 } },
13970 		.fill_helper = bpf_fill_jmp32_jlt_imm,
13971 		.nr_testruns = NR_PATTERN_RUNS,
13972 	},
13973 	{
13974 		"JMP32_JLE_K: all immediate value magnitudes",
13975 		{ },
13976 		INTERNAL | FLAG_NO_DATA,
13977 		{ },
13978 		{ { 0, 1 } },
13979 		.fill_helper = bpf_fill_jmp32_jle_imm,
13980 		.nr_testruns = NR_PATTERN_RUNS,
13981 	},
13982 	{
13983 		"JMP32_JSGT_K: all immediate value magnitudes",
13984 		{ },
13985 		INTERNAL | FLAG_NO_DATA,
13986 		{ },
13987 		{ { 0, 1 } },
13988 		.fill_helper = bpf_fill_jmp32_jsgt_imm,
13989 		.nr_testruns = NR_PATTERN_RUNS,
13990 	},
13991 	{
13992 		"JMP32_JSGE_K: all immediate value magnitudes",
13993 		{ },
13994 		INTERNAL | FLAG_NO_DATA,
13995 		{ },
13996 		{ { 0, 1 } },
13997 		.fill_helper = bpf_fill_jmp32_jsge_imm,
13998 		.nr_testruns = NR_PATTERN_RUNS,
13999 	},
14000 	{
14001 		"JMP32_JSLT_K: all immediate value magnitudes",
14002 		{ },
14003 		INTERNAL | FLAG_NO_DATA,
14004 		{ },
14005 		{ { 0, 1 } },
14006 		.fill_helper = bpf_fill_jmp32_jslt_imm,
14007 		.nr_testruns = NR_PATTERN_RUNS,
14008 	},
14009 	{
14010 		"JMP32_JSLE_K: all immediate value magnitudes",
14011 		{ },
14012 		INTERNAL | FLAG_NO_DATA,
14013 		{ },
14014 		{ { 0, 1 } },
14015 		.fill_helper = bpf_fill_jmp32_jsle_imm,
14016 		.nr_testruns = NR_PATTERN_RUNS,
14017 	},
14018 	/* JMP32 register magnitudes */
14019 	{
14020 		"JMP32_JSET_X: all register value magnitudes",
14021 		{ },
14022 		INTERNAL | FLAG_NO_DATA,
14023 		{ },
14024 		{ { 0, 1 } },
14025 		.fill_helper = bpf_fill_jmp32_jset_reg,
14026 		.nr_testruns = NR_PATTERN_RUNS,
14027 	},
14028 	{
14029 		"JMP32_JEQ_X: all register value magnitudes",
14030 		{ },
14031 		INTERNAL | FLAG_NO_DATA,
14032 		{ },
14033 		{ { 0, 1 } },
14034 		.fill_helper = bpf_fill_jmp32_jeq_reg,
14035 		.nr_testruns = NR_PATTERN_RUNS,
14036 	},
14037 	{
14038 		"JMP32_JNE_X: all register value magnitudes",
14039 		{ },
14040 		INTERNAL | FLAG_NO_DATA,
14041 		{ },
14042 		{ { 0, 1 } },
14043 		.fill_helper = bpf_fill_jmp32_jne_reg,
14044 		.nr_testruns = NR_PATTERN_RUNS,
14045 	},
14046 	{
14047 		"JMP32_JGT_X: all register value magnitudes",
14048 		{ },
14049 		INTERNAL | FLAG_NO_DATA,
14050 		{ },
14051 		{ { 0, 1 } },
14052 		.fill_helper = bpf_fill_jmp32_jgt_reg,
14053 		.nr_testruns = NR_PATTERN_RUNS,
14054 	},
14055 	{
14056 		"JMP32_JGE_X: all register value magnitudes",
14057 		{ },
14058 		INTERNAL | FLAG_NO_DATA,
14059 		{ },
14060 		{ { 0, 1 } },
14061 		.fill_helper = bpf_fill_jmp32_jge_reg,
14062 		.nr_testruns = NR_PATTERN_RUNS,
14063 	},
14064 	{
14065 		"JMP32_JLT_X: all register value magnitudes",
14066 		{ },
14067 		INTERNAL | FLAG_NO_DATA,
14068 		{ },
14069 		{ { 0, 1 } },
14070 		.fill_helper = bpf_fill_jmp32_jlt_reg,
14071 		.nr_testruns = NR_PATTERN_RUNS,
14072 	},
14073 	{
14074 		"JMP32_JLE_X: all register value magnitudes",
14075 		{ },
14076 		INTERNAL | FLAG_NO_DATA,
14077 		{ },
14078 		{ { 0, 1 } },
14079 		.fill_helper = bpf_fill_jmp32_jle_reg,
14080 		.nr_testruns = NR_PATTERN_RUNS,
14081 	},
14082 	{
14083 		"JMP32_JSGT_X: all register value magnitudes",
14084 		{ },
14085 		INTERNAL | FLAG_NO_DATA,
14086 		{ },
14087 		{ { 0, 1 } },
14088 		.fill_helper = bpf_fill_jmp32_jsgt_reg,
14089 		.nr_testruns = NR_PATTERN_RUNS,
14090 	},
14091 	{
14092 		"JMP32_JSGE_X: all register value magnitudes",
14093 		{ },
14094 		INTERNAL | FLAG_NO_DATA,
14095 		{ },
14096 		{ { 0, 1 } },
14097 		.fill_helper = bpf_fill_jmp32_jsge_reg,
14098 		.nr_testruns = NR_PATTERN_RUNS,
14099 	},
14100 	{
14101 		"JMP32_JSLT_X: all register value magnitudes",
14102 		{ },
14103 		INTERNAL | FLAG_NO_DATA,
14104 		{ },
14105 		{ { 0, 1 } },
14106 		.fill_helper = bpf_fill_jmp32_jslt_reg,
14107 		.nr_testruns = NR_PATTERN_RUNS,
14108 	},
14109 	{
14110 		"JMP32_JSLE_X: all register value magnitudes",
14111 		{ },
14112 		INTERNAL | FLAG_NO_DATA,
14113 		{ },
14114 		{ { 0, 1 } },
14115 		.fill_helper = bpf_fill_jmp32_jsle_reg,
14116 		.nr_testruns = NR_PATTERN_RUNS,
14117 	},
14118 	/* Conditional jumps with constant decision */
14119 	{
14120 		"JMP_JSET_K: imm = 0 -> never taken",
14121 		.u.insns_int = {
14122 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
14123 			BPF_JMP_IMM(BPF_JSET, R1, 0, 1),
14124 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14125 			BPF_EXIT_INSN(),
14126 		},
14127 		INTERNAL | FLAG_NO_DATA,
14128 		{ },
14129 		{ { 0, 0 } },
14130 	},
14131 	{
14132 		"JMP_JLT_K: imm = 0 -> never taken",
14133 		.u.insns_int = {
14134 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
14135 			BPF_JMP_IMM(BPF_JLT, R1, 0, 1),
14136 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14137 			BPF_EXIT_INSN(),
14138 		},
14139 		INTERNAL | FLAG_NO_DATA,
14140 		{ },
14141 		{ { 0, 0 } },
14142 	},
14143 	{
14144 		"JMP_JGE_K: imm = 0 -> always taken",
14145 		.u.insns_int = {
14146 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
14147 			BPF_JMP_IMM(BPF_JGE, R1, 0, 1),
14148 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14149 			BPF_EXIT_INSN(),
14150 		},
14151 		INTERNAL | FLAG_NO_DATA,
14152 		{ },
14153 		{ { 0, 1 } },
14154 	},
14155 	{
14156 		"JMP_JGT_K: imm = 0xffffffff -> never taken",
14157 		.u.insns_int = {
14158 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
14159 			BPF_JMP_IMM(BPF_JGT, R1, U32_MAX, 1),
14160 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14161 			BPF_EXIT_INSN(),
14162 		},
14163 		INTERNAL | FLAG_NO_DATA,
14164 		{ },
14165 		{ { 0, 0 } },
14166 	},
14167 	{
14168 		"JMP_JLE_K: imm = 0xffffffff -> always taken",
14169 		.u.insns_int = {
14170 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
14171 			BPF_JMP_IMM(BPF_JLE, R1, U32_MAX, 1),
14172 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14173 			BPF_EXIT_INSN(),
14174 		},
14175 		INTERNAL | FLAG_NO_DATA,
14176 		{ },
14177 		{ { 0, 1 } },
14178 	},
14179 	{
14180 		"JMP32_JSGT_K: imm = 0x7fffffff -> never taken",
14181 		.u.insns_int = {
14182 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
14183 			BPF_JMP32_IMM(BPF_JSGT, R1, S32_MAX, 1),
14184 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14185 			BPF_EXIT_INSN(),
14186 		},
14187 		INTERNAL | FLAG_NO_DATA,
14188 		{ },
14189 		{ { 0, 0 } },
14190 	},
14191 	{
14192 		"JMP32_JSGE_K: imm = -0x80000000 -> always taken",
14193 		.u.insns_int = {
14194 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
14195 			BPF_JMP32_IMM(BPF_JSGE, R1, S32_MIN, 1),
14196 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14197 			BPF_EXIT_INSN(),
14198 		},
14199 		INTERNAL | FLAG_NO_DATA,
14200 		{ },
14201 		{ { 0, 1 } },
14202 	},
14203 	{
14204 		"JMP32_JSLT_K: imm = -0x80000000 -> never taken",
14205 		.u.insns_int = {
14206 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
14207 			BPF_JMP32_IMM(BPF_JSLT, R1, S32_MIN, 1),
14208 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14209 			BPF_EXIT_INSN(),
14210 		},
14211 		INTERNAL | FLAG_NO_DATA,
14212 		{ },
14213 		{ { 0, 0 } },
14214 	},
14215 	{
14216 		"JMP32_JSLE_K: imm = 0x7fffffff -> always taken",
14217 		.u.insns_int = {
14218 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
14219 			BPF_JMP32_IMM(BPF_JSLE, R1, S32_MAX, 1),
14220 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14221 			BPF_EXIT_INSN(),
14222 		},
14223 		INTERNAL | FLAG_NO_DATA,
14224 		{ },
14225 		{ { 0, 1 } },
14226 	},
14227 	{
14228 		"JMP_JEQ_X: dst = src -> always taken",
14229 		.u.insns_int = {
14230 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
14231 			BPF_JMP_REG(BPF_JEQ, R1, R1, 1),
14232 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14233 			BPF_EXIT_INSN(),
14234 		},
14235 		INTERNAL | FLAG_NO_DATA,
14236 		{ },
14237 		{ { 0, 1 } },
14238 	},
14239 	{
14240 		"JMP_JGE_X: dst = src -> always taken",
14241 		.u.insns_int = {
14242 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
14243 			BPF_JMP_REG(BPF_JGE, R1, R1, 1),
14244 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14245 			BPF_EXIT_INSN(),
14246 		},
14247 		INTERNAL | FLAG_NO_DATA,
14248 		{ },
14249 		{ { 0, 1 } },
14250 	},
14251 	{
14252 		"JMP_JLE_X: dst = src -> always taken",
14253 		.u.insns_int = {
14254 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
14255 			BPF_JMP_REG(BPF_JLE, R1, R1, 1),
14256 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14257 			BPF_EXIT_INSN(),
14258 		},
14259 		INTERNAL | FLAG_NO_DATA,
14260 		{ },
14261 		{ { 0, 1 } },
14262 	},
14263 	{
14264 		"JMP_JSGE_X: dst = src -> always taken",
14265 		.u.insns_int = {
14266 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
14267 			BPF_JMP_REG(BPF_JSGE, R1, R1, 1),
14268 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14269 			BPF_EXIT_INSN(),
14270 		},
14271 		INTERNAL | FLAG_NO_DATA,
14272 		{ },
14273 		{ { 0, 1 } },
14274 	},
14275 	{
14276 		"JMP_JSLE_X: dst = src -> always taken",
14277 		.u.insns_int = {
14278 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
14279 			BPF_JMP_REG(BPF_JSLE, R1, R1, 1),
14280 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14281 			BPF_EXIT_INSN(),
14282 		},
14283 		INTERNAL | FLAG_NO_DATA,
14284 		{ },
14285 		{ { 0, 1 } },
14286 	},
14287 	{
14288 		"JMP_JNE_X: dst = src -> never taken",
14289 		.u.insns_int = {
14290 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
14291 			BPF_JMP_REG(BPF_JNE, R1, R1, 1),
14292 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14293 			BPF_EXIT_INSN(),
14294 		},
14295 		INTERNAL | FLAG_NO_DATA,
14296 		{ },
14297 		{ { 0, 0 } },
14298 	},
14299 	{
14300 		"JMP_JGT_X: dst = src -> never taken",
14301 		.u.insns_int = {
14302 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
14303 			BPF_JMP_REG(BPF_JGT, R1, R1, 1),
14304 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14305 			BPF_EXIT_INSN(),
14306 		},
14307 		INTERNAL | FLAG_NO_DATA,
14308 		{ },
14309 		{ { 0, 0 } },
14310 	},
14311 	{
14312 		"JMP_JLT_X: dst = src -> never taken",
14313 		.u.insns_int = {
14314 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
14315 			BPF_JMP_REG(BPF_JLT, R1, R1, 1),
14316 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14317 			BPF_EXIT_INSN(),
14318 		},
14319 		INTERNAL | FLAG_NO_DATA,
14320 		{ },
14321 		{ { 0, 0 } },
14322 	},
14323 	{
14324 		"JMP_JSGT_X: dst = src -> never taken",
14325 		.u.insns_int = {
14326 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
14327 			BPF_JMP_REG(BPF_JSGT, R1, R1, 1),
14328 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14329 			BPF_EXIT_INSN(),
14330 		},
14331 		INTERNAL | FLAG_NO_DATA,
14332 		{ },
14333 		{ { 0, 0 } },
14334 	},
14335 	{
14336 		"JMP_JSLT_X: dst = src -> never taken",
14337 		.u.insns_int = {
14338 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
14339 			BPF_JMP_REG(BPF_JSLT, R1, R1, 1),
14340 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14341 			BPF_EXIT_INSN(),
14342 		},
14343 		INTERNAL | FLAG_NO_DATA,
14344 		{ },
14345 		{ { 0, 0 } },
14346 	},
14347 	/* Short relative jumps */
14348 	{
14349 		"Short relative jump: offset=0",
14350 		.u.insns_int = {
14351 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14352 			BPF_JMP_IMM(BPF_JEQ, R0, 0, 0),
14353 			BPF_EXIT_INSN(),
14354 			BPF_ALU32_IMM(BPF_MOV, R0, -1),
14355 		},
14356 		INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
14357 		{ },
14358 		{ { 0, 0 } },
14359 	},
14360 	{
14361 		"Short relative jump: offset=1",
14362 		.u.insns_int = {
14363 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14364 			BPF_JMP_IMM(BPF_JEQ, R0, 0, 1),
14365 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
14366 			BPF_EXIT_INSN(),
14367 			BPF_ALU32_IMM(BPF_MOV, R0, -1),
14368 		},
14369 		INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
14370 		{ },
14371 		{ { 0, 0 } },
14372 	},
14373 	{
14374 		"Short relative jump: offset=2",
14375 		.u.insns_int = {
14376 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14377 			BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
14378 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
14379 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
14380 			BPF_EXIT_INSN(),
14381 			BPF_ALU32_IMM(BPF_MOV, R0, -1),
14382 		},
14383 		INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
14384 		{ },
14385 		{ { 0, 0 } },
14386 	},
14387 	{
14388 		"Short relative jump: offset=3",
14389 		.u.insns_int = {
14390 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14391 			BPF_JMP_IMM(BPF_JEQ, R0, 0, 3),
14392 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
14393 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
14394 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
14395 			BPF_EXIT_INSN(),
14396 			BPF_ALU32_IMM(BPF_MOV, R0, -1),
14397 		},
14398 		INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
14399 		{ },
14400 		{ { 0, 0 } },
14401 	},
14402 	{
14403 		"Short relative jump: offset=4",
14404 		.u.insns_int = {
14405 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14406 			BPF_JMP_IMM(BPF_JEQ, R0, 0, 4),
14407 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
14408 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
14409 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
14410 			BPF_ALU32_IMM(BPF_ADD, R0, 1),
14411 			BPF_EXIT_INSN(),
14412 			BPF_ALU32_IMM(BPF_MOV, R0, -1),
14413 		},
14414 		INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
14415 		{ },
14416 		{ { 0, 0 } },
14417 	},
14418 	/* Conditional branch conversions */
14419 	{
14420 		"Long conditional jump: taken at runtime (32 bits)",
14421 		{ },
14422 		INTERNAL | FLAG_NO_DATA,
14423 		{ },
14424 		{ { 0, 1 } },
14425 		.fill_helper = bpf_fill_max_jmp_taken_32,
14426 	},
14427 	{
14428 		"Long conditional jump: not taken at runtime (32 bits)",
14429 		{ },
14430 		INTERNAL | FLAG_NO_DATA,
14431 		{ },
14432 		{ { 0, 2 } },
14433 		.fill_helper = bpf_fill_max_jmp_not_taken_32,
14434 	},
14435 	{
14436 		"Long conditional jump: always taken, known at JIT time (32 bits)",
14437 		{ },
14438 		INTERNAL | FLAG_NO_DATA,
14439 		{ },
14440 		{ { 0, 1 } },
14441 		.fill_helper = bpf_fill_max_jmp_always_taken_32,
14442 	},
14443 	{
14444 		"Long conditional jump: never taken, known at JIT time (32 bits)",
14445 		{ },
14446 		INTERNAL | FLAG_NO_DATA,
14447 		{ },
14448 		{ { 0, 2 } },
14449 		.fill_helper = bpf_fill_max_jmp_never_taken_32,
14450 	},
14451 	{
14452 		"Long conditional jump: taken at runtime",
14453 		{ },
14454 		INTERNAL | FLAG_NO_DATA,
14455 		{ },
14456 		{ { 0, 1 } },
14457 		.fill_helper = bpf_fill_max_jmp_taken,
14458 	},
14459 	{
14460 		"Long conditional jump: not taken at runtime",
14461 		{ },
14462 		INTERNAL | FLAG_NO_DATA,
14463 		{ },
14464 		{ { 0, 2 } },
14465 		.fill_helper = bpf_fill_max_jmp_not_taken,
14466 	},
14467 	{
14468 		"Long conditional jump: always taken, known at JIT time",
14469 		{ },
14470 		INTERNAL | FLAG_NO_DATA,
14471 		{ },
14472 		{ { 0, 1 } },
14473 		.fill_helper = bpf_fill_max_jmp_always_taken,
14474 	},
14475 	{
14476 		"Long conditional jump: never taken, known at JIT time",
14477 		{ },
14478 		INTERNAL | FLAG_NO_DATA,
14479 		{ },
14480 		{ { 0, 2 } },
14481 		.fill_helper = bpf_fill_max_jmp_never_taken,
14482 	},
14483 	/* Staggered jump sequences, immediate */
14484 	{
14485 		"Staggered jumps: JMP_JA",
14486 		{ },
14487 		INTERNAL | FLAG_NO_DATA,
14488 		{ },
14489 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14490 		.fill_helper = bpf_fill_staggered_ja,
14491 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14492 	},
14493 	{
14494 		"Staggered jumps: JMP_JEQ_K",
14495 		{ },
14496 		INTERNAL | FLAG_NO_DATA,
14497 		{ },
14498 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14499 		.fill_helper = bpf_fill_staggered_jeq_imm,
14500 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14501 	},
14502 	{
14503 		"Staggered jumps: JMP_JNE_K",
14504 		{ },
14505 		INTERNAL | FLAG_NO_DATA,
14506 		{ },
14507 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14508 		.fill_helper = bpf_fill_staggered_jne_imm,
14509 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14510 	},
14511 	{
14512 		"Staggered jumps: JMP_JSET_K",
14513 		{ },
14514 		INTERNAL | FLAG_NO_DATA,
14515 		{ },
14516 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14517 		.fill_helper = bpf_fill_staggered_jset_imm,
14518 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14519 	},
14520 	{
14521 		"Staggered jumps: JMP_JGT_K",
14522 		{ },
14523 		INTERNAL | FLAG_NO_DATA,
14524 		{ },
14525 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14526 		.fill_helper = bpf_fill_staggered_jgt_imm,
14527 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14528 	},
14529 	{
14530 		"Staggered jumps: JMP_JGE_K",
14531 		{ },
14532 		INTERNAL | FLAG_NO_DATA,
14533 		{ },
14534 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14535 		.fill_helper = bpf_fill_staggered_jge_imm,
14536 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14537 	},
14538 	{
14539 		"Staggered jumps: JMP_JLT_K",
14540 		{ },
14541 		INTERNAL | FLAG_NO_DATA,
14542 		{ },
14543 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14544 		.fill_helper = bpf_fill_staggered_jlt_imm,
14545 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14546 	},
14547 	{
14548 		"Staggered jumps: JMP_JLE_K",
14549 		{ },
14550 		INTERNAL | FLAG_NO_DATA,
14551 		{ },
14552 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14553 		.fill_helper = bpf_fill_staggered_jle_imm,
14554 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14555 	},
14556 	{
14557 		"Staggered jumps: JMP_JSGT_K",
14558 		{ },
14559 		INTERNAL | FLAG_NO_DATA,
14560 		{ },
14561 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14562 		.fill_helper = bpf_fill_staggered_jsgt_imm,
14563 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14564 	},
14565 	{
14566 		"Staggered jumps: JMP_JSGE_K",
14567 		{ },
14568 		INTERNAL | FLAG_NO_DATA,
14569 		{ },
14570 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14571 		.fill_helper = bpf_fill_staggered_jsge_imm,
14572 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14573 	},
14574 	{
14575 		"Staggered jumps: JMP_JSLT_K",
14576 		{ },
14577 		INTERNAL | FLAG_NO_DATA,
14578 		{ },
14579 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14580 		.fill_helper = bpf_fill_staggered_jslt_imm,
14581 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14582 	},
14583 	{
14584 		"Staggered jumps: JMP_JSLE_K",
14585 		{ },
14586 		INTERNAL | FLAG_NO_DATA,
14587 		{ },
14588 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14589 		.fill_helper = bpf_fill_staggered_jsle_imm,
14590 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14591 	},
14592 	/* Staggered jump sequences, register */
14593 	{
14594 		"Staggered jumps: JMP_JEQ_X",
14595 		{ },
14596 		INTERNAL | FLAG_NO_DATA,
14597 		{ },
14598 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14599 		.fill_helper = bpf_fill_staggered_jeq_reg,
14600 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14601 	},
14602 	{
14603 		"Staggered jumps: JMP_JNE_X",
14604 		{ },
14605 		INTERNAL | FLAG_NO_DATA,
14606 		{ },
14607 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14608 		.fill_helper = bpf_fill_staggered_jne_reg,
14609 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14610 	},
14611 	{
14612 		"Staggered jumps: JMP_JSET_X",
14613 		{ },
14614 		INTERNAL | FLAG_NO_DATA,
14615 		{ },
14616 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14617 		.fill_helper = bpf_fill_staggered_jset_reg,
14618 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14619 	},
14620 	{
14621 		"Staggered jumps: JMP_JGT_X",
14622 		{ },
14623 		INTERNAL | FLAG_NO_DATA,
14624 		{ },
14625 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14626 		.fill_helper = bpf_fill_staggered_jgt_reg,
14627 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14628 	},
14629 	{
14630 		"Staggered jumps: JMP_JGE_X",
14631 		{ },
14632 		INTERNAL | FLAG_NO_DATA,
14633 		{ },
14634 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14635 		.fill_helper = bpf_fill_staggered_jge_reg,
14636 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14637 	},
14638 	{
14639 		"Staggered jumps: JMP_JLT_X",
14640 		{ },
14641 		INTERNAL | FLAG_NO_DATA,
14642 		{ },
14643 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14644 		.fill_helper = bpf_fill_staggered_jlt_reg,
14645 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14646 	},
14647 	{
14648 		"Staggered jumps: JMP_JLE_X",
14649 		{ },
14650 		INTERNAL | FLAG_NO_DATA,
14651 		{ },
14652 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14653 		.fill_helper = bpf_fill_staggered_jle_reg,
14654 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14655 	},
14656 	{
14657 		"Staggered jumps: JMP_JSGT_X",
14658 		{ },
14659 		INTERNAL | FLAG_NO_DATA,
14660 		{ },
14661 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14662 		.fill_helper = bpf_fill_staggered_jsgt_reg,
14663 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14664 	},
14665 	{
14666 		"Staggered jumps: JMP_JSGE_X",
14667 		{ },
14668 		INTERNAL | FLAG_NO_DATA,
14669 		{ },
14670 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14671 		.fill_helper = bpf_fill_staggered_jsge_reg,
14672 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14673 	},
14674 	{
14675 		"Staggered jumps: JMP_JSLT_X",
14676 		{ },
14677 		INTERNAL | FLAG_NO_DATA,
14678 		{ },
14679 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14680 		.fill_helper = bpf_fill_staggered_jslt_reg,
14681 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14682 	},
14683 	{
14684 		"Staggered jumps: JMP_JSLE_X",
14685 		{ },
14686 		INTERNAL | FLAG_NO_DATA,
14687 		{ },
14688 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14689 		.fill_helper = bpf_fill_staggered_jsle_reg,
14690 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14691 	},
14692 	/* Staggered jump sequences, JMP32 immediate */
14693 	{
14694 		"Staggered jumps: JMP32_JEQ_K",
14695 		{ },
14696 		INTERNAL | FLAG_NO_DATA,
14697 		{ },
14698 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14699 		.fill_helper = bpf_fill_staggered_jeq32_imm,
14700 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14701 	},
14702 	{
14703 		"Staggered jumps: JMP32_JNE_K",
14704 		{ },
14705 		INTERNAL | FLAG_NO_DATA,
14706 		{ },
14707 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14708 		.fill_helper = bpf_fill_staggered_jne32_imm,
14709 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14710 	},
14711 	{
14712 		"Staggered jumps: JMP32_JSET_K",
14713 		{ },
14714 		INTERNAL | FLAG_NO_DATA,
14715 		{ },
14716 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14717 		.fill_helper = bpf_fill_staggered_jset32_imm,
14718 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14719 	},
14720 	{
14721 		"Staggered jumps: JMP32_JGT_K",
14722 		{ },
14723 		INTERNAL | FLAG_NO_DATA,
14724 		{ },
14725 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14726 		.fill_helper = bpf_fill_staggered_jgt32_imm,
14727 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14728 	},
14729 	{
14730 		"Staggered jumps: JMP32_JGE_K",
14731 		{ },
14732 		INTERNAL | FLAG_NO_DATA,
14733 		{ },
14734 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14735 		.fill_helper = bpf_fill_staggered_jge32_imm,
14736 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14737 	},
14738 	{
14739 		"Staggered jumps: JMP32_JLT_K",
14740 		{ },
14741 		INTERNAL | FLAG_NO_DATA,
14742 		{ },
14743 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14744 		.fill_helper = bpf_fill_staggered_jlt32_imm,
14745 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14746 	},
14747 	{
14748 		"Staggered jumps: JMP32_JLE_K",
14749 		{ },
14750 		INTERNAL | FLAG_NO_DATA,
14751 		{ },
14752 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14753 		.fill_helper = bpf_fill_staggered_jle32_imm,
14754 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14755 	},
14756 	{
14757 		"Staggered jumps: JMP32_JSGT_K",
14758 		{ },
14759 		INTERNAL | FLAG_NO_DATA,
14760 		{ },
14761 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14762 		.fill_helper = bpf_fill_staggered_jsgt32_imm,
14763 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14764 	},
14765 	{
14766 		"Staggered jumps: JMP32_JSGE_K",
14767 		{ },
14768 		INTERNAL | FLAG_NO_DATA,
14769 		{ },
14770 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14771 		.fill_helper = bpf_fill_staggered_jsge32_imm,
14772 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14773 	},
14774 	{
14775 		"Staggered jumps: JMP32_JSLT_K",
14776 		{ },
14777 		INTERNAL | FLAG_NO_DATA,
14778 		{ },
14779 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14780 		.fill_helper = bpf_fill_staggered_jslt32_imm,
14781 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14782 	},
14783 	{
14784 		"Staggered jumps: JMP32_JSLE_K",
14785 		{ },
14786 		INTERNAL | FLAG_NO_DATA,
14787 		{ },
14788 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14789 		.fill_helper = bpf_fill_staggered_jsle32_imm,
14790 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14791 	},
14792 	/* Staggered jump sequences, JMP32 register */
14793 	{
14794 		"Staggered jumps: JMP32_JEQ_X",
14795 		{ },
14796 		INTERNAL | FLAG_NO_DATA,
14797 		{ },
14798 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14799 		.fill_helper = bpf_fill_staggered_jeq32_reg,
14800 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14801 	},
14802 	{
14803 		"Staggered jumps: JMP32_JNE_X",
14804 		{ },
14805 		INTERNAL | FLAG_NO_DATA,
14806 		{ },
14807 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14808 		.fill_helper = bpf_fill_staggered_jne32_reg,
14809 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14810 	},
14811 	{
14812 		"Staggered jumps: JMP32_JSET_X",
14813 		{ },
14814 		INTERNAL | FLAG_NO_DATA,
14815 		{ },
14816 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14817 		.fill_helper = bpf_fill_staggered_jset32_reg,
14818 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14819 	},
14820 	{
14821 		"Staggered jumps: JMP32_JGT_X",
14822 		{ },
14823 		INTERNAL | FLAG_NO_DATA,
14824 		{ },
14825 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14826 		.fill_helper = bpf_fill_staggered_jgt32_reg,
14827 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14828 	},
14829 	{
14830 		"Staggered jumps: JMP32_JGE_X",
14831 		{ },
14832 		INTERNAL | FLAG_NO_DATA,
14833 		{ },
14834 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14835 		.fill_helper = bpf_fill_staggered_jge32_reg,
14836 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14837 	},
14838 	{
14839 		"Staggered jumps: JMP32_JLT_X",
14840 		{ },
14841 		INTERNAL | FLAG_NO_DATA,
14842 		{ },
14843 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14844 		.fill_helper = bpf_fill_staggered_jlt32_reg,
14845 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14846 	},
14847 	{
14848 		"Staggered jumps: JMP32_JLE_X",
14849 		{ },
14850 		INTERNAL | FLAG_NO_DATA,
14851 		{ },
14852 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14853 		.fill_helper = bpf_fill_staggered_jle32_reg,
14854 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14855 	},
14856 	{
14857 		"Staggered jumps: JMP32_JSGT_X",
14858 		{ },
14859 		INTERNAL | FLAG_NO_DATA,
14860 		{ },
14861 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14862 		.fill_helper = bpf_fill_staggered_jsgt32_reg,
14863 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14864 	},
14865 	{
14866 		"Staggered jumps: JMP32_JSGE_X",
14867 		{ },
14868 		INTERNAL | FLAG_NO_DATA,
14869 		{ },
14870 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14871 		.fill_helper = bpf_fill_staggered_jsge32_reg,
14872 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14873 	},
14874 	{
14875 		"Staggered jumps: JMP32_JSLT_X",
14876 		{ },
14877 		INTERNAL | FLAG_NO_DATA,
14878 		{ },
14879 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14880 		.fill_helper = bpf_fill_staggered_jslt32_reg,
14881 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14882 	},
14883 	{
14884 		"Staggered jumps: JMP32_JSLE_X",
14885 		{ },
14886 		INTERNAL | FLAG_NO_DATA,
14887 		{ },
14888 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14889 		.fill_helper = bpf_fill_staggered_jsle32_reg,
14890 		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14891 	},
14892 };
14893 
14894 static struct net_device dev;
14895 
14896 static struct sk_buff *populate_skb(char *buf, int size)
14897 {
14898 	struct sk_buff *skb;
14899 
14900 	if (size >= MAX_DATA)
14901 		return NULL;
14902 
14903 	skb = alloc_skb(MAX_DATA, GFP_KERNEL);
14904 	if (!skb)
14905 		return NULL;
14906 
14907 	__skb_put_data(skb, buf, size);
14908 
14909 	/* Initialize a fake skb with test pattern. */
14910 	skb_reset_mac_header(skb);
14911 	skb->protocol = htons(ETH_P_IP);
14912 	skb->pkt_type = SKB_TYPE;
14913 	skb->mark = SKB_MARK;
14914 	skb->hash = SKB_HASH;
14915 	skb->queue_mapping = SKB_QUEUE_MAP;
14916 	skb->vlan_tci = SKB_VLAN_TCI;
14917 	skb->vlan_proto = htons(ETH_P_IP);
14918 	dev_net_set(&dev, &init_net);
14919 	skb->dev = &dev;
14920 	skb->dev->ifindex = SKB_DEV_IFINDEX;
14921 	skb->dev->type = SKB_DEV_TYPE;
14922 	skb_set_network_header(skb, min(size, ETH_HLEN));
14923 
14924 	return skb;
14925 }
14926 
14927 static void *generate_test_data(struct bpf_test *test, int sub)
14928 {
14929 	struct sk_buff *skb;
14930 	struct page *page;
14931 
14932 	if (test->aux & FLAG_NO_DATA)
14933 		return NULL;
14934 
14935 	if (test->aux & FLAG_LARGE_MEM)
14936 		return kmalloc(test->test[sub].data_size, GFP_KERNEL);
14937 
14938 	/* Test case expects an skb, so populate one. Various
14939 	 * subtests generate skbs of different sizes based on
14940 	 * the same data.
14941 	 */
14942 	skb = populate_skb(test->data, test->test[sub].data_size);
14943 	if (!skb)
14944 		return NULL;
14945 
14946 	if (test->aux & FLAG_SKB_FRAG) {
14947 		/*
14948 		 * when the test requires a fragmented skb, add a
14949 		 * single fragment to the skb, filled with
14950 		 * test->frag_data.
14951 		 */
14952 		page = alloc_page(GFP_KERNEL);
14953 		if (!page)
14954 			goto err_kfree_skb;
14955 
14956 		memcpy(page_address(page), test->frag_data, MAX_DATA);
14957 		skb_add_rx_frag(skb, 0, page, 0, MAX_DATA, MAX_DATA);
14958 	}
14959 
14960 	return skb;
14961 err_kfree_skb:
14962 	kfree_skb(skb);
14963 	return NULL;
14964 }
14965 
14966 static void release_test_data(const struct bpf_test *test, void *data)
14967 {
14968 	if (test->aux & FLAG_NO_DATA)
14969 		return;
14970 
14971 	if (test->aux & FLAG_LARGE_MEM)
14972 		kfree(data);
14973 	else
14974 		kfree_skb(data);
14975 }
14976 
14977 static int filter_length(int which)
14978 {
14979 	struct sock_filter *fp;
14980 	int len;
14981 
14982 	if (tests[which].fill_helper)
14983 		return tests[which].u.ptr.len;
14984 
14985 	fp = tests[which].u.insns;
14986 	for (len = MAX_INSNS - 1; len > 0; --len)
14987 		if (fp[len].code != 0 || fp[len].k != 0)
14988 			break;
14989 
14990 	return len + 1;
14991 }
14992 
14993 static void *filter_pointer(int which)
14994 {
14995 	if (tests[which].fill_helper)
14996 		return tests[which].u.ptr.insns;
14997 	else
14998 		return tests[which].u.insns;
14999 }
15000 
15001 static struct bpf_prog *generate_filter(int which, int *err)
15002 {
15003 	__u8 test_type = tests[which].aux & TEST_TYPE_MASK;
15004 	unsigned int flen = filter_length(which);
15005 	void *fptr = filter_pointer(which);
15006 	struct sock_fprog_kern fprog;
15007 	struct bpf_prog *fp;
15008 
15009 	switch (test_type) {
15010 	case CLASSIC:
15011 		fprog.filter = fptr;
15012 		fprog.len = flen;
15013 
15014 		*err = bpf_prog_create(&fp, &fprog);
15015 		if (tests[which].aux & FLAG_EXPECTED_FAIL) {
15016 			if (*err == tests[which].expected_errcode) {
15017 				pr_cont("PASS\n");
15018 				/* Verifier rejected filter as expected. */
15019 				*err = 0;
15020 				return NULL;
15021 			} else {
15022 				pr_cont("UNEXPECTED_PASS\n");
15023 				/* Verifier didn't reject the test that's
15024 				 * bad enough, just return!
15025 				 */
15026 				*err = -EINVAL;
15027 				return NULL;
15028 			}
15029 		}
15030 		if (*err) {
15031 			pr_cont("FAIL to prog_create err=%d len=%d\n",
15032 				*err, fprog.len);
15033 			return NULL;
15034 		}
15035 		break;
15036 
15037 	case INTERNAL:
15038 		fp = bpf_prog_alloc(bpf_prog_size(flen), 0);
15039 		if (fp == NULL) {
15040 			pr_cont("UNEXPECTED_FAIL no memory left\n");
15041 			*err = -ENOMEM;
15042 			return NULL;
15043 		}
15044 
15045 		fp->len = flen;
15046 		/* Type doesn't really matter here as long as it's not unspec. */
15047 		fp->type = BPF_PROG_TYPE_SOCKET_FILTER;
15048 		memcpy(fp->insnsi, fptr, fp->len * sizeof(struct bpf_insn));
15049 		fp->aux->stack_depth = tests[which].stack_depth;
15050 		fp->aux->verifier_zext = !!(tests[which].aux &
15051 					    FLAG_VERIFIER_ZEXT);
15052 
15053 		/* We cannot error here as we don't need type compatibility
15054 		 * checks.
15055 		 */
15056 		fp = bpf_prog_select_runtime(fp, err);
15057 		if (*err) {
15058 			pr_cont("FAIL to select_runtime err=%d\n", *err);
15059 			return NULL;
15060 		}
15061 		break;
15062 	}
15063 
15064 	*err = 0;
15065 	return fp;
15066 }
15067 
15068 static void release_filter(struct bpf_prog *fp, int which)
15069 {
15070 	__u8 test_type = tests[which].aux & TEST_TYPE_MASK;
15071 
15072 	switch (test_type) {
15073 	case CLASSIC:
15074 		bpf_prog_destroy(fp);
15075 		break;
15076 	case INTERNAL:
15077 		bpf_prog_free(fp);
15078 		break;
15079 	}
15080 }
15081 
15082 static int __run_one(const struct bpf_prog *fp, const void *data,
15083 		     int runs, u64 *duration)
15084 {
15085 	u64 start, finish;
15086 	int ret = 0, i;
15087 
15088 	migrate_disable();
15089 	start = ktime_get_ns();
15090 
15091 	for (i = 0; i < runs; i++)
15092 		ret = bpf_prog_run(fp, data);
15093 
15094 	finish = ktime_get_ns();
15095 	migrate_enable();
15096 
15097 	*duration = finish - start;
15098 	do_div(*duration, runs);
15099 
15100 	return ret;
15101 }
15102 
15103 static int run_one(const struct bpf_prog *fp, struct bpf_test *test)
15104 {
15105 	int err_cnt = 0, i, runs = MAX_TESTRUNS;
15106 
15107 	if (test->nr_testruns)
15108 		runs = min(test->nr_testruns, MAX_TESTRUNS);
15109 
15110 	for (i = 0; i < MAX_SUBTESTS; i++) {
15111 		void *data;
15112 		u64 duration;
15113 		u32 ret;
15114 
15115 		/*
15116 		 * NOTE: Several sub-tests may be present, in which case
15117 		 * a zero {data_size, result} tuple indicates the end of
15118 		 * the sub-test array. The first test is always run,
15119 		 * even if both data_size and result happen to be zero.
15120 		 */
15121 		if (i > 0 &&
15122 		    test->test[i].data_size == 0 &&
15123 		    test->test[i].result == 0)
15124 			break;
15125 
15126 		data = generate_test_data(test, i);
15127 		if (!data && !(test->aux & FLAG_NO_DATA)) {
15128 			pr_cont("data generation failed ");
15129 			err_cnt++;
15130 			break;
15131 		}
15132 		ret = __run_one(fp, data, runs, &duration);
15133 		release_test_data(test, data);
15134 
15135 		if (ret == test->test[i].result) {
15136 			pr_cont("%lld ", duration);
15137 		} else {
15138 			s32 res = test->test[i].result;
15139 
15140 			pr_cont("ret %d != %d (%#x != %#x)",
15141 				ret, res, ret, res);
15142 			err_cnt++;
15143 		}
15144 	}
15145 
15146 	return err_cnt;
15147 }
15148 
15149 static char test_name[64];
15150 module_param_string(test_name, test_name, sizeof(test_name), 0);
15151 
15152 static int test_id = -1;
15153 module_param(test_id, int, 0);
15154 
15155 static int test_range[2] = { 0, INT_MAX };
15156 module_param_array(test_range, int, NULL, 0);
15157 
15158 static bool exclude_test(int test_id)
15159 {
15160 	return test_id < test_range[0] || test_id > test_range[1];
15161 }
15162 
15163 static __init struct sk_buff *build_test_skb(void)
15164 {
15165 	u32 headroom = NET_SKB_PAD + NET_IP_ALIGN + ETH_HLEN;
15166 	struct sk_buff *skb[2];
15167 	struct page *page[2];
15168 	int i, data_size = 8;
15169 
15170 	for (i = 0; i < 2; i++) {
15171 		page[i] = alloc_page(GFP_KERNEL);
15172 		if (!page[i]) {
15173 			if (i == 0)
15174 				goto err_page0;
15175 			else
15176 				goto err_page1;
15177 		}
15178 
15179 		/* this will set skb[i]->head_frag */
15180 		skb[i] = dev_alloc_skb(headroom + data_size);
15181 		if (!skb[i]) {
15182 			if (i == 0)
15183 				goto err_skb0;
15184 			else
15185 				goto err_skb1;
15186 		}
15187 
15188 		skb_reserve(skb[i], headroom);
15189 		skb_put(skb[i], data_size);
15190 		skb[i]->protocol = htons(ETH_P_IP);
15191 		skb_reset_network_header(skb[i]);
15192 		skb_set_mac_header(skb[i], -ETH_HLEN);
15193 
15194 		skb_add_rx_frag(skb[i], 0, page[i], 0, 64, 64);
15195 		// skb_headlen(skb[i]): 8, skb[i]->head_frag = 1
15196 	}
15197 
15198 	/* setup shinfo */
15199 	skb_shinfo(skb[0])->gso_size = 1448;
15200 	skb_shinfo(skb[0])->gso_type = SKB_GSO_TCPV4;
15201 	skb_shinfo(skb[0])->gso_type |= SKB_GSO_DODGY;
15202 	skb_shinfo(skb[0])->gso_segs = 0;
15203 	skb_shinfo(skb[0])->frag_list = skb[1];
15204 	skb_shinfo(skb[0])->hwtstamps.hwtstamp = 1000;
15205 
15206 	/* adjust skb[0]'s len */
15207 	skb[0]->len += skb[1]->len;
15208 	skb[0]->data_len += skb[1]->data_len;
15209 	skb[0]->truesize += skb[1]->truesize;
15210 
15211 	return skb[0];
15212 
15213 err_skb1:
15214 	__free_page(page[1]);
15215 err_page1:
15216 	kfree_skb(skb[0]);
15217 err_skb0:
15218 	__free_page(page[0]);
15219 err_page0:
15220 	return NULL;
15221 }
15222 
15223 static __init struct sk_buff *build_test_skb_linear_no_head_frag(void)
15224 {
15225 	unsigned int alloc_size = 2000;
15226 	unsigned int headroom = 102, doffset = 72, data_size = 1308;
15227 	struct sk_buff *skb[2];
15228 	int i;
15229 
15230 	/* skbs linked in a frag_list, both with linear data, with head_frag=0
15231 	 * (data allocated by kmalloc), both have tcp data of 1308 bytes
15232 	 * (total payload is 2616 bytes).
15233 	 * Data offset is 72 bytes (40 ipv6 hdr, 32 tcp hdr). Some headroom.
15234 	 */
15235 	for (i = 0; i < 2; i++) {
15236 		skb[i] = alloc_skb(alloc_size, GFP_KERNEL);
15237 		if (!skb[i]) {
15238 			if (i == 0)
15239 				goto err_skb0;
15240 			else
15241 				goto err_skb1;
15242 		}
15243 
15244 		skb[i]->protocol = htons(ETH_P_IPV6);
15245 		skb_reserve(skb[i], headroom);
15246 		skb_put(skb[i], doffset + data_size);
15247 		skb_reset_network_header(skb[i]);
15248 		if (i == 0)
15249 			skb_reset_mac_header(skb[i]);
15250 		else
15251 			skb_set_mac_header(skb[i], -ETH_HLEN);
15252 		__skb_pull(skb[i], doffset);
15253 	}
15254 
15255 	/* setup shinfo.
15256 	 * mimic bpf_skb_proto_4_to_6, which resets gso_segs and assigns a
15257 	 * reduced gso_size.
15258 	 */
15259 	skb_shinfo(skb[0])->gso_size = 1288;
15260 	skb_shinfo(skb[0])->gso_type = SKB_GSO_TCPV6 | SKB_GSO_DODGY;
15261 	skb_shinfo(skb[0])->gso_segs = 0;
15262 	skb_shinfo(skb[0])->frag_list = skb[1];
15263 
15264 	/* adjust skb[0]'s len */
15265 	skb[0]->len += skb[1]->len;
15266 	skb[0]->data_len += skb[1]->len;
15267 	skb[0]->truesize += skb[1]->truesize;
15268 
15269 	return skb[0];
15270 
15271 err_skb1:
15272 	kfree_skb(skb[0]);
15273 err_skb0:
15274 	return NULL;
15275 }
15276 
15277 struct skb_segment_test {
15278 	const char *descr;
15279 	struct sk_buff *(*build_skb)(void);
15280 	netdev_features_t features;
15281 };
15282 
15283 static struct skb_segment_test skb_segment_tests[] __initconst = {
15284 	{
15285 		.descr = "gso_with_rx_frags",
15286 		.build_skb = build_test_skb,
15287 		.features = NETIF_F_SG | NETIF_F_GSO_PARTIAL | NETIF_F_IP_CSUM |
15288 			    NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM
15289 	},
15290 	{
15291 		.descr = "gso_linear_no_head_frag",
15292 		.build_skb = build_test_skb_linear_no_head_frag,
15293 		.features = NETIF_F_SG | NETIF_F_FRAGLIST |
15294 			    NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_GSO |
15295 			    NETIF_F_GRO | NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM |
15296 			    NETIF_F_HW_VLAN_STAG_TX
15297 	}
15298 };
15299 
15300 static __init int test_skb_segment_single(const struct skb_segment_test *test)
15301 {
15302 	struct sk_buff *skb, *segs;
15303 	int ret = -1;
15304 
15305 	skb = test->build_skb();
15306 	if (!skb) {
15307 		pr_info("%s: failed to build_test_skb", __func__);
15308 		goto done;
15309 	}
15310 
15311 	segs = skb_segment(skb, test->features);
15312 	if (!IS_ERR(segs)) {
15313 		kfree_skb_list(segs);
15314 		ret = 0;
15315 	}
15316 	kfree_skb(skb);
15317 done:
15318 	return ret;
15319 }
15320 
15321 static __init int test_skb_segment(void)
15322 {
15323 	int i, err_cnt = 0, pass_cnt = 0;
15324 
15325 	for (i = 0; i < ARRAY_SIZE(skb_segment_tests); i++) {
15326 		const struct skb_segment_test *test = &skb_segment_tests[i];
15327 
15328 		cond_resched();
15329 		if (exclude_test(i))
15330 			continue;
15331 
15332 		pr_info("#%d %s ", i, test->descr);
15333 
15334 		if (test_skb_segment_single(test)) {
15335 			pr_cont("FAIL\n");
15336 			err_cnt++;
15337 		} else {
15338 			pr_cont("PASS\n");
15339 			pass_cnt++;
15340 		}
15341 	}
15342 
15343 	pr_info("%s: Summary: %d PASSED, %d FAILED\n", __func__,
15344 		pass_cnt, err_cnt);
15345 	return err_cnt ? -EINVAL : 0;
15346 }
15347 
15348 static __init int test_bpf(void)
15349 {
15350 	int i, err_cnt = 0, pass_cnt = 0;
15351 	int jit_cnt = 0, run_cnt = 0;
15352 
15353 	for (i = 0; i < ARRAY_SIZE(tests); i++) {
15354 		struct bpf_prog *fp;
15355 		int err;
15356 
15357 		cond_resched();
15358 		if (exclude_test(i))
15359 			continue;
15360 
15361 		pr_info("#%d %s ", i, tests[i].descr);
15362 
15363 		if (tests[i].fill_helper &&
15364 		    tests[i].fill_helper(&tests[i]) < 0) {
15365 			pr_cont("FAIL to prog_fill\n");
15366 			continue;
15367 		}
15368 
15369 		fp = generate_filter(i, &err);
15370 
15371 		if (tests[i].fill_helper) {
15372 			kfree(tests[i].u.ptr.insns);
15373 			tests[i].u.ptr.insns = NULL;
15374 		}
15375 
15376 		if (fp == NULL) {
15377 			if (err == 0) {
15378 				pass_cnt++;
15379 				continue;
15380 			}
15381 			err_cnt++;
15382 			continue;
15383 		}
15384 
15385 		pr_cont("jited:%u ", fp->jited);
15386 
15387 		run_cnt++;
15388 		if (fp->jited)
15389 			jit_cnt++;
15390 
15391 		err = run_one(fp, &tests[i]);
15392 		release_filter(fp, i);
15393 
15394 		if (err) {
15395 			pr_cont("FAIL (%d times)\n", err);
15396 			err_cnt++;
15397 		} else {
15398 			pr_cont("PASS\n");
15399 			pass_cnt++;
15400 		}
15401 	}
15402 
15403 	pr_info("Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n",
15404 		pass_cnt, err_cnt, jit_cnt, run_cnt);
15405 
15406 	return err_cnt ? -EINVAL : 0;
15407 }
15408 
15409 struct tail_call_test {
15410 	const char *descr;
15411 	struct bpf_insn insns[MAX_INSNS];
15412 	int flags;
15413 	int result;
15414 	int stack_depth;
15415 	bool has_tail_call;
15416 };
15417 
15418 /* Flags that can be passed to tail call test cases */
15419 #define FLAG_NEED_STATE		BIT(0)
15420 #define FLAG_RESULT_IN_STATE	BIT(1)
15421 
15422 /*
15423  * Magic marker used in test snippets for tail calls below.
15424  * BPF_LD/MOV to R2 and R2 with this immediate value is replaced
15425  * with the proper values by the test runner.
15426  */
15427 #define TAIL_CALL_MARKER 0x7a11ca11
15428 
15429 /* Special offset to indicate a NULL call target */
15430 #define TAIL_CALL_NULL 0x7fff
15431 
15432 /* Special offset to indicate an out-of-range index */
15433 #define TAIL_CALL_INVALID 0x7ffe
15434 
15435 #define TAIL_CALL(offset)			       \
15436 	BPF_LD_IMM64(R2, TAIL_CALL_MARKER),	       \
15437 	BPF_RAW_INSN(BPF_ALU | BPF_MOV | BPF_K, R3, 0, \
15438 		     offset, TAIL_CALL_MARKER),	       \
15439 	BPF_JMP_IMM(BPF_TAIL_CALL, 0, 0, 0)
15440 
15441 /*
15442  * A test function to be called from a BPF program, clobbering a lot of
15443  * CPU registers in the process. A JITed BPF program calling this function
15444  * must save and restore any caller-saved registers it uses for internal
15445  * state, for example the current tail call count.
15446  */
15447 BPF_CALL_1(bpf_test_func, u64, arg)
15448 {
15449 	char buf[64];
15450 	long a = 0;
15451 	long b = 1;
15452 	long c = 2;
15453 	long d = 3;
15454 	long e = 4;
15455 	long f = 5;
15456 	long g = 6;
15457 	long h = 7;
15458 
15459 	return snprintf(buf, sizeof(buf),
15460 			"%ld %lu %lx %ld %lu %lx %ld %lu %x",
15461 			a, b, c, d, e, f, g, h, (int)arg);
15462 }
15463 #define BPF_FUNC_test_func __BPF_FUNC_MAX_ID
15464 
15465 /*
15466  * Tail call tests. Each test case may call any other test in the table,
15467  * including itself, specified as a relative index offset from the calling
15468  * test. The index TAIL_CALL_NULL can be used to specify a NULL target
15469  * function to test the JIT error path. Similarly, the index TAIL_CALL_INVALID
15470  * results in a target index that is out of range.
15471  */
15472 static struct tail_call_test tail_call_tests[] = {
15473 	{
15474 		"Tail call leaf",
15475 		.insns = {
15476 			BPF_ALU64_REG(BPF_MOV, R0, R1),
15477 			BPF_ALU64_IMM(BPF_ADD, R0, 1),
15478 			BPF_EXIT_INSN(),
15479 		},
15480 		.result = 1,
15481 	},
15482 	{
15483 		"Tail call 2",
15484 		.insns = {
15485 			BPF_ALU64_IMM(BPF_ADD, R1, 2),
15486 			TAIL_CALL(-1),
15487 			BPF_ALU64_IMM(BPF_MOV, R0, -1),
15488 			BPF_EXIT_INSN(),
15489 		},
15490 		.result = 3,
15491 		.has_tail_call = true,
15492 	},
15493 	{
15494 		"Tail call 3",
15495 		.insns = {
15496 			BPF_ALU64_IMM(BPF_ADD, R1, 3),
15497 			TAIL_CALL(-1),
15498 			BPF_ALU64_IMM(BPF_MOV, R0, -1),
15499 			BPF_EXIT_INSN(),
15500 		},
15501 		.result = 6,
15502 		.has_tail_call = true,
15503 	},
15504 	{
15505 		"Tail call 4",
15506 		.insns = {
15507 			BPF_ALU64_IMM(BPF_ADD, R1, 4),
15508 			TAIL_CALL(-1),
15509 			BPF_ALU64_IMM(BPF_MOV, R0, -1),
15510 			BPF_EXIT_INSN(),
15511 		},
15512 		.result = 10,
15513 		.has_tail_call = true,
15514 	},
15515 	{
15516 		"Tail call load/store leaf",
15517 		.insns = {
15518 			BPF_ALU64_IMM(BPF_MOV, R1, 1),
15519 			BPF_ALU64_IMM(BPF_MOV, R2, 2),
15520 			BPF_ALU64_REG(BPF_MOV, R3, BPF_REG_FP),
15521 			BPF_STX_MEM(BPF_DW, R3, R1, -8),
15522 			BPF_STX_MEM(BPF_DW, R3, R2, -16),
15523 			BPF_LDX_MEM(BPF_DW, R0, BPF_REG_FP, -8),
15524 			BPF_JMP_REG(BPF_JNE, R0, R1, 3),
15525 			BPF_LDX_MEM(BPF_DW, R0, BPF_REG_FP, -16),
15526 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
15527 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
15528 			BPF_EXIT_INSN(),
15529 		},
15530 		.result = 0,
15531 		.stack_depth = 32,
15532 	},
15533 	{
15534 		"Tail call load/store",
15535 		.insns = {
15536 			BPF_ALU64_IMM(BPF_MOV, R0, 3),
15537 			BPF_STX_MEM(BPF_DW, BPF_REG_FP, R0, -8),
15538 			TAIL_CALL(-1),
15539 			BPF_ALU64_IMM(BPF_MOV, R0, -1),
15540 			BPF_EXIT_INSN(),
15541 		},
15542 		.result = 0,
15543 		.stack_depth = 16,
15544 		.has_tail_call = true,
15545 	},
15546 	{
15547 		"Tail call error path, max count reached",
15548 		.insns = {
15549 			BPF_LDX_MEM(BPF_W, R2, R1, 0),
15550 			BPF_ALU64_IMM(BPF_ADD, R2, 1),
15551 			BPF_STX_MEM(BPF_W, R1, R2, 0),
15552 			TAIL_CALL(0),
15553 			BPF_EXIT_INSN(),
15554 		},
15555 		.flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE,
15556 		.result = (MAX_TAIL_CALL_CNT + 1) * MAX_TESTRUNS,
15557 		.has_tail_call = true,
15558 	},
15559 	{
15560 		"Tail call count preserved across function calls",
15561 		.insns = {
15562 			BPF_LDX_MEM(BPF_W, R2, R1, 0),
15563 			BPF_ALU64_IMM(BPF_ADD, R2, 1),
15564 			BPF_STX_MEM(BPF_W, R1, R2, 0),
15565 			BPF_STX_MEM(BPF_DW, R10, R1, -8),
15566 			BPF_CALL_REL(BPF_FUNC_get_numa_node_id),
15567 			BPF_CALL_REL(BPF_FUNC_ktime_get_ns),
15568 			BPF_CALL_REL(BPF_FUNC_ktime_get_boot_ns),
15569 			BPF_CALL_REL(BPF_FUNC_ktime_get_coarse_ns),
15570 			BPF_CALL_REL(BPF_FUNC_jiffies64),
15571 			BPF_CALL_REL(BPF_FUNC_test_func),
15572 			BPF_LDX_MEM(BPF_DW, R1, R10, -8),
15573 			BPF_ALU32_REG(BPF_MOV, R0, R1),
15574 			TAIL_CALL(0),
15575 			BPF_EXIT_INSN(),
15576 		},
15577 		.stack_depth = 8,
15578 		.flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE,
15579 		.result = (MAX_TAIL_CALL_CNT + 1) * MAX_TESTRUNS,
15580 		.has_tail_call = true,
15581 	},
15582 	{
15583 		"Tail call error path, NULL target",
15584 		.insns = {
15585 			BPF_LDX_MEM(BPF_W, R2, R1, 0),
15586 			BPF_ALU64_IMM(BPF_ADD, R2, 1),
15587 			BPF_STX_MEM(BPF_W, R1, R2, 0),
15588 			TAIL_CALL(TAIL_CALL_NULL),
15589 			BPF_EXIT_INSN(),
15590 		},
15591 		.flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE,
15592 		.result = MAX_TESTRUNS,
15593 		.has_tail_call = true,
15594 	},
15595 	{
15596 		"Tail call error path, index out of range",
15597 		.insns = {
15598 			BPF_LDX_MEM(BPF_W, R2, R1, 0),
15599 			BPF_ALU64_IMM(BPF_ADD, R2, 1),
15600 			BPF_STX_MEM(BPF_W, R1, R2, 0),
15601 			TAIL_CALL(TAIL_CALL_INVALID),
15602 			BPF_EXIT_INSN(),
15603 		},
15604 		.flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE,
15605 		.result = MAX_TESTRUNS,
15606 		.has_tail_call = true,
15607 	},
15608 };
15609 
15610 static void __init destroy_tail_call_tests(struct bpf_array *progs)
15611 {
15612 	int i;
15613 
15614 	for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++)
15615 		if (progs->ptrs[i])
15616 			bpf_prog_free(progs->ptrs[i]);
15617 	kfree(progs);
15618 }
15619 
15620 static __init int prepare_tail_call_tests(struct bpf_array **pprogs)
15621 {
15622 	int ntests = ARRAY_SIZE(tail_call_tests);
15623 	struct bpf_array *progs;
15624 	int which, err;
15625 
15626 	/* Allocate the table of programs to be used for tail calls */
15627 	progs = kzalloc_flex(*progs, ptrs, ntests + 1);
15628 	if (!progs)
15629 		goto out_nomem;
15630 
15631 	/* Create all eBPF programs and populate the table */
15632 	for (which = 0; which < ntests; which++) {
15633 		struct tail_call_test *test = &tail_call_tests[which];
15634 		struct bpf_prog *fp;
15635 		int len, i;
15636 
15637 		/* Compute the number of program instructions */
15638 		for (len = 0; len < MAX_INSNS; len++) {
15639 			struct bpf_insn *insn = &test->insns[len];
15640 
15641 			if (len < MAX_INSNS - 1 &&
15642 			    insn->code == (BPF_LD | BPF_DW | BPF_IMM))
15643 				len++;
15644 			if (insn->code == 0)
15645 				break;
15646 		}
15647 
15648 		/* Allocate and initialize the program */
15649 		fp = bpf_prog_alloc(bpf_prog_size(len), 0);
15650 		if (!fp)
15651 			goto out_nomem;
15652 
15653 		fp->len = len;
15654 		fp->type = BPF_PROG_TYPE_SOCKET_FILTER;
15655 		fp->aux->stack_depth = test->stack_depth;
15656 		fp->aux->tail_call_reachable = test->has_tail_call;
15657 		memcpy(fp->insnsi, test->insns, len * sizeof(struct bpf_insn));
15658 
15659 		/* Relocate runtime tail call offsets and addresses */
15660 		for (i = 0; i < len; i++) {
15661 			struct bpf_insn *insn = &fp->insnsi[i];
15662 			long addr = 0;
15663 
15664 			switch (insn->code) {
15665 			case BPF_LD | BPF_DW | BPF_IMM:
15666 				if (insn->imm != TAIL_CALL_MARKER)
15667 					break;
15668 				insn[0].imm = (u32)(long)progs;
15669 				insn[1].imm = ((u64)(long)progs) >> 32;
15670 				break;
15671 
15672 			case BPF_ALU | BPF_MOV | BPF_K:
15673 				if (insn->imm != TAIL_CALL_MARKER)
15674 					break;
15675 				if (insn->off == TAIL_CALL_NULL)
15676 					insn->imm = ntests;
15677 				else if (insn->off == TAIL_CALL_INVALID)
15678 					insn->imm = ntests + 1;
15679 				else
15680 					insn->imm = which + insn->off;
15681 				insn->off = 0;
15682 				break;
15683 
15684 			case BPF_JMP | BPF_CALL:
15685 				if (insn->src_reg != BPF_PSEUDO_CALL)
15686 					break;
15687 				switch (insn->imm) {
15688 				case BPF_FUNC_get_numa_node_id:
15689 					addr = (long)&numa_node_id;
15690 					break;
15691 				case BPF_FUNC_ktime_get_ns:
15692 					addr = (long)&ktime_get_ns;
15693 					break;
15694 				case BPF_FUNC_ktime_get_boot_ns:
15695 					addr = (long)&ktime_get_boot_fast_ns;
15696 					break;
15697 				case BPF_FUNC_ktime_get_coarse_ns:
15698 					addr = (long)&ktime_get_coarse_ns;
15699 					break;
15700 				case BPF_FUNC_jiffies64:
15701 					addr = (long)&get_jiffies_64;
15702 					break;
15703 				case BPF_FUNC_test_func:
15704 					addr = (long)&bpf_test_func;
15705 					break;
15706 				default:
15707 					err = -EFAULT;
15708 					goto out_err;
15709 				}
15710 				*insn = BPF_EMIT_CALL(addr);
15711 				if ((long)__bpf_call_base + insn->imm != addr)
15712 					*insn = BPF_JMP_A(0); /* Skip: NOP */
15713 				break;
15714 			}
15715 		}
15716 
15717 		fp = bpf_prog_select_runtime(fp, &err);
15718 		if (err)
15719 			goto out_err;
15720 
15721 		progs->ptrs[which] = fp;
15722 	}
15723 
15724 	/* The last entry contains a NULL program pointer */
15725 	progs->map.max_entries = ntests + 1;
15726 	*pprogs = progs;
15727 	return 0;
15728 
15729 out_nomem:
15730 	err = -ENOMEM;
15731 
15732 out_err:
15733 	if (progs)
15734 		destroy_tail_call_tests(progs);
15735 	return err;
15736 }
15737 
15738 static __init int test_tail_calls(struct bpf_array *progs)
15739 {
15740 	int i, err_cnt = 0, pass_cnt = 0;
15741 	int jit_cnt = 0, run_cnt = 0;
15742 
15743 	for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++) {
15744 		struct tail_call_test *test = &tail_call_tests[i];
15745 		struct bpf_prog *fp = progs->ptrs[i];
15746 		int *data = NULL;
15747 		int state = 0;
15748 		u64 duration;
15749 		int ret;
15750 
15751 		cond_resched();
15752 		if (exclude_test(i))
15753 			continue;
15754 
15755 		pr_info("#%d %s ", i, test->descr);
15756 		if (!fp) {
15757 			err_cnt++;
15758 			continue;
15759 		}
15760 		pr_cont("jited:%u ", fp->jited);
15761 
15762 		run_cnt++;
15763 		if (fp->jited)
15764 			jit_cnt++;
15765 
15766 		if (test->flags & FLAG_NEED_STATE)
15767 			data = &state;
15768 		ret = __run_one(fp, data, MAX_TESTRUNS, &duration);
15769 		if (test->flags & FLAG_RESULT_IN_STATE)
15770 			ret = state;
15771 		if (ret == test->result) {
15772 			pr_cont("%lld PASS", duration);
15773 			pass_cnt++;
15774 		} else {
15775 			pr_cont("ret %d != %d FAIL", ret, test->result);
15776 			err_cnt++;
15777 		}
15778 	}
15779 
15780 	pr_info("%s: Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n",
15781 		__func__, pass_cnt, err_cnt, jit_cnt, run_cnt);
15782 
15783 	return err_cnt ? -EINVAL : 0;
15784 }
15785 
15786 static char test_suite[32];
15787 module_param_string(test_suite, test_suite, sizeof(test_suite), 0);
15788 
15789 static __init int find_test_index(const char *test_name)
15790 {
15791 	int i;
15792 
15793 	if (!strcmp(test_suite, "test_bpf")) {
15794 		for (i = 0; i < ARRAY_SIZE(tests); i++) {
15795 			if (!strcmp(tests[i].descr, test_name))
15796 				return i;
15797 		}
15798 	}
15799 
15800 	if (!strcmp(test_suite, "test_tail_calls")) {
15801 		for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++) {
15802 			if (!strcmp(tail_call_tests[i].descr, test_name))
15803 				return i;
15804 		}
15805 	}
15806 
15807 	if (!strcmp(test_suite, "test_skb_segment")) {
15808 		for (i = 0; i < ARRAY_SIZE(skb_segment_tests); i++) {
15809 			if (!strcmp(skb_segment_tests[i].descr, test_name))
15810 				return i;
15811 		}
15812 	}
15813 
15814 	return -1;
15815 }
15816 
15817 static __init int prepare_test_range(void)
15818 {
15819 	int valid_range;
15820 
15821 	if (!strcmp(test_suite, "test_bpf"))
15822 		valid_range = ARRAY_SIZE(tests);
15823 	else if (!strcmp(test_suite, "test_tail_calls"))
15824 		valid_range = ARRAY_SIZE(tail_call_tests);
15825 	else if (!strcmp(test_suite, "test_skb_segment"))
15826 		valid_range = ARRAY_SIZE(skb_segment_tests);
15827 	else
15828 		return 0;
15829 
15830 	if (test_id >= 0) {
15831 		/*
15832 		 * if a test_id was specified, use test_range to
15833 		 * cover only that test.
15834 		 */
15835 		if (test_id >= valid_range) {
15836 			pr_err("test_bpf: invalid test_id specified for '%s' suite.\n",
15837 			       test_suite);
15838 			return -EINVAL;
15839 		}
15840 
15841 		test_range[0] = test_id;
15842 		test_range[1] = test_id;
15843 	} else if (*test_name) {
15844 		/*
15845 		 * if a test_name was specified, find it and setup
15846 		 * test_range to cover only that test.
15847 		 */
15848 		int idx = find_test_index(test_name);
15849 
15850 		if (idx < 0) {
15851 			pr_err("test_bpf: no test named '%s' found for '%s' suite.\n",
15852 			       test_name, test_suite);
15853 			return -EINVAL;
15854 		}
15855 		test_range[0] = idx;
15856 		test_range[1] = idx;
15857 	} else if (test_range[0] != 0 || test_range[1] != INT_MAX) {
15858 		/*
15859 		 * check that the supplied test_range is valid.
15860 		 */
15861 		if (test_range[0] < 0 || test_range[1] >= valid_range) {
15862 			pr_err("test_bpf: test_range is out of bound for '%s' suite.\n",
15863 			       test_suite);
15864 			return -EINVAL;
15865 		}
15866 
15867 		if (test_range[1] < test_range[0]) {
15868 			pr_err("test_bpf: test_range is ending before it starts.\n");
15869 			return -EINVAL;
15870 		}
15871 	}
15872 
15873 	return 0;
15874 }
15875 
15876 static int __init test_bpf_init(void)
15877 {
15878 	struct bpf_array *progs = NULL;
15879 	int ret;
15880 
15881 	if (strlen(test_suite) &&
15882 	    strcmp(test_suite, "test_bpf") &&
15883 	    strcmp(test_suite, "test_tail_calls") &&
15884 	    strcmp(test_suite, "test_skb_segment")) {
15885 		pr_err("test_bpf: invalid test_suite '%s' specified.\n", test_suite);
15886 		return -EINVAL;
15887 	}
15888 
15889 	/*
15890 	 * if test_suite is not specified, but test_id, test_name or test_range
15891 	 * is specified, set 'test_bpf' as the default test suite.
15892 	 */
15893 	if (!strlen(test_suite) &&
15894 	    (test_id != -1 || strlen(test_name) ||
15895 	    (test_range[0] != 0 || test_range[1] != INT_MAX))) {
15896 		pr_info("test_bpf: set 'test_bpf' as the default test_suite.\n");
15897 		strscpy(test_suite, "test_bpf", sizeof(test_suite));
15898 	}
15899 
15900 	ret = prepare_test_range();
15901 	if (ret < 0)
15902 		return ret;
15903 
15904 	if (!strlen(test_suite) || !strcmp(test_suite, "test_bpf")) {
15905 		ret = test_bpf();
15906 		if (ret)
15907 			return ret;
15908 	}
15909 
15910 	if (!strlen(test_suite) || !strcmp(test_suite, "test_tail_calls")) {
15911 		ret = prepare_tail_call_tests(&progs);
15912 		if (ret)
15913 			return ret;
15914 		ret = test_tail_calls(progs);
15915 		destroy_tail_call_tests(progs);
15916 		if (ret)
15917 			return ret;
15918 	}
15919 
15920 	if (!strlen(test_suite) || !strcmp(test_suite, "test_skb_segment"))
15921 		return test_skb_segment();
15922 
15923 	return 0;
15924 }
15925 
15926 static void __exit test_bpf_exit(void)
15927 {
15928 }
15929 
15930 module_init(test_bpf_init);
15931 module_exit(test_bpf_exit);
15932 
15933 MODULE_DESCRIPTION("Testsuite for BPF interpreter and BPF JIT compiler");
15934 MODULE_LICENSE("GPL");
15935