26 #define MAX_K		0xffffFFFF
30 #define SKB_MARK	0x1234aaaa
31 #define SKB_HASH	0x1234aaab
33 #define SKB_VLAN_TCI	0xffff
52 #define FLAG_NO_DATA		BIT(0)
85 	int nr_testruns; /* Custom run count, defaults to MAX_TESTRUNS if 0 */
94 	__u32 k = ~0;  in bpf_fill_maxinsns1()
101 	for (i = 0; i < len; i++, k--)  in bpf_fill_maxinsns1()
107 	return 0;  in bpf_fill_maxinsns1()
120 	for (i = 0; i < len; i++)  in bpf_fill_maxinsns2()
121 		insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);  in bpf_fill_maxinsns2()
126 	return 0;  in bpf_fill_maxinsns2()
142 	for (i = 0; i < len - 1; i++) {  in bpf_fill_maxinsns3()
148 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);  in bpf_fill_maxinsns3()
153 	return 0;  in bpf_fill_maxinsns3()
166 	for (i = 0; i < len; i++)  in bpf_fill_maxinsns4()
167 		insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);  in bpf_fill_maxinsns4()
172 	return 0;  in bpf_fill_maxinsns4()
185 	insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0);  in bpf_fill_maxinsns5()
188 		insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);  in bpf_fill_maxinsns5()
190 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab);  in bpf_fill_maxinsns5()
195 	return 0;  in bpf_fill_maxinsns5()
208 	for (i = 0; i < len - 1; i++)  in bpf_fill_maxinsns6()
212 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);  in bpf_fill_maxinsns6()
217 	return 0;  in bpf_fill_maxinsns6()
230 	for (i = 0; i < len - 4; i++)  in bpf_fill_maxinsns7()
234 	insn[len - 4] = __BPF_STMT(BPF_MISC | BPF_TAX, 0);  in bpf_fill_maxinsns7()
237 	insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0);  in bpf_fill_maxinsns7()
238 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);  in bpf_fill_maxinsns7()
243 	return 0;  in bpf_fill_maxinsns7()
256 	insn[0] = __BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff);  in bpf_fill_maxinsns8()
259 		insn[i] = __BPF_JUMP(BPF_JMP | BPF_JGT, 0xffffffff, jmp_off--, 0);  in bpf_fill_maxinsns8()
261 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);  in bpf_fill_maxinsns8()
266 	return 0;  in bpf_fill_maxinsns8()
279 	insn[0] = BPF_JMP_IMM(BPF_JA, 0, 0, len - 2);  in bpf_fill_maxinsns9()
280 	insn[1] = BPF_ALU32_IMM(BPF_MOV, R0, 0xcbababab);  in bpf_fill_maxinsns9()
284 		insn[i] = BPF_ALU32_IMM(BPF_MOV, R0, 0xfefefefe);  in bpf_fill_maxinsns9()
287 	insn[len - 1] = BPF_JMP_IMM(BPF_JA, 0, 0, -(len - 1));  in bpf_fill_maxinsns9()
292 	return 0;  in bpf_fill_maxinsns9()
305 	for (i = 0; i < hlen / 2; i++)  in bpf_fill_maxinsns10()
306 		insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 2 - 2 * i);  in bpf_fill_maxinsns10()
308 		insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 1 - 2 * i);  in bpf_fill_maxinsns10()
310 	insn[hlen / 2] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen / 2 - 1);  in bpf_fill_maxinsns10()
311 	insn[hlen]     = BPF_ALU32_IMM(BPF_MOV, R0, 0xabababac);  in bpf_fill_maxinsns10()
317 	return 0;  in bpf_fill_maxinsns10()
333 	for (i = 0; i + plen < len; i += plen)  in __bpf_fill_ja()
334 		for (j = 0; j < plen; j++)  in __bpf_fill_ja()
336 						 plen - 1 - j, 0, 0);  in __bpf_fill_ja()
337 	for (j = 0; j < rlen; j++)  in __bpf_fill_ja()
339 					 0, 0);  in __bpf_fill_ja()
341 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xababcbac);  in __bpf_fill_ja()
346 	return 0;  in __bpf_fill_ja()
359 	int i = 0;  in bpf_fill_maxinsns12()
365 	insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0);  in bpf_fill_maxinsns12()
368 		insn[i] = __BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0);  in bpf_fill_maxinsns12()
370 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab);  in bpf_fill_maxinsns12()
375 	return 0;  in bpf_fill_maxinsns12()
382 	int i = 0;  in bpf_fill_maxinsns13()
388 	for (i = 0; i < len - 3; i++)  in bpf_fill_maxinsns13()
389 		insn[i] = __BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0);  in bpf_fill_maxinsns13()
391 	insn[len - 3] = __BPF_STMT(BPF_LD | BPF_IMM, 0xabababab);  in bpf_fill_maxinsns13()
392 	insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0);  in bpf_fill_maxinsns13()
393 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);  in bpf_fill_maxinsns13()
398 	return 0;  in bpf_fill_maxinsns13()
417 	for (i = 0; i < len - 1; i += 2) {  in bpf_fill_ld_abs_get_processor_id()
418 		insn[i] = __BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 0);  in bpf_fill_ld_abs_get_processor_id()
423 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xbee);  in bpf_fill_ld_abs_get_processor_id()
428 	return 0;  in bpf_fill_ld_abs_get_processor_id()
441 	insn[0] = BPF_ALU32_IMM(BPF_MOV, R0, 1);  in __bpf_fill_stxdw()
454 	return 0;  in __bpf_fill_stxdw()
491 	i = __bpf_ld_imm64(insns, R1, 0x0123456789abcdefULL);  in __bpf_fill_max_jmp()
515 	return 0;  in __bpf_fill_max_jmp()
532 	return __bpf_fill_max_jmp(self, BPF_JEQ, 0, true);  in bpf_fill_max_jmp_not_taken_32()
537 	return __bpf_fill_max_jmp(self, BPF_JEQ, 0, false);  in bpf_fill_max_jmp_not_taken()
543 	return __bpf_fill_max_jmp(self, BPF_JGE, 0, true);  in bpf_fill_max_jmp_always_taken_32()
548 	return __bpf_fill_max_jmp(self, BPF_JGE, 0, false);  in bpf_fill_max_jmp_always_taken()
554 	return __bpf_fill_max_jmp(self, BPF_JLT, 0, true);  in bpf_fill_max_jmp_never_taken_32()
559 	return __bpf_fill_max_jmp(self, BPF_JLT, 0, false);  in bpf_fill_max_jmp_never_taken()
565 	*res = 0;  in __bpf_alu_result()
587 		if (v2 > 0 && v1 > S64_MAX)  in __bpf_alu_result()
588 			*res |= ~0ULL << (64 - v2);  in __bpf_alu_result()
600 		if (v2 == 0)  in __bpf_alu_result()
605 		if (v2 == 0)  in __bpf_alu_result()
618 		0x0123456789abcdefLL, /* dword > 0, word < 0 */  in __bpf_fill_alu_shift()
619 		0xfedcba9876543210LL, /* dword < 0, word > 0 */  in __bpf_fill_alu_shift()
620 		0xfedcba0198765432LL, /* dword < 0, word < 0 */  in __bpf_fill_alu_shift()
621 		0x0123458967abcdefLL, /* dword > 0, word > 0 */  in __bpf_fill_alu_shift()
627 	int i = 0;  in __bpf_fill_alu_shift()
633 	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);  in __bpf_fill_alu_shift()
635 	for (k = 0; k < ARRAY_SIZE(regs); k++) {  in __bpf_fill_alu_shift()
640 		for (imm = 0; imm < bits; imm++) {  in __bpf_fill_alu_shift()
686 	return 0;  in __bpf_fill_alu_shift()
759 	int i = 0;  in __bpf_fill_alu_shift_same_reg()
766 	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);  in __bpf_fill_alu_shift_same_reg()
768 	for (val = 0; val < bits; val++) {  in __bpf_fill_alu_shift_same_reg()
796 	return 0;  in __bpf_fill_alu_shift_same_reg()
851 	int i = 0;  in __bpf_fill_pattern()
858 	len = extra + count * (*emit)(self, arg, NULL, 0, 0);  in __bpf_fill_pattern()
864 	insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);  in __bpf_fill_pattern()
870 	for (di = 0; di < dbits - 1; di++)                 /* Dst magnitudes */  in __bpf_fill_pattern()
871 		for (si = 0; si < sbits - 1; si++)         /* Src magnitudes */  in __bpf_fill_pattern()
872 			for (k = 0; k < ARRAY_SIZE(sgn); k++) /* Sign combos */  in __bpf_fill_pattern()
879 						dst = value(di, db, sgn[k][0]);  in __bpf_fill_pattern()
890 	for (bt = 0; bt < max(dbits, sbits) - 1; bt++)        /* Magnitude   */  in __bpf_fill_pattern()
891 		for (k = 0; k < ARRAY_SIZE(sgn); k++)         /* Sign combos */  in __bpf_fill_pattern()
897 					dst = value(bt % dbits, db, sgn[k][0]);  in __bpf_fill_pattern()
911 	return 0;  in __bpf_fill_pattern()
919  *           0     none
921  *           2     (1 << MSB) + [-1, 0]
922  *           3     (1 << MSB) + [-1, 0, 1]
940 	int i = 0;  in __bpf_emit_alu64_imm()
961 	int i = 0;  in __bpf_emit_alu32_imm()
982 	int i = 0;  in __bpf_emit_alu64_reg()
1004 	int i = 0;  in __bpf_emit_alu32_reg()
1243 	int i = 0;  in __bpf_fill_alu_imm_regs()
1253 		dst = 0x76543210U;  in __bpf_fill_alu_imm_regs()
1255 		dst = 0x7edcba9876543210ULL;  in __bpf_fill_alu_imm_regs()
1256 	imm = 0x01234567U;  in __bpf_fill_alu_imm_regs()
1292 	return 0;  in __bpf_fill_alu_imm_regs()
1427 	int i = 0;  in __bpf_fill_alu_reg_pairs()
1435 		dst = 0x76543210U;  in __bpf_fill_alu_reg_pairs()
1436 		src = 0x01234567U;  in __bpf_fill_alu_reg_pairs()
1438 		dst = 0x7edcba9876543210ULL;  in __bpf_fill_alu_reg_pairs()
1439 		src = 0x0123456789abcdefULL;  in __bpf_fill_alu_reg_pairs()
1484 	return 0;  in __bpf_fill_alu_reg_pairs()
1619 	int i = 0;  in __bpf_emit_atomic64()
1632 	keep = 0x0123456789abcdefULL;  in __bpf_emit_atomic64()
1666 	int i = 0;  in __bpf_emit_atomic32()
1679 	keep = 0x0123456789abcdefULL;  in __bpf_emit_atomic32()
1711 	int i = 0;  in __bpf_emit_cmpxchg64()
1751 	int i = 0;  in __bpf_emit_cmpxchg32()
1794 				  0, PATTERN_BLOCK2,  in __bpf_fill_atomic64()
1801 				  0, PATTERN_BLOCK2,  in __bpf_fill_atomic32()
1853 	return __bpf_fill_pattern(self, NULL, 64, 64, 0, PATTERN_BLOCK2,  in bpf_fill_cmpxchg64()
1905 	return __bpf_fill_pattern(self, NULL, 64, 64, 0, PATTERN_BLOCK2,  in bpf_fill_cmpxchg32()
1918 	int rd, rs, i = 0;  in __bpf_fill_atomic_reg_pairs()
1926 		mem = 0x0123456789abcdefULL;  in __bpf_fill_atomic_reg_pairs()
1927 		upd = 0xfedcba9876543210ULL;  in __bpf_fill_atomic_reg_pairs()
1929 		mem = 0x01234567U;  in __bpf_fill_atomic_reg_pairs()
1930 		upd = 0x76543210U;  in __bpf_fill_atomic_reg_pairs()
1968 				cmp = 0;    /* Aliased, checked below */  in __bpf_fill_atomic_reg_pairs()
1985 				src = 0;   /* Aliased with R0, checked above */  in __bpf_fill_atomic_reg_pairs()
1988 				src = 0;   /* Aliased with rd, checked below */  in __bpf_fill_atomic_reg_pairs()
2044 	return 0;  in __bpf_fill_atomic_reg_pairs()
2164 	int i = 0;  in bpf_fill_ld_imm64_magn()
2170 	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);  in bpf_fill_ld_imm64_magn()
2172 	for (bit = 0; bit <= 62; bit++) {  in bpf_fill_ld_imm64_magn()
2201 	return 0;  in bpf_fill_ld_imm64_magn()
2218 	int i = 0;  in __bpf_fill_ld_imm64_bytes()
2224 	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);  in __bpf_fill_ld_imm64_bytes()
2226 	for (pattern = 0; pattern < BIT(8); pattern++) {  in __bpf_fill_ld_imm64_bytes()
2227 		u64 imm = 0;  in __bpf_fill_ld_imm64_bytes()
2229 		for (index = 0; index < 8; index++) {  in __bpf_fill_ld_imm64_bytes()
2263 	return 0;  in __bpf_fill_ld_imm64_bytes()
2268 	return __bpf_fill_ld_imm64_bytes(self, 0, 0xff, 0xff, 0xff);  in bpf_fill_ld_imm64_checker()
2273 	return __bpf_fill_ld_imm64_bytes(self, 1, 0x81, 0x80, 0x80);  in bpf_fill_ld_imm64_pos_neg()
2278 	return __bpf_fill_ld_imm64_bytes(self, 1, 0x81, 0, 0xff);  in bpf_fill_ld_imm64_pos_zero()
2283 	return __bpf_fill_ld_imm64_bytes(self, 0x80, 0x80, 0, 0xff);  in bpf_fill_ld_imm64_neg_zero()
2329 		int i = 0;  in __bpf_emit_jmp_imm()
2336 			insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);  in __bpf_emit_jmp_imm()
2352 		int i = 0;  in __bpf_emit_jmp32_imm()
2357 			insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);  in __bpf_emit_jmp32_imm()
2373 		int i = 0;  in __bpf_emit_jmp_reg()
2379 			insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);  in __bpf_emit_jmp_reg()
2395 		int i = 0;  in __bpf_emit_jmp32_reg()
2401 			insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);  in __bpf_emit_jmp32_reg()
2678  *                     R0 = 0
2682  * ,----------|-ind 0- if R0 != 7 JMP 8 * 3 + 1 <--------------------.
2694  * | | | | ,--t=====4> if R0 != 0 JMP 4 * 3 + 1    1  2  3  4  5  6  7  8 loc
2706  * | | paths | | | ,8- if R0 != 8 JMP 0 * 3 + 1 <-----------------------'
2713 #define MAX_STAGGERED_JMP_SIZE ((0x7fff / 3) & ~1)
2722 	int size = self->test[0].result - 1;  in __bpf_fill_staggered_jumps()
2732 	insns[0] = BPF_ALU64_IMM(BPF_MOV, R0, 0);  in __bpf_fill_staggered_jumps()
2735 	insns[3] = BPF_JMP_IMM(BPF_JA, 0, 0, 3 * size / 2);  in __bpf_fill_staggered_jumps()
2738 	for (ind = 0, off = size; ind <= size; ind++, off -= 2) {  in __bpf_fill_staggered_jumps()
2742 		if (off == 0)  in __bpf_fill_staggered_jumps()
2746 		ins[0] = BPF_JMP_IMM(BPF_JNE, R0, loc - 1,  in __bpf_fill_staggered_jumps()
2759 	return 0;  in __bpf_fill_staggered_jumps()
2765 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JA, 0, 0, 0);  in bpf_fill_staggered_ja()
2767 	return __bpf_fill_staggered_jumps(self, &jmp, 0, 0);  in bpf_fill_staggered_ja()
2773 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JEQ, R1, 1234, 0);  in bpf_fill_staggered_jeq_imm()
2775 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);  in bpf_fill_staggered_jeq_imm()
2780 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JNE, R1, 1234, 0);  in bpf_fill_staggered_jne_imm()
2782 	return __bpf_fill_staggered_jumps(self, &jmp, 4321, 0);  in bpf_fill_staggered_jne_imm()
2787 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSET, R1, 0x82, 0);  in bpf_fill_staggered_jset_imm()
2789 	return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0);  in bpf_fill_staggered_jset_imm()
2794 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JGT, R1, 1234, 0);  in bpf_fill_staggered_jgt_imm()
2796 	return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 0);  in bpf_fill_staggered_jgt_imm()
2801 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JGE, R1, 1234, 0);  in bpf_fill_staggered_jge_imm()
2803 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);  in bpf_fill_staggered_jge_imm()
2808 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JLT, R1, 0x80000000, 0);  in bpf_fill_staggered_jlt_imm()
2810 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);  in bpf_fill_staggered_jlt_imm()
2815 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JLE, R1, 1234, 0);  in bpf_fill_staggered_jle_imm()
2817 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);  in bpf_fill_staggered_jle_imm()
2822 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSGT, R1, -2, 0);  in bpf_fill_staggered_jsgt_imm()
2824 	return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);  in bpf_fill_staggered_jsgt_imm()
2829 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSGE, R1, -2, 0);  in bpf_fill_staggered_jsge_imm()
2831 	return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);  in bpf_fill_staggered_jsge_imm()
2836 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSLT, R1, -1, 0);  in bpf_fill_staggered_jslt_imm()
2838 	return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);  in bpf_fill_staggered_jslt_imm()
2843 	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSLE, R1, -1, 0);  in bpf_fill_staggered_jsle_imm()
2845 	return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);  in bpf_fill_staggered_jsle_imm()
2851 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JEQ, R1, R2, 0);  in bpf_fill_staggered_jeq_reg()
2858 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JNE, R1, R2, 0);  in bpf_fill_staggered_jne_reg()
2865 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JSET, R1, R2, 0);  in bpf_fill_staggered_jset_reg()
2867 	return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0x82);  in bpf_fill_staggered_jset_reg()
2872 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JGT, R1, R2, 0);  in bpf_fill_staggered_jgt_reg()
2874 	return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 1234);  in bpf_fill_staggered_jgt_reg()
2879 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JGE, R1, R2, 0);  in bpf_fill_staggered_jge_reg()
2886 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JLT, R1, R2, 0);  in bpf_fill_staggered_jlt_reg()
2888 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0x80000000);  in bpf_fill_staggered_jlt_reg()
2893 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JLE, R1, R2, 0);  in bpf_fill_staggered_jle_reg()
2900 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JSGT, R1, R2, 0);  in bpf_fill_staggered_jsgt_reg()
2907 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JSGE, R1, R2, 0);  in bpf_fill_staggered_jsge_reg()
2914 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JSLT, R1, R2, 0);  in bpf_fill_staggered_jslt_reg()
2921 	struct bpf_insn jmp = BPF_JMP_REG(BPF_JSLE, R1, R2, 0);  in bpf_fill_staggered_jsle_reg()
2929 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JEQ, R1, 1234, 0);  in bpf_fill_staggered_jeq32_imm()
2931 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);  in bpf_fill_staggered_jeq32_imm()
2936 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JNE, R1, 1234, 0);  in bpf_fill_staggered_jne32_imm()
2938 	return __bpf_fill_staggered_jumps(self, &jmp, 4321, 0);  in bpf_fill_staggered_jne32_imm()
2943 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSET, R1, 0x82, 0);  in bpf_fill_staggered_jset32_imm()
2945 	return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0);  in bpf_fill_staggered_jset32_imm()
2950 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JGT, R1, 1234, 0);  in bpf_fill_staggered_jgt32_imm()
2952 	return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 0);  in bpf_fill_staggered_jgt32_imm()
2957 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JGE, R1, 1234, 0);  in bpf_fill_staggered_jge32_imm()
2959 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);  in bpf_fill_staggered_jge32_imm()
2964 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JLT, R1, 0x80000000, 0);  in bpf_fill_staggered_jlt32_imm()
2966 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);  in bpf_fill_staggered_jlt32_imm()
2971 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JLE, R1, 1234, 0);  in bpf_fill_staggered_jle32_imm()
2973 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);  in bpf_fill_staggered_jle32_imm()
2978 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSGT, R1, -2, 0);  in bpf_fill_staggered_jsgt32_imm()
2980 	return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);  in bpf_fill_staggered_jsgt32_imm()
2985 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSGE, R1, -2, 0);  in bpf_fill_staggered_jsge32_imm()
2987 	return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);  in bpf_fill_staggered_jsge32_imm()
2992 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSLT, R1, -1, 0);  in bpf_fill_staggered_jslt32_imm()
2994 	return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);  in bpf_fill_staggered_jslt32_imm()
2999 	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSLE, R1, -1, 0);  in bpf_fill_staggered_jsle32_imm()
3001 	return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);  in bpf_fill_staggered_jsle32_imm()
3007 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JEQ, R1, R2, 0);  in bpf_fill_staggered_jeq32_reg()
3014 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JNE, R1, R2, 0);  in bpf_fill_staggered_jne32_reg()
3021 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSET, R1, R2, 0);  in bpf_fill_staggered_jset32_reg()
3023 	return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0x82);  in bpf_fill_staggered_jset32_reg()
3028 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JGT, R1, R2, 0);  in bpf_fill_staggered_jgt32_reg()
3030 	return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 1234);  in bpf_fill_staggered_jgt32_reg()
3035 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JGE, R1, R2, 0);  in bpf_fill_staggered_jge32_reg()
3042 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JLT, R1, R2, 0);  in bpf_fill_staggered_jlt32_reg()
3044 	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0x80000000);  in bpf_fill_staggered_jlt32_reg()
3049 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JLE, R1, R2, 0);  in bpf_fill_staggered_jle32_reg()
3056 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSGT, R1, R2, 0);  in bpf_fill_staggered_jsgt32_reg()
3063 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSGE, R1, R2, 0);  in bpf_fill_staggered_jsge32_reg()
3070 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSLT, R1, R2, 0);  in bpf_fill_staggered_jslt32_reg()
3077 	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSLE, R1, R2, 0);  in bpf_fill_staggered_jsle32_reg()
3088 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3090 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3091 			BPF_STMT(BPF_ALU | BPF_NEG, 0), /* A == -3 */
3092 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3093 			BPF_STMT(BPF_LD | BPF_LEN, 0),
3094 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3095 			BPF_STMT(BPF_MISC | BPF_TAX, 0), /* X == len - 3 */
3097 			BPF_STMT(BPF_RET | BPF_A, 0)
3106 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3107 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
3108 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3109 			BPF_STMT(BPF_RET | BPF_A, 0) /* A == len * 2 */
3121 			BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
3122 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0xffffffff),
3124 			BPF_STMT(BPF_RET | BPF_A, 0)
3128 		{ { 0, 0xfffffffd } }
3135 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3136 			BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
3137 			BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
3138 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3139 			BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
3140 			BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x70000000),
3141 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3142 			BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
3143 			BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
3144 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3145 			BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
3146 			BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x70000000),
3147 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3148 			BPF_STMT(BPF_RET | BPF_A, 0)
3152 		{ { 0, 0x20000000 } }
3157 			BPF_STMT(BPF_LD | BPF_IMM, 0xff),
3158 			BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
3160 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3161 			BPF_STMT(BPF_LD | BPF_IMM, 0xf),
3162 			BPF_STMT(BPF_ALU | BPF_OR | BPF_K, 0xf0),
3163 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3164 			BPF_STMT(BPF_RET | BPF_A, 0)
3168 		{ { 0, 0x800000ff }, { 1, 0x800000ff } },
3173 			BPF_STMT(BPF_LD | BPF_IMM, 0), /* ld #0 */
3174 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0, 1, 0),
3175 			BPF_STMT(BPF_RET | BPF_K, 0),
3185 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3191 		{ { 1, 0 }, { 10, 0 }, { 60, 0 } },
3201 		{ { 1, 0 }, { 10, 0 }, { 60, 0 } },
3207 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3209 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3210 			BPF_STMT(BPF_RET | BPF_A, 0)
3214 		{ { 1, 0 }, { 2, 3 } },
3220 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3221 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3222 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3223 			BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
3224 			BPF_STMT(BPF_RET | BPF_A, 0)
3227 		{ 1, 2, 3, 0xff },
3228 		{ { 1, 1 }, { 3, 3 }, { 4, 0xff } },
3234 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3236 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3237 			BPF_STMT(BPF_RET | BPF_A, 0)
3240 		{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
3241 		{ { 15, 0 }, { 16, 3 } },
3247 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3248 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3249 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3250 			BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
3251 			BPF_STMT(BPF_RET | BPF_A, 0)
3254 		{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
3255 		{ { 14, 0 }, { 15, 1 }, { 17, 3 } },
3262 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
3266 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
3270 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
3272 			BPF_STMT(BPF_RET | BPF_A, 0)
3283 			BPF_STMT(BPF_RET | BPF_A, 0)
3294 			BPF_STMT(BPF_RET | BPF_A, 0)
3305 			BPF_STMT(BPF_RET | BPF_A, 0)
3315 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 20, 1, 0),
3316 			BPF_STMT(BPF_RET | BPF_K, 0),
3319 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3321 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 30, 1, 0),
3322 			BPF_STMT(BPF_RET | BPF_K, 0),
3323 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
3324 			BPF_STMT(BPF_RET | BPF_A, 0)
3335 			BPF_STMT(BPF_RET | BPF_A, 0)
3349 			BPF_STMT(BPF_RET | BPF_A, 0)
3363 			BPF_STMT(BPF_RET | BPF_A, 0)
3374 			BPF_STMT(BPF_RET | BPF_A, 0)
3385 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3388 			BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
3389 			BPF_STMT(BPF_RET | BPF_A, 0)
3393 		{ { 1, 0 }, { 10, 0 } },
3399 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
3403 			BPF_STMT(BPF_RET | BPF_A, 0)
3407 		{ 0xff, 0xff, 0, 4, 0, 2, 0, 4, 0, 3 },
3409 		{ 0xff, 0xff, 4, 0, 2, 0, 4, 0, 3, 0 },
3411 		{ { 4, 0 }, { 20, 6 } },
3441 			BPF_STMT(BPF_RET | BPF_A, 0)
3445 		{ 0xff, 0xff, 0, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3 },
3447 		{ 0xff, 0xff, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3, 0 },
3449 		{ { 4, 0 }, { 20, 10 } },
3464 			BPF_STMT(BPF_RET | BPF_A, 0)
3467 		/* 00:00:00:00:00:00 > 00:00:00:00:00:00, ethtype IPv4 (0x0800),
3471 		{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3472 		  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3473 		  0x08, 0x00,
3474 		  0x45, 0x00, 0x00, 0x54, 0xac, 0x8b, 0x40, 0x00, 0x40,
3475 		  0x01, 0x90, 0x1b, 0x7f, 0x00, 0x00, 0x01 },
3476 		{ { 30, 0 }, { 100, 42 } },
3485 			BPF_STMT(BPF_RET | BPF_A, 0)
3489 		{ { 4, 0xA ^ 300 }, { 20, 0xA ^ 300 } },
3494 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3497 			BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
3499 			BPF_STMT(BPF_ALU | BPF_XOR | BPF_K, 0x80000000),
3500 			BPF_STMT(BPF_ST, 2), /* M2 = 1 ^ len ^ 0x80000000 */
3504 			BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
3506 			BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
3507 			BPF_STMT(BPF_RET | BPF_A, 0)
3511 		{ { 1, 0x80000001 }, { 2, 0x80000002 }, { 60, 0x80000000 ^ 60 } }
3516 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3518 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 0, 1),
3524 		{ { 1, 0 }, { 3, 1 }, { 4, MAX_K } },
3529 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3531 			BPF_JUMP(BPF_JMP | BPF_JGT | BPF_X, 0, 0, 1),
3537 		{ { 2, 0 }, { 3, 1 }, { 4, MAX_K } },
3540 		"JGE (jt 0), test 1",
3542 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3544 			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 1),
3550 		{ { 2, 0 }, { 3, 1 }, { 4, 1 } },
3553 		"JGE (jt 0), test 2",
3555 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3557 			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 1),
3568 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3570 			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 1, 1, 0),
3572 			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 2, 1, 0),
3574 			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 3, 1, 0),
3576 			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 4, 1, 0),
3587 			BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
3589 			BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
3590 			BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
3591 			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3592 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
3594 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3595 			BPF_STMT(BPF_LD | BPF_W | BPF_IND, 0),
3596 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 1, 0, 1),
3598 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x80000000, 0, 1),
3600 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
3602 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
3604 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
3606 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
3608 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
3613 		{ 0, 0xAA, 0x55, 1 },
3620 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 0, 8), /* IPv6 */
3622 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
3623 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
3624 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 17),
3626 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 14, 0),
3629 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0800, 0, 12), /* IPv4 */
3631 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
3632 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
3633 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 8),
3635 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 6, 0),
3638 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
3640 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 1),
3641 			BPF_STMT(BPF_RET | BPF_K, 0xffff),
3642 			BPF_STMT(BPF_RET | BPF_K, 0),
3645 		/* 3c:07:54:43:e5:76 > 10:bf:48:d6:43:d6, ethertype IPv4(0x0800)
3650 		{ 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
3651 		  0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
3652 		  0x08, 0x00,
3653 		  0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
3654 		  0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
3655 		  0x0a, 0x01, 0x01, 0x95, /* ip src */
3656 		  0x0a, 0x01, 0x02, 0x0a, /* ip dst */
3657 		  0xc2, 0x24,
3658 		  0x00, 0x16 /* dst port */ },
3659 		{ { 10, 0 }, { 30, 0 }, { 100, 65535 } },
3665 			 * ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0) and
3669 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 30, 0),
3670 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x800, 0, 29),
3672 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 0, 27),
3674 			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 25, 0),
3677 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
3679 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 20),
3683 			BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf),
3685 			BPF_STMT(BPF_MISC | BPF_TAX, 0x5), /* libpcap emits K on TAX */
3687 			BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
3691 			BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
3693 			BPF_STMT(BPF_MISC | BPF_TAX, 0x9), /* libpcap emits K on TAX */
3695 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 4, 0),
3696 			BPF_STMT(BPF_LD | BPF_LEN, 0),
3697 			BPF_JUMP(BPF_JMP | BPF_JGT | BPF_K, 0x73, 1, 0),
3698 			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 0xfc23ac00, 1, 0),
3699 			BPF_STMT(BPF_RET | BPF_K, 0xffff),
3700 			BPF_STMT(BPF_RET | BPF_K, 0),
3703 		{ 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
3704 		  0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
3705 		  0x08, 0x00,
3706 		  0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
3707 		  0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
3708 		  0x0a, 0x01, 0x01, 0x95, /* ip src */
3709 		  0x0a, 0x01, 0x02, 0x0a, /* ip dst */
3710 		  0xc2, 0x24,
3711 		  0x00, 0x16 /* dst port */ },
3712 		{ { 10, 0 }, { 30, 0 }, { 100, 65535 } },
3718 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
3719 			BPF_STMT(BPF_RET | BPF_A, 0)
3723 		{ {1, 0}, {2, 0} },
3739 		{ { 0, 0xfffffffd } }
3748 			BPF_JMP_IMM(BPF_JEQ, R1, 0xfffffffd, 1),
3755 		{ { 0, 1 } }
3765 			BPF_JMP_IMM(BPF_JEQ, R1, 0x2ffffff, 1),
3772 		{ { 0, 1 } }
3782 			BPF_JMP_IMM(BPF_JEQ, R1, 0xffffff, 1),
3789 		{ { 0, 1 } }
3798 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
3951 		{ { 0, 2957380 } }
4097 		{ { 0, 2957380 } }
4102 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
4216 			BPF_ALU64_IMM(BPF_NEG, R0, 0),
4230 		{ { 0, 11 } }
4289 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
4296 		{ { 0, 1 } }
4336 			BPF_JMP_IMM(BPF_JEQ, R2, 0x5a924, 1),
4340 			BPF_JMP_IMM(BPF_JEQ, R1, 0xebb90000, 1),
4358 		{ { 0, 0x35d97ef2 } }
4363 			BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
4373 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
4374 			BPF_ALU64_IMM(BPF_MOV, R1, 0),
4375 			BPF_ALU64_IMM(BPF_MOV, R2, 0),
4376 			BPF_ALU64_IMM(BPF_MOV, R3, 0),
4377 			BPF_ALU64_IMM(BPF_MOV, R4, 0),
4378 			BPF_ALU64_IMM(BPF_MOV, R5, 0),
4379 			BPF_ALU64_IMM(BPF_MOV, R6, 0),
4380 			BPF_ALU64_IMM(BPF_MOV, R7, 0),
4381 			BPF_ALU64_IMM(BPF_MOV, R8, 0),
4382 			BPF_ALU64_IMM(BPF_MOV, R9, 0),
4393 			BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
4398 		{ { 0, 0xfefe } }
4403 			BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
4413 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
4414 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
4415 			BPF_ALU32_IMM(BPF_MOV, R2, 0),
4416 			BPF_ALU32_IMM(BPF_MOV, R3, 0),
4417 			BPF_ALU32_IMM(BPF_MOV, R4, 0),
4418 			BPF_ALU32_IMM(BPF_MOV, R5, 0),
4419 			BPF_ALU32_IMM(BPF_MOV, R6, 0),
4420 			BPF_ALU32_IMM(BPF_MOV, R7, 0),
4421 			BPF_ALU32_IMM(BPF_MOV, R8, 0),
4422 			BPF_ALU32_IMM(BPF_MOV, R9, 0),
4433 			BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
4438 		{ { 0, 0xfefe } }
4443 			BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
4453 			BPF_LD_IMM64(R0, 0x0LL),
4454 			BPF_LD_IMM64(R1, 0x0LL),
4455 			BPF_LD_IMM64(R2, 0x0LL),
4456 			BPF_LD_IMM64(R3, 0x0LL),
4457 			BPF_LD_IMM64(R4, 0x0LL),
4458 			BPF_LD_IMM64(R5, 0x0LL),
4459 			BPF_LD_IMM64(R6, 0x0LL),
4460 			BPF_LD_IMM64(R7, 0x0LL),
4461 			BPF_LD_IMM64(R8, 0x0LL),
4462 			BPF_LD_IMM64(R9, 0x0LL),
4473 			BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
4478 		{ { 0, 0xfefe } }
4498 		{ { 0, -1 } }
4506 			BPF_JMP_IMM(BPF_JEQ, R0, 0x7ffffd97, 1),
4536 		{ { 0, -1 } }
4542 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
4543 			BPF_JMP32_IMM(BPF_JEQ, R1, 0, 3),
4545 			BPF_JMP32_IMM(BPF_JNE, R1, 0, 1),
4551 		{ { 0, 1 } }
4568 			BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0),
4569 			BPF_STMT(BPF_RET | BPF_K, 0)
4581 			BPF_STMT(BPF_LDX | BPF_W | BPF_ABS, 0),
4582 			BPF_STMT(BPF_RET | BPF_K, 0)
4594 			BPF_STMT(BPF_RET | BPF_K, 0)
4605 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4606 			BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 15),
4607 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4608 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4609 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4610 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4611 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4612 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4613 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4614 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4615 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4616 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4617 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4618 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4619 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4620 			BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 3, 4),
4621 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4622 			BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 1, 2),
4623 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4624 			BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
4625 			BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
4626 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4627 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4628 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4629 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4630 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4631 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4632 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4633 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4634 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4635 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4636 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4637 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4638 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4639 			BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 2, 3),
4640 			BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 1, 2),
4641 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4642 			BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
4643 			BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
4644 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4645 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4646 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4647 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4648 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4649 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4650 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4651 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4652 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4653 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4654 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4655 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4656 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4657 			BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 2, 3),
4658 			BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 1, 2),
4659 			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4660 			BPF_STMT(BPF_RET | BPF_A, 0),
4661 			BPF_STMT(BPF_RET | BPF_A, 0),
4664 		{ 0x00, 0x1b, 0x21, 0x3c, 0x9d, 0xf8,
4665 		  0x90, 0xe2, 0xba, 0x0a, 0x56, 0xb4,
4666 		  0x08, 0x00,
4667 		  0x45, 0x00, 0x00, 0x28, 0x00, 0x00,
4668 		  0x20, 0x00, 0x40, 0x11, 0x00, 0x00, /* IP header */
4669 		  0xc0, 0xa8, 0x33, 0x01,
4670 		  0xc0, 0xa8, 0x33, 0x02,
4671 		  0xbb, 0xb6,
4672 		  0xa9, 0xfa,
4673 		  0x00, 0x14, 0x00, 0x00,
4674 		  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4675 		  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4676 		  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4677 		  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4678 		  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4679 		  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4680 		  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4681 		  0xcc, 0xcc, 0xcc, 0xcc },
4682 		{ { 88, 0x001b } }
4687 			BPF_STMT(BPF_RET | BPF_X, 0),
4699 			BPF_STMT(BPF_RET | BPF_X, 0),
4711 			BPF_STMT(BPF_STX, 0),
4712 			BPF_STMT(BPF_LDX | BPF_MEM, 0),
4713 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4715 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4718 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4720 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4723 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4725 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4728 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4730 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4733 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4735 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4738 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4740 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4743 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4745 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4748 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4750 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4753 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4755 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4758 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4760 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4763 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4765 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4768 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4770 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4773 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4775 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4778 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4780 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4783 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4785 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4788 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4790 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4791 			BPF_STMT(BPF_RET | BPF_A, 0),
4795 		{ { 0, 116 } },
4800 			BPF_STMT(BPF_LDX | BPF_IMM, 0xbadfeedb),
4801 			BPF_STMT(BPF_STX, 0),
4802 			BPF_STMT(BPF_LDX | BPF_IMM, 0xecabedae),
4804 			BPF_STMT(BPF_LDX | BPF_IMM, 0xafccfeaf),
4806 			BPF_STMT(BPF_LDX | BPF_IMM, 0xbffdcedc),
4808 			BPF_STMT(BPF_LDX | BPF_IMM, 0xfbbbdccb),
4810 			BPF_STMT(BPF_LDX | BPF_IMM, 0xfbabcbda),
4812 			BPF_STMT(BPF_LDX | BPF_IMM, 0xaedecbdb),
4814 			BPF_STMT(BPF_LDX | BPF_IMM, 0xadebbade),
4816 			BPF_STMT(BPF_LDX | BPF_IMM, 0xfcfcfaec),
4818 			BPF_STMT(BPF_LDX | BPF_IMM, 0xbcdddbdc),
4820 			BPF_STMT(BPF_LDX | BPF_IMM, 0xfeefdfac),
4822 			BPF_STMT(BPF_LDX | BPF_IMM, 0xcddcdeea),
4824 			BPF_STMT(BPF_LDX | BPF_IMM, 0xaccfaebb),
4826 			BPF_STMT(BPF_LDX | BPF_IMM, 0xbdcccdcf),
4828 			BPF_STMT(BPF_LDX | BPF_IMM, 0xaaedecde),
4830 			BPF_STMT(BPF_LDX | BPF_IMM, 0xfaeacdad),
4832 			BPF_STMT(BPF_LDX | BPF_MEM, 0),
4833 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4835 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4837 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4839 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4841 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4843 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4845 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4847 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4849 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4851 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4853 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4855 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4857 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4859 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4861 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4863 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4864 			BPF_STMT(BPF_RET | BPF_A, 0),
4868 		{ { 0, 0x2a5a5e5 } },
4875 			BPF_STMT(BPF_RET | BPF_A, 0),
4892 		{ { 1, 0 } },
4897 			BPF_LD_IMM64(R1, 0x567800001234LL),
4903 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
4904 			BPF_JMP_IMM(BPF_JEQ, R2, 0x5678, 1),
4906 			BPF_JMP_IMM(BPF_JEQ, R3, 0x1234, 1),
4908 			BPF_LD_IMM64(R0, 0x1ffffffffLL),
4914 		{ { 0, 1 } }
4926 		{ { 0, 2 } },
4937 		{ { 0, 4294967295U } },
4948 		{ { 0, 2 } },
4959 		{ { 0, 4294967295U } },
4970 		{ { 0, 2 } },
4980 		{ { 0, 4294967295U } },
4983 		"ALU_MOV_K: 0x0000ffffffff0000 = 0x00000000ffffffff",
4985 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
4986 			BPF_LD_IMM64(R3, 0x00000000ffffffffLL),
4987 			BPF_ALU32_IMM(BPF_MOV, R2, 0xffffffff),
4996 		{ { 0, 0x1 } },
5006 		{ { 0, -123 } }
5017 		{ { 0, 0 } }
5027 		{ { 0, -123456789 } }
5038 		{ { 0, 0 } }
5048 		{ { 0, 2 } },
5058 		{ { 0, 2147483647 } },
5061 		"ALU64_OR_K: dst = 0x0",
5063 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
5064 			BPF_LD_IMM64(R3, 0x0),
5065 			BPF_ALU64_IMM(BPF_MOV, R2, 0x0),
5074 		{ { 0, 0x1 } },
5079 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
5080 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
5081 			BPF_ALU64_IMM(BPF_MOV, R2, 0xffffffff),
5090 		{ { 0, 0x1 } },
5100 		{ { 0, -123 } }
5111 		{ { 0, 0xffffffff } }
5121 		{ { 0, -123456789 } }
5132 		{ { 0, 0xffffffff } }
5138 			BPF_LD_IMM64(R2, 0x00000000ffffffefLL),
5139 			BPF_LD_IMM64(R3, 0xdeadbeefdeadbeefLL),
5149 		{ { 0, 0x1 } },
5154 			BPF_LD_IMM64(R2, 0x00000000ffffbeefLL),
5155 			BPF_LD_IMM64(R3, 0xdeadbeefdeadbeefLL),
5165 		{ { 0, 0x1 } },
5171 			BPF_LD_IMM64(R2, 0xffffffffffffffefLL),
5172 			BPF_LD_IMM64(R3, 0xdeadbeefdeadbeefLL),
5182 		{ { 0, 0x1 } },
5187 			BPF_LD_IMM64(R2, 0xffffffffffffbeefLL),
5188 			BPF_LD_IMM64(R3, 0xdeadbeefdeadbeefLL),
5198 		{ { 0, 0x1 } },
5203 			BPF_LD_IMM64(R2, 0xffffffffdeadbeefLL),
5204 			BPF_LD_IMM64(R3, 0xdeadbeefdeadbeefLL),
5214 		{ { 0, 0x1 } },
5227 		{ { 0, 3 } },
5239 		{ { 0, 4294967295U } },
5242 		"ALU_ADD_X: 2 + 4294967294 = 0",
5247 			BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
5248 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
5255 		{ { 0, 1 } },
5267 		{ { 0, 3 } },
5279 		{ { 0, 4294967295U } },
5289 			BPF_MOV32_IMM(R0, 0),
5296 		{ { 0, 1 } },
5308 		{ { 0, 3 } },
5311 		"ALU_ADD_K: 3 + 0 = 3",
5314 			BPF_ALU32_IMM(BPF_ADD, R0, 0),
5319 		{ { 0, 3 } },
5330 		{ { 0, 4294967295U } },
5333 		"ALU_ADD_K: 4294967294 + 2 = 0",
5337 			BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
5338 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
5345 		{ { 0, 1 } },
5348 		"ALU_ADD_K: 0 + (-1) = 0x00000000ffffffff",
5350 			BPF_LD_IMM64(R2, 0x0),
5351 			BPF_LD_IMM64(R3, 0x00000000ffffffff),
5352 			BPF_ALU32_IMM(BPF_ADD, R2, 0xffffffff),
5361 		{ { 0, 0x1 } },
5364 		"ALU_ADD_K: 0 + 0xffff = 0xffff",
5366 			BPF_LD_IMM64(R2, 0x0),
5367 			BPF_LD_IMM64(R3, 0xffff),
5368 			BPF_ALU32_IMM(BPF_ADD, R2, 0xffff),
5377 		{ { 0, 0x1 } },
5380 		"ALU_ADD_K: 0 + 0x7fffffff = 0x7fffffff",
5382 			BPF_LD_IMM64(R2, 0x0),
5383 			BPF_LD_IMM64(R3, 0x7fffffff),
5384 			BPF_ALU32_IMM(BPF_ADD, R2, 0x7fffffff),
5393 		{ { 0, 0x1 } },
5396 		"ALU_ADD_K: 0 + 0x80000000 = 0x80000000",
5398 			BPF_LD_IMM64(R2, 0x0),
5399 			BPF_LD_IMM64(R3, 0x80000000),
5400 			BPF_ALU32_IMM(BPF_ADD, R2, 0x80000000),
5409 		{ { 0, 0x1 } },
5412 		"ALU_ADD_K: 0 + 0x80008000 = 0x80008000",
5414 			BPF_LD_IMM64(R2, 0x0),
5415 			BPF_LD_IMM64(R3, 0x80008000),
5416 			BPF_ALU32_IMM(BPF_ADD, R2, 0x80008000),
5425 		{ { 0, 0x1 } },
5436 		{ { 0, 3 } },
5439 		"ALU64_ADD_K: 3 + 0 = 3",
5442 			BPF_ALU64_IMM(BPF_ADD, R0, 0),
5447 		{ { 0, 3 } },
5458 		{ { 0, 2147483647 } },
5467 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
5474 		{ { 0, 1 } },
5485 		{ { 0, -1 } },
5488 		"ALU64_ADD_K: 1 + 0 = 1",
5490 			BPF_LD_IMM64(R2, 0x1),
5491 			BPF_LD_IMM64(R3, 0x1),
5492 			BPF_ALU64_IMM(BPF_ADD, R2, 0x0),
5501 		{ { 0, 0x1 } },
5504 		"ALU64_ADD_K: 0 + (-1) = 0xffffffffffffffff",
5506 			BPF_LD_IMM64(R2, 0x0),
5507 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
5508 			BPF_ALU64_IMM(BPF_ADD, R2, 0xffffffff),
5517 		{ { 0, 0x1 } },
5520 		"ALU64_ADD_K: 0 + 0xffff = 0xffff",
5522 			BPF_LD_IMM64(R2, 0x0),
5523 			BPF_LD_IMM64(R3, 0xffff),
5524 			BPF_ALU64_IMM(BPF_ADD, R2, 0xffff),
5533 		{ { 0, 0x1 } },
5536 		"ALU64_ADD_K: 0 + 0x7fffffff = 0x7fffffff",
5538 			BPF_LD_IMM64(R2, 0x0),
5539 			BPF_LD_IMM64(R3, 0x7fffffff),
5540 			BPF_ALU64_IMM(BPF_ADD, R2, 0x7fffffff),
5549 		{ { 0, 0x1 } },
5552 		"ALU64_ADD_K: 0 + 0x80000000 = 0xffffffff80000000",
5554 			BPF_LD_IMM64(R2, 0x0),
5555 			BPF_LD_IMM64(R3, 0xffffffff80000000LL),
5556 			BPF_ALU64_IMM(BPF_ADD, R2, 0x80000000),
5565 		{ { 0, 0x1 } },
5568 		"ALU_ADD_K: 0 + 0x80008000 = 0xffffffff80008000",
5570 			BPF_LD_IMM64(R2, 0x0),
5571 			BPF_LD_IMM64(R3, 0xffffffff80008000LL),
5572 			BPF_ALU64_IMM(BPF_ADD, R2, 0x80008000),
5581 		{ { 0, 0x1 } },
5594 		{ { 0, 2 } },
5606 		{ { 0, 1 } },
5618 		{ { 0, 2 } },
5630 		{ { 0, 1 } },
5642 		{ { 0, 2 } },
5645 		"ALU_SUB_K: 3 - 0 = 3",
5648 			BPF_ALU32_IMM(BPF_SUB, R0, 0),
5653 		{ { 0, 3 } },
5664 		{ { 0, 1 } },
5675 		{ { 0, 2 } },
5678 		"ALU64_SUB_K: 3 - 0 = 3",
5681 			BPF_ALU64_IMM(BPF_SUB, R0, 0),
5686 		{ { 0, 3 } },
5697 		{ { 0, -1 } },
5708 		{ { 0, -1 } },
5721 		{ { 0, 6 } },
5724 		"ALU_MUL_X: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
5727 			BPF_ALU32_IMM(BPF_MOV, R1, 0x7FFFFFF8),
5733 		{ { 0, 0xFFFFFFF0 } },
5745 		{ { 0, 1 } },
5757 		{ { 0, 6 } },
5769 		{ { 0, 2147483647 } },
5774 			BPF_LD_IMM64(R0, 0x0fedcba987654321LL),
5775 			BPF_LD_IMM64(R1, 0x123456789abcdef0LL),
5781 		{ { 0, 0xe5618cf0 } }
5786 			BPF_LD_IMM64(R0, 0x0fedcba987654321LL),
5787 			BPF_LD_IMM64(R1, 0x123456789abcdef0LL),
5794 		{ { 0, 0x2236d88f } }
5806 		{ { 0, 6 } },
5817 		{ { 0, 3 } },
5820 		"ALU_MUL_K: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
5823 			BPF_ALU32_IMM(BPF_MUL, R0, 0x7FFFFFF8),
5828 		{ { 0, 0xFFFFFFF0 } },
5831 		"ALU_MUL_K: 1 * (-1) = 0x00000000ffffffff",
5833 			BPF_LD_IMM64(R2, 0x1),
5834 			BPF_LD_IMM64(R3, 0x00000000ffffffff),
5835 			BPF_ALU32_IMM(BPF_MUL, R2, 0xffffffff),
5844 		{ { 0, 0x1 } },
5855 		{ { 0, 6 } },
5866 		{ { 0, 3 } },
5877 		{ { 0, 2147483647 } },
5888 		{ { 0, -2147483647 } },
5891 		"ALU64_MUL_K: 1 * (-1) = 0xffffffffffffffff",
5893 			BPF_LD_IMM64(R2, 0x1),
5894 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
5895 			BPF_ALU64_IMM(BPF_MUL, R2, 0xffffffff),
5904 		{ { 0, 0x1 } },
5909 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5910 			BPF_ALU64_IMM(BPF_MUL, R0, 0x12345678),
5915 		{ { 0, 0xe242d208 } }
5920 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5921 			BPF_ALU64_IMM(BPF_MUL, R0, 0x12345678),
5927 		{ { 0, 0xc28f5c28 } }
5940 		{ { 0, 3 } },
5952 		{ { 0, 1 } },
5964 		{ { 0, 3 } },
5976 		{ { 0, 1 } },
5979 		"ALU64_DIV_X: 0xffffffffffffffff / (-1) = 0x0000000000000001",
5981 			BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
5982 			BPF_LD_IMM64(R4, 0xffffffffffffffffLL),
5983 			BPF_LD_IMM64(R3, 0x0000000000000001LL),
5993 		{ { 0, 0x1 } },
6005 		{ { 0, 3 } },
6016 		{ { 0, 3 } },
6027 		{ { 0, 1 } },
6030 		"ALU_DIV_K: 0xffffffffffffffff / (-1) = 0x1",
6032 			BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
6033 			BPF_LD_IMM64(R3, 0x1UL),
6034 			BPF_ALU32_IMM(BPF_DIV, R2, 0xffffffff),
6043 		{ { 0, 0x1 } },
6054 		{ { 0, 3 } },
6065 		{ { 0, 3 } },
6076 		{ { 0, 1 } },
6079 		"ALU64_DIV_K: 0xffffffffffffffff / (-1) = 0x0000000000000001",
6081 			BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
6082 			BPF_LD_IMM64(R3, 0x0000000000000001LL),
6083 			BPF_ALU64_IMM(BPF_DIV, R2, 0xffffffff),
6092 		{ { 0, 0x1 } },
6105 		{ { 0, 1 } },
6117 		{ { 0, 2 } },
6129 		{ { 0, 1 } },
6141 		{ { 0, 2 } },
6153 		{ { 0, 1 } },
6156 		"ALU_MOD_K: 3 % 1 = 0",
6164 		{ { 0, 0 } },
6175 		{ { 0, 2 } },
6186 		{ { 0, 1 } },
6189 		"ALU64_MOD_K: 3 % 1 = 0",
6197 		{ { 0, 0 } },
6208 		{ { 0, 2 } },
6221 		{ { 0, -3 } },
6233 		{ { 0, -3 } },
6246 		{ { 0, -3 } },
6258 		{ { 0, -3 } },
6271 		{ { 0, -1 } },
6283 		{ { 0, -1 } },
6296 		{ { 0, -1 } },
6308 		{ { 0, -1 } },
6321 		{ { 0, 2 } },
6324 		"ALU_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
6326 			BPF_LD_IMM64(R0, 0xffffffff),
6327 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6333 		{ { 0, 0xffffffff } },
6345 		{ { 0, 2 } },
6348 		"ALU64_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
6350 			BPF_LD_IMM64(R0, 0xffffffff),
6351 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6357 		{ { 0, 0xffffffff } },
6369 		{ { 0, 2 } },
6372 		"ALU_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
6374 			BPF_LD_IMM64(R0, 0xffffffff),
6375 			BPF_ALU32_IMM(BPF_AND, R0, 0xffffffff),
6380 		{ { 0, 0xffffffff } },
6385 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
6391 		{ { 0, 4 } }
6396 			BPF_ALU32_IMM(BPF_MOV, R0, 0xf1f2f3f4),
6397 			BPF_ALU32_IMM(BPF_AND, R0, 0xafbfcfdf),
6402 		{ { 0, 0xa1b2c3d4 } }
6407 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6408 			BPF_LD_IMM64(R1, 0x0000000080a0c0e0LL),
6409 			BPF_ALU32_IMM(BPF_AND, R0, 0xf0f0f0f0),
6418 		{ { 0, 1 } }
6429 		{ { 0, 2 } },
6432 		"ALU64_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
6434 			BPF_LD_IMM64(R0, 0xffffffff),
6435 			BPF_ALU64_IMM(BPF_AND, R0, 0xffffffff),
6440 		{ { 0, 0xffffffff } },
6443 		"ALU64_AND_K: 0x0000ffffffff0000 & 0x0 = 0x0000000000000000",
6445 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6446 			BPF_LD_IMM64(R3, 0x0000000000000000LL),
6447 			BPF_ALU64_IMM(BPF_AND, R2, 0x0),
6456 		{ { 0, 0x1 } },
6459 		"ALU64_AND_K: 0x0000ffffffff0000 & -1 = 0x0000ffffffff0000",
6461 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6462 			BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
6463 			BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
6472 		{ { 0, 0x1 } },
6475 		"ALU64_AND_K: 0xffffffffffffffff & -1 = 0xffffffffffffffff",
6477 			BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
6478 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
6479 			BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
6488 		{ { 0, 0x1 } },
6493 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6494 			BPF_LD_IMM64(R1, 0x00000000090b0d0fLL),
6495 			BPF_ALU64_IMM(BPF_AND, R0, 0x0f0f0f0f),
6504 		{ { 0, 1 } }
6509 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6510 			BPF_LD_IMM64(R1, 0x0123456780a0c0e0LL),
6511 			BPF_ALU64_IMM(BPF_AND, R0, 0xf0f0f0f0),
6520 		{ { 0, 1 } }
6533 		{ { 0, 3 } },
6536 		"ALU_OR_X: 0x0 | 0xffffffff = 0xffffffff",
6538 			BPF_LD_IMM64(R0, 0),
6539 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6545 		{ { 0, 0xffffffff } },
6557 		{ { 0, 3 } },
6560 		"ALU64_OR_X: 0 | 0xffffffff = 0xffffffff",
6562 			BPF_LD_IMM64(R0, 0),
6563 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6569 		{ { 0, 0xffffffff } },
6581 		{ { 0, 3 } },
6584 		"ALU_OR_K: 0 & 0xffffffff = 0xffffffff",
6586 			BPF_LD_IMM64(R0, 0),
6587 			BPF_ALU32_IMM(BPF_OR, R0, 0xffffffff),
6592 		{ { 0, 0xffffffff } },
6597 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
6603 		{ { 0, 0x01020305 } }
6608 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
6609 			BPF_ALU32_IMM(BPF_OR, R0, 0xa0b0c0d0),
6614 		{ { 0, 0xa1b2c3d4 } }
6619 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6620 			BPF_LD_IMM64(R1, 0x00000000f9fbfdffLL),
6621 			BPF_ALU32_IMM(BPF_OR, R0, 0xf0f0f0f0),
6630 		{ { 0, 1 } }
6641 		{ { 0, 3 } },
6644 		"ALU64_OR_K: 0 & 0xffffffff = 0xffffffff",
6646 			BPF_LD_IMM64(R0, 0),
6647 			BPF_ALU64_IMM(BPF_OR, R0, 0xffffffff),
6652 		{ { 0, 0xffffffff } },
6655 		"ALU64_OR_K: 0x0000ffffffff0000 | 0x0 = 0x0000ffffffff0000",
6657 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6658 			BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
6659 			BPF_ALU64_IMM(BPF_OR, R2, 0x0),
6668 		{ { 0, 0x1 } },
6671 		"ALU64_OR_K: 0x0000ffffffff0000 | -1 = 0xffffffffffffffff",
6673 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6674 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
6675 			BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
6684 		{ { 0, 0x1 } },
6687 		"ALU64_OR_K: 0x000000000000000 | -1 = 0xffffffffffffffff",
6689 			BPF_LD_IMM64(R2, 0x0000000000000000LL),
6690 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
6691 			BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
6700 		{ { 0, 0x1 } },
6705 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6706 			BPF_LD_IMM64(R1, 0x012345678fafcfefLL),
6707 			BPF_ALU64_IMM(BPF_OR, R0, 0x0f0f0f0f),
6716 		{ { 0, 1 } }
6721 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6722 			BPF_LD_IMM64(R1, 0xfffffffff9fbfdffLL),
6723 			BPF_ALU64_IMM(BPF_OR, R0, 0xf0f0f0f0),
6732 		{ { 0, 1 } }
6745 		{ { 0, 3 } },
6748 		"ALU_XOR_X: 0x1 ^ 0xffffffff = 0xfffffffe",
6751 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6757 		{ { 0, 0xfffffffe } },
6769 		{ { 0, 3 } },
6772 		"ALU64_XOR_X: 1 ^ 0xffffffff = 0xfffffffe",
6775 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6781 		{ { 0, 0xfffffffe } },
6793 		{ { 0, 3 } },
6796 		"ALU_XOR_K: 1 ^ 0xffffffff = 0xfffffffe",
6799 			BPF_ALU32_IMM(BPF_XOR, R0, 0xffffffff),
6804 		{ { 0, 0xfffffffe } },
6809 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
6815 		{ { 0, 0x0102030b } }
6820 			BPF_ALU32_IMM(BPF_MOV, R0, 0xf1f2f3f4),
6821 			BPF_ALU32_IMM(BPF_XOR, R0, 0xafbfcfdf),
6826 		{ { 0, 0x5e4d3c2b } }
6831 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6832 			BPF_LD_IMM64(R1, 0x00000000795b3d1fLL),
6833 			BPF_ALU32_IMM(BPF_XOR, R0, 0xf0f0f0f0),
6842 		{ { 0, 1 } }
6853 		{ { 0, 3 } },
6856 		"ALU64_XOR_K: 1 ^ 0xffffffff = 0xfffffffe",
6859 			BPF_ALU64_IMM(BPF_XOR, R0, 0xffffffff),
6864 		{ { 0, 0xfffffffe } },
6867 		"ALU64_XOR_K: 0x0000ffffffff0000 ^ 0x0 = 0x0000ffffffff0000",
6869 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6870 			BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
6871 			BPF_ALU64_IMM(BPF_XOR, R2, 0x0),
6880 		{ { 0, 0x1 } },
6883 		"ALU64_XOR_K: 0x0000ffffffff0000 ^ -1 = 0xffff00000000ffff",
6885 			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6886 			BPF_LD_IMM64(R3, 0xffff00000000ffffLL),
6887 			BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
6896 		{ { 0, 0x1 } },
6899 		"ALU64_XOR_K: 0x000000000000000 ^ -1 = 0xffffffffffffffff",
6901 			BPF_LD_IMM64(R2, 0x0000000000000000LL),
6902 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
6903 			BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
6912 		{ { 0, 0x1 } },
6917 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6918 			BPF_LD_IMM64(R1, 0x0123456786a4c2e0LL),
6919 			BPF_ALU64_IMM(BPF_XOR, R0, 0x0f0f0f0f),
6928 		{ { 0, 1 } }
6933 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6934 			BPF_LD_IMM64(R1, 0xfedcba98795b3d1fLL),
6935 			BPF_ALU64_IMM(BPF_XOR, R0, 0xf0f0f0f0),
6944 		{ { 0, 1 } }
6957 		{ { 0, 2 } },
6960 		"ALU_LSH_X: 1 << 31 = 0x80000000",
6969 		{ { 0, 0x80000000 } },
6972 		"ALU_LSH_X: 0x12345678 << 12 = 0x45678000",
6974 			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
6981 		{ { 0, 0x45678000 } }
6993 		{ { 0, 2 } },
6996 		"ALU64_LSH_X: 1 << 31 = 0x80000000",
7005 		{ { 0, 0x80000000 } },
7010 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7017 		{ { 0, 0xbcdef000 } }
7022 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7030 		{ { 0, 0x3456789a } }
7035 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7042 		{ { 0, 0 } }
7047 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7055 		{ { 0, 0x9abcdef0 } }
7060 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7067 		{ { 0, 0 } }
7072 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7080 		{ { 0, 0x89abcdef } }
7085 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7086 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
7092 		{ { 0, 0x89abcdef } }
7097 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7098 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
7105 		{ { 0, 0x01234567 } }
7117 		{ { 0, 2 } },
7120 		"ALU_LSH_K: 1 << 31 = 0x80000000",
7128 		{ { 0, 0x80000000 } },
7131 		"ALU_LSH_K: 0x12345678 << 12 = 0x45678000",
7133 			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
7139 		{ { 0, 0x45678000 } }
7142 		"ALU_LSH_K: 0x12345678 << 0 = 0x12345678",
7144 			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
7145 			BPF_ALU32_IMM(BPF_LSH, R0, 0),
7150 		{ { 0, 0x12345678 } }
7161 		{ { 0, 2 } },
7164 		"ALU64_LSH_K: 1 << 31 = 0x80000000",
7172 		{ { 0, 0x80000000 } },
7177 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7183 		{ { 0, 0xbcdef000 } }
7188 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7195 		{ { 0, 0x3456789a } }
7200 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7206 		{ { 0, 0 } }
7211 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7218 		{ { 0, 0x9abcdef0 } }
7223 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7229 		{ { 0, 0 } }
7234 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7241 		{ { 0, 0x89abcdef } }
7246 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7247 			BPF_ALU64_IMM(BPF_LSH, R0, 0),
7252 		{ { 0, 0x89abcdef } }
7265 		{ { 0, 1 } },
7268 		"ALU_RSH_X: 0x80000000 >> 31 = 1",
7270 			BPF_LD_IMM64(R0, 0x80000000),
7277 		{ { 0, 1 } },
7280 		"ALU_RSH_X: 0x12345678 >> 20 = 0x123",
7282 			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
7289 		{ { 0, 0x123 } }
7301 		{ { 0, 1 } },
7304 		"ALU64_RSH_X: 0x80000000 >> 31 = 1",
7306 			BPF_LD_IMM64(R0, 0x80000000),
7313 		{ { 0, 1 } },
7318 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7325 		{ { 0, 0x56789abc } }
7330 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7338 		{ { 0, 0x00081234 } }
7343 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7350 		{ { 0, 0x08123456 } }
7355 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7363 		{ { 0, 0 } }
7368 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7375 		{ { 0, 0x81234567 } }
7380 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7388 		{ { 0, 0 } }
7393 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7394 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
7400 		{ { 0, 0x89abcdef } }
7405 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7406 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
7413 		{ { 0, 0x81234567 } }
7425 		{ { 0, 1 } },
7428 		"ALU_RSH_K: 0x80000000 >> 31 = 1",
7430 			BPF_LD_IMM64(R0, 0x80000000),
7436 		{ { 0, 1 } },
7439 		"ALU_RSH_K: 0x12345678 >> 20 = 0x123",
7441 			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
7447 		{ { 0, 0x123 } }
7450 		"ALU_RSH_K: 0x12345678 >> 0 = 0x12345678",
7452 			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
7453 			BPF_ALU32_IMM(BPF_RSH, R0, 0),
7458 		{ { 0, 0x12345678 } }
7469 		{ { 0, 1 } },
7472 		"ALU64_RSH_K: 0x80000000 >> 31 = 1",
7474 			BPF_LD_IMM64(R0, 0x80000000),
7480 		{ { 0, 1 } },
7485 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7491 		{ { 0, 0x56789abc } }
7496 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7503 		{ { 0, 0x00081234 } }
7508 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7514 		{ { 0, 0x08123456 } }
7519 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7526 		{ { 0, 0 } }
7531 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7537 		{ { 0, 0x81234567 } }
7542 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7549 		{ { 0, 0 } }
7554 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7555 			BPF_ALU64_IMM(BPF_RSH, R0, 0),
7560 		{ { 0, 0x89abcdef } }
7573 		{ { 0, -10 } }
7576 		"ALU64_ARSH_X: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
7578 			BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
7585 		{ { 0, 0xffff00ff } },
7590 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7597 		{ { 0, 0x56789abc } }
7602 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7610 		{ { 0, 0xfff81234 } }
7615 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7622 		{ { 0, 0xf8123456 } }
7627 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7635 		{ { 0, -1 } }
7640 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7647 		{ { 0, 0x81234567 } }
7652 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7660 		{ { 0, -1 } }
7665 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7666 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
7672 		{ { 0, 0x89abcdef } }
7677 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7678 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
7685 		{ { 0, 0x81234567 } }
7697 		{ { 0, -10 } }
7700 		"ALU32_ARSH_K: -1234 >> 0 = -1234",
7703 			BPF_ALU32_IMM(BPF_ARSH, R0, 0),
7708 		{ { 0, -1234 } }
7711 		"ALU64_ARSH_K: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
7713 			BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
7719 		{ { 0, 0xffff00ff } },
7724 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7730 		{ { 0, 0x56789abc } }
7735 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7742 		{ { 0, 0xfff81234 } }
7747 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7753 		{ { 0, 0xf8123456 } }
7758 			BPF_LD_IMM64(R0, 0xf123456789abcdefLL),
7765 		{ { 0, -1 } }
7770 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7776 		{ { 0, 0x81234567 } }
7781 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7788 		{ { 0, -1 } }
7793 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7794 			BPF_ALU64_IMM(BPF_ARSH, R0, 0),
7799 		{ { 0, 0x89abcdef } }
7806 			BPF_ALU32_IMM(BPF_NEG, R0, 0),
7811 		{ { 0, -3 } },
7817 			BPF_ALU32_IMM(BPF_NEG, R0, 0),
7822 		{ { 0, 3 } },
7828 			BPF_ALU64_IMM(BPF_NEG, R0, 0),
7833 		{ { 0, -3 } },
7839 			BPF_ALU64_IMM(BPF_NEG, R0, 0),
7844 		{ { 0, 3 } },
7848 		"ALU_END_FROM_BE 16: 0x0123456789abcdef -> 0xcdef",
7850 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7856 		{ { 0,  cpu_to_be16(0xcdef) } },
7859 		"ALU_END_FROM_BE 32: 0x0123456789abcdef -> 0x89abcdef",
7861 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7865 			BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
7870 		{ { 0, cpu_to_be32(0x89abcdef) } },
7873 		"ALU_END_FROM_BE 64: 0x0123456789abcdef -> 0x89abcdef",
7875 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7881 		{ { 0, (u32) cpu_to_be64(0x0123456789abcdefLL) } },
7884 		"ALU_END_FROM_BE 64: 0x0123456789abcdef >> 32 -> 0x01234567",
7886 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7893 		{ { 0, (u32) (cpu_to_be64(0x0123456789abcdefLL) >> 32) } },
7897 		"ALU_END_FROM_BE 16: 0xfedcba9876543210 -> 0x3210",
7899 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7905 		{ { 0,  cpu_to_be16(0x3210) } },
7908 		"ALU_END_FROM_BE 32: 0xfedcba9876543210 -> 0x76543210",
7910 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7914 			BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
7919 		{ { 0, cpu_to_be32(0x76543210) } },
7922 		"ALU_END_FROM_BE 64: 0xfedcba9876543210 -> 0x76543210",
7924 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7930 		{ { 0, (u32) cpu_to_be64(0xfedcba9876543210ULL) } },
7933 		"ALU_END_FROM_BE 64: 0xfedcba9876543210 >> 32 -> 0xfedcba98",
7935 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7942 		{ { 0, (u32) (cpu_to_be64(0xfedcba9876543210ULL) >> 32) } },
7946 		"ALU_END_FROM_LE 16: 0x0123456789abcdef -> 0xefcd",
7948 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7954 		{ { 0, cpu_to_le16(0xcdef) } },
7957 		"ALU_END_FROM_LE 32: 0x0123456789abcdef -> 0xefcdab89",
7959 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7963 			BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
7968 		{ { 0, cpu_to_le32(0x89abcdef) } },
7971 		"ALU_END_FROM_LE 64: 0x0123456789abcdef -> 0x67452301",
7973 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7979 		{ { 0, (u32) cpu_to_le64(0x0123456789abcdefLL) } },
7982 		"ALU_END_FROM_LE 64: 0x0123456789abcdef >> 32 -> 0xefcdab89",
7984 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7991 		{ { 0, (u32) (cpu_to_le64(0x0123456789abcdefLL) >> 32) } },
7995 		"ALU_END_FROM_LE 16: 0xfedcba9876543210 -> 0x1032",
7997 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
8003 		{ { 0,  cpu_to_le16(0x3210) } },
8006 		"ALU_END_FROM_LE 32: 0xfedcba9876543210 -> 0x10325476",
8008 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
8012 			BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
8017 		{ { 0, cpu_to_le32(0x76543210) } },
8020 		"ALU_END_FROM_LE 64: 0xfedcba9876543210 -> 0x10325476",
8022 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
8028 		{ { 0, (u32) cpu_to_le64(0xfedcba9876543210ULL) } },
8031 		"ALU_END_FROM_LE 64: 0xfedcba9876543210 >> 32 -> 0x98badcfe",
8033 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
8040 		{ { 0, (u32) (cpu_to_le64(0xfedcba9876543210ULL) >> 32) } },
8044 		"BSWAP 16: 0x0123456789abcdef -> 0xefcd",
8046 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
8052 		{ { 0, 0xefcd } },
8055 		"BSWAP 32: 0x0123456789abcdef -> 0xefcdab89",
8057 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
8061 			BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
8066 		{ { 0, 0xefcdab89 } },
8069 		"BSWAP 64: 0x0123456789abcdef -> 0x67452301",
8071 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
8077 		{ { 0, 0x67452301 } },
8080 		"BSWAP 64: 0x0123456789abcdef >> 32 -> 0xefcdab89",
8082 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
8089 		{ { 0, 0xefcdab89 } },
8093 		"BSWAP 16: 0xfedcba9876543210 -> 0x1032",
8095 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
8101 		{ { 0, 0x1032 } },
8104 		"BSWAP 32: 0xfedcba9876543210 -> 0x10325476",
8106 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
8110 			BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
8115 		{ { 0, 0x10325476 } },
8118 		"BSWAP 64: 0xfedcba9876543210 -> 0x98badcfe",
8120 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
8126 		{ { 0, 0x98badcfe } },
8129 		"BSWAP 64: 0xfedcba9876543210 >> 32 -> 0x10325476",
8131 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
8138 		{ { 0, 0x10325476 } },
8144 			BPF_LD_IMM64(R1, 0x0102030405060708ULL),
8145 			BPF_LD_IMM64(R2, 0x0000000000000008ULL),
8153 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8158 		{ { 0, 0 } },
8164 			BPF_LD_IMM64(R1, 0x8182838485868788ULL),
8165 			BPF_LD_IMM64(R2, 0x0000000000000088ULL),
8173 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8178 		{ { 0, 0 } },
8184 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8185 			BPF_LD_IMM64(R3, 0x0000000000000088ULL),
8190 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8195 		{ { 512, 0 } },
8196 		.stack_depth = 0,
8201 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8202 			BPF_LD_IMM64(R3, 0x0000000000000088ULL),
8206 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8211 		{ { 512, 0 } },
8212 		.stack_depth = 0,
8217 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8218 			BPF_LD_IMM64(R3, 0x0000000000000088ULL),
8222 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8227 		{ { 4096 + 16, 0 } },
8228 		.stack_depth = 0,
8233 			BPF_LD_IMM64(R1, 0x0102030405060708ULL),
8234 			BPF_LD_IMM64(R2, 0x0000000000000708ULL),
8242 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8247 		{ { 0, 0 } },
8253 			BPF_LD_IMM64(R1, 0x8182838485868788ULL),
8254 			BPF_LD_IMM64(R2, 0x0000000000008788ULL),
8262 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8267 		{ { 0, 0 } },
8273 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8274 			BPF_LD_IMM64(R3, 0x0000000000008788ULL),
8279 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8284 		{ { 512, 0 } },
8285 		.stack_depth = 0,
8290 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8291 			BPF_LD_IMM64(R3, 0x0000000000008788ULL),
8295 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8300 		{ { 512, 0 } },
8301 		.stack_depth = 0,
8306 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8307 			BPF_LD_IMM64(R3, 0x0000000000008788ULL),
8311 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8316 		{ { 8192 + 16, 0 } },
8317 		.stack_depth = 0,
8322 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8323 			BPF_LD_IMM64(R3, 0x0000000000008788ULL),
8327 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8332 		{ { 32, 0 } },
8333 		.stack_depth = 0,
8338 			BPF_LD_IMM64(R1, 0x0102030405060708ULL),
8339 			BPF_LD_IMM64(R2, 0x0000000005060708ULL),
8347 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8352 		{ { 0, 0 } },
8358 			BPF_LD_IMM64(R1, 0x8182838485868788ULL),
8359 			BPF_LD_IMM64(R2, 0x0000000085868788ULL),
8367 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8372 		{ { 0, 0 } },
8378 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8379 			BPF_LD_IMM64(R3, 0x0000000085868788ULL),
8384 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8389 		{ { 512, 0 } },
8390 		.stack_depth = 0,
8395 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8396 			BPF_LD_IMM64(R3, 0x0000000085868788ULL),
8400 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8405 		{ { 512, 0 } },
8406 		.stack_depth = 0,
8411 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8412 			BPF_LD_IMM64(R3, 0x0000000085868788ULL),
8416 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8421 		{ { 16384 + 16, 0 } },
8422 		.stack_depth = 0,
8427 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8428 			BPF_LD_IMM64(R3, 0x0000000085868788ULL),
8432 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8437 		{ { 32, 0 } },
8438 		.stack_depth = 0,
8443 			BPF_LD_IMM64(R1, 0x0102030405060708ULL),
8447 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8452 		{ { 0, 0 } },
8458 			BPF_LD_IMM64(R1, 0x8182838485868788ULL),
8462 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8467 		{ { 0, 0 } },
8473 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8478 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8483 		{ { 512, 0 } },
8484 		.stack_depth = 0,
8489 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8493 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8498 		{ { 512, 0 } },
8504 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8508 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8513 		{ { 32768, 0 } },
8514 		.stack_depth = 0,
8519 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8523 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8528 		{ { 32, 0 } },
8529 		.stack_depth = 0,
8535 			BPF_LD_IMM64(R1, 0xdead0000000000f0ULL),
8536 			BPF_LD_IMM64(R2, 0xfffffffffffffff0ULL),
8544 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8549 		{ { 0, 0 } },
8555 			BPF_LD_IMM64(R1, 0xdead00000000f123ULL),
8556 			BPF_LD_IMM64(R2, 0xfffffffffffff123ULL),
8564 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8569 		{ { 0, 0 } },
8575 			BPF_LD_IMM64(R1, 0x00000000deadbeefULL),
8576 			BPF_LD_IMM64(R2, 0xffffffffdeadbeefULL),
8584 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8589 		{ { 0, 0 } },
8596 			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8597 			BPF_LD_IMM64(R2, 0x0102030405060708ULL),
8598 			BPF_LD_IMM64(R3, 0x8090a0b0c0d0e008ULL),
8607 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8612 		{ { 0, 0 } },
8618 			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8619 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8620 			BPF_LD_IMM64(R3, 0x8090a0b0c0d0e088ULL),
8629 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8634 		{ { 0, 0 } },
8640 			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8641 			BPF_LD_IMM64(R2, 0x0102030405060708ULL),
8642 			BPF_LD_IMM64(R3, 0x8090a0b0c0d00708ULL),
8651 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8656 		{ { 0, 0 } },
8662 			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8663 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8664 			BPF_LD_IMM64(R3, 0x8090a0b0c0d08788ULL),
8673 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8678 		{ { 0, 0 } },
8684 			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8685 			BPF_LD_IMM64(R2, 0x0102030405060708ULL),
8686 			BPF_LD_IMM64(R3, 0x8090a0b005060708ULL),
8695 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8700 		{ { 0, 0 } },
8706 			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8707 			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8708 			BPF_LD_IMM64(R3, 0x8090a0b085868788ULL),
8717 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8722 		{ { 0, 0 } },
8730 			BPF_ST_MEM(BPF_B, R10, -40, 0xff),
8736 		{ { 0, 0xff } },
8743 			BPF_ST_MEM(BPF_H, R10, -40, 0x7f),
8749 		{ { 0, 0x7f } },
8755 			BPF_LD_IMM64(R0, 0),
8756 			BPF_LD_IMM64(R1, 0xffLL),
8763 		{ { 0, 0xff } },
8770 			BPF_ST_MEM(BPF_H, R10, -40, 0xffff),
8776 		{ { 0, 0xffff } },
8783 			BPF_ST_MEM(BPF_H, R10, -40, 0x7fff),
8789 		{ { 0, 0x7fff } },
8795 			BPF_LD_IMM64(R0, 0),
8796 			BPF_LD_IMM64(R1, 0xffffLL),
8803 		{ { 0, 0xffff } },
8810 			BPF_ST_MEM(BPF_W, R10, -40, 0xffffffff),
8816 		{ { 0, 0xffffffff } },
8823 			BPF_ST_MEM(BPF_W, R10, -40, 0x7fffffff),
8829 		{ { 0, 0x7fffffff } },
8835 			BPF_LD_IMM64(R0, 0),
8836 			BPF_LD_IMM64(R1, 0xffffffffLL),
8843 		{ { 0, 0xffffffff } },
8850 			BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
8856 		{ { 0, 0xffffffff } },
8862 			BPF_LD_IMM64(R2, 0xffff00000000ffffLL),
8863 			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
8864 			BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
8874 		{ { 0, 0x1 } },
8881 			BPF_ST_MEM(BPF_DW, R10, -40, 0x7fffffff),
8887 		{ { 0, 0x7fffffff } },
8893 			BPF_LD_IMM64(R0, 0),
8894 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
8901 		{ { 0, 0xffffffff } },
8907 			BPF_LD_IMM64(R0, 0),
8908 			BPF_LD_IMM64(R1, 0x0123456789abcdefLL),
8916 		{ { 0, 0x01234567 } },
8918 		{ { 0, 0x89abcdef } },
8925 			BPF_LD_IMM64(R0, 0),
8926 			BPF_LD_IMM64(R1, 0x0123456789abcdefLL),
8934 		{ { 0, 0x89abcdef } },
8936 		{ { 0, 0x01234567 } },
8946 		{ { 0, 4134 } },
8954 		{ { 0, 4134 } },
8962 #define BPF_ATOMIC_POISON(width) ((width) == BPF_W ? (0xbaadf00dULL << 32) : 0)
8980 	{ { 0, result } },						\
9001 	{ { 0, 0 } },							\
9021 	{ { 0, 0 } },                                                   \
9037 	{ { 0, (op) & BPF_FETCH ? old : update } },			\
9041 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
9042 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
9043 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
9044 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
9046 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
9047 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
9048 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
9049 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
9051 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
9052 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
9053 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
9054 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
9056 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
9057 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
9058 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
9059 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
9061 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
9062 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
9063 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
9064 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
9066 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
9067 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
9068 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
9069 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
9071 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
9072 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
9073 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
9074 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
9076 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
9077 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
9078 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
9079 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
9081 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
9082 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
9083 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
9084 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
9086 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
9087 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
9088 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
9089 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
9091 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
9092 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
9093 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
9094 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
9096 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
9097 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
9098 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
9099 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
9101 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
9102 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
9103 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
9104 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
9106 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
9107 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
9108 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
9109 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
9111 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
9112 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
9113 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
9114 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
9116 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
9117 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
9118 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
9119 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
9121 	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
9122 	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
9123 	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
9124 	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
9126 	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
9127 	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
9128 	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
9129 	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
9139 			BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
9140 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
9141 			BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
9147 		{ { 0, 0x01234567 } },
9153 			BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
9154 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
9155 			BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
9162 		{ { 0, 0x89abcdef } },
9168 			BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
9169 			BPF_ALU32_IMM(BPF_MOV, R0, 0x76543210),
9170 			BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
9176 		{ { 0, 0x01234567 } },
9182 			BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
9183 			BPF_ALU32_IMM(BPF_MOV, R0, 0x76543210),
9184 			BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
9191 		{ { 0, 0x01234567 } },
9197 			BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
9198 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
9199 			BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
9207 		{ { 0, 0x89abcdef } },
9214 			BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
9215 			BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
9225 		{ { 0, 0 } },
9231 			BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
9232 			BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
9243 		{ { 0, 0 } },
9249 			BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
9250 			BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
9261 		{ { 0, 0 } },
9267 			BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
9268 			BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
9280 		{ { 0, 0 } },
9286 			BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
9287 			BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
9291 			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
9298 		{ { 0, 0 } },
9308 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9313 		{ { 0, 123 } }
9319 			BPF_JMP32_IMM(BPF_JEQ, R0, 12345678 & 0xffff, 1),
9321 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9326 		{ { 0, 12345678 } }
9334 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9339 		{ { 0, -123 } }
9350 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9355 		{ { 0, 1234 } }
9364 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9369 		{ { 0, 123 } }
9376 			BPF_JMP32_IMM(BPF_JNE, R0, 12345678 & 0xffff, 1),
9377 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9382 		{ { 0, 12345678 } }
9390 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9395 		{ { 0, -123 } }
9406 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9411 		{ { 0, 1234 } }
9420 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9425 		{ { 0, 1 } }
9430 			BPF_ALU32_IMM(BPF_MOV, R0, 0x40000000),
9431 			BPF_JMP32_IMM(BPF_JSET, R0, 0x3fffffff, 1),
9432 			BPF_JMP32_IMM(BPF_JSET, R0, 0x60000000, 1),
9433 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9438 		{ { 0, 0x40000000 } }
9445 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9450 		{ { 0, -123 } }
9461 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9466 		{ { 0, 8 } }
9475 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9480 		{ { 0, 123 } }
9485 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9486 			BPF_JMP32_IMM(BPF_JGT, R0, 0xffffffff, 1),
9487 			BPF_JMP32_IMM(BPF_JGT, R0, 0xfffffffd, 1),
9488 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9493 		{ { 0, 0xfffffffe } }
9499 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9500 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
9502 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
9504 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9509 		{ { 0, 0xfffffffe } }
9518 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9523 		{ { 0, 123 } }
9528 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9529 			BPF_JMP32_IMM(BPF_JGE, R0, 0xffffffff, 1),
9530 			BPF_JMP32_IMM(BPF_JGE, R0, 0xfffffffe, 1),
9531 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9536 		{ { 0, 0xfffffffe } }
9542 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9543 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
9545 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffe),
9547 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9552 		{ { 0, 0xfffffffe } }
9561 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9566 		{ { 0, 123 } }
9571 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9572 			BPF_JMP32_IMM(BPF_JLT, R0, 0xfffffffd, 1),
9573 			BPF_JMP32_IMM(BPF_JLT, R0, 0xffffffff, 1),
9574 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9579 		{ { 0, 0xfffffffe } }
9585 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9586 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
9588 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
9590 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9595 		{ { 0, 0xfffffffe } }
9604 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9609 		{ { 0, 123 } }
9614 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9615 			BPF_JMP32_IMM(BPF_JLE, R0, 0xfffffffd, 1),
9616 			BPF_JMP32_IMM(BPF_JLE, R0, 0xfffffffe, 1),
9617 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9622 		{ { 0, 0xfffffffe } }
9628 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9629 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
9631 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffe),
9633 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9638 		{ { 0, 0xfffffffe } }
9647 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9652 		{ { 0, -123 } }
9660 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9665 		{ { 0, -12345678 } }
9676 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9681 		{ { 0, -12345678 } }
9690 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9695 		{ { 0, -123 } }
9703 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9708 		{ { 0, -12345678 } }
9719 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9724 		{ { 0, -12345678 } }
9733 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9738 		{ { 0, -123 } }
9746 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9751 		{ { 0, -12345678 } }
9762 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9767 		{ { 0, -12345678 } }
9776 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9781 		{ { 0, -123 } }
9789 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9794 		{ { 0, -12345678 } }
9805 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9810 		{ { 0, -12345678 } }
9816 			BPF_ALU32_IMM(BPF_MOV, R0, 0x4711),
9818 			BPF_ALU32_IMM(BPF_MOV, R0, 0x4712),
9822 		{ { 0, 0x4711 } },
9828 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9829 			BPF_JMP_IMM(BPF_JA, 0, 0, 1),
9836 		{ { 0, 1 } },
9842 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9843 			BPF_JMP32_IMM(BPF_JA, 0, 1, 0),
9850 		{ { 0, 1 } },
9856 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9857 			BPF_LD_IMM64(R1, 0xfffffffffffffffeLL),
9865 		{ { 0, 1 } },
9868 		"JMP_JSLT_K: Signed jump: if (-1 < -1) return 0",
9871 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9874 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9879 		{ { 0, 1 } },
9885 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9886 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9894 		{ { 0, 1 } },
9897 		"JMP_JSGT_K: Signed jump: if (-1 > -1) return 0",
9900 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9903 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9908 		{ { 0, 1 } },
9914 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9915 			BPF_LD_IMM64(R1, 0xfffffffffffffffeLL),
9923 		{ { 0, 1 } },
9928 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9929 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9937 		{ { 0, 1 } },
9942 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9944 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 6),
9946 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 4),
9948 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 2),
9950 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 1),
9957 		{ { 0, 1 } },
9962 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9964 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 4),
9966 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 2),
9968 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 1),
9975 		{ { 0, 1 } },
9981 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9982 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9990 		{ { 0, 1 } },
9995 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9996 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
10004 		{ { 0, 1 } },
10009 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10011 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 6),
10013 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 4),
10015 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 2),
10017 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 1),
10024 		{ { 0, 1 } },
10029 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10031 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 4),
10033 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 2),
10035 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 1),
10042 		{ { 0, 1 } },
10048 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10057 		{ { 0, 1 } },
10062 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10071 		{ { 0, 1 } },
10077 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10086 		{ { 0, 1 } },
10091 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10100 		{ { 0, 1 } },
10106 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10115 		{ { 0, 1 } },
10121 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10130 		{ { 0, 1 } },
10136 			BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
10139 			BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
10146 		{ { 0, 1 } },
10151 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10160 		{ { 0, 1 } },
10166 			BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
10169 			BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
10176 		{ { 0, 1 } },
10181 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10190 		{ { 0, 1 } },
10196 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10205 		{ { 0, 1 } },
10211 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10220 		{ { 0, 1 } },
10224 		"JMP_JSET_K: if (0x3 & 0x2) return 1",
10226 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10235 		{ { 0, 1 } },
10238 		"JMP_JSET_K: if (0x3 & 0xffffffff) return 1",
10240 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10242 			BPF_JMP_IMM(BPF_JSET, R1, 0xffffffff, 1),
10249 		{ { 0, 1 } },
10255 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10265 		{ { 0, 1 } },
10268 		"JMP_JSGT_X: Signed jump: if (-1 > -1) return 0",
10275 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10280 		{ { 0, 1 } },
10286 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10296 		{ { 0, 1 } },
10299 		"JMP_JSLT_X: Signed jump: if (-1 < -1) return 0",
10306 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10311 		{ { 0, 1 } },
10317 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10327 		{ { 0, 1 } },
10332 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10342 		{ { 0, 1 } },
10348 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10358 		{ { 0, 1 } },
10363 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10373 		{ { 0, 1 } },
10379 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10389 		{ { 0, 1 } },
10394 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10404 		{ { 0, 1 } },
10410 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10420 		{ { 0, 1 } },
10425 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10435 		{ { 0, 1 } },
10441 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10451 		{ { 0, 1 } },
10456 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10466 		{ { 0, 1 } },
10472 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10482 		{ { 0, 1 } },
10487 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10497 		{ { 0, 1 } },
10503 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10507 			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
10508 			BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
10513 		{ { 0, 0xeeeeeeeeU } },
10518 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10521 			BPF_JMP_REG(BPF_JGE, R1, R2, 0),
10522 			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
10527 		{ { 0, 0xffffffffU } },
10536 			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
10537 			BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
10542 		{ { 0, 1 } },
10547 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10551 			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
10552 			BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
10557 		{ { 0, 0xeeeeeeeeU } },
10562 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10565 			BPF_JMP_REG(BPF_JLE, R2, R1, 0),
10566 			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
10571 		{ { 0, 0xffffffffU } },
10580 			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
10581 			BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
10586 		{ { 0, 1 } },
10592 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10602 		{ { 0, 1 } },
10608 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10618 		{ { 0, 1 } },
10622 		"JMP_JSET_X: if (0x3 & 0x2) return 1",
10624 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10634 		{ { 0, 1 } },
10637 		"JMP_JSET_X: if (0x3 & 0xffffffff) return 1",
10639 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
10641 			BPF_LD_IMM64(R2, 0xffffffff),
10649 		{ { 0, 1 } },
10656 		{ { 0, 0xababcbac } },
10664 		{ { 0, 0xffffffff } },
10672 		{ { 0, 0xfefefefe } },
10680 		{ { 0, 0x947bf368 } },
10697 		{ { 0, 0xabababab } },
10716 		{ { 1, 0 }, { 10, 0 } },
10724 		{ { 0, 0xffffffff } },
10732 		{ { 0, 0xcbababab } },
10740 		{ { 0, 0xabababac } },
10748 		{ { 0, 0xababcbac } },
10755 		{ 0xfa, 0xfb, 0xfc, 0xfd, },
10756 		{ { 4, 0xabababab } },
10764 		{ 0xfa, 0xfb, 0xfc, 0xfd, },
10765 		{ { 4, 0xababab83 } },
10773 		{ { 1, 0xbee } },
10782 			BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
10783 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x0),
10784 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10788 		{ {0x40, 0x42} },
10790 			0x42, 0x00, 0x00, 0x00,
10791 			0x43, 0x44, 0x00, 0x00,
10792 			0x21, 0x07, 0x19, 0x83,
10798 			BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
10799 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x4),
10800 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10804 		{ {0x40, 0x4344} },
10806 			0x42, 0x00, 0x00, 0x00,
10807 			0x43, 0x44, 0x00, 0x00,
10808 			0x21, 0x07, 0x19, 0x83,
10814 			BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
10815 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x8),
10816 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10820 		{ {0x40, 0x21071983} },
10822 			0x42, 0x00, 0x00, 0x00,
10823 			0x43, 0x44, 0x00, 0x00,
10824 			0x21, 0x07, 0x19, 0x83,
10830 			BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
10831 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
10832 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10835 		{ [0x3e] = 0x25, [0x3f] = 0x05, },
10836 		{ {0x40, 0x0519} },
10837 		.frag_data = { 0x19, 0x82 },
10842 			BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
10843 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
10844 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10847 		{ [0x3e] = 0x25, [0x3f] = 0x05, },
10848 		{ {0x40, 0x25051982} },
10849 		.frag_data = { 0x19, 0x82 },
10854 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x40),
10855 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10859 		{ {0x40, 0x42} },
10861 			0x42, 0x00, 0x00, 0x00,
10862 			0x43, 0x44, 0x00, 0x00,
10863 			0x21, 0x07, 0x19, 0x83,
10869 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x44),
10870 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10874 		{ {0x40, 0x4344} },
10876 			0x42, 0x00, 0x00, 0x00,
10877 			0x43, 0x44, 0x00, 0x00,
10878 			0x21, 0x07, 0x19, 0x83,
10884 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x48),
10885 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10889 		{ {0x40, 0x21071983} },
10891 			0x42, 0x00, 0x00, 0x00,
10892 			0x43, 0x44, 0x00, 0x00,
10893 			0x21, 0x07, 0x19, 0x83,
10899 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f),
10900 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10903 		{ [0x3e] = 0x25, [0x3f] = 0x05, },
10904 		{ {0x40, 0x0519} },
10905 		.frag_data = { 0x19, 0x82 },
10910 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3e),
10911 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10914 		{ [0x3e] = 0x25, [0x3f] = 0x05, },
10915 		{ {0x40, 0x25051982} },
10916 		.frag_data = { 0x19, 0x82 },
10928 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
10929 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10932 		{ [0x1] = 0x42 },
10933 		{ {0x40, 0x42 } },
10938 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10939 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
10940 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10943 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10944 		{ {0x40, 0x82 } },
10949 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10950 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x1),
10951 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10954 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10955 		{ {0x40, 0x05 } },
10960 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10961 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
10962 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10965 		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
10966 		{ {0x40, 0xff } },
10971 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10972 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
10973 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10976 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10977 		{ {0x3f, 0 }, },
10982 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10983 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x3f),
10984 			BPF_STMT(BPF_RET | BPF_A, 0x0),
10987 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10988 		{ {0x3f, 0 } },
10993 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3b),
10998 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11001 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11002 		{ {0x40, 0x82 }, },
11007 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
11008 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x2),
11009 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11013 			[0x1c] = 0xaa, [0x1d] = 0x55,
11014 			[0x1e] = 0xbb, [0x1f] = 0x66,
11015 			[0x20] = 0xcc, [0x21] = 0x77,
11016 			[0x22] = 0xdd, [0x23] = 0x88,
11018 		{ {0x40, 0xdd88 } },
11023 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
11024 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x2),
11025 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11029 			[0x1c] = 0xaa, [0x1d] = 0x55,
11030 			[0x1e] = 0xbb, [0x1f] = 0x66,
11031 			[0x20] = 0xcc, [0x21] = 0x77,
11032 			[0x22] = 0xdd, [0x23] = 0x88,
11034 		{ {0x40, 0xbb66 } },
11039 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
11040 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
11041 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11045 			[0x1c] = 0xaa, [0x1d] = 0x55,
11046 			[0x1e] = 0xbb, [0x1f] = 0x66,
11047 			[0x20] = 0xcc, [0x21] = 0x77,
11048 			[0x22] = 0xdd, [0x23] = 0x88,
11050 		{ {0x40, 0x66cc } },
11055 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3d),
11056 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1),
11057 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11060 		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
11061 		{ {0x40, 0xffff } },
11066 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
11067 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1),
11068 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11071 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11072 		{ {0x3f, 0 }, },
11077 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
11078 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x3f),
11079 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11082 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11083 		{ {0x3f, 0 } },
11088 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
11089 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x4),
11090 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11094 			[0x1c] = 0xaa, [0x1d] = 0x55,
11095 			[0x1e] = 0xbb, [0x1f] = 0x66,
11096 			[0x20] = 0xcc, [0x21] = 0x77,
11097 			[0x22] = 0xdd, [0x23] = 0x88,
11098 			[0x24] = 0xee, [0x25] = 0x99,
11099 			[0x26] = 0xff, [0x27] = 0xaa,
11101 		{ {0x40, 0xee99ffaa } },
11106 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
11107 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x4),
11108 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11112 			[0x1c] = 0xaa, [0x1d] = 0x55,
11113 			[0x1e] = 0xbb, [0x1f] = 0x66,
11114 			[0x20] = 0xcc, [0x21] = 0x77,
11115 			[0x22] = 0xdd, [0x23] = 0x88,
11116 			[0x24] = 0xee, [0x25] = 0x99,
11117 			[0x26] = 0xff, [0x27] = 0xaa,
11119 		{ {0x40, 0xaa55bb66 } },
11124 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
11125 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
11126 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11130 			[0x1c] = 0xaa, [0x1d] = 0x55,
11131 			[0x1e] = 0xbb, [0x1f] = 0x66,
11132 			[0x20] = 0xcc, [0x21] = 0x77,
11133 			[0x22] = 0xdd, [0x23] = 0x88,
11134 			[0x24] = 0xee, [0x25] = 0x99,
11135 			[0x26] = 0xff, [0x27] = 0xaa,
11137 		{ {0x40, 0xbb66cc77 } },
11142 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
11143 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3),
11144 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11148 			[0x1c] = 0xaa, [0x1d] = 0x55,
11149 			[0x1e] = 0xbb, [0x1f] = 0x66,
11150 			[0x20] = 0xcc, [0x21] = 0x77,
11151 			[0x22] = 0xdd, [0x23] = 0x88,
11152 			[0x24] = 0xee, [0x25] = 0x99,
11153 			[0x26] = 0xff, [0x27] = 0xaa,
11155 		{ {0x40, 0x55bb66cc } },
11160 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
11161 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x1),
11162 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11166 			[0x1c] = 0xaa, [0x1d] = 0x55,
11167 			[0x1e] = 0xbb, [0x1f] = 0x66,
11168 			[0x20] = 0xcc, [0x21] = 0x77,
11169 			[0x22] = 0xdd, [0x23] = 0x88,
11170 			[0x24] = 0xee, [0x25] = 0x99,
11171 			[0x26] = 0xff, [0x27] = 0xaa,
11173 		{ {0x40, 0x66cc77dd } },
11178 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3b),
11179 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1),
11180 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11183 		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
11184 		{ {0x40, 0xffffffff } },
11189 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
11190 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1),
11191 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11194 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11195 		{ {0x3f, 0 }, },
11200 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
11201 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3f),
11202 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11205 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11206 		{ {0x3f, 0 } },
11211 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x20),
11212 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11216 			[0x1c] = 0xaa, [0x1d] = 0x55,
11217 			[0x1e] = 0xbb, [0x1f] = 0x66,
11218 			[0x20] = 0xcc, [0x21] = 0x77,
11219 			[0x22] = 0xdd, [0x23] = 0x88,
11220 			[0x24] = 0xee, [0x25] = 0x99,
11221 			[0x26] = 0xff, [0x27] = 0xaa,
11223 		{ {0x40, 0xcc } },
11228 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f),
11229 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11232 		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
11233 		{ {0x40, 0xff } },
11238 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f),
11239 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11242 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11243 		{ {0x3f, 0 }, },
11249 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11257 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
11258 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11261 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11262 		{ {0x40, 0x82 }, },
11267 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
11268 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11271 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11272 		{ {0x3f, 0 }, },
11277 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3c),
11278 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3d),
11279 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3e),
11280 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
11281 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11284 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11285 		{ {0x40, 0x82 }, },
11290 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x22),
11291 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11295 			[0x1c] = 0xaa, [0x1d] = 0x55,
11296 			[0x1e] = 0xbb, [0x1f] = 0x66,
11297 			[0x20] = 0xcc, [0x21] = 0x77,
11298 			[0x22] = 0xdd, [0x23] = 0x88,
11299 			[0x24] = 0xee, [0x25] = 0x99,
11300 			[0x26] = 0xff, [0x27] = 0xaa,
11302 		{ {0x40, 0xdd88 } },
11307 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x25),
11308 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11312 			[0x1c] = 0xaa, [0x1d] = 0x55,
11313 			[0x1e] = 0xbb, [0x1f] = 0x66,
11314 			[0x20] = 0xcc, [0x21] = 0x77,
11315 			[0x22] = 0xdd, [0x23] = 0x88,
11316 			[0x24] = 0xee, [0x25] = 0x99,
11317 			[0x26] = 0xff, [0x27] = 0xaa,
11319 		{ {0x40, 0x99ff } },
11324 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3e),
11325 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11328 		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
11329 		{ {0x40, 0xffff } },
11334 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f),
11335 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11338 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11339 		{ {0x3f, 0 }, },
11345 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11353 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e),
11354 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11357 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11358 		{ {0x40, 0x1982 }, },
11363 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e),
11364 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11367 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11368 		{ {0x3f, 0 }, },
11373 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x1c),
11374 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11378 			[0x1c] = 0xaa, [0x1d] = 0x55,
11379 			[0x1e] = 0xbb, [0x1f] = 0x66,
11380 			[0x20] = 0xcc, [0x21] = 0x77,
11381 			[0x22] = 0xdd, [0x23] = 0x88,
11382 			[0x24] = 0xee, [0x25] = 0x99,
11383 			[0x26] = 0xff, [0x27] = 0xaa,
11385 		{ {0x40, 0xaa55bb66 } },
11390 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x22),
11391 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11395 			[0x1c] = 0xaa, [0x1d] = 0x55,
11396 			[0x1e] = 0xbb, [0x1f] = 0x66,
11397 			[0x20] = 0xcc, [0x21] = 0x77,
11398 			[0x22] = 0xdd, [0x23] = 0x88,
11399 			[0x24] = 0xee, [0x25] = 0x99,
11400 			[0x26] = 0xff, [0x27] = 0xaa,
11402 		{ {0x40, 0xdd88ee99 } },
11407 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x21),
11408 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11412 			[0x1c] = 0xaa, [0x1d] = 0x55,
11413 			[0x1e] = 0xbb, [0x1f] = 0x66,
11414 			[0x20] = 0xcc, [0x21] = 0x77,
11415 			[0x22] = 0xdd, [0x23] = 0x88,
11416 			[0x24] = 0xee, [0x25] = 0x99,
11417 			[0x26] = 0xff, [0x27] = 0xaa,
11419 		{ {0x40, 0x77dd88ee } },
11424 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x23),
11425 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11429 			[0x1c] = 0xaa, [0x1d] = 0x55,
11430 			[0x1e] = 0xbb, [0x1f] = 0x66,
11431 			[0x20] = 0xcc, [0x21] = 0x77,
11432 			[0x22] = 0xdd, [0x23] = 0x88,
11433 			[0x24] = 0xee, [0x25] = 0x99,
11434 			[0x26] = 0xff, [0x27] = 0xaa,
11436 		{ {0x40, 0x88ee99ff } },
11441 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3c),
11442 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11445 		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
11446 		{ {0x40, 0xffffffff } },
11451 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3f),
11452 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11455 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11456 		{ {0x3f, 0 }, },
11462 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11470 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c),
11471 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11474 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11475 		{ {0x40, 0x25051982 }, },
11480 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c),
11481 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11484 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11485 		{ {0x3f, 0 }, },
11490 			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
11491 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
11492 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11495 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11496 		{ {0x40, 0xffeebbaa }, },
11501 			BPF_STMT(BPF_LD | BPF_IMM, 0x175e9d63),
11502 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
11503 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3d),
11504 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e),
11505 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3f),
11506 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11509 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11510 		{ {0x40, 0x175e9d63 }, },
11515 			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
11516 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
11517 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
11518 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11521 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11522 		{ {0x40, 0x14 }, },
11527 			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
11528 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e),
11529 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
11530 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11533 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11534 		{ {0x40, 0x24 }, },
11539 			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
11541 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
11542 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11545 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11546 		{ {0x40, 0 }, },
11551 			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
11552 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, SKF_LL_OFF + 0x3e),
11553 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
11554 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11557 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11558 		{ {0x40, 0x24 }, },
11563 			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
11564 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x40),
11565 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
11566 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11569 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11570 		{ {0x40, 0 }, },
11574 	 * to 0.
11580 			 * A = 0x42
11584 			BPF_STMT(BPF_LD | BPF_IMM, 0x42),
11585 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
11586 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11590 		{ {0x1, 0x42 } },
11596 			 * A = A + 0x42
11599 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0x42),
11600 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11604 		{ {0x1, 0x42 } },
11610 			 * A = 0x66
11614 			BPF_STMT(BPF_LD | BPF_IMM, 0x66),
11615 			BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
11616 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11620 		{ {0x1, 0x66 } },
11626 			 * A = A - -0x66
11629 			BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, -0x66),
11630 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11634 		{ {0x1, 0x66 } },
11640 			 * A = 0x42
11644 			BPF_STMT(BPF_LD | BPF_IMM, 0x42),
11645 			BPF_STMT(BPF_ALU | BPF_MUL | BPF_X, 0),
11646 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11650 		{ {0x1, 0x0 } },
11656 			 * A = A * 0x66
11659 			BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 0x66),
11660 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11664 		{ {0x1, 0x0 } },
11670 			 * A = 0x42
11671 			 * A = A / X ; this halt the filter execution if X is 0
11672 			 * ret 0x42
11674 			BPF_STMT(BPF_LD | BPF_IMM, 0x42),
11675 			BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
11676 			BPF_STMT(BPF_RET | BPF_K, 0x42),
11680 		{ {0x1, 0x0 } },
11689 			BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x1),
11690 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11694 		{ {0x1, 0x0 } },
11700 			 * A = 0x42
11701 			 * A = A mod X ; this halt the filter execution if X is 0
11702 			 * ret 0x42
11704 			BPF_STMT(BPF_LD | BPF_IMM, 0x42),
11705 			BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
11706 			BPF_STMT(BPF_RET | BPF_K, 0x42),
11710 		{ {0x1, 0x0 } },
11719 			BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x1),
11720 			BPF_STMT(BPF_RET | BPF_A, 0x0),
11724 		{ {0x1, 0x0 } },
11730 			 * cmp A, 0x0, 0, 1
11731 			 * ret 0x42
11732 			 * ret 0x66
11734 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0, 0, 1),
11735 			BPF_STMT(BPF_RET | BPF_K, 0x42),
11736 			BPF_STMT(BPF_RET | BPF_K, 0x66),
11740 		{ {0x1, 0x42 } },
11746 			 * A = 0x0
11747 			 * cmp A, X, 0, 1
11748 			 * ret 0x42
11749 			 * ret 0x66
11751 			BPF_STMT(BPF_LD | BPF_IMM, 0x0),
11752 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0x0, 0, 1),
11753 			BPF_STMT(BPF_RET | BPF_K, 0x42),
11754 			BPF_STMT(BPF_RET | BPF_K, 0x66),
11758 		{ {0x1, 0x42 } },
11764 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
11765 			BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
11775 		{ { 0, 1 } },
11780 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
11781 			BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
11785 			BPF_JMP_IMM(BPF_JNE, R2, 0xfefb0000, 1),
11791 		{ { 0, 1 } },
11796 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
11797 			BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
11798 			BPF_ALU32_IMM(BPF_MOV, R4, 0xfefb0000),
11808 		{ { 0, 2 } },
11821 		{ { 0, 2 } },
11826 			BPF_LD_IMM64(R1, 0xfefb0000),
11828 			BPF_JMP_IMM(BPF_JNE, R1, 0xfefb0000, 1),
11834 		{ { 0, 1 } },
11839 			BPF_LD_IMM64(R1, 0x7efb0000),
11841 			BPF_JMP_IMM(BPF_JNE, R1, 0x7efb0000, 1),
11847 		{ { 0, 2 } },
11852 			BPF_STMT(BPF_LD | BPF_IMM, 0xffff0000),
11853 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
11854 			BPF_STMT(BPF_LD | BPF_IMM, 0xfefbbc12),
11855 			BPF_STMT(BPF_ALU | BPF_AND | BPF_X, 0),
11856 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0xfefb0000, 1, 0),
11862 		{ { 0, 2 } },
11875 		{ { 0, 123 } },
11888 		{ { 0, 12345 } },
11901 		{ { 0, 123456789 } },
11907 			BPF_LD_IMM64(R1, 0x123456789abcdefULL),
11919 		{ { 0, 0 } },
11965 		{ { 0, 1 } }					\
12064 			BPF_ALU64_IMM(BPF_MOV, R0, 0),		\
12075 				   (op) == BPF_CMPXCHG ? 0 :	\
12076 				   (op) & BPF_FETCH ? 1 : 0),	\
12078 			BPF_JMP_IMM(BPF_JNE, R0, 0, 10),	\
12093 		{ { 0, 1 } },					\
12124 			BPF_LD_IMM64(R1, 0x0123456789acbdefULL),\
12125 			BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),\
12136 		{ { 0, 0 } },					\
12153 			BPF_LD_IMM64(R0, 0x0123456789acbdefULL),	\
12155 			BPF_ST_MEM(BPF_W, R10, -4, 0),			\
12165 		{ { 0, 0 } },						\
12177 			BPF_LD_IMM64(R1, 0x0123456789acbdefULL),
12179 			BPF_ALU64_REG(BPF_MOV, R0, 0),
12180 			BPF_ST_MEM(BPF_W, R10, -4, 0),
12191 		{ { 0, 0 } },
12199 			BPF_LD_IMM64(R0, 0x0123456789acbdefULL),\
12202 			BPF_JMP_A(0), /* Nop */			\
12211 		{ { 0, 0 } },					\
12230 			BPF_LD_IMM64(R0, 0x0123456789acbdefULL),\
12231 			BPF_LD_IMM64(R1, 0xfedcba9876543210ULL),\
12235 			BPF_JMP_A(0), /* Nop */			\
12246 		{ { 0, 0 } },					\
12266 		{ { 0, 1 } },
12274 		{ { 0, 1 } },
12282 		{ { 0, 1 } },
12290 		{ { 0, 1 } },
12298 		{ { 0, 1 } },
12306 		{ { 0, 1 } },
12314 		{ { 0, 1 } },
12322 		{ { 0, 1 } },
12330 		{ { 0, 1 } },
12338 		{ { 0, 1 } },
12346 		{ { 0, 1 } },
12354 		{ { 0, 1 } },
12363 		{ { 0, 1 } },
12371 		{ { 0, 1 } },
12379 		{ { 0, 1 } },
12387 		{ { 0, 1 } },
12395 		{ { 0, 1 } },
12403 		{ { 0, 1 } },
12411 		{ { 0, 1 } },
12419 		{ { 0, 1 } },
12427 		{ { 0, 1 } },
12435 		{ { 0, 1 } },
12443 		{ { 0, 1 } },
12451 		{ { 0, 1 } },
12460 		{ { 0, 1 } },
12468 		{ { 0, 1 } },
12476 		{ { 0, 1 } },
12484 		{ { 0, 1 } },
12492 		{ { 0, 1 } },
12500 		{ { 0, 1 } },
12508 		{ { 0, 1 } },
12516 		{ { 0, 1 } },
12524 		{ { 0, 1 } },
12532 		{ { 0, 1 } },
12540 		{ { 0, 1 } },
12548 		{ { 0, 1 } },
12557 		{ { 0, 1 } },
12565 		{ { 0, 1 } },
12573 		{ { 0, 1 } },
12581 		{ { 0, 1 } },
12589 		{ { 0, 1 } },
12597 		{ { 0, 1 } },
12605 		{ { 0, 1 } },
12613 		{ { 0, 1 } },
12621 		{ { 0, 1 } },
12629 		{ { 0, 1 } },
12637 		{ { 0, 1 } },
12645 		{ { 0, 1 } },
12654 		{ { 0, 1 } },
12662 		{ { 0, 1 } },
12670 		{ { 0, 1 } },
12678 		{ { 0, 1 } },
12686 		{ { 0, 1 } },
12694 		{ { 0, 1 } },
12703 		{ { 0, 1 } },
12711 		{ { 0, 1 } },
12719 		{ { 0, 1 } },
12727 		{ { 0, 1 } },
12735 		{ { 0, 1 } },
12743 		{ { 0, 1 } },
12755 		{ { 0, 1 } },
12763 		{ { 0, 1 } },
12771 		{ { 0, 1 } },
12783 		{ { 0, 1 } },
12791 		{ { 0, 1 } },
12799 		{ { 0, 1 } },
12808 		{ { 0, 1 } },
12817 		{ { 0, 1 } },
12826 		{ { 0, 1 } },
12835 		{ { 0, 1 } },
12844 		{ { 0, 1 } },
12853 		{ { 0, 1 } },
12862 		{ { 0, 1 } },
12871 		{ { 0, 1 } },
12880 		{ { 0, 1 } },
12890 		{ { 0, 1 } },
12899 		{ { 0, 1 } },
12908 		{ { 0, 1 } },
12917 		{ { 0, 1 } },
12926 		{ { 0, 1 } },
12935 		{ { 0, 1 } },
12944 		{ { 0, 1 } },
12953 		{ { 0, 1 } },
12962 		{ { 0, 1 } },
12972 		{ { 0, 1 } },
12981 		{ { 0, 1 } },
12990 		{ { 0, 1 } },
12999 		{ { 0, 1 } },
13008 		{ { 0, 1 } },
13017 		{ { 0, 1 } },
13026 		{ { 0, 1 } },
13035 		{ { 0, 1 } },
13044 		{ { 0, 1 } },
13054 		{ { 0, 1 } },
13063 		{ { 0, 1 } },
13072 		{ { 0, 1 } },
13081 		{ { 0, 1 } },
13090 		{ { 0, 1 } },
13099 		{ { 0, 1 } },
13108 		{ { 0, 1 } },
13117 		{ { 0, 1 } },
13126 		{ { 0, 1 } },
13136 		{ { 0, 1 } },
13144 		{ { 0, 1 } },
13152 		{ { 0, 1 } },
13160 		{ { 0, 1 } },
13168 		{ { 0, 1 } },
13177 		{ { 0, 1 } },
13186 		{ { 0, 1 } },
13195 		{ { 0, 1 } },
13204 		{ { 0, 1 } },
13213 		{ { 0, 1 } },
13222 		{ { 0, 1 } },
13231 		{ { 0, 1 } },
13240 		{ { 0, 1 } },
13249 		{ { 0, 1 } },
13258 		{ { 0, 1 } },
13268 		{ { 0, 1 } },
13277 		{ { 0, 1 } },
13286 		{ { 0, 1 } },
13295 		{ { 0, 1 } },
13304 		{ { 0, 1 } },
13313 		{ { 0, 1 } },
13322 		{ { 0, 1 } },
13331 		{ { 0, 1 } },
13340 		{ { 0, 1 } },
13349 		{ { 0, 1 } },
13359 		{ { 0, 1 } },
13369 		{ { 0, 1 } },
13379 		{ { 0, 1 } },
13389 		{ { 0, 1 } },
13399 		{ { 0, 1 } },
13409 		{ { 0, 1 } },
13419 		{ { 0, 1 } },
13429 		{ { 0, 1 } },
13439 		{ { 0, 1 } },
13449 		{ { 0, 1 } },
13460 		{ { 0, 1 } },
13470 		{ { 0, 1 } },
13480 		{ { 0, 1 } },
13490 		{ { 0, 1 } },
13500 		{ { 0, 1 } },
13510 		{ { 0, 1 } },
13520 		{ { 0, 1 } },
13530 		{ { 0, 1 } },
13540 		{ { 0, 1 } },
13550 		{ { 0, 1 } },
13561 		{ { 0, 1 } },
13570 		{ { 0, 1 } },
13579 		{ { 0, 1 } },
13588 		{ { 0, 1 } },
13597 		{ { 0, 1 } },
13606 		{ { 0, 1 } },
13615 		{ { 0, 1 } },
13624 		{ { 0, 1 } },
13633 		{ { 0, 1 } },
13642 		{ { 0, 1 } },
13651 		{ { 0, 1 } },
13661 		{ { 0, 1 } },
13670 		{ { 0, 1 } },
13679 		{ { 0, 1 } },
13688 		{ { 0, 1 } },
13697 		{ { 0, 1 } },
13706 		{ { 0, 1 } },
13715 		{ { 0, 1 } },
13724 		{ { 0, 1 } },
13733 		{ { 0, 1 } },
13742 		{ { 0, 1 } },
13751 		{ { 0, 1 } },
13761 		{ { 0, 1 } },
13770 		{ { 0, 1 } },
13779 		{ { 0, 1 } },
13788 		{ { 0, 1 } },
13797 		{ { 0, 1 } },
13806 		{ { 0, 1 } },
13815 		{ { 0, 1 } },
13824 		{ { 0, 1 } },
13833 		{ { 0, 1 } },
13842 		{ { 0, 1 } },
13851 		{ { 0, 1 } },
13861 		{ { 0, 1 } },
13870 		{ { 0, 1 } },
13879 		{ { 0, 1 } },
13888 		{ { 0, 1 } },
13897 		{ { 0, 1 } },
13906 		{ { 0, 1 } },
13915 		{ { 0, 1 } },
13924 		{ { 0, 1 } },
13933 		{ { 0, 1 } },
13942 		{ { 0, 1 } },
13951 		{ { 0, 1 } },
13957 		"JMP_JSET_K: imm = 0 -> never taken",
13960 			BPF_JMP_IMM(BPF_JSET, R1, 0, 1),
13961 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13966 		{ { 0, 0 } },
13969 		"JMP_JLT_K: imm = 0 -> never taken",
13972 			BPF_JMP_IMM(BPF_JLT, R1, 0, 1),
13973 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13978 		{ { 0, 0 } },
13981 		"JMP_JGE_K: imm = 0 -> always taken",
13984 			BPF_JMP_IMM(BPF_JGE, R1, 0, 1),
13985 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13990 		{ { 0, 1 } },
13993 		"JMP_JGT_K: imm = 0xffffffff -> never taken",
13997 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14002 		{ { 0, 0 } },
14005 		"JMP_JLE_K: imm = 0xffffffff -> always taken",
14009 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14014 		{ { 0, 1 } },
14017 		"JMP32_JSGT_K: imm = 0x7fffffff -> never taken",
14021 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14026 		{ { 0, 0 } },
14029 		"JMP32_JSGE_K: imm = -0x80000000 -> always taken",
14033 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14038 		{ { 0, 1 } },
14041 		"JMP32_JSLT_K: imm = -0x80000000 -> never taken",
14045 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14050 		{ { 0, 0 } },
14053 		"JMP32_JSLE_K: imm = 0x7fffffff -> always taken",
14057 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14062 		{ { 0, 1 } },
14069 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14074 		{ { 0, 1 } },
14081 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14086 		{ { 0, 1 } },
14093 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14098 		{ { 0, 1 } },
14105 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14110 		{ { 0, 1 } },
14117 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14122 		{ { 0, 1 } },
14129 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14134 		{ { 0, 0 } },
14141 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14146 		{ { 0, 0 } },
14153 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14158 		{ { 0, 0 } },
14165 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14170 		{ { 0, 0 } },
14177 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14182 		{ { 0, 0 } },
14186 		"Short relative jump: offset=0",
14188 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14189 			BPF_JMP_IMM(BPF_JEQ, R0, 0, 0),
14195 		{ { 0, 0 } },
14200 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14201 			BPF_JMP_IMM(BPF_JEQ, R0, 0, 1),
14208 		{ { 0, 0 } },
14213 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14214 			BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
14222 		{ { 0, 0 } },
14227 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14228 			BPF_JMP_IMM(BPF_JEQ, R0, 0, 3),
14237 		{ { 0, 0 } },
14242 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
14243 			BPF_JMP_IMM(BPF_JEQ, R0, 0, 4),
14253 		{ { 0, 0 } },
14261 		{ { 0, 1 } },
14269 		{ { 0, 2 } },
14277 		{ { 0, 1 } },
14285 		{ { 0, 2 } },
14293 		{ { 0, 1 } },
14301 		{ { 0, 2 } },
14309 		{ { 0, 1 } },
14317 		{ { 0, 2 } },
14326 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14335 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14344 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14353 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14362 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14371 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14380 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14389 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14398 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14407 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14416 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14425 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14435 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14444 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14453 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14462 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14471 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14480 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14489 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14498 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14507 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14516 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14525 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14535 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14544 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14553 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14562 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14571 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14580 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14589 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14598 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14607 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14616 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14625 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14635 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14644 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14653 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14662 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14671 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14680 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14689 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14698 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14707 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14716 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14725 		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14794 		skb_add_rx_frag(skb, 0, page, 0, MAX_DATA, MAX_DATA);  in generate_test_data()
14823 	for (len = MAX_INSNS - 1; len > 0; --len)  in filter_length()
14824 		if (fp[len].code != 0 || fp[len].k != 0)  in filter_length()
14856 				*err = 0;  in generate_filter()
14875 		fp = bpf_prog_alloc(bpf_prog_size(flen), 0);  in generate_filter()
14901 	*err = 0;  in generate_filter()
14923 	int ret = 0, i;  in __run_one()
14928 	for (i = 0; i < runs; i++)  in __run_one()
14942 	int err_cnt = 0, i, runs = MAX_TESTRUNS;  in run_one()
14947 	for (i = 0; i < MAX_SUBTESTS; i++) {  in run_one()
14958 		if (i > 0 &&  in run_one()
14959 		    test->test[i].data_size == 0 &&  in run_one()
14960 		    test->test[i].result == 0)  in run_one()
14987 module_param_string(test_name, test_name, sizeof(test_name), 0);
14990 module_param(test_id, int, 0);
14992 static int test_range[2] = { 0, INT_MAX };
14993 module_param_array(test_range, int, NULL, 0);
14997 	return test_id < test_range[0] || test_id > test_range[1];  in exclude_test()
15007 	for (i = 0; i < 2; i++) {  in build_test_skb()
15010 			if (i == 0)  in build_test_skb()
15019 			if (i == 0)  in build_test_skb()
15031 		skb_add_rx_frag(skb[i], 0, page[i], 0, 64, 64);  in build_test_skb()
15036 	skb_shinfo(skb[0])->gso_size = 1448;  in build_test_skb()
15037 	skb_shinfo(skb[0])->gso_type = SKB_GSO_TCPV4;  in build_test_skb()
15038 	skb_shinfo(skb[0])->gso_type |= SKB_GSO_DODGY;  in build_test_skb()
15039 	skb_shinfo(skb[0])->gso_segs = 0;  in build_test_skb()
15040 	skb_shinfo(skb[0])->frag_list = skb[1];  in build_test_skb()
15041 	skb_shinfo(skb[0])->hwtstamps.hwtstamp = 1000;  in build_test_skb()
15043 	/* adjust skb[0]'s len */  in build_test_skb()
15044 	skb[0]->len += skb[1]->len;  in build_test_skb()
15045 	skb[0]->data_len += skb[1]->data_len;  in build_test_skb()
15046 	skb[0]->truesize += skb[1]->truesize;  in build_test_skb()
15048 	return skb[0];  in build_test_skb()
15053 	kfree_skb(skb[0]);  in build_test_skb()
15055 	__free_page(page[0]);  in build_test_skb()
15067 	/* skbs linked in a frag_list, both with linear data, with head_frag=0  in build_test_skb_linear_no_head_frag()
15072 	for (i = 0; i < 2; i++) {  in build_test_skb_linear_no_head_frag()
15075 			if (i == 0)  in build_test_skb_linear_no_head_frag()
15085 		if (i == 0)  in build_test_skb_linear_no_head_frag()
15096 	skb_shinfo(skb[0])->gso_size = 1288;  in build_test_skb_linear_no_head_frag()
15097 	skb_shinfo(skb[0])->gso_type = SKB_GSO_TCPV6 | SKB_GSO_DODGY;  in build_test_skb_linear_no_head_frag()
15098 	skb_shinfo(skb[0])->gso_segs = 0;  in build_test_skb_linear_no_head_frag()
15099 	skb_shinfo(skb[0])->frag_list = skb[1];  in build_test_skb_linear_no_head_frag()
15101 	/* adjust skb[0]'s len */  in build_test_skb_linear_no_head_frag()
15102 	skb[0]->len += skb[1]->len;  in build_test_skb_linear_no_head_frag()
15103 	skb[0]->data_len += skb[1]->len;  in build_test_skb_linear_no_head_frag()
15104 	skb[0]->truesize += skb[1]->truesize;  in build_test_skb_linear_no_head_frag()
15106 	return skb[0];  in build_test_skb_linear_no_head_frag()
15109 	kfree_skb(skb[0]);  in build_test_skb_linear_no_head_frag()
15151 		ret = 0;  in test_skb_segment_single()
15160 	int i, err_cnt = 0, pass_cnt = 0;  in test_skb_segment()
15162 	for (i = 0; i < ARRAY_SIZE(skb_segment_tests); i++) {  in test_skb_segment()
15182 	return err_cnt ? -EINVAL : 0;  in test_skb_segment()
15187 	int i, err_cnt = 0, pass_cnt = 0;  in test_bpf()
15188 	int jit_cnt = 0, run_cnt = 0;  in test_bpf()
15190 	for (i = 0; i < ARRAY_SIZE(tests); i++) {  in test_bpf()
15201 		    tests[i].fill_helper(&tests[i]) < 0) {  in test_bpf()
15214 			if (err == 0) {  in test_bpf()
15243 	return err_cnt ? -EINVAL : 0;  in test_bpf()
15256 #define FLAG_NEED_STATE		BIT(0)
15264 #define TAIL_CALL_MARKER 0x7a11ca11
15267 #define TAIL_CALL_NULL 0x7fff
15270 #define TAIL_CALL_INVALID 0x7ffe
15274 	BPF_RAW_INSN(BPF_ALU | BPF_MOV | BPF_K, R3, 0, \
15276 	BPF_JMP_IMM(BPF_TAIL_CALL, 0, 0, 0)
15287 	long a = 0;  in BPF_CALL_1()
15364 			BPF_ALU64_IMM(BPF_MOV, R0, 0),
15367 		.result = 0,
15379 		.result = 0,
15386 			BPF_LDX_MEM(BPF_W, R2, R1, 0),
15388 			BPF_STX_MEM(BPF_W, R1, R2, 0),
15389 			TAIL_CALL(0),
15399 			BPF_LDX_MEM(BPF_W, R2, R1, 0),
15401 			BPF_STX_MEM(BPF_W, R1, R2, 0),
15411 			TAIL_CALL(0),
15422 			BPF_LDX_MEM(BPF_W, R2, R1, 0),
15424 			BPF_STX_MEM(BPF_W, R1, R2, 0),
15435 			BPF_LDX_MEM(BPF_W, R2, R1, 0),
15437 			BPF_STX_MEM(BPF_W, R1, R2, 0),
15451 	for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++)  in destroy_tail_call_tests()
15469 	for (which = 0; which < ntests; which++) {  in prepare_tail_call_tests()
15475 		for (len = 0; len < MAX_INSNS; len++) {  in prepare_tail_call_tests()
15481 			if (insn->code == 0)  in prepare_tail_call_tests()
15486 		fp = bpf_prog_alloc(bpf_prog_size(len), 0);  in prepare_tail_call_tests()
15497 		for (i = 0; i < len; i++) {  in prepare_tail_call_tests()
15499 			long addr = 0;  in prepare_tail_call_tests()
15505 				insn[0].imm = (u32)(long)progs;  in prepare_tail_call_tests()
15518 				insn->off = 0;  in prepare_tail_call_tests()
15549 					*insn = BPF_JMP_A(0); /* Skip: NOP */  in prepare_tail_call_tests()
15564 	return 0;  in prepare_tail_call_tests()
15577 	int i, err_cnt = 0, pass_cnt = 0;  in test_tail_calls()
15578 	int jit_cnt = 0, run_cnt = 0;  in test_tail_calls()
15580 	for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++) {  in test_tail_calls()
15584 		int state = 0;  in test_tail_calls()
15620 	return err_cnt ? -EINVAL : 0;  in test_tail_calls()
15624 module_param_string(test_suite, test_suite, sizeof(test_suite), 0);
15631 		for (i = 0; i < ARRAY_SIZE(tests); i++) {  in find_test_index()
15638 		for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++) {  in find_test_index()
15645 		for (i = 0; i < ARRAY_SIZE(skb_segment_tests); i++) {  in find_test_index()
15665 		return 0;  in prepare_test_range()
15667 	if (test_id >= 0) {  in prepare_test_range()
15678 		test_range[0] = test_id;  in prepare_test_range()
15687 		if (idx < 0) {  in prepare_test_range()
15692 		test_range[0] = idx;  in prepare_test_range()
15694 	} else if (test_range[0] != 0 || test_range[1] != INT_MAX) {  in prepare_test_range()
15698 		if (test_range[0] < 0 || test_range[1] >= valid_range) {  in prepare_test_range()
15704 		if (test_range[1] < test_range[0]) {  in prepare_test_range()
15710 	return 0;  in prepare_test_range()
15732 	    (test_range[0] != 0 || test_range[1] != INT_MAX))) {  in test_bpf_init()
15738 	if (ret < 0)  in test_bpf_init()
15760 	return 0;  in test_bpf_init()