xref: /linux/lib/test_bpf.c (revision b73119222f2dd6b1c294cc6ef4b1fb7f9ff3adf5) 
1  // SPDX-License-Identifier: GPL-2.0-only
2  /*
3   * Testsuite for BPF interpreter and BPF JIT compiler
4   *
5   * Copyright (c) 2011-2014 PLUMgrid, http://plumgrid.com
6   */
7  
8  #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
9  
10  #include <linux/init.h>
11  #include <linux/module.h>
12  #include <linux/filter.h>
13  #include <linux/bpf.h>
14  #include <linux/skbuff.h>
15  #include <linux/netdevice.h>
16  #include <linux/if_vlan.h>
17  #include <linux/random.h>
18  #include <linux/highmem.h>
19  #include <linux/sched.h>
20  
21  /* General test specific settings */
22  #define MAX_SUBTESTS	3
23  #define MAX_TESTRUNS	1000
24  #define MAX_DATA	128
25  #define MAX_INSNS	512
26  #define MAX_K		0xffffFFFF
27  
28  /* Few constants used to init test 'skb' */
29  #define SKB_TYPE	3
30  #define SKB_MARK	0x1234aaaa
31  #define SKB_HASH	0x1234aaab
32  #define SKB_QUEUE_MAP	123
33  #define SKB_VLAN_TCI	0xffff
34  #define SKB_VLAN_PRESENT	1
35  #define SKB_DEV_IFINDEX	577
36  #define SKB_DEV_TYPE	588
37  
38  /* Redefine REGs to make tests less verbose */
39  #define R0		BPF_REG_0
40  #define R1		BPF_REG_1
41  #define R2		BPF_REG_2
42  #define R3		BPF_REG_3
43  #define R4		BPF_REG_4
44  #define R5		BPF_REG_5
45  #define R6		BPF_REG_6
46  #define R7		BPF_REG_7
47  #define R8		BPF_REG_8
48  #define R9		BPF_REG_9
49  #define R10		BPF_REG_10
50  
51  /* Flags that can be passed to test cases */
52  #define FLAG_NO_DATA		BIT(0)
53  #define FLAG_EXPECTED_FAIL	BIT(1)
54  #define FLAG_SKB_FRAG		BIT(2)
55  #define FLAG_VERIFIER_ZEXT	BIT(3)
56  
57  enum {
58  	CLASSIC  = BIT(6),	/* Old BPF instructions only. */
59  	INTERNAL = BIT(7),	/* Extended instruction set.  */
60  };
61  
62  #define TEST_TYPE_MASK		(CLASSIC | INTERNAL)
63  
64  struct bpf_test {
65  	const char *descr;
66  	union {
67  		struct sock_filter insns[MAX_INSNS];
68  		struct bpf_insn insns_int[MAX_INSNS];
69  		struct {
70  			void *insns;
71  			unsigned int len;
72  		} ptr;
73  	} u;
74  	__u8 aux;
75  	__u8 data[MAX_DATA];
76  	struct {
77  		int data_size;
78  		__u32 result;
79  	} test[MAX_SUBTESTS];
80  	int (*fill_helper)(struct bpf_test *self);
81  	int expected_errcode; /* used when FLAG_EXPECTED_FAIL is set in the aux */
82  	__u8 frag_data[MAX_DATA];
83  	int stack_depth; /* for eBPF only, since tests don't call verifier */
84  	int nr_testruns; /* Custom run count, defaults to MAX_TESTRUNS if 0 */
85  };
86  
87  /* Large test cases need separate allocation and fill handler. */
88  
89  static int bpf_fill_maxinsns1(struct bpf_test *self)
90  {
91  	unsigned int len = BPF_MAXINSNS;
92  	struct sock_filter *insn;
93  	__u32 k = ~0;
94  	int i;
95  
96  	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
97  	if (!insn)
98  		return -ENOMEM;
99  
100  	for (i = 0; i < len; i++, k--)
101  		insn[i] = __BPF_STMT(BPF_RET | BPF_K, k);
102  
103  	self->u.ptr.insns = insn;
104  	self->u.ptr.len = len;
105  
106  	return 0;
107  }
108  
109  static int bpf_fill_maxinsns2(struct bpf_test *self)
110  {
111  	unsigned int len = BPF_MAXINSNS;
112  	struct sock_filter *insn;
113  	int i;
114  
115  	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
116  	if (!insn)
117  		return -ENOMEM;
118  
119  	for (i = 0; i < len; i++)
120  		insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
121  
122  	self->u.ptr.insns = insn;
123  	self->u.ptr.len = len;
124  
125  	return 0;
126  }
127  
128  static int bpf_fill_maxinsns3(struct bpf_test *self)
129  {
130  	unsigned int len = BPF_MAXINSNS;
131  	struct sock_filter *insn;
132  	struct rnd_state rnd;
133  	int i;
134  
135  	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
136  	if (!insn)
137  		return -ENOMEM;
138  
139  	prandom_seed_state(&rnd, 3141592653589793238ULL);
140  
141  	for (i = 0; i < len - 1; i++) {
142  		__u32 k = prandom_u32_state(&rnd);
143  
144  		insn[i] = __BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, k);
145  	}
146  
147  	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
148  
149  	self->u.ptr.insns = insn;
150  	self->u.ptr.len = len;
151  
152  	return 0;
153  }
154  
155  static int bpf_fill_maxinsns4(struct bpf_test *self)
156  {
157  	unsigned int len = BPF_MAXINSNS + 1;
158  	struct sock_filter *insn;
159  	int i;
160  
161  	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
162  	if (!insn)
163  		return -ENOMEM;
164  
165  	for (i = 0; i < len; i++)
166  		insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
167  
168  	self->u.ptr.insns = insn;
169  	self->u.ptr.len = len;
170  
171  	return 0;
172  }
173  
174  static int bpf_fill_maxinsns5(struct bpf_test *self)
175  {
176  	unsigned int len = BPF_MAXINSNS;
177  	struct sock_filter *insn;
178  	int i;
179  
180  	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
181  	if (!insn)
182  		return -ENOMEM;
183  
184  	insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0);
185  
186  	for (i = 1; i < len - 1; i++)
187  		insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
188  
189  	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab);
190  
191  	self->u.ptr.insns = insn;
192  	self->u.ptr.len = len;
193  
194  	return 0;
195  }
196  
197  static int bpf_fill_maxinsns6(struct bpf_test *self)
198  {
199  	unsigned int len = BPF_MAXINSNS;
200  	struct sock_filter *insn;
201  	int i;
202  
203  	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
204  	if (!insn)
205  		return -ENOMEM;
206  
207  	for (i = 0; i < len - 1; i++)
208  		insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
209  				     SKF_AD_VLAN_TAG_PRESENT);
210  
211  	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
212  
213  	self->u.ptr.insns = insn;
214  	self->u.ptr.len = len;
215  
216  	return 0;
217  }
218  
219  static int bpf_fill_maxinsns7(struct bpf_test *self)
220  {
221  	unsigned int len = BPF_MAXINSNS;
222  	struct sock_filter *insn;
223  	int i;
224  
225  	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
226  	if (!insn)
227  		return -ENOMEM;
228  
229  	for (i = 0; i < len - 4; i++)
230  		insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
231  				     SKF_AD_CPU);
232  
233  	insn[len - 4] = __BPF_STMT(BPF_MISC | BPF_TAX, 0);
234  	insn[len - 3] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
235  				   SKF_AD_CPU);
236  	insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0);
237  	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
238  
239  	self->u.ptr.insns = insn;
240  	self->u.ptr.len = len;
241  
242  	return 0;
243  }
244  
245  static int bpf_fill_maxinsns8(struct bpf_test *self)
246  {
247  	unsigned int len = BPF_MAXINSNS;
248  	struct sock_filter *insn;
249  	int i, jmp_off = len - 3;
250  
251  	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
252  	if (!insn)
253  		return -ENOMEM;
254  
255  	insn[0] = __BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff);
256  
257  	for (i = 1; i < len - 1; i++)
258  		insn[i] = __BPF_JUMP(BPF_JMP | BPF_JGT, 0xffffffff, jmp_off--, 0);
259  
260  	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
261  
262  	self->u.ptr.insns = insn;
263  	self->u.ptr.len = len;
264  
265  	return 0;
266  }
267  
268  static int bpf_fill_maxinsns9(struct bpf_test *self)
269  {
270  	unsigned int len = BPF_MAXINSNS;
271  	struct bpf_insn *insn;
272  	int i;
273  
274  	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
275  	if (!insn)
276  		return -ENOMEM;
277  
278  	insn[0] = BPF_JMP_IMM(BPF_JA, 0, 0, len - 2);
279  	insn[1] = BPF_ALU32_IMM(BPF_MOV, R0, 0xcbababab);
280  	insn[2] = BPF_EXIT_INSN();
281  
282  	for (i = 3; i < len - 2; i++)
283  		insn[i] = BPF_ALU32_IMM(BPF_MOV, R0, 0xfefefefe);
284  
285  	insn[len - 2] = BPF_EXIT_INSN();
286  	insn[len - 1] = BPF_JMP_IMM(BPF_JA, 0, 0, -(len - 1));
287  
288  	self->u.ptr.insns = insn;
289  	self->u.ptr.len = len;
290  
291  	return 0;
292  }
293  
294  static int bpf_fill_maxinsns10(struct bpf_test *self)
295  {
296  	unsigned int len = BPF_MAXINSNS, hlen = len - 2;
297  	struct bpf_insn *insn;
298  	int i;
299  
300  	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
301  	if (!insn)
302  		return -ENOMEM;
303  
304  	for (i = 0; i < hlen / 2; i++)
305  		insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 2 - 2 * i);
306  	for (i = hlen - 1; i > hlen / 2; i--)
307  		insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 1 - 2 * i);
308  
309  	insn[hlen / 2] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen / 2 - 1);
310  	insn[hlen]     = BPF_ALU32_IMM(BPF_MOV, R0, 0xabababac);
311  	insn[hlen + 1] = BPF_EXIT_INSN();
312  
313  	self->u.ptr.insns = insn;
314  	self->u.ptr.len = len;
315  
316  	return 0;
317  }
318  
319  static int __bpf_fill_ja(struct bpf_test *self, unsigned int len,
320  			 unsigned int plen)
321  {
322  	struct sock_filter *insn;
323  	unsigned int rlen;
324  	int i, j;
325  
326  	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
327  	if (!insn)
328  		return -ENOMEM;
329  
330  	rlen = (len % plen) - 1;
331  
332  	for (i = 0; i + plen < len; i += plen)
333  		for (j = 0; j < plen; j++)
334  			insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA,
335  						 plen - 1 - j, 0, 0);
336  	for (j = 0; j < rlen; j++)
337  		insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA, rlen - 1 - j,
338  					 0, 0);
339  
340  	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xababcbac);
341  
342  	self->u.ptr.insns = insn;
343  	self->u.ptr.len = len;
344  
345  	return 0;
346  }
347  
348  static int bpf_fill_maxinsns11(struct bpf_test *self)
349  {
350  	/* Hits 70 passes on x86_64 and triggers NOPs padding. */
351  	return __bpf_fill_ja(self, BPF_MAXINSNS, 68);
352  }
353  
354  static int bpf_fill_maxinsns12(struct bpf_test *self)
355  {
356  	unsigned int len = BPF_MAXINSNS;
357  	struct sock_filter *insn;
358  	int i = 0;
359  
360  	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
361  	if (!insn)
362  		return -ENOMEM;
363  
364  	insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0);
365  
366  	for (i = 1; i < len - 1; i++)
367  		insn[i] = __BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0);
368  
369  	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab);
370  
371  	self->u.ptr.insns = insn;
372  	self->u.ptr.len = len;
373  
374  	return 0;
375  }
376  
377  static int bpf_fill_maxinsns13(struct bpf_test *self)
378  {
379  	unsigned int len = BPF_MAXINSNS;
380  	struct sock_filter *insn;
381  	int i = 0;
382  
383  	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
384  	if (!insn)
385  		return -ENOMEM;
386  
387  	for (i = 0; i < len - 3; i++)
388  		insn[i] = __BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0);
389  
390  	insn[len - 3] = __BPF_STMT(BPF_LD | BPF_IMM, 0xabababab);
391  	insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0);
392  	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
393  
394  	self->u.ptr.insns = insn;
395  	self->u.ptr.len = len;
396  
397  	return 0;
398  }
399  
400  static int bpf_fill_ja(struct bpf_test *self)
401  {
402  	/* Hits exactly 11 passes on x86_64 JIT. */
403  	return __bpf_fill_ja(self, 12, 9);
404  }
405  
406  static int bpf_fill_ld_abs_get_processor_id(struct bpf_test *self)
407  {
408  	unsigned int len = BPF_MAXINSNS;
409  	struct sock_filter *insn;
410  	int i;
411  
412  	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
413  	if (!insn)
414  		return -ENOMEM;
415  
416  	for (i = 0; i < len - 1; i += 2) {
417  		insn[i] = __BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 0);
418  		insn[i + 1] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
419  					 SKF_AD_OFF + SKF_AD_CPU);
420  	}
421  
422  	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xbee);
423  
424  	self->u.ptr.insns = insn;
425  	self->u.ptr.len = len;
426  
427  	return 0;
428  }
429  
430  static int __bpf_fill_stxdw(struct bpf_test *self, int size)
431  {
432  	unsigned int len = BPF_MAXINSNS;
433  	struct bpf_insn *insn;
434  	int i;
435  
436  	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
437  	if (!insn)
438  		return -ENOMEM;
439  
440  	insn[0] = BPF_ALU32_IMM(BPF_MOV, R0, 1);
441  	insn[1] = BPF_ST_MEM(size, R10, -40, 42);
442  
443  	for (i = 2; i < len - 2; i++)
444  		insn[i] = BPF_STX_XADD(size, R10, R0, -40);
445  
446  	insn[len - 2] = BPF_LDX_MEM(size, R0, R10, -40);
447  	insn[len - 1] = BPF_EXIT_INSN();
448  
449  	self->u.ptr.insns = insn;
450  	self->u.ptr.len = len;
451  	self->stack_depth = 40;
452  
453  	return 0;
454  }
455  
456  static int bpf_fill_stxw(struct bpf_test *self)
457  {
458  	return __bpf_fill_stxdw(self, BPF_W);
459  }
460  
461  static int bpf_fill_stxdw(struct bpf_test *self)
462  {
463  	return __bpf_fill_stxdw(self, BPF_DW);
464  }
465  
466  static int __bpf_ld_imm64(struct bpf_insn insns[2], u8 reg, s64 imm64)
467  {
468  	struct bpf_insn tmp[] = {BPF_LD_IMM64(reg, imm64)};
469  
470  	memcpy(insns, tmp, sizeof(tmp));
471  	return 2;
472  }
473  
474  /*
475   * Branch conversion tests. Complex operations can expand to a lot
476   * of instructions when JITed. This in turn may cause jump offsets
477   * to overflow the field size of the native instruction, triggering
478   * a branch conversion mechanism in some JITs.
479   */
480  static int __bpf_fill_max_jmp(struct bpf_test *self, int jmp, int imm)
481  {
482  	struct bpf_insn *insns;
483  	int len = S16_MAX + 5;
484  	int i;
485  
486  	insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL);
487  	if (!insns)
488  		return -ENOMEM;
489  
490  	i = __bpf_ld_imm64(insns, R1, 0x0123456789abcdefULL);
491  	insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
492  	insns[i++] = BPF_JMP_IMM(jmp, R0, imm, S16_MAX);
493  	insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 2);
494  	insns[i++] = BPF_EXIT_INSN();
495  
496  	while (i < len - 1) {
497  		static const int ops[] = {
498  			BPF_LSH, BPF_RSH, BPF_ARSH, BPF_ADD,
499  			BPF_SUB, BPF_MUL, BPF_DIV, BPF_MOD,
500  		};
501  		int op = ops[(i >> 1) % ARRAY_SIZE(ops)];
502  
503  		if (i & 1)
504  			insns[i++] = BPF_ALU32_REG(op, R0, R1);
505  		else
506  			insns[i++] = BPF_ALU64_REG(op, R0, R1);
507  	}
508  
509  	insns[i++] = BPF_EXIT_INSN();
510  	self->u.ptr.insns = insns;
511  	self->u.ptr.len = len;
512  	BUG_ON(i != len);
513  
514  	return 0;
515  }
516  
517  /* Branch taken by runtime decision */
518  static int bpf_fill_max_jmp_taken(struct bpf_test *self)
519  {
520  	return __bpf_fill_max_jmp(self, BPF_JEQ, 1);
521  }
522  
523  /* Branch not taken by runtime decision */
524  static int bpf_fill_max_jmp_not_taken(struct bpf_test *self)
525  {
526  	return __bpf_fill_max_jmp(self, BPF_JEQ, 0);
527  }
528  
529  /* Branch always taken, known at JIT time */
530  static int bpf_fill_max_jmp_always_taken(struct bpf_test *self)
531  {
532  	return __bpf_fill_max_jmp(self, BPF_JGE, 0);
533  }
534  
535  /* Branch never taken, known at JIT time */
536  static int bpf_fill_max_jmp_never_taken(struct bpf_test *self)
537  {
538  	return __bpf_fill_max_jmp(self, BPF_JLT, 0);
539  }
540  
541  /* ALU result computation used in tests */
542  static bool __bpf_alu_result(u64 *res, u64 v1, u64 v2, u8 op)
543  {
544  	*res = 0;
545  	switch (op) {
546  	case BPF_MOV:
547  		*res = v2;
548  		break;
549  	case BPF_AND:
550  		*res = v1 & v2;
551  		break;
552  	case BPF_OR:
553  		*res = v1 | v2;
554  		break;
555  	case BPF_XOR:
556  		*res = v1 ^ v2;
557  		break;
558  	case BPF_LSH:
559  		*res = v1 << v2;
560  		break;
561  	case BPF_RSH:
562  		*res = v1 >> v2;
563  		break;
564  	case BPF_ARSH:
565  		*res = v1 >> v2;
566  		if (v2 > 0 && v1 > S64_MAX)
567  			*res |= ~0ULL << (64 - v2);
568  		break;
569  	case BPF_ADD:
570  		*res = v1 + v2;
571  		break;
572  	case BPF_SUB:
573  		*res = v1 - v2;
574  		break;
575  	case BPF_MUL:
576  		*res = v1 * v2;
577  		break;
578  	case BPF_DIV:
579  		if (v2 == 0)
580  			return false;
581  		*res = div64_u64(v1, v2);
582  		break;
583  	case BPF_MOD:
584  		if (v2 == 0)
585  			return false;
586  		div64_u64_rem(v1, v2, res);
587  		break;
588  	}
589  	return true;
590  }
591  
592  /* Test an ALU shift operation for all valid shift values */
593  static int __bpf_fill_alu_shift(struct bpf_test *self, u8 op,
594  				u8 mode, bool alu32)
595  {
596  	static const s64 regs[] = {
597  		0x0123456789abcdefLL, /* dword > 0, word < 0 */
598  		0xfedcba9876543210LL, /* dowrd < 0, word > 0 */
599  		0xfedcba0198765432LL, /* dowrd < 0, word < 0 */
600  		0x0123458967abcdefLL, /* dword > 0, word > 0 */
601  	};
602  	int bits = alu32 ? 32 : 64;
603  	int len = (2 + 7 * bits) * ARRAY_SIZE(regs) + 3;
604  	struct bpf_insn *insn;
605  	int imm, k;
606  	int i = 0;
607  
608  	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
609  	if (!insn)
610  		return -ENOMEM;
611  
612  	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
613  
614  	for (k = 0; k < ARRAY_SIZE(regs); k++) {
615  		s64 reg = regs[k];
616  
617  		i += __bpf_ld_imm64(&insn[i], R3, reg);
618  
619  		for (imm = 0; imm < bits; imm++) {
620  			u64 val;
621  
622  			/* Perform operation */
623  			insn[i++] = BPF_ALU64_REG(BPF_MOV, R1, R3);
624  			insn[i++] = BPF_ALU64_IMM(BPF_MOV, R2, imm);
625  			if (alu32) {
626  				if (mode == BPF_K)
627  					insn[i++] = BPF_ALU32_IMM(op, R1, imm);
628  				else
629  					insn[i++] = BPF_ALU32_REG(op, R1, R2);
630  
631  				if (op == BPF_ARSH)
632  					reg = (s32)reg;
633  				else
634  					reg = (u32)reg;
635  				__bpf_alu_result(&val, reg, imm, op);
636  				val = (u32)val;
637  			} else {
638  				if (mode == BPF_K)
639  					insn[i++] = BPF_ALU64_IMM(op, R1, imm);
640  				else
641  					insn[i++] = BPF_ALU64_REG(op, R1, R2);
642  				__bpf_alu_result(&val, reg, imm, op);
643  			}
644  
645  			/*
646  			 * When debugging a JIT that fails this test, one
647  			 * can write the immediate value to R0 here to find
648  			 * out which operand values that fail.
649  			 */
650  
651  			/* Load reference and check the result */
652  			i += __bpf_ld_imm64(&insn[i], R4, val);
653  			insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R4, 1);
654  			insn[i++] = BPF_EXIT_INSN();
655  		}
656  	}
657  
658  	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
659  	insn[i++] = BPF_EXIT_INSN();
660  
661  	self->u.ptr.insns = insn;
662  	self->u.ptr.len = len;
663  	BUG_ON(i != len);
664  
665  	return 0;
666  }
667  
668  static int bpf_fill_alu64_lsh_imm(struct bpf_test *self)
669  {
670  	return __bpf_fill_alu_shift(self, BPF_LSH, BPF_K, false);
671  }
672  
673  static int bpf_fill_alu64_rsh_imm(struct bpf_test *self)
674  {
675  	return __bpf_fill_alu_shift(self, BPF_RSH, BPF_K, false);
676  }
677  
678  static int bpf_fill_alu64_arsh_imm(struct bpf_test *self)
679  {
680  	return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_K, false);
681  }
682  
683  static int bpf_fill_alu64_lsh_reg(struct bpf_test *self)
684  {
685  	return __bpf_fill_alu_shift(self, BPF_LSH, BPF_X, false);
686  }
687  
688  static int bpf_fill_alu64_rsh_reg(struct bpf_test *self)
689  {
690  	return __bpf_fill_alu_shift(self, BPF_RSH, BPF_X, false);
691  }
692  
693  static int bpf_fill_alu64_arsh_reg(struct bpf_test *self)
694  {
695  	return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_X, false);
696  }
697  
698  static int bpf_fill_alu32_lsh_imm(struct bpf_test *self)
699  {
700  	return __bpf_fill_alu_shift(self, BPF_LSH, BPF_K, true);
701  }
702  
703  static int bpf_fill_alu32_rsh_imm(struct bpf_test *self)
704  {
705  	return __bpf_fill_alu_shift(self, BPF_RSH, BPF_K, true);
706  }
707  
708  static int bpf_fill_alu32_arsh_imm(struct bpf_test *self)
709  {
710  	return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_K, true);
711  }
712  
713  static int bpf_fill_alu32_lsh_reg(struct bpf_test *self)
714  {
715  	return __bpf_fill_alu_shift(self, BPF_LSH, BPF_X, true);
716  }
717  
718  static int bpf_fill_alu32_rsh_reg(struct bpf_test *self)
719  {
720  	return __bpf_fill_alu_shift(self, BPF_RSH, BPF_X, true);
721  }
722  
723  static int bpf_fill_alu32_arsh_reg(struct bpf_test *self)
724  {
725  	return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_X, true);
726  }
727  
728  /*
729   * Test an ALU register shift operation for all valid shift values
730   * for the case when the source and destination are the same.
731   */
732  static int __bpf_fill_alu_shift_same_reg(struct bpf_test *self, u8 op,
733  					 bool alu32)
734  {
735  	int bits = alu32 ? 32 : 64;
736  	int len = 3 + 6 * bits;
737  	struct bpf_insn *insn;
738  	int i = 0;
739  	u64 val;
740  
741  	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
742  	if (!insn)
743  		return -ENOMEM;
744  
745  	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
746  
747  	for (val = 0; val < bits; val++) {
748  		u64 res;
749  
750  		/* Perform operation */
751  		insn[i++] = BPF_ALU64_IMM(BPF_MOV, R1, val);
752  		if (alu32)
753  			insn[i++] = BPF_ALU32_REG(op, R1, R1);
754  		else
755  			insn[i++] = BPF_ALU64_REG(op, R1, R1);
756  
757  		/* Compute the reference result */
758  		__bpf_alu_result(&res, val, val, op);
759  		if (alu32)
760  			res = (u32)res;
761  		i += __bpf_ld_imm64(&insn[i], R2, res);
762  
763  		/* Check the actual result */
764  		insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R2, 1);
765  		insn[i++] = BPF_EXIT_INSN();
766  	}
767  
768  	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
769  	insn[i++] = BPF_EXIT_INSN();
770  
771  	self->u.ptr.insns = insn;
772  	self->u.ptr.len = len;
773  	BUG_ON(i != len);
774  
775  	return 0;
776  }
777  
778  static int bpf_fill_alu64_lsh_same_reg(struct bpf_test *self)
779  {
780  	return __bpf_fill_alu_shift_same_reg(self, BPF_LSH, false);
781  }
782  
783  static int bpf_fill_alu64_rsh_same_reg(struct bpf_test *self)
784  {
785  	return __bpf_fill_alu_shift_same_reg(self, BPF_RSH, false);
786  }
787  
788  static int bpf_fill_alu64_arsh_same_reg(struct bpf_test *self)
789  {
790  	return __bpf_fill_alu_shift_same_reg(self, BPF_ARSH, false);
791  }
792  
793  static int bpf_fill_alu32_lsh_same_reg(struct bpf_test *self)
794  {
795  	return __bpf_fill_alu_shift_same_reg(self, BPF_LSH, true);
796  }
797  
798  static int bpf_fill_alu32_rsh_same_reg(struct bpf_test *self)
799  {
800  	return __bpf_fill_alu_shift_same_reg(self, BPF_RSH, true);
801  }
802  
803  static int bpf_fill_alu32_arsh_same_reg(struct bpf_test *self)
804  {
805  	return __bpf_fill_alu_shift_same_reg(self, BPF_ARSH, true);
806  }
807  
808  /*
809   * Common operand pattern generator for exhaustive power-of-two magnitudes
810   * tests. The block size parameters can be adjusted to increase/reduce the
811   * number of combinatons tested and thereby execution speed and memory
812   * footprint.
813   */
814  
815  static inline s64 value(int msb, int delta, int sign)
816  {
817  	return sign * (1LL << msb) + delta;
818  }
819  
820  static int __bpf_fill_pattern(struct bpf_test *self, void *arg,
821  			      int dbits, int sbits, int block1, int block2,
822  			      int (*emit)(struct bpf_test*, void*,
823  					  struct bpf_insn*, s64, s64))
824  {
825  	static const int sgn[][2] = {{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
826  	struct bpf_insn *insns;
827  	int di, si, bt, db, sb;
828  	int count, len, k;
829  	int extra = 1 + 2;
830  	int i = 0;
831  
832  	/* Total number of iterations for the two pattern */
833  	count = (dbits - 1) * (sbits - 1) * block1 * block1 * ARRAY_SIZE(sgn);
834  	count += (max(dbits, sbits) - 1) * block2 * block2 * ARRAY_SIZE(sgn);
835  
836  	/* Compute the maximum number of insns and allocate the buffer */
837  	len = extra + count * (*emit)(self, arg, NULL, 0, 0);
838  	insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL);
839  	if (!insns)
840  		return -ENOMEM;
841  
842  	/* Add head instruction(s) */
843  	insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
844  
845  	/*
846  	 * Pattern 1: all combinations of power-of-two magnitudes and sign,
847  	 * and with a block of contiguous values around each magnitude.
848  	 */
849  	for (di = 0; di < dbits - 1; di++)                 /* Dst magnitudes */
850  		for (si = 0; si < sbits - 1; si++)         /* Src magnitudes */
851  			for (k = 0; k < ARRAY_SIZE(sgn); k++) /* Sign combos */
852  				for (db = -(block1 / 2);
853  				     db < (block1 + 1) / 2; db++)
854  					for (sb = -(block1 / 2);
855  					     sb < (block1 + 1) / 2; sb++) {
856  						s64 dst, src;
857  
858  						dst = value(di, db, sgn[k][0]);
859  						src = value(si, sb, sgn[k][1]);
860  						i += (*emit)(self, arg,
861  							     &insns[i],
862  							     dst, src);
863  					}
864  	/*
865  	 * Pattern 2: all combinations for a larger block of values
866  	 * for each power-of-two magnitude and sign, where the magnitude is
867  	 * the same for both operands.
868  	 */
869  	for (bt = 0; bt < max(dbits, sbits) - 1; bt++)        /* Magnitude   */
870  		for (k = 0; k < ARRAY_SIZE(sgn); k++)         /* Sign combos */
871  			for (db = -(block2 / 2); db < (block2 + 1) / 2; db++)
872  				for (sb = -(block2 / 2);
873  				     sb < (block2 + 1) / 2; sb++) {
874  					s64 dst, src;
875  
876  					dst = value(bt % dbits, db, sgn[k][0]);
877  					src = value(bt % sbits, sb, sgn[k][1]);
878  					i += (*emit)(self, arg, &insns[i],
879  						     dst, src);
880  				}
881  
882  	/* Append tail instructions */
883  	insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
884  	insns[i++] = BPF_EXIT_INSN();
885  	BUG_ON(i > len);
886  
887  	self->u.ptr.insns = insns;
888  	self->u.ptr.len = i;
889  
890  	return 0;
891  }
892  
893  /*
894   * Block size parameters used in pattern tests below. une as needed to
895   * increase/reduce the number combinations tested, see following examples.
896   *        block   values per operand MSB
897   * ----------------------------------------
898   *           0     none
899   *           1     (1 << MSB)
900   *           2     (1 << MSB) + [-1, 0]
901   *           3     (1 << MSB) + [-1, 0, 1]
902   */
903  #define PATTERN_BLOCK1 1
904  #define PATTERN_BLOCK2 5
905  
906  /* Number of test runs for a pattern test */
907  #define NR_PATTERN_RUNS 1
908  
909  /*
910   * Exhaustive tests of ALU operations for all combinations of power-of-two
911   * magnitudes of the operands, both for positive and negative values. The
912   * test is designed to verify e.g. the ALU and ALU64 operations for JITs that
913   * emit different code depending on the magnitude of the immediate value.
914   */
915  static int __bpf_emit_alu64_imm(struct bpf_test *self, void *arg,
916  				struct bpf_insn *insns, s64 dst, s64 imm)
917  {
918  	int op = *(int *)arg;
919  	int i = 0;
920  	u64 res;
921  
922  	if (!insns)
923  		return 7;
924  
925  	if (__bpf_alu_result(&res, dst, (s32)imm, op)) {
926  		i += __bpf_ld_imm64(&insns[i], R1, dst);
927  		i += __bpf_ld_imm64(&insns[i], R3, res);
928  		insns[i++] = BPF_ALU64_IMM(op, R1, imm);
929  		insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
930  		insns[i++] = BPF_EXIT_INSN();
931  	}
932  
933  	return i;
934  }
935  
936  static int __bpf_emit_alu32_imm(struct bpf_test *self, void *arg,
937  				struct bpf_insn *insns, s64 dst, s64 imm)
938  {
939  	int op = *(int *)arg;
940  	int i = 0;
941  	u64 res;
942  
943  	if (!insns)
944  		return 7;
945  
946  	if (__bpf_alu_result(&res, (u32)dst, (u32)imm, op)) {
947  		i += __bpf_ld_imm64(&insns[i], R1, dst);
948  		i += __bpf_ld_imm64(&insns[i], R3, (u32)res);
949  		insns[i++] = BPF_ALU32_IMM(op, R1, imm);
950  		insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
951  		insns[i++] = BPF_EXIT_INSN();
952  	}
953  
954  	return i;
955  }
956  
957  static int __bpf_emit_alu64_reg(struct bpf_test *self, void *arg,
958  				struct bpf_insn *insns, s64 dst, s64 src)
959  {
960  	int op = *(int *)arg;
961  	int i = 0;
962  	u64 res;
963  
964  	if (!insns)
965  		return 9;
966  
967  	if (__bpf_alu_result(&res, dst, src, op)) {
968  		i += __bpf_ld_imm64(&insns[i], R1, dst);
969  		i += __bpf_ld_imm64(&insns[i], R2, src);
970  		i += __bpf_ld_imm64(&insns[i], R3, res);
971  		insns[i++] = BPF_ALU64_REG(op, R1, R2);
972  		insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
973  		insns[i++] = BPF_EXIT_INSN();
974  	}
975  
976  	return i;
977  }
978  
979  static int __bpf_emit_alu32_reg(struct bpf_test *self, void *arg,
980  				struct bpf_insn *insns, s64 dst, s64 src)
981  {
982  	int op = *(int *)arg;
983  	int i = 0;
984  	u64 res;
985  
986  	if (!insns)
987  		return 9;
988  
989  	if (__bpf_alu_result(&res, (u32)dst, (u32)src, op)) {
990  		i += __bpf_ld_imm64(&insns[i], R1, dst);
991  		i += __bpf_ld_imm64(&insns[i], R2, src);
992  		i += __bpf_ld_imm64(&insns[i], R3, (u32)res);
993  		insns[i++] = BPF_ALU32_REG(op, R1, R2);
994  		insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
995  		insns[i++] = BPF_EXIT_INSN();
996  	}
997  
998  	return i;
999  }
1000  
1001  static int __bpf_fill_alu64_imm(struct bpf_test *self, int op)
1002  {
1003  	return __bpf_fill_pattern(self, &op, 64, 32,
1004  				  PATTERN_BLOCK1, PATTERN_BLOCK2,
1005  				  &__bpf_emit_alu64_imm);
1006  }
1007  
1008  static int __bpf_fill_alu32_imm(struct bpf_test *self, int op)
1009  {
1010  	return __bpf_fill_pattern(self, &op, 64, 32,
1011  				  PATTERN_BLOCK1, PATTERN_BLOCK2,
1012  				  &__bpf_emit_alu32_imm);
1013  }
1014  
1015  static int __bpf_fill_alu64_reg(struct bpf_test *self, int op)
1016  {
1017  	return __bpf_fill_pattern(self, &op, 64, 64,
1018  				  PATTERN_BLOCK1, PATTERN_BLOCK2,
1019  				  &__bpf_emit_alu64_reg);
1020  }
1021  
1022  static int __bpf_fill_alu32_reg(struct bpf_test *self, int op)
1023  {
1024  	return __bpf_fill_pattern(self, &op, 64, 64,
1025  				  PATTERN_BLOCK1, PATTERN_BLOCK2,
1026  				  &__bpf_emit_alu32_reg);
1027  }
1028  
1029  /* ALU64 immediate operations */
1030  static int bpf_fill_alu64_mov_imm(struct bpf_test *self)
1031  {
1032  	return __bpf_fill_alu64_imm(self, BPF_MOV);
1033  }
1034  
1035  static int bpf_fill_alu64_and_imm(struct bpf_test *self)
1036  {
1037  	return __bpf_fill_alu64_imm(self, BPF_AND);
1038  }
1039  
1040  static int bpf_fill_alu64_or_imm(struct bpf_test *self)
1041  {
1042  	return __bpf_fill_alu64_imm(self, BPF_OR);
1043  }
1044  
1045  static int bpf_fill_alu64_xor_imm(struct bpf_test *self)
1046  {
1047  	return __bpf_fill_alu64_imm(self, BPF_XOR);
1048  }
1049  
1050  static int bpf_fill_alu64_add_imm(struct bpf_test *self)
1051  {
1052  	return __bpf_fill_alu64_imm(self, BPF_ADD);
1053  }
1054  
1055  static int bpf_fill_alu64_sub_imm(struct bpf_test *self)
1056  {
1057  	return __bpf_fill_alu64_imm(self, BPF_SUB);
1058  }
1059  
1060  static int bpf_fill_alu64_mul_imm(struct bpf_test *self)
1061  {
1062  	return __bpf_fill_alu64_imm(self, BPF_MUL);
1063  }
1064  
1065  static int bpf_fill_alu64_div_imm(struct bpf_test *self)
1066  {
1067  	return __bpf_fill_alu64_imm(self, BPF_DIV);
1068  }
1069  
1070  static int bpf_fill_alu64_mod_imm(struct bpf_test *self)
1071  {
1072  	return __bpf_fill_alu64_imm(self, BPF_MOD);
1073  }
1074  
1075  /* ALU32 immediate operations */
1076  static int bpf_fill_alu32_mov_imm(struct bpf_test *self)
1077  {
1078  	return __bpf_fill_alu32_imm(self, BPF_MOV);
1079  }
1080  
1081  static int bpf_fill_alu32_and_imm(struct bpf_test *self)
1082  {
1083  	return __bpf_fill_alu32_imm(self, BPF_AND);
1084  }
1085  
1086  static int bpf_fill_alu32_or_imm(struct bpf_test *self)
1087  {
1088  	return __bpf_fill_alu32_imm(self, BPF_OR);
1089  }
1090  
1091  static int bpf_fill_alu32_xor_imm(struct bpf_test *self)
1092  {
1093  	return __bpf_fill_alu32_imm(self, BPF_XOR);
1094  }
1095  
1096  static int bpf_fill_alu32_add_imm(struct bpf_test *self)
1097  {
1098  	return __bpf_fill_alu32_imm(self, BPF_ADD);
1099  }
1100  
1101  static int bpf_fill_alu32_sub_imm(struct bpf_test *self)
1102  {
1103  	return __bpf_fill_alu32_imm(self, BPF_SUB);
1104  }
1105  
1106  static int bpf_fill_alu32_mul_imm(struct bpf_test *self)
1107  {
1108  	return __bpf_fill_alu32_imm(self, BPF_MUL);
1109  }
1110  
1111  static int bpf_fill_alu32_div_imm(struct bpf_test *self)
1112  {
1113  	return __bpf_fill_alu32_imm(self, BPF_DIV);
1114  }
1115  
1116  static int bpf_fill_alu32_mod_imm(struct bpf_test *self)
1117  {
1118  	return __bpf_fill_alu32_imm(self, BPF_MOD);
1119  }
1120  
1121  /* ALU64 register operations */
1122  static int bpf_fill_alu64_mov_reg(struct bpf_test *self)
1123  {
1124  	return __bpf_fill_alu64_reg(self, BPF_MOV);
1125  }
1126  
1127  static int bpf_fill_alu64_and_reg(struct bpf_test *self)
1128  {
1129  	return __bpf_fill_alu64_reg(self, BPF_AND);
1130  }
1131  
1132  static int bpf_fill_alu64_or_reg(struct bpf_test *self)
1133  {
1134  	return __bpf_fill_alu64_reg(self, BPF_OR);
1135  }
1136  
1137  static int bpf_fill_alu64_xor_reg(struct bpf_test *self)
1138  {
1139  	return __bpf_fill_alu64_reg(self, BPF_XOR);
1140  }
1141  
1142  static int bpf_fill_alu64_add_reg(struct bpf_test *self)
1143  {
1144  	return __bpf_fill_alu64_reg(self, BPF_ADD);
1145  }
1146  
1147  static int bpf_fill_alu64_sub_reg(struct bpf_test *self)
1148  {
1149  	return __bpf_fill_alu64_reg(self, BPF_SUB);
1150  }
1151  
1152  static int bpf_fill_alu64_mul_reg(struct bpf_test *self)
1153  {
1154  	return __bpf_fill_alu64_reg(self, BPF_MUL);
1155  }
1156  
1157  static int bpf_fill_alu64_div_reg(struct bpf_test *self)
1158  {
1159  	return __bpf_fill_alu64_reg(self, BPF_DIV);
1160  }
1161  
1162  static int bpf_fill_alu64_mod_reg(struct bpf_test *self)
1163  {
1164  	return __bpf_fill_alu64_reg(self, BPF_MOD);
1165  }
1166  
1167  /* ALU32 register operations */
1168  static int bpf_fill_alu32_mov_reg(struct bpf_test *self)
1169  {
1170  	return __bpf_fill_alu32_reg(self, BPF_MOV);
1171  }
1172  
1173  static int bpf_fill_alu32_and_reg(struct bpf_test *self)
1174  {
1175  	return __bpf_fill_alu32_reg(self, BPF_AND);
1176  }
1177  
1178  static int bpf_fill_alu32_or_reg(struct bpf_test *self)
1179  {
1180  	return __bpf_fill_alu32_reg(self, BPF_OR);
1181  }
1182  
1183  static int bpf_fill_alu32_xor_reg(struct bpf_test *self)
1184  {
1185  	return __bpf_fill_alu32_reg(self, BPF_XOR);
1186  }
1187  
1188  static int bpf_fill_alu32_add_reg(struct bpf_test *self)
1189  {
1190  	return __bpf_fill_alu32_reg(self, BPF_ADD);
1191  }
1192  
1193  static int bpf_fill_alu32_sub_reg(struct bpf_test *self)
1194  {
1195  	return __bpf_fill_alu32_reg(self, BPF_SUB);
1196  }
1197  
1198  static int bpf_fill_alu32_mul_reg(struct bpf_test *self)
1199  {
1200  	return __bpf_fill_alu32_reg(self, BPF_MUL);
1201  }
1202  
1203  static int bpf_fill_alu32_div_reg(struct bpf_test *self)
1204  {
1205  	return __bpf_fill_alu32_reg(self, BPF_DIV);
1206  }
1207  
1208  static int bpf_fill_alu32_mod_reg(struct bpf_test *self)
1209  {
1210  	return __bpf_fill_alu32_reg(self, BPF_MOD);
1211  }
1212  
1213  /*
1214   * Test JITs that implement complex ALU operations as function
1215   * calls, and must re-arrange operands for argument passing.
1216   */
1217  static int __bpf_fill_alu_imm_regs(struct bpf_test *self, u8 op, bool alu32)
1218  {
1219  	int len = 2 + 10 * 10;
1220  	struct bpf_insn *insns;
1221  	u64 dst, res;
1222  	int i = 0;
1223  	u32 imm;
1224  	int rd;
1225  
1226  	insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL);
1227  	if (!insns)
1228  		return -ENOMEM;
1229  
1230  	/* Operand and result values according to operation */
1231  	if (alu32)
1232  		dst = 0x76543210U;
1233  	else
1234  		dst = 0x7edcba9876543210ULL;
1235  	imm = 0x01234567U;
1236  
1237  	if (op == BPF_LSH || op == BPF_RSH || op == BPF_ARSH)
1238  		imm &= 31;
1239  
1240  	__bpf_alu_result(&res, dst, imm, op);
1241  
1242  	if (alu32)
1243  		res = (u32)res;
1244  
1245  	/* Check all operand registers */
1246  	for (rd = R0; rd <= R9; rd++) {
1247  		i += __bpf_ld_imm64(&insns[i], rd, dst);
1248  
1249  		if (alu32)
1250  			insns[i++] = BPF_ALU32_IMM(op, rd, imm);
1251  		else
1252  			insns[i++] = BPF_ALU64_IMM(op, rd, imm);
1253  
1254  		insns[i++] = BPF_JMP32_IMM(BPF_JEQ, rd, res, 2);
1255  		insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1256  		insns[i++] = BPF_EXIT_INSN();
1257  
1258  		insns[i++] = BPF_ALU64_IMM(BPF_RSH, rd, 32);
1259  		insns[i++] = BPF_JMP32_IMM(BPF_JEQ, rd, res >> 32, 2);
1260  		insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1261  		insns[i++] = BPF_EXIT_INSN();
1262  	}
1263  
1264  	insns[i++] = BPF_MOV64_IMM(R0, 1);
1265  	insns[i++] = BPF_EXIT_INSN();
1266  
1267  	self->u.ptr.insns = insns;
1268  	self->u.ptr.len = len;
1269  	BUG_ON(i != len);
1270  
1271  	return 0;
1272  }
1273  
1274  /* ALU64 K registers */
1275  static int bpf_fill_alu64_mov_imm_regs(struct bpf_test *self)
1276  {
1277  	return __bpf_fill_alu_imm_regs(self, BPF_MOV, false);
1278  }
1279  
1280  static int bpf_fill_alu64_and_imm_regs(struct bpf_test *self)
1281  {
1282  	return __bpf_fill_alu_imm_regs(self, BPF_AND, false);
1283  }
1284  
1285  static int bpf_fill_alu64_or_imm_regs(struct bpf_test *self)
1286  {
1287  	return __bpf_fill_alu_imm_regs(self, BPF_OR, false);
1288  }
1289  
1290  static int bpf_fill_alu64_xor_imm_regs(struct bpf_test *self)
1291  {
1292  	return __bpf_fill_alu_imm_regs(self, BPF_XOR, false);
1293  }
1294  
1295  static int bpf_fill_alu64_lsh_imm_regs(struct bpf_test *self)
1296  {
1297  	return __bpf_fill_alu_imm_regs(self, BPF_LSH, false);
1298  }
1299  
1300  static int bpf_fill_alu64_rsh_imm_regs(struct bpf_test *self)
1301  {
1302  	return __bpf_fill_alu_imm_regs(self, BPF_RSH, false);
1303  }
1304  
1305  static int bpf_fill_alu64_arsh_imm_regs(struct bpf_test *self)
1306  {
1307  	return __bpf_fill_alu_imm_regs(self, BPF_ARSH, false);
1308  }
1309  
1310  static int bpf_fill_alu64_add_imm_regs(struct bpf_test *self)
1311  {
1312  	return __bpf_fill_alu_imm_regs(self, BPF_ADD, false);
1313  }
1314  
1315  static int bpf_fill_alu64_sub_imm_regs(struct bpf_test *self)
1316  {
1317  	return __bpf_fill_alu_imm_regs(self, BPF_SUB, false);
1318  }
1319  
1320  static int bpf_fill_alu64_mul_imm_regs(struct bpf_test *self)
1321  {
1322  	return __bpf_fill_alu_imm_regs(self, BPF_MUL, false);
1323  }
1324  
1325  static int bpf_fill_alu64_div_imm_regs(struct bpf_test *self)
1326  {
1327  	return __bpf_fill_alu_imm_regs(self, BPF_DIV, false);
1328  }
1329  
1330  static int bpf_fill_alu64_mod_imm_regs(struct bpf_test *self)
1331  {
1332  	return __bpf_fill_alu_imm_regs(self, BPF_MOD, false);
1333  }
1334  
1335  /* ALU32 K registers */
1336  static int bpf_fill_alu32_mov_imm_regs(struct bpf_test *self)
1337  {
1338  	return __bpf_fill_alu_imm_regs(self, BPF_MOV, true);
1339  }
1340  
1341  static int bpf_fill_alu32_and_imm_regs(struct bpf_test *self)
1342  {
1343  	return __bpf_fill_alu_imm_regs(self, BPF_AND, true);
1344  }
1345  
1346  static int bpf_fill_alu32_or_imm_regs(struct bpf_test *self)
1347  {
1348  	return __bpf_fill_alu_imm_regs(self, BPF_OR, true);
1349  }
1350  
1351  static int bpf_fill_alu32_xor_imm_regs(struct bpf_test *self)
1352  {
1353  	return __bpf_fill_alu_imm_regs(self, BPF_XOR, true);
1354  }
1355  
1356  static int bpf_fill_alu32_lsh_imm_regs(struct bpf_test *self)
1357  {
1358  	return __bpf_fill_alu_imm_regs(self, BPF_LSH, true);
1359  }
1360  
1361  static int bpf_fill_alu32_rsh_imm_regs(struct bpf_test *self)
1362  {
1363  	return __bpf_fill_alu_imm_regs(self, BPF_RSH, true);
1364  }
1365  
1366  static int bpf_fill_alu32_arsh_imm_regs(struct bpf_test *self)
1367  {
1368  	return __bpf_fill_alu_imm_regs(self, BPF_ARSH, true);
1369  }
1370  
1371  static int bpf_fill_alu32_add_imm_regs(struct bpf_test *self)
1372  {
1373  	return __bpf_fill_alu_imm_regs(self, BPF_ADD, true);
1374  }
1375  
1376  static int bpf_fill_alu32_sub_imm_regs(struct bpf_test *self)
1377  {
1378  	return __bpf_fill_alu_imm_regs(self, BPF_SUB, true);
1379  }
1380  
1381  static int bpf_fill_alu32_mul_imm_regs(struct bpf_test *self)
1382  {
1383  	return __bpf_fill_alu_imm_regs(self, BPF_MUL, true);
1384  }
1385  
1386  static int bpf_fill_alu32_div_imm_regs(struct bpf_test *self)
1387  {
1388  	return __bpf_fill_alu_imm_regs(self, BPF_DIV, true);
1389  }
1390  
1391  static int bpf_fill_alu32_mod_imm_regs(struct bpf_test *self)
1392  {
1393  	return __bpf_fill_alu_imm_regs(self, BPF_MOD, true);
1394  }
1395  
1396  /*
1397   * Test JITs that implement complex ALU operations as function
1398   * calls, and must re-arrange operands for argument passing.
1399   */
1400  static int __bpf_fill_alu_reg_pairs(struct bpf_test *self, u8 op, bool alu32)
1401  {
1402  	int len = 2 + 10 * 10 * 12;
1403  	u64 dst, src, res, same;
1404  	struct bpf_insn *insns;
1405  	int rd, rs;
1406  	int i = 0;
1407  
1408  	insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL);
1409  	if (!insns)
1410  		return -ENOMEM;
1411  
1412  	/* Operand and result values according to operation */
1413  	if (alu32) {
1414  		dst = 0x76543210U;
1415  		src = 0x01234567U;
1416  	} else {
1417  		dst = 0x7edcba9876543210ULL;
1418  		src = 0x0123456789abcdefULL;
1419  	}
1420  
1421  	if (op == BPF_LSH || op == BPF_RSH || op == BPF_ARSH)
1422  		src &= 31;
1423  
1424  	__bpf_alu_result(&res, dst, src, op);
1425  	__bpf_alu_result(&same, src, src, op);
1426  
1427  	if (alu32) {
1428  		res = (u32)res;
1429  		same = (u32)same;
1430  	}
1431  
1432  	/* Check all combinations of operand registers */
1433  	for (rd = R0; rd <= R9; rd++) {
1434  		for (rs = R0; rs <= R9; rs++) {
1435  			u64 val = rd == rs ? same : res;
1436  
1437  			i += __bpf_ld_imm64(&insns[i], rd, dst);
1438  			i += __bpf_ld_imm64(&insns[i], rs, src);
1439  
1440  			if (alu32)
1441  				insns[i++] = BPF_ALU32_REG(op, rd, rs);
1442  			else
1443  				insns[i++] = BPF_ALU64_REG(op, rd, rs);
1444  
1445  			insns[i++] = BPF_JMP32_IMM(BPF_JEQ, rd, val, 2);
1446  			insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1447  			insns[i++] = BPF_EXIT_INSN();
1448  
1449  			insns[i++] = BPF_ALU64_IMM(BPF_RSH, rd, 32);
1450  			insns[i++] = BPF_JMP32_IMM(BPF_JEQ, rd, val >> 32, 2);
1451  			insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1452  			insns[i++] = BPF_EXIT_INSN();
1453  		}
1454  	}
1455  
1456  	insns[i++] = BPF_MOV64_IMM(R0, 1);
1457  	insns[i++] = BPF_EXIT_INSN();
1458  
1459  	self->u.ptr.insns = insns;
1460  	self->u.ptr.len = len;
1461  	BUG_ON(i != len);
1462  
1463  	return 0;
1464  }
1465  
1466  /* ALU64 X register combinations */
1467  static int bpf_fill_alu64_mov_reg_pairs(struct bpf_test *self)
1468  {
1469  	return __bpf_fill_alu_reg_pairs(self, BPF_MOV, false);
1470  }
1471  
1472  static int bpf_fill_alu64_and_reg_pairs(struct bpf_test *self)
1473  {
1474  	return __bpf_fill_alu_reg_pairs(self, BPF_AND, false);
1475  }
1476  
1477  static int bpf_fill_alu64_or_reg_pairs(struct bpf_test *self)
1478  {
1479  	return __bpf_fill_alu_reg_pairs(self, BPF_OR, false);
1480  }
1481  
1482  static int bpf_fill_alu64_xor_reg_pairs(struct bpf_test *self)
1483  {
1484  	return __bpf_fill_alu_reg_pairs(self, BPF_XOR, false);
1485  }
1486  
1487  static int bpf_fill_alu64_lsh_reg_pairs(struct bpf_test *self)
1488  {
1489  	return __bpf_fill_alu_reg_pairs(self, BPF_LSH, false);
1490  }
1491  
1492  static int bpf_fill_alu64_rsh_reg_pairs(struct bpf_test *self)
1493  {
1494  	return __bpf_fill_alu_reg_pairs(self, BPF_RSH, false);
1495  }
1496  
1497  static int bpf_fill_alu64_arsh_reg_pairs(struct bpf_test *self)
1498  {
1499  	return __bpf_fill_alu_reg_pairs(self, BPF_ARSH, false);
1500  }
1501  
1502  static int bpf_fill_alu64_add_reg_pairs(struct bpf_test *self)
1503  {
1504  	return __bpf_fill_alu_reg_pairs(self, BPF_ADD, false);
1505  }
1506  
1507  static int bpf_fill_alu64_sub_reg_pairs(struct bpf_test *self)
1508  {
1509  	return __bpf_fill_alu_reg_pairs(self, BPF_SUB, false);
1510  }
1511  
1512  static int bpf_fill_alu64_mul_reg_pairs(struct bpf_test *self)
1513  {
1514  	return __bpf_fill_alu_reg_pairs(self, BPF_MUL, false);
1515  }
1516  
1517  static int bpf_fill_alu64_div_reg_pairs(struct bpf_test *self)
1518  {
1519  	return __bpf_fill_alu_reg_pairs(self, BPF_DIV, false);
1520  }
1521  
1522  static int bpf_fill_alu64_mod_reg_pairs(struct bpf_test *self)
1523  {
1524  	return __bpf_fill_alu_reg_pairs(self, BPF_MOD, false);
1525  }
1526  
1527  /* ALU32 X register combinations */
1528  static int bpf_fill_alu32_mov_reg_pairs(struct bpf_test *self)
1529  {
1530  	return __bpf_fill_alu_reg_pairs(self, BPF_MOV, true);
1531  }
1532  
1533  static int bpf_fill_alu32_and_reg_pairs(struct bpf_test *self)
1534  {
1535  	return __bpf_fill_alu_reg_pairs(self, BPF_AND, true);
1536  }
1537  
1538  static int bpf_fill_alu32_or_reg_pairs(struct bpf_test *self)
1539  {
1540  	return __bpf_fill_alu_reg_pairs(self, BPF_OR, true);
1541  }
1542  
1543  static int bpf_fill_alu32_xor_reg_pairs(struct bpf_test *self)
1544  {
1545  	return __bpf_fill_alu_reg_pairs(self, BPF_XOR, true);
1546  }
1547  
1548  static int bpf_fill_alu32_lsh_reg_pairs(struct bpf_test *self)
1549  {
1550  	return __bpf_fill_alu_reg_pairs(self, BPF_LSH, true);
1551  }
1552  
1553  static int bpf_fill_alu32_rsh_reg_pairs(struct bpf_test *self)
1554  {
1555  	return __bpf_fill_alu_reg_pairs(self, BPF_RSH, true);
1556  }
1557  
1558  static int bpf_fill_alu32_arsh_reg_pairs(struct bpf_test *self)
1559  {
1560  	return __bpf_fill_alu_reg_pairs(self, BPF_ARSH, true);
1561  }
1562  
1563  static int bpf_fill_alu32_add_reg_pairs(struct bpf_test *self)
1564  {
1565  	return __bpf_fill_alu_reg_pairs(self, BPF_ADD, true);
1566  }
1567  
1568  static int bpf_fill_alu32_sub_reg_pairs(struct bpf_test *self)
1569  {
1570  	return __bpf_fill_alu_reg_pairs(self, BPF_SUB, true);
1571  }
1572  
1573  static int bpf_fill_alu32_mul_reg_pairs(struct bpf_test *self)
1574  {
1575  	return __bpf_fill_alu_reg_pairs(self, BPF_MUL, true);
1576  }
1577  
1578  static int bpf_fill_alu32_div_reg_pairs(struct bpf_test *self)
1579  {
1580  	return __bpf_fill_alu_reg_pairs(self, BPF_DIV, true);
1581  }
1582  
1583  static int bpf_fill_alu32_mod_reg_pairs(struct bpf_test *self)
1584  {
1585  	return __bpf_fill_alu_reg_pairs(self, BPF_MOD, true);
1586  }
1587  
1588  /*
1589   * Exhaustive tests of atomic operations for all power-of-two operand
1590   * magnitudes, both for positive and negative values.
1591   */
1592  
1593  static int __bpf_emit_atomic64(struct bpf_test *self, void *arg,
1594  			       struct bpf_insn *insns, s64 dst, s64 src)
1595  {
1596  	int op = *(int *)arg;
1597  	u64 keep, fetch, res;
1598  	int i = 0;
1599  
1600  	if (!insns)
1601  		return 21;
1602  
1603  	switch (op) {
1604  	case BPF_XCHG:
1605  		res = src;
1606  		break;
1607  	default:
1608  		__bpf_alu_result(&res, dst, src, BPF_OP(op));
1609  	}
1610  
1611  	keep = 0x0123456789abcdefULL;
1612  	if (op & BPF_FETCH)
1613  		fetch = dst;
1614  	else
1615  		fetch = src;
1616  
1617  	i += __bpf_ld_imm64(&insns[i], R0, keep);
1618  	i += __bpf_ld_imm64(&insns[i], R1, dst);
1619  	i += __bpf_ld_imm64(&insns[i], R2, src);
1620  	i += __bpf_ld_imm64(&insns[i], R3, res);
1621  	i += __bpf_ld_imm64(&insns[i], R4, fetch);
1622  	i += __bpf_ld_imm64(&insns[i], R5, keep);
1623  
1624  	insns[i++] = BPF_STX_MEM(BPF_DW, R10, R1, -8);
1625  	insns[i++] = BPF_ATOMIC_OP(BPF_DW, op, R10, R2, -8);
1626  	insns[i++] = BPF_LDX_MEM(BPF_DW, R1, R10, -8);
1627  
1628  	insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
1629  	insns[i++] = BPF_EXIT_INSN();
1630  
1631  	insns[i++] = BPF_JMP_REG(BPF_JEQ, R2, R4, 1);
1632  	insns[i++] = BPF_EXIT_INSN();
1633  
1634  	insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R5, 1);
1635  	insns[i++] = BPF_EXIT_INSN();
1636  
1637  	return i;
1638  }
1639  
1640  static int __bpf_emit_atomic32(struct bpf_test *self, void *arg,
1641  			       struct bpf_insn *insns, s64 dst, s64 src)
1642  {
1643  	int op = *(int *)arg;
1644  	u64 keep, fetch, res;
1645  	int i = 0;
1646  
1647  	if (!insns)
1648  		return 21;
1649  
1650  	switch (op) {
1651  	case BPF_XCHG:
1652  		res = src;
1653  		break;
1654  	default:
1655  		__bpf_alu_result(&res, (u32)dst, (u32)src, BPF_OP(op));
1656  	}
1657  
1658  	keep = 0x0123456789abcdefULL;
1659  	if (op & BPF_FETCH)
1660  		fetch = (u32)dst;
1661  	else
1662  		fetch = src;
1663  
1664  	i += __bpf_ld_imm64(&insns[i], R0, keep);
1665  	i += __bpf_ld_imm64(&insns[i], R1, (u32)dst);
1666  	i += __bpf_ld_imm64(&insns[i], R2, src);
1667  	i += __bpf_ld_imm64(&insns[i], R3, (u32)res);
1668  	i += __bpf_ld_imm64(&insns[i], R4, fetch);
1669  	i += __bpf_ld_imm64(&insns[i], R5, keep);
1670  
1671  	insns[i++] = BPF_STX_MEM(BPF_W, R10, R1, -4);
1672  	insns[i++] = BPF_ATOMIC_OP(BPF_W, op, R10, R2, -4);
1673  	insns[i++] = BPF_LDX_MEM(BPF_W, R1, R10, -4);
1674  
1675  	insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
1676  	insns[i++] = BPF_EXIT_INSN();
1677  
1678  	insns[i++] = BPF_JMP_REG(BPF_JEQ, R2, R4, 1);
1679  	insns[i++] = BPF_EXIT_INSN();
1680  
1681  	insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R5, 1);
1682  	insns[i++] = BPF_EXIT_INSN();
1683  
1684  	return i;
1685  }
1686  
1687  static int __bpf_emit_cmpxchg64(struct bpf_test *self, void *arg,
1688  				struct bpf_insn *insns, s64 dst, s64 src)
1689  {
1690  	int i = 0;
1691  
1692  	if (!insns)
1693  		return 23;
1694  
1695  	i += __bpf_ld_imm64(&insns[i], R0, ~dst);
1696  	i += __bpf_ld_imm64(&insns[i], R1, dst);
1697  	i += __bpf_ld_imm64(&insns[i], R2, src);
1698  
1699  	/* Result unsuccessful */
1700  	insns[i++] = BPF_STX_MEM(BPF_DW, R10, R1, -8);
1701  	insns[i++] = BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -8);
1702  	insns[i++] = BPF_LDX_MEM(BPF_DW, R3, R10, -8);
1703  
1704  	insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 2);
1705  	insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1706  	insns[i++] = BPF_EXIT_INSN();
1707  
1708  	insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R3, 2);
1709  	insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1710  	insns[i++] = BPF_EXIT_INSN();
1711  
1712  	/* Result successful */
1713  	insns[i++] = BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -8);
1714  	insns[i++] = BPF_LDX_MEM(BPF_DW, R3, R10, -8);
1715  
1716  	insns[i++] = BPF_JMP_REG(BPF_JEQ, R2, R3, 2);
1717  	insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1718  	insns[i++] = BPF_EXIT_INSN();
1719  
1720  	insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R1, 2);
1721  	insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1722  	insns[i++] = BPF_EXIT_INSN();
1723  
1724  	return i;
1725  }
1726  
1727  static int __bpf_emit_cmpxchg32(struct bpf_test *self, void *arg,
1728  				struct bpf_insn *insns, s64 dst, s64 src)
1729  {
1730  	int i = 0;
1731  
1732  	if (!insns)
1733  		return 27;
1734  
1735  	i += __bpf_ld_imm64(&insns[i], R0, ~dst);
1736  	i += __bpf_ld_imm64(&insns[i], R1, (u32)dst);
1737  	i += __bpf_ld_imm64(&insns[i], R2, src);
1738  
1739  	/* Result unsuccessful */
1740  	insns[i++] = BPF_STX_MEM(BPF_W, R10, R1, -4);
1741  	insns[i++] = BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R2, -4);
1742  	insns[i++] = BPF_ZEXT_REG(R0), /* Zext always inserted by verifier */
1743  	insns[i++] = BPF_LDX_MEM(BPF_W, R3, R10, -4);
1744  
1745  	insns[i++] = BPF_JMP32_REG(BPF_JEQ, R1, R3, 2);
1746  	insns[i++] = BPF_MOV32_IMM(R0, __LINE__);
1747  	insns[i++] = BPF_EXIT_INSN();
1748  
1749  	insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R3, 2);
1750  	insns[i++] = BPF_MOV32_IMM(R0, __LINE__);
1751  	insns[i++] = BPF_EXIT_INSN();
1752  
1753  	/* Result successful */
1754  	i += __bpf_ld_imm64(&insns[i], R0, dst);
1755  	insns[i++] = BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R2, -4);
1756  	insns[i++] = BPF_ZEXT_REG(R0), /* Zext always inserted by verifier */
1757  	insns[i++] = BPF_LDX_MEM(BPF_W, R3, R10, -4);
1758  
1759  	insns[i++] = BPF_JMP32_REG(BPF_JEQ, R2, R3, 2);
1760  	insns[i++] = BPF_MOV32_IMM(R0, __LINE__);
1761  	insns[i++] = BPF_EXIT_INSN();
1762  
1763  	insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R1, 2);
1764  	insns[i++] = BPF_MOV32_IMM(R0, __LINE__);
1765  	insns[i++] = BPF_EXIT_INSN();
1766  
1767  	return i;
1768  }
1769  
1770  static int __bpf_fill_atomic64(struct bpf_test *self, int op)
1771  {
1772  	return __bpf_fill_pattern(self, &op, 64, 64,
1773  				  0, PATTERN_BLOCK2,
1774  				  &__bpf_emit_atomic64);
1775  }
1776  
1777  static int __bpf_fill_atomic32(struct bpf_test *self, int op)
1778  {
1779  	return __bpf_fill_pattern(self, &op, 64, 64,
1780  				  0, PATTERN_BLOCK2,
1781  				  &__bpf_emit_atomic32);
1782  }
1783  
1784  /* 64-bit atomic operations */
1785  static int bpf_fill_atomic64_add(struct bpf_test *self)
1786  {
1787  	return __bpf_fill_atomic64(self, BPF_ADD);
1788  }
1789  
1790  static int bpf_fill_atomic64_and(struct bpf_test *self)
1791  {
1792  	return __bpf_fill_atomic64(self, BPF_AND);
1793  }
1794  
1795  static int bpf_fill_atomic64_or(struct bpf_test *self)
1796  {
1797  	return __bpf_fill_atomic64(self, BPF_OR);
1798  }
1799  
1800  static int bpf_fill_atomic64_xor(struct bpf_test *self)
1801  {
1802  	return __bpf_fill_atomic64(self, BPF_XOR);
1803  }
1804  
1805  static int bpf_fill_atomic64_add_fetch(struct bpf_test *self)
1806  {
1807  	return __bpf_fill_atomic64(self, BPF_ADD | BPF_FETCH);
1808  }
1809  
1810  static int bpf_fill_atomic64_and_fetch(struct bpf_test *self)
1811  {
1812  	return __bpf_fill_atomic64(self, BPF_AND | BPF_FETCH);
1813  }
1814  
1815  static int bpf_fill_atomic64_or_fetch(struct bpf_test *self)
1816  {
1817  	return __bpf_fill_atomic64(self, BPF_OR | BPF_FETCH);
1818  }
1819  
1820  static int bpf_fill_atomic64_xor_fetch(struct bpf_test *self)
1821  {
1822  	return __bpf_fill_atomic64(self, BPF_XOR | BPF_FETCH);
1823  }
1824  
1825  static int bpf_fill_atomic64_xchg(struct bpf_test *self)
1826  {
1827  	return __bpf_fill_atomic64(self, BPF_XCHG);
1828  }
1829  
1830  static int bpf_fill_cmpxchg64(struct bpf_test *self)
1831  {
1832  	return __bpf_fill_pattern(self, NULL, 64, 64, 0, PATTERN_BLOCK2,
1833  				  &__bpf_emit_cmpxchg64);
1834  }
1835  
1836  /* 32-bit atomic operations */
1837  static int bpf_fill_atomic32_add(struct bpf_test *self)
1838  {
1839  	return __bpf_fill_atomic32(self, BPF_ADD);
1840  }
1841  
1842  static int bpf_fill_atomic32_and(struct bpf_test *self)
1843  {
1844  	return __bpf_fill_atomic32(self, BPF_AND);
1845  }
1846  
1847  static int bpf_fill_atomic32_or(struct bpf_test *self)
1848  {
1849  	return __bpf_fill_atomic32(self, BPF_OR);
1850  }
1851  
1852  static int bpf_fill_atomic32_xor(struct bpf_test *self)
1853  {
1854  	return __bpf_fill_atomic32(self, BPF_XOR);
1855  }
1856  
1857  static int bpf_fill_atomic32_add_fetch(struct bpf_test *self)
1858  {
1859  	return __bpf_fill_atomic32(self, BPF_ADD | BPF_FETCH);
1860  }
1861  
1862  static int bpf_fill_atomic32_and_fetch(struct bpf_test *self)
1863  {
1864  	return __bpf_fill_atomic32(self, BPF_AND | BPF_FETCH);
1865  }
1866  
1867  static int bpf_fill_atomic32_or_fetch(struct bpf_test *self)
1868  {
1869  	return __bpf_fill_atomic32(self, BPF_OR | BPF_FETCH);
1870  }
1871  
1872  static int bpf_fill_atomic32_xor_fetch(struct bpf_test *self)
1873  {
1874  	return __bpf_fill_atomic32(self, BPF_XOR | BPF_FETCH);
1875  }
1876  
1877  static int bpf_fill_atomic32_xchg(struct bpf_test *self)
1878  {
1879  	return __bpf_fill_atomic32(self, BPF_XCHG);
1880  }
1881  
1882  static int bpf_fill_cmpxchg32(struct bpf_test *self)
1883  {
1884  	return __bpf_fill_pattern(self, NULL, 64, 64, 0, PATTERN_BLOCK2,
1885  				  &__bpf_emit_cmpxchg32);
1886  }
1887  
1888  /*
1889   * Test JITs that implement ATOMIC operations as function calls or
1890   * other primitives, and must re-arrange operands for argument passing.
1891   */
1892  static int __bpf_fill_atomic_reg_pairs(struct bpf_test *self, u8 width, u8 op)
1893  {
1894  	struct bpf_insn *insn;
1895  	int len = 2 + 34 * 10 * 10;
1896  	u64 mem, upd, res;
1897  	int rd, rs, i = 0;
1898  
1899  	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
1900  	if (!insn)
1901  		return -ENOMEM;
1902  
1903  	/* Operand and memory values */
1904  	if (width == BPF_DW) {
1905  		mem = 0x0123456789abcdefULL;
1906  		upd = 0xfedcba9876543210ULL;
1907  	} else { /* BPF_W */
1908  		mem = 0x01234567U;
1909  		upd = 0x76543210U;
1910  	}
1911  
1912  	/* Memory updated according to operation */
1913  	switch (op) {
1914  	case BPF_XCHG:
1915  		res = upd;
1916  		break;
1917  	case BPF_CMPXCHG:
1918  		res = mem;
1919  		break;
1920  	default:
1921  		__bpf_alu_result(&res, mem, upd, BPF_OP(op));
1922  	}
1923  
1924  	/* Test all operand registers */
1925  	for (rd = R0; rd <= R9; rd++) {
1926  		for (rs = R0; rs <= R9; rs++) {
1927  			u64 cmp, src;
1928  
1929  			/* Initialize value in memory */
1930  			i += __bpf_ld_imm64(&insn[i], R0, mem);
1931  			insn[i++] = BPF_STX_MEM(width, R10, R0, -8);
1932  
1933  			/* Initialize registers in order */
1934  			i += __bpf_ld_imm64(&insn[i], R0, ~mem);
1935  			i += __bpf_ld_imm64(&insn[i], rs, upd);
1936  			insn[i++] = BPF_MOV64_REG(rd, R10);
1937  
1938  			/* Perform atomic operation */
1939  			insn[i++] = BPF_ATOMIC_OP(width, op, rd, rs, -8);
1940  			if (op == BPF_CMPXCHG && width == BPF_W)
1941  				insn[i++] = BPF_ZEXT_REG(R0);
1942  
1943  			/* Check R0 register value */
1944  			if (op == BPF_CMPXCHG)
1945  				cmp = mem;  /* Expect value from memory */
1946  			else if (R0 == rd || R0 == rs)
1947  				cmp = 0;    /* Aliased, checked below */
1948  			else
1949  				cmp = ~mem; /* Expect value to be preserved */
1950  			if (cmp) {
1951  				insn[i++] = BPF_JMP32_IMM(BPF_JEQ, R0,
1952  							   (u32)cmp, 2);
1953  				insn[i++] = BPF_MOV32_IMM(R0, __LINE__);
1954  				insn[i++] = BPF_EXIT_INSN();
1955  				insn[i++] = BPF_ALU64_IMM(BPF_RSH, R0, 32);
1956  				insn[i++] = BPF_JMP32_IMM(BPF_JEQ, R0,
1957  							   cmp >> 32, 2);
1958  				insn[i++] = BPF_MOV32_IMM(R0, __LINE__);
1959  				insn[i++] = BPF_EXIT_INSN();
1960  			}
1961  
1962  			/* Check source register value */
1963  			if (rs == R0 && op == BPF_CMPXCHG)
1964  				src = 0;   /* Aliased with R0, checked above */
1965  			else if (rs == rd && (op == BPF_CMPXCHG ||
1966  					      !(op & BPF_FETCH)))
1967  				src = 0;   /* Aliased with rd, checked below */
1968  			else if (op == BPF_CMPXCHG)
1969  				src = upd; /* Expect value to be preserved */
1970  			else if (op & BPF_FETCH)
1971  				src = mem; /* Expect fetched value from mem */
1972  			else /* no fetch */
1973  				src = upd; /* Expect value to be preserved */
1974  			if (src) {
1975  				insn[i++] = BPF_JMP32_IMM(BPF_JEQ, rs,
1976  							   (u32)src, 2);
1977  				insn[i++] = BPF_MOV32_IMM(R0, __LINE__);
1978  				insn[i++] = BPF_EXIT_INSN();
1979  				insn[i++] = BPF_ALU64_IMM(BPF_RSH, rs, 32);
1980  				insn[i++] = BPF_JMP32_IMM(BPF_JEQ, rs,
1981  							   src >> 32, 2);
1982  				insn[i++] = BPF_MOV32_IMM(R0, __LINE__);
1983  				insn[i++] = BPF_EXIT_INSN();
1984  			}
1985  
1986  			/* Check destination register value */
1987  			if (!(rd == R0 && op == BPF_CMPXCHG) &&
1988  			    !(rd == rs && (op & BPF_FETCH))) {
1989  				insn[i++] = BPF_JMP_REG(BPF_JEQ, rd, R10, 2);
1990  				insn[i++] = BPF_MOV32_IMM(R0, __LINE__);
1991  				insn[i++] = BPF_EXIT_INSN();
1992  			}
1993  
1994  			/* Check value in memory */
1995  			if (rs != rd) {                  /* No aliasing */
1996  				i += __bpf_ld_imm64(&insn[i], R1, res);
1997  			} else if (op == BPF_XCHG) {     /* Aliased, XCHG */
1998  				insn[i++] = BPF_MOV64_REG(R1, R10);
1999  			} else if (op == BPF_CMPXCHG) {  /* Aliased, CMPXCHG */
2000  				i += __bpf_ld_imm64(&insn[i], R1, mem);
2001  			} else {                        /* Aliased, ALU oper */
2002  				i += __bpf_ld_imm64(&insn[i], R1, mem);
2003  				insn[i++] = BPF_ALU64_REG(BPF_OP(op), R1, R10);
2004  			}
2005  
2006  			insn[i++] = BPF_LDX_MEM(width, R0, R10, -8);
2007  			if (width == BPF_DW)
2008  				insn[i++] = BPF_JMP_REG(BPF_JEQ, R0, R1, 2);
2009  			else /* width == BPF_W */
2010  				insn[i++] = BPF_JMP32_REG(BPF_JEQ, R0, R1, 2);
2011  			insn[i++] = BPF_MOV32_IMM(R0, __LINE__);
2012  			insn[i++] = BPF_EXIT_INSN();
2013  		}
2014  	}
2015  
2016  	insn[i++] = BPF_MOV64_IMM(R0, 1);
2017  	insn[i++] = BPF_EXIT_INSN();
2018  
2019  	self->u.ptr.insns = insn;
2020  	self->u.ptr.len = i;
2021  	BUG_ON(i > len);
2022  
2023  	return 0;
2024  }
2025  
2026  /* 64-bit atomic register tests */
2027  static int bpf_fill_atomic64_add_reg_pairs(struct bpf_test *self)
2028  {
2029  	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_ADD);
2030  }
2031  
2032  static int bpf_fill_atomic64_and_reg_pairs(struct bpf_test *self)
2033  {
2034  	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_AND);
2035  }
2036  
2037  static int bpf_fill_atomic64_or_reg_pairs(struct bpf_test *self)
2038  {
2039  	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_OR);
2040  }
2041  
2042  static int bpf_fill_atomic64_xor_reg_pairs(struct bpf_test *self)
2043  {
2044  	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_XOR);
2045  }
2046  
2047  static int bpf_fill_atomic64_add_fetch_reg_pairs(struct bpf_test *self)
2048  {
2049  	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_ADD | BPF_FETCH);
2050  }
2051  
2052  static int bpf_fill_atomic64_and_fetch_reg_pairs(struct bpf_test *self)
2053  {
2054  	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_AND | BPF_FETCH);
2055  }
2056  
2057  static int bpf_fill_atomic64_or_fetch_reg_pairs(struct bpf_test *self)
2058  {
2059  	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_OR | BPF_FETCH);
2060  }
2061  
2062  static int bpf_fill_atomic64_xor_fetch_reg_pairs(struct bpf_test *self)
2063  {
2064  	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_XOR | BPF_FETCH);
2065  }
2066  
2067  static int bpf_fill_atomic64_xchg_reg_pairs(struct bpf_test *self)
2068  {
2069  	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_XCHG);
2070  }
2071  
2072  static int bpf_fill_atomic64_cmpxchg_reg_pairs(struct bpf_test *self)
2073  {
2074  	return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_CMPXCHG);
2075  }
2076  
2077  /* 32-bit atomic register tests */
2078  static int bpf_fill_atomic32_add_reg_pairs(struct bpf_test *self)
2079  {
2080  	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_ADD);
2081  }
2082  
2083  static int bpf_fill_atomic32_and_reg_pairs(struct bpf_test *self)
2084  {
2085  	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_AND);
2086  }
2087  
2088  static int bpf_fill_atomic32_or_reg_pairs(struct bpf_test *self)
2089  {
2090  	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_OR);
2091  }
2092  
2093  static int bpf_fill_atomic32_xor_reg_pairs(struct bpf_test *self)
2094  {
2095  	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_XOR);
2096  }
2097  
2098  static int bpf_fill_atomic32_add_fetch_reg_pairs(struct bpf_test *self)
2099  {
2100  	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_ADD | BPF_FETCH);
2101  }
2102  
2103  static int bpf_fill_atomic32_and_fetch_reg_pairs(struct bpf_test *self)
2104  {
2105  	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_AND | BPF_FETCH);
2106  }
2107  
2108  static int bpf_fill_atomic32_or_fetch_reg_pairs(struct bpf_test *self)
2109  {
2110  	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_OR | BPF_FETCH);
2111  }
2112  
2113  static int bpf_fill_atomic32_xor_fetch_reg_pairs(struct bpf_test *self)
2114  {
2115  	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_XOR | BPF_FETCH);
2116  }
2117  
2118  static int bpf_fill_atomic32_xchg_reg_pairs(struct bpf_test *self)
2119  {
2120  	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_XCHG);
2121  }
2122  
2123  static int bpf_fill_atomic32_cmpxchg_reg_pairs(struct bpf_test *self)
2124  {
2125  	return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_CMPXCHG);
2126  }
2127  
2128  /*
2129   * Test the two-instruction 64-bit immediate load operation for all
2130   * power-of-two magnitudes of the immediate operand. For each MSB, a block
2131   * of immediate values centered around the power-of-two MSB are tested,
2132   * both for positive and negative values. The test is designed to verify
2133   * the operation for JITs that emit different code depending on the magnitude
2134   * of the immediate value. This is often the case if the native instruction
2135   * immediate field width is narrower than 32 bits.
2136   */
2137  static int bpf_fill_ld_imm64_magn(struct bpf_test *self)
2138  {
2139  	int block = 64; /* Increase for more tests per MSB position */
2140  	int len = 3 + 8 * 63 * block * 2;
2141  	struct bpf_insn *insn;
2142  	int bit, adj, sign;
2143  	int i = 0;
2144  
2145  	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
2146  	if (!insn)
2147  		return -ENOMEM;
2148  
2149  	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
2150  
2151  	for (bit = 0; bit <= 62; bit++) {
2152  		for (adj = -block / 2; adj < block / 2; adj++) {
2153  			for (sign = -1; sign <= 1; sign += 2) {
2154  				s64 imm = sign * ((1LL << bit) + adj);
2155  
2156  				/* Perform operation */
2157  				i += __bpf_ld_imm64(&insn[i], R1, imm);
2158  
2159  				/* Load reference */
2160  				insn[i++] = BPF_ALU32_IMM(BPF_MOV, R2, imm);
2161  				insn[i++] = BPF_ALU32_IMM(BPF_MOV, R3,
2162  							  (u32)(imm >> 32));
2163  				insn[i++] = BPF_ALU64_IMM(BPF_LSH, R3, 32);
2164  				insn[i++] = BPF_ALU64_REG(BPF_OR, R2, R3);
2165  
2166  				/* Check result */
2167  				insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R2, 1);
2168  				insn[i++] = BPF_EXIT_INSN();
2169  			}
2170  		}
2171  	}
2172  
2173  	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
2174  	insn[i++] = BPF_EXIT_INSN();
2175  
2176  	self->u.ptr.insns = insn;
2177  	self->u.ptr.len = len;
2178  	BUG_ON(i != len);
2179  
2180  	return 0;
2181  }
2182  
2183  /*
2184   * Test the two-instruction 64-bit immediate load operation for different
2185   * combinations of bytes. Each byte in the 64-bit word is constructed as
2186   * (base & mask) | (rand() & ~mask), where rand() is a deterministic LCG.
2187   * All patterns (base1, mask1) and (base2, mask2) bytes are tested.
2188   */
2189  static int __bpf_fill_ld_imm64_bytes(struct bpf_test *self,
2190  				     u8 base1, u8 mask1,
2191  				     u8 base2, u8 mask2)
2192  {
2193  	struct bpf_insn *insn;
2194  	int len = 3 + 8 * BIT(8);
2195  	int pattern, index;
2196  	u32 rand = 1;
2197  	int i = 0;
2198  
2199  	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
2200  	if (!insn)
2201  		return -ENOMEM;
2202  
2203  	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
2204  
2205  	for (pattern = 0; pattern < BIT(8); pattern++) {
2206  		u64 imm = 0;
2207  
2208  		for (index = 0; index < 8; index++) {
2209  			int byte;
2210  
2211  			if (pattern & BIT(index))
2212  				byte = (base1 & mask1) | (rand & ~mask1);
2213  			else
2214  				byte = (base2 & mask2) | (rand & ~mask2);
2215  			imm = (imm << 8) | byte;
2216  		}
2217  
2218  		/* Update our LCG */
2219  		rand = rand * 1664525 + 1013904223;
2220  
2221  		/* Perform operation */
2222  		i += __bpf_ld_imm64(&insn[i], R1, imm);
2223  
2224  		/* Load reference */
2225  		insn[i++] = BPF_ALU32_IMM(BPF_MOV, R2, imm);
2226  		insn[i++] = BPF_ALU32_IMM(BPF_MOV, R3, (u32)(imm >> 32));
2227  		insn[i++] = BPF_ALU64_IMM(BPF_LSH, R3, 32);
2228  		insn[i++] = BPF_ALU64_REG(BPF_OR, R2, R3);
2229  
2230  		/* Check result */
2231  		insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R2, 1);
2232  		insn[i++] = BPF_EXIT_INSN();
2233  	}
2234  
2235  	insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
2236  	insn[i++] = BPF_EXIT_INSN();
2237  
2238  	self->u.ptr.insns = insn;
2239  	self->u.ptr.len = len;
2240  	BUG_ON(i != len);
2241  
2242  	return 0;
2243  }
2244  
2245  static int bpf_fill_ld_imm64_checker(struct bpf_test *self)
2246  {
2247  	return __bpf_fill_ld_imm64_bytes(self, 0, 0xff, 0xff, 0xff);
2248  }
2249  
2250  static int bpf_fill_ld_imm64_pos_neg(struct bpf_test *self)
2251  {
2252  	return __bpf_fill_ld_imm64_bytes(self, 1, 0x81, 0x80, 0x80);
2253  }
2254  
2255  static int bpf_fill_ld_imm64_pos_zero(struct bpf_test *self)
2256  {
2257  	return __bpf_fill_ld_imm64_bytes(self, 1, 0x81, 0, 0xff);
2258  }
2259  
2260  static int bpf_fill_ld_imm64_neg_zero(struct bpf_test *self)
2261  {
2262  	return __bpf_fill_ld_imm64_bytes(self, 0x80, 0x80, 0, 0xff);
2263  }
2264  
2265  /*
2266   * Exhaustive tests of JMP operations for all combinations of power-of-two
2267   * magnitudes of the operands, both for positive and negative values. The
2268   * test is designed to verify e.g. the JMP and JMP32 operations for JITs that
2269   * emit different code depending on the magnitude of the immediate value.
2270   */
2271  
2272  static bool __bpf_match_jmp_cond(s64 v1, s64 v2, u8 op)
2273  {
2274  	switch (op) {
2275  	case BPF_JSET:
2276  		return !!(v1 & v2);
2277  	case BPF_JEQ:
2278  		return v1 == v2;
2279  	case BPF_JNE:
2280  		return v1 != v2;
2281  	case BPF_JGT:
2282  		return (u64)v1 > (u64)v2;
2283  	case BPF_JGE:
2284  		return (u64)v1 >= (u64)v2;
2285  	case BPF_JLT:
2286  		return (u64)v1 < (u64)v2;
2287  	case BPF_JLE:
2288  		return (u64)v1 <= (u64)v2;
2289  	case BPF_JSGT:
2290  		return v1 > v2;
2291  	case BPF_JSGE:
2292  		return v1 >= v2;
2293  	case BPF_JSLT:
2294  		return v1 < v2;
2295  	case BPF_JSLE:
2296  		return v1 <= v2;
2297  	}
2298  	return false;
2299  }
2300  
2301  static int __bpf_emit_jmp_imm(struct bpf_test *self, void *arg,
2302  			      struct bpf_insn *insns, s64 dst, s64 imm)
2303  {
2304  	int op = *(int *)arg;
2305  
2306  	if (insns) {
2307  		bool match = __bpf_match_jmp_cond(dst, (s32)imm, op);
2308  		int i = 0;
2309  
2310  		insns[i++] = BPF_ALU32_IMM(BPF_MOV, R0, match);
2311  
2312  		i += __bpf_ld_imm64(&insns[i], R1, dst);
2313  		insns[i++] = BPF_JMP_IMM(op, R1, imm, 1);
2314  		if (!match)
2315  			insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
2316  		insns[i++] = BPF_EXIT_INSN();
2317  
2318  		return i;
2319  	}
2320  
2321  	return 5 + 1;
2322  }
2323  
2324  static int __bpf_emit_jmp32_imm(struct bpf_test *self, void *arg,
2325  				struct bpf_insn *insns, s64 dst, s64 imm)
2326  {
2327  	int op = *(int *)arg;
2328  
2329  	if (insns) {
2330  		bool match = __bpf_match_jmp_cond((s32)dst, (s32)imm, op);
2331  		int i = 0;
2332  
2333  		i += __bpf_ld_imm64(&insns[i], R1, dst);
2334  		insns[i++] = BPF_JMP32_IMM(op, R1, imm, 1);
2335  		if (!match)
2336  			insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
2337  		insns[i++] = BPF_EXIT_INSN();
2338  
2339  		return i;
2340  	}
2341  
2342  	return 5;
2343  }
2344  
2345  static int __bpf_emit_jmp_reg(struct bpf_test *self, void *arg,
2346  			      struct bpf_insn *insns, s64 dst, s64 src)
2347  {
2348  	int op = *(int *)arg;
2349  
2350  	if (insns) {
2351  		bool match = __bpf_match_jmp_cond(dst, src, op);
2352  		int i = 0;
2353  
2354  		i += __bpf_ld_imm64(&insns[i], R1, dst);
2355  		i += __bpf_ld_imm64(&insns[i], R2, src);
2356  		insns[i++] = BPF_JMP_REG(op, R1, R2, 1);
2357  		if (!match)
2358  			insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
2359  		insns[i++] = BPF_EXIT_INSN();
2360  
2361  		return i;
2362  	}
2363  
2364  	return 7;
2365  }
2366  
2367  static int __bpf_emit_jmp32_reg(struct bpf_test *self, void *arg,
2368  				struct bpf_insn *insns, s64 dst, s64 src)
2369  {
2370  	int op = *(int *)arg;
2371  
2372  	if (insns) {
2373  		bool match = __bpf_match_jmp_cond((s32)dst, (s32)src, op);
2374  		int i = 0;
2375  
2376  		i += __bpf_ld_imm64(&insns[i], R1, dst);
2377  		i += __bpf_ld_imm64(&insns[i], R2, src);
2378  		insns[i++] = BPF_JMP32_REG(op, R1, R2, 1);
2379  		if (!match)
2380  			insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
2381  		insns[i++] = BPF_EXIT_INSN();
2382  
2383  		return i;
2384  	}
2385  
2386  	return 7;
2387  }
2388  
2389  static int __bpf_fill_jmp_imm(struct bpf_test *self, int op)
2390  {
2391  	return __bpf_fill_pattern(self, &op, 64, 32,
2392  				  PATTERN_BLOCK1, PATTERN_BLOCK2,
2393  				  &__bpf_emit_jmp_imm);
2394  }
2395  
2396  static int __bpf_fill_jmp32_imm(struct bpf_test *self, int op)
2397  {
2398  	return __bpf_fill_pattern(self, &op, 64, 32,
2399  				  PATTERN_BLOCK1, PATTERN_BLOCK2,
2400  				  &__bpf_emit_jmp32_imm);
2401  }
2402  
2403  static int __bpf_fill_jmp_reg(struct bpf_test *self, int op)
2404  {
2405  	return __bpf_fill_pattern(self, &op, 64, 64,
2406  				  PATTERN_BLOCK1, PATTERN_BLOCK2,
2407  				  &__bpf_emit_jmp_reg);
2408  }
2409  
2410  static int __bpf_fill_jmp32_reg(struct bpf_test *self, int op)
2411  {
2412  	return __bpf_fill_pattern(self, &op, 64, 64,
2413  				  PATTERN_BLOCK1, PATTERN_BLOCK2,
2414  				  &__bpf_emit_jmp32_reg);
2415  }
2416  
2417  /* JMP immediate tests */
2418  static int bpf_fill_jmp_jset_imm(struct bpf_test *self)
2419  {
2420  	return __bpf_fill_jmp_imm(self, BPF_JSET);
2421  }
2422  
2423  static int bpf_fill_jmp_jeq_imm(struct bpf_test *self)
2424  {
2425  	return __bpf_fill_jmp_imm(self, BPF_JEQ);
2426  }
2427  
2428  static int bpf_fill_jmp_jne_imm(struct bpf_test *self)
2429  {
2430  	return __bpf_fill_jmp_imm(self, BPF_JNE);
2431  }
2432  
2433  static int bpf_fill_jmp_jgt_imm(struct bpf_test *self)
2434  {
2435  	return __bpf_fill_jmp_imm(self, BPF_JGT);
2436  }
2437  
2438  static int bpf_fill_jmp_jge_imm(struct bpf_test *self)
2439  {
2440  	return __bpf_fill_jmp_imm(self, BPF_JGE);
2441  }
2442  
2443  static int bpf_fill_jmp_jlt_imm(struct bpf_test *self)
2444  {
2445  	return __bpf_fill_jmp_imm(self, BPF_JLT);
2446  }
2447  
2448  static int bpf_fill_jmp_jle_imm(struct bpf_test *self)
2449  {
2450  	return __bpf_fill_jmp_imm(self, BPF_JLE);
2451  }
2452  
2453  static int bpf_fill_jmp_jsgt_imm(struct bpf_test *self)
2454  {
2455  	return __bpf_fill_jmp_imm(self, BPF_JSGT);
2456  }
2457  
2458  static int bpf_fill_jmp_jsge_imm(struct bpf_test *self)
2459  {
2460  	return __bpf_fill_jmp_imm(self, BPF_JSGE);
2461  }
2462  
2463  static int bpf_fill_jmp_jslt_imm(struct bpf_test *self)
2464  {
2465  	return __bpf_fill_jmp_imm(self, BPF_JSLT);
2466  }
2467  
2468  static int bpf_fill_jmp_jsle_imm(struct bpf_test *self)
2469  {
2470  	return __bpf_fill_jmp_imm(self, BPF_JSLE);
2471  }
2472  
2473  /* JMP32 immediate tests */
2474  static int bpf_fill_jmp32_jset_imm(struct bpf_test *self)
2475  {
2476  	return __bpf_fill_jmp32_imm(self, BPF_JSET);
2477  }
2478  
2479  static int bpf_fill_jmp32_jeq_imm(struct bpf_test *self)
2480  {
2481  	return __bpf_fill_jmp32_imm(self, BPF_JEQ);
2482  }
2483  
2484  static int bpf_fill_jmp32_jne_imm(struct bpf_test *self)
2485  {
2486  	return __bpf_fill_jmp32_imm(self, BPF_JNE);
2487  }
2488  
2489  static int bpf_fill_jmp32_jgt_imm(struct bpf_test *self)
2490  {
2491  	return __bpf_fill_jmp32_imm(self, BPF_JGT);
2492  }
2493  
2494  static int bpf_fill_jmp32_jge_imm(struct bpf_test *self)
2495  {
2496  	return __bpf_fill_jmp32_imm(self, BPF_JGE);
2497  }
2498  
2499  static int bpf_fill_jmp32_jlt_imm(struct bpf_test *self)
2500  {
2501  	return __bpf_fill_jmp32_imm(self, BPF_JLT);
2502  }
2503  
2504  static int bpf_fill_jmp32_jle_imm(struct bpf_test *self)
2505  {
2506  	return __bpf_fill_jmp32_imm(self, BPF_JLE);
2507  }
2508  
2509  static int bpf_fill_jmp32_jsgt_imm(struct bpf_test *self)
2510  {
2511  	return __bpf_fill_jmp32_imm(self, BPF_JSGT);
2512  }
2513  
2514  static int bpf_fill_jmp32_jsge_imm(struct bpf_test *self)
2515  {
2516  	return __bpf_fill_jmp32_imm(self, BPF_JSGE);
2517  }
2518  
2519  static int bpf_fill_jmp32_jslt_imm(struct bpf_test *self)
2520  {
2521  	return __bpf_fill_jmp32_imm(self, BPF_JSLT);
2522  }
2523  
2524  static int bpf_fill_jmp32_jsle_imm(struct bpf_test *self)
2525  {
2526  	return __bpf_fill_jmp32_imm(self, BPF_JSLE);
2527  }
2528  
2529  /* JMP register tests */
2530  static int bpf_fill_jmp_jset_reg(struct bpf_test *self)
2531  {
2532  	return __bpf_fill_jmp_reg(self, BPF_JSET);
2533  }
2534  
2535  static int bpf_fill_jmp_jeq_reg(struct bpf_test *self)
2536  {
2537  	return __bpf_fill_jmp_reg(self, BPF_JEQ);
2538  }
2539  
2540  static int bpf_fill_jmp_jne_reg(struct bpf_test *self)
2541  {
2542  	return __bpf_fill_jmp_reg(self, BPF_JNE);
2543  }
2544  
2545  static int bpf_fill_jmp_jgt_reg(struct bpf_test *self)
2546  {
2547  	return __bpf_fill_jmp_reg(self, BPF_JGT);
2548  }
2549  
2550  static int bpf_fill_jmp_jge_reg(struct bpf_test *self)
2551  {
2552  	return __bpf_fill_jmp_reg(self, BPF_JGE);
2553  }
2554  
2555  static int bpf_fill_jmp_jlt_reg(struct bpf_test *self)
2556  {
2557  	return __bpf_fill_jmp_reg(self, BPF_JLT);
2558  }
2559  
2560  static int bpf_fill_jmp_jle_reg(struct bpf_test *self)
2561  {
2562  	return __bpf_fill_jmp_reg(self, BPF_JLE);
2563  }
2564  
2565  static int bpf_fill_jmp_jsgt_reg(struct bpf_test *self)
2566  {
2567  	return __bpf_fill_jmp_reg(self, BPF_JSGT);
2568  }
2569  
2570  static int bpf_fill_jmp_jsge_reg(struct bpf_test *self)
2571  {
2572  	return __bpf_fill_jmp_reg(self, BPF_JSGE);
2573  }
2574  
2575  static int bpf_fill_jmp_jslt_reg(struct bpf_test *self)
2576  {
2577  	return __bpf_fill_jmp_reg(self, BPF_JSLT);
2578  }
2579  
2580  static int bpf_fill_jmp_jsle_reg(struct bpf_test *self)
2581  {
2582  	return __bpf_fill_jmp_reg(self, BPF_JSLE);
2583  }
2584  
2585  /* JMP32 register tests */
2586  static int bpf_fill_jmp32_jset_reg(struct bpf_test *self)
2587  {
2588  	return __bpf_fill_jmp32_reg(self, BPF_JSET);
2589  }
2590  
2591  static int bpf_fill_jmp32_jeq_reg(struct bpf_test *self)
2592  {
2593  	return __bpf_fill_jmp32_reg(self, BPF_JEQ);
2594  }
2595  
2596  static int bpf_fill_jmp32_jne_reg(struct bpf_test *self)
2597  {
2598  	return __bpf_fill_jmp32_reg(self, BPF_JNE);
2599  }
2600  
2601  static int bpf_fill_jmp32_jgt_reg(struct bpf_test *self)
2602  {
2603  	return __bpf_fill_jmp32_reg(self, BPF_JGT);
2604  }
2605  
2606  static int bpf_fill_jmp32_jge_reg(struct bpf_test *self)
2607  {
2608  	return __bpf_fill_jmp32_reg(self, BPF_JGE);
2609  }
2610  
2611  static int bpf_fill_jmp32_jlt_reg(struct bpf_test *self)
2612  {
2613  	return __bpf_fill_jmp32_reg(self, BPF_JLT);
2614  }
2615  
2616  static int bpf_fill_jmp32_jle_reg(struct bpf_test *self)
2617  {
2618  	return __bpf_fill_jmp32_reg(self, BPF_JLE);
2619  }
2620  
2621  static int bpf_fill_jmp32_jsgt_reg(struct bpf_test *self)
2622  {
2623  	return __bpf_fill_jmp32_reg(self, BPF_JSGT);
2624  }
2625  
2626  static int bpf_fill_jmp32_jsge_reg(struct bpf_test *self)
2627  {
2628  	return __bpf_fill_jmp32_reg(self, BPF_JSGE);
2629  }
2630  
2631  static int bpf_fill_jmp32_jslt_reg(struct bpf_test *self)
2632  {
2633  	return __bpf_fill_jmp32_reg(self, BPF_JSLT);
2634  }
2635  
2636  static int bpf_fill_jmp32_jsle_reg(struct bpf_test *self)
2637  {
2638  	return __bpf_fill_jmp32_reg(self, BPF_JSLE);
2639  }
2640  
2641  /*
2642   * Set up a sequence of staggered jumps, forwards and backwards with
2643   * increasing offset. This tests the conversion of relative jumps to
2644   * JITed native jumps. On some architectures, for example MIPS, a large
2645   * PC-relative jump offset may overflow the immediate field of the native
2646   * conditional branch instruction, triggering a conversion to use an
2647   * absolute jump instead. Since this changes the jump offsets, another
2648   * offset computation pass is necessary, and that may in turn trigger
2649   * another branch conversion. This jump sequence is particularly nasty
2650   * in that regard.
2651   *
2652   * The sequence generation is parameterized by size and jump type.
2653   * The size must be even, and the expected result is always size + 1.
2654   * Below is an example with size=8 and result=9.
2655   *
2656   *                     ________________________Start
2657   *                     R0 = 0
2658   *                     R1 = r1
2659   *                     R2 = r2
2660   *            ,------- JMP +4 * 3______________Preamble: 4 insns
2661   * ,----------|-ind 0- if R0 != 7 JMP 8 * 3 + 1 <--------------------.
2662   * |          |        R0 = 8                                        |
2663   * |          |        JMP +7 * 3               ------------------------.
2664   * | ,--------|-----1- if R0 != 5 JMP 7 * 3 + 1 <--------------.     |  |
2665   * | |        |        R0 = 6                                  |     |  |
2666   * | |        |        JMP +5 * 3               ------------------.  |  |
2667   * | | ,------|-----2- if R0 != 3 JMP 6 * 3 + 1 <--------.     |  |  |  |
2668   * | | |      |        R0 = 4                            |     |  |  |  |
2669   * | | |      |        JMP +3 * 3               ------------.  |  |  |  |
2670   * | | | ,----|-----3- if R0 != 1 JMP 5 * 3 + 1 <--.     |  |  |  |  |  |
2671   * | | | |    |        R0 = 2                      |     |  |  |  |  |  |
2672   * | | | |    |        JMP +1 * 3               ------.  |  |  |  |  |  |
2673   * | | | | ,--t=====4> if R0 != 0 JMP 4 * 3 + 1    1  2  3  4  5  6  7  8 loc
2674   * | | | | |           R0 = 1                     -1 +2 -3 +4 -5 +6 -7 +8 off
2675   * | | | | |           JMP -2 * 3               ---'  |  |  |  |  |  |  |
2676   * | | | | | ,------5- if R0 != 2 JMP 3 * 3 + 1 <-----'  |  |  |  |  |  |
2677   * | | | | | |         R0 = 3                            |  |  |  |  |  |
2678   * | | | | | |         JMP -4 * 3               ---------'  |  |  |  |  |
2679   * | | | | | | ,----6- if R0 != 4 JMP 2 * 3 + 1 <-----------'  |  |  |  |
2680   * | | | | | | |       R0 = 5                                  |  |  |  |
2681   * | | | | | | |       JMP -6 * 3               ---------------'  |  |  |
2682   * | | | | | | | ,--7- if R0 != 6 JMP 1 * 3 + 1 <-----------------'  |  |
2683   * | | | | | | | |     R0 = 7                                        |  |
2684   * | | Error | | |     JMP -8 * 3               ---------------------'  |
2685   * | | paths | | | ,8- if R0 != 8 JMP 0 * 3 + 1 <-----------------------'
2686   * | | | | | | | | |   R0 = 9__________________Sequence: 3 * size - 1 insns
2687   * `-+-+-+-+-+-+-+-+-> EXIT____________________Return: 1 insn
2688   *
2689   */
2690  
2691  /* The maximum size parameter */
2692  #define MAX_STAGGERED_JMP_SIZE ((0x7fff / 3) & ~1)
2693  
2694  /* We use a reduced number of iterations to get a reasonable execution time */
2695  #define NR_STAGGERED_JMP_RUNS 10
2696  
2697  static int __bpf_fill_staggered_jumps(struct bpf_test *self,
2698  				      const struct bpf_insn *jmp,
2699  				      u64 r1, u64 r2)
2700  {
2701  	int size = self->test[0].result - 1;
2702  	int len = 4 + 3 * (size + 1);
2703  	struct bpf_insn *insns;
2704  	int off, ind;
2705  
2706  	insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL);
2707  	if (!insns)
2708  		return -ENOMEM;
2709  
2710  	/* Preamble */
2711  	insns[0] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
2712  	insns[1] = BPF_ALU64_IMM(BPF_MOV, R1, r1);
2713  	insns[2] = BPF_ALU64_IMM(BPF_MOV, R2, r2);
2714  	insns[3] = BPF_JMP_IMM(BPF_JA, 0, 0, 3 * size / 2);
2715  
2716  	/* Sequence */
2717  	for (ind = 0, off = size; ind <= size; ind++, off -= 2) {
2718  		struct bpf_insn *ins = &insns[4 + 3 * ind];
2719  		int loc;
2720  
2721  		if (off == 0)
2722  			off--;
2723  
2724  		loc = abs(off);
2725  		ins[0] = BPF_JMP_IMM(BPF_JNE, R0, loc - 1,
2726  				     3 * (size - ind) + 1);
2727  		ins[1] = BPF_ALU64_IMM(BPF_MOV, R0, loc);
2728  		ins[2] = *jmp;
2729  		ins[2].off = 3 * (off - 1);
2730  	}
2731  
2732  	/* Return */
2733  	insns[len - 1] = BPF_EXIT_INSN();
2734  
2735  	self->u.ptr.insns = insns;
2736  	self->u.ptr.len = len;
2737  
2738  	return 0;
2739  }
2740  
2741  /* 64-bit unconditional jump */
2742  static int bpf_fill_staggered_ja(struct bpf_test *self)
2743  {
2744  	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JA, 0, 0, 0);
2745  
2746  	return __bpf_fill_staggered_jumps(self, &jmp, 0, 0);
2747  }
2748  
2749  /* 64-bit immediate jumps */
2750  static int bpf_fill_staggered_jeq_imm(struct bpf_test *self)
2751  {
2752  	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JEQ, R1, 1234, 0);
2753  
2754  	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2755  }
2756  
2757  static int bpf_fill_staggered_jne_imm(struct bpf_test *self)
2758  {
2759  	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JNE, R1, 1234, 0);
2760  
2761  	return __bpf_fill_staggered_jumps(self, &jmp, 4321, 0);
2762  }
2763  
2764  static int bpf_fill_staggered_jset_imm(struct bpf_test *self)
2765  {
2766  	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSET, R1, 0x82, 0);
2767  
2768  	return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0);
2769  }
2770  
2771  static int bpf_fill_staggered_jgt_imm(struct bpf_test *self)
2772  {
2773  	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JGT, R1, 1234, 0);
2774  
2775  	return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 0);
2776  }
2777  
2778  static int bpf_fill_staggered_jge_imm(struct bpf_test *self)
2779  {
2780  	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JGE, R1, 1234, 0);
2781  
2782  	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2783  }
2784  
2785  static int bpf_fill_staggered_jlt_imm(struct bpf_test *self)
2786  {
2787  	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JLT, R1, 0x80000000, 0);
2788  
2789  	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2790  }
2791  
2792  static int bpf_fill_staggered_jle_imm(struct bpf_test *self)
2793  {
2794  	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JLE, R1, 1234, 0);
2795  
2796  	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2797  }
2798  
2799  static int bpf_fill_staggered_jsgt_imm(struct bpf_test *self)
2800  {
2801  	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSGT, R1, -2, 0);
2802  
2803  	return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
2804  }
2805  
2806  static int bpf_fill_staggered_jsge_imm(struct bpf_test *self)
2807  {
2808  	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSGE, R1, -2, 0);
2809  
2810  	return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
2811  }
2812  
2813  static int bpf_fill_staggered_jslt_imm(struct bpf_test *self)
2814  {
2815  	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSLT, R1, -1, 0);
2816  
2817  	return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
2818  }
2819  
2820  static int bpf_fill_staggered_jsle_imm(struct bpf_test *self)
2821  {
2822  	struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSLE, R1, -1, 0);
2823  
2824  	return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
2825  }
2826  
2827  /* 64-bit register jumps */
2828  static int bpf_fill_staggered_jeq_reg(struct bpf_test *self)
2829  {
2830  	struct bpf_insn jmp = BPF_JMP_REG(BPF_JEQ, R1, R2, 0);
2831  
2832  	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
2833  }
2834  
2835  static int bpf_fill_staggered_jne_reg(struct bpf_test *self)
2836  {
2837  	struct bpf_insn jmp = BPF_JMP_REG(BPF_JNE, R1, R2, 0);
2838  
2839  	return __bpf_fill_staggered_jumps(self, &jmp, 4321, 1234);
2840  }
2841  
2842  static int bpf_fill_staggered_jset_reg(struct bpf_test *self)
2843  {
2844  	struct bpf_insn jmp = BPF_JMP_REG(BPF_JSET, R1, R2, 0);
2845  
2846  	return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0x82);
2847  }
2848  
2849  static int bpf_fill_staggered_jgt_reg(struct bpf_test *self)
2850  {
2851  	struct bpf_insn jmp = BPF_JMP_REG(BPF_JGT, R1, R2, 0);
2852  
2853  	return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 1234);
2854  }
2855  
2856  static int bpf_fill_staggered_jge_reg(struct bpf_test *self)
2857  {
2858  	struct bpf_insn jmp = BPF_JMP_REG(BPF_JGE, R1, R2, 0);
2859  
2860  	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
2861  }
2862  
2863  static int bpf_fill_staggered_jlt_reg(struct bpf_test *self)
2864  {
2865  	struct bpf_insn jmp = BPF_JMP_REG(BPF_JLT, R1, R2, 0);
2866  
2867  	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0x80000000);
2868  }
2869  
2870  static int bpf_fill_staggered_jle_reg(struct bpf_test *self)
2871  {
2872  	struct bpf_insn jmp = BPF_JMP_REG(BPF_JLE, R1, R2, 0);
2873  
2874  	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
2875  }
2876  
2877  static int bpf_fill_staggered_jsgt_reg(struct bpf_test *self)
2878  {
2879  	struct bpf_insn jmp = BPF_JMP_REG(BPF_JSGT, R1, R2, 0);
2880  
2881  	return __bpf_fill_staggered_jumps(self, &jmp, -1, -2);
2882  }
2883  
2884  static int bpf_fill_staggered_jsge_reg(struct bpf_test *self)
2885  {
2886  	struct bpf_insn jmp = BPF_JMP_REG(BPF_JSGE, R1, R2, 0);
2887  
2888  	return __bpf_fill_staggered_jumps(self, &jmp, -2, -2);
2889  }
2890  
2891  static int bpf_fill_staggered_jslt_reg(struct bpf_test *self)
2892  {
2893  	struct bpf_insn jmp = BPF_JMP_REG(BPF_JSLT, R1, R2, 0);
2894  
2895  	return __bpf_fill_staggered_jumps(self, &jmp, -2, -1);
2896  }
2897  
2898  static int bpf_fill_staggered_jsle_reg(struct bpf_test *self)
2899  {
2900  	struct bpf_insn jmp = BPF_JMP_REG(BPF_JSLE, R1, R2, 0);
2901  
2902  	return __bpf_fill_staggered_jumps(self, &jmp, -1, -1);
2903  }
2904  
2905  /* 32-bit immediate jumps */
2906  static int bpf_fill_staggered_jeq32_imm(struct bpf_test *self)
2907  {
2908  	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JEQ, R1, 1234, 0);
2909  
2910  	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2911  }
2912  
2913  static int bpf_fill_staggered_jne32_imm(struct bpf_test *self)
2914  {
2915  	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JNE, R1, 1234, 0);
2916  
2917  	return __bpf_fill_staggered_jumps(self, &jmp, 4321, 0);
2918  }
2919  
2920  static int bpf_fill_staggered_jset32_imm(struct bpf_test *self)
2921  {
2922  	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSET, R1, 0x82, 0);
2923  
2924  	return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0);
2925  }
2926  
2927  static int bpf_fill_staggered_jgt32_imm(struct bpf_test *self)
2928  {
2929  	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JGT, R1, 1234, 0);
2930  
2931  	return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 0);
2932  }
2933  
2934  static int bpf_fill_staggered_jge32_imm(struct bpf_test *self)
2935  {
2936  	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JGE, R1, 1234, 0);
2937  
2938  	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2939  }
2940  
2941  static int bpf_fill_staggered_jlt32_imm(struct bpf_test *self)
2942  {
2943  	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JLT, R1, 0x80000000, 0);
2944  
2945  	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2946  }
2947  
2948  static int bpf_fill_staggered_jle32_imm(struct bpf_test *self)
2949  {
2950  	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JLE, R1, 1234, 0);
2951  
2952  	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2953  }
2954  
2955  static int bpf_fill_staggered_jsgt32_imm(struct bpf_test *self)
2956  {
2957  	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSGT, R1, -2, 0);
2958  
2959  	return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
2960  }
2961  
2962  static int bpf_fill_staggered_jsge32_imm(struct bpf_test *self)
2963  {
2964  	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSGE, R1, -2, 0);
2965  
2966  	return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
2967  }
2968  
2969  static int bpf_fill_staggered_jslt32_imm(struct bpf_test *self)
2970  {
2971  	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSLT, R1, -1, 0);
2972  
2973  	return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
2974  }
2975  
2976  static int bpf_fill_staggered_jsle32_imm(struct bpf_test *self)
2977  {
2978  	struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSLE, R1, -1, 0);
2979  
2980  	return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
2981  }
2982  
2983  /* 32-bit register jumps */
2984  static int bpf_fill_staggered_jeq32_reg(struct bpf_test *self)
2985  {
2986  	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JEQ, R1, R2, 0);
2987  
2988  	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
2989  }
2990  
2991  static int bpf_fill_staggered_jne32_reg(struct bpf_test *self)
2992  {
2993  	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JNE, R1, R2, 0);
2994  
2995  	return __bpf_fill_staggered_jumps(self, &jmp, 4321, 1234);
2996  }
2997  
2998  static int bpf_fill_staggered_jset32_reg(struct bpf_test *self)
2999  {
3000  	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSET, R1, R2, 0);
3001  
3002  	return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0x82);
3003  }
3004  
3005  static int bpf_fill_staggered_jgt32_reg(struct bpf_test *self)
3006  {
3007  	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JGT, R1, R2, 0);
3008  
3009  	return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 1234);
3010  }
3011  
3012  static int bpf_fill_staggered_jge32_reg(struct bpf_test *self)
3013  {
3014  	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JGE, R1, R2, 0);
3015  
3016  	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
3017  }
3018  
3019  static int bpf_fill_staggered_jlt32_reg(struct bpf_test *self)
3020  {
3021  	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JLT, R1, R2, 0);
3022  
3023  	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0x80000000);
3024  }
3025  
3026  static int bpf_fill_staggered_jle32_reg(struct bpf_test *self)
3027  {
3028  	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JLE, R1, R2, 0);
3029  
3030  	return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
3031  }
3032  
3033  static int bpf_fill_staggered_jsgt32_reg(struct bpf_test *self)
3034  {
3035  	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSGT, R1, R2, 0);
3036  
3037  	return __bpf_fill_staggered_jumps(self, &jmp, -1, -2);
3038  }
3039  
3040  static int bpf_fill_staggered_jsge32_reg(struct bpf_test *self)
3041  {
3042  	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSGE, R1, R2, 0);
3043  
3044  	return __bpf_fill_staggered_jumps(self, &jmp, -2, -2);
3045  }
3046  
3047  static int bpf_fill_staggered_jslt32_reg(struct bpf_test *self)
3048  {
3049  	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSLT, R1, R2, 0);
3050  
3051  	return __bpf_fill_staggered_jumps(self, &jmp, -2, -1);
3052  }
3053  
3054  static int bpf_fill_staggered_jsle32_reg(struct bpf_test *self)
3055  {
3056  	struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSLE, R1, R2, 0);
3057  
3058  	return __bpf_fill_staggered_jumps(self, &jmp, -1, -1);
3059  }
3060  
3061  
3062  static struct bpf_test tests[] = {
3063  	{
3064  		"TAX",
3065  		.u.insns = {
3066  			BPF_STMT(BPF_LD | BPF_IMM, 1),
3067  			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3068  			BPF_STMT(BPF_LD | BPF_IMM, 2),
3069  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3070  			BPF_STMT(BPF_ALU | BPF_NEG, 0), /* A == -3 */
3071  			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3072  			BPF_STMT(BPF_LD | BPF_LEN, 0),
3073  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3074  			BPF_STMT(BPF_MISC | BPF_TAX, 0), /* X == len - 3 */
3075  			BPF_STMT(BPF_LD | BPF_B | BPF_IND, 1),
3076  			BPF_STMT(BPF_RET | BPF_A, 0)
3077  		},
3078  		CLASSIC,
3079  		{ 10, 20, 30, 40, 50 },
3080  		{ { 2, 10 }, { 3, 20 }, { 4, 30 } },
3081  	},
3082  	{
3083  		"TXA",
3084  		.u.insns = {
3085  			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3086  			BPF_STMT(BPF_MISC | BPF_TXA, 0),
3087  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3088  			BPF_STMT(BPF_RET | BPF_A, 0) /* A == len * 2 */
3089  		},
3090  		CLASSIC,
3091  		{ 10, 20, 30, 40, 50 },
3092  		{ { 1, 2 }, { 3, 6 }, { 4, 8 } },
3093  	},
3094  	{
3095  		"ADD_SUB_MUL_K",
3096  		.u.insns = {
3097  			BPF_STMT(BPF_LD | BPF_IMM, 1),
3098  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 2),
3099  			BPF_STMT(BPF_LDX | BPF_IMM, 3),
3100  			BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
3101  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0xffffffff),
3102  			BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 3),
3103  			BPF_STMT(BPF_RET | BPF_A, 0)
3104  		},
3105  		CLASSIC | FLAG_NO_DATA,
3106  		{ },
3107  		{ { 0, 0xfffffffd } }
3108  	},
3109  	{
3110  		"DIV_MOD_KX",
3111  		.u.insns = {
3112  			BPF_STMT(BPF_LD | BPF_IMM, 8),
3113  			BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 2),
3114  			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3115  			BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
3116  			BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
3117  			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3118  			BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
3119  			BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x70000000),
3120  			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3121  			BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
3122  			BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
3123  			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3124  			BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
3125  			BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x70000000),
3126  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3127  			BPF_STMT(BPF_RET | BPF_A, 0)
3128  		},
3129  		CLASSIC | FLAG_NO_DATA,
3130  		{ },
3131  		{ { 0, 0x20000000 } }
3132  	},
3133  	{
3134  		"AND_OR_LSH_K",
3135  		.u.insns = {
3136  			BPF_STMT(BPF_LD | BPF_IMM, 0xff),
3137  			BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
3138  			BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 27),
3139  			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3140  			BPF_STMT(BPF_LD | BPF_IMM, 0xf),
3141  			BPF_STMT(BPF_ALU | BPF_OR | BPF_K, 0xf0),
3142  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3143  			BPF_STMT(BPF_RET | BPF_A, 0)
3144  		},
3145  		CLASSIC | FLAG_NO_DATA,
3146  		{ },
3147  		{ { 0, 0x800000ff }, { 1, 0x800000ff } },
3148  	},
3149  	{
3150  		"LD_IMM_0",
3151  		.u.insns = {
3152  			BPF_STMT(BPF_LD | BPF_IMM, 0), /* ld #0 */
3153  			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0, 1, 0),
3154  			BPF_STMT(BPF_RET | BPF_K, 0),
3155  			BPF_STMT(BPF_RET | BPF_K, 1),
3156  		},
3157  		CLASSIC,
3158  		{ },
3159  		{ { 1, 1 } },
3160  	},
3161  	{
3162  		"LD_IND",
3163  		.u.insns = {
3164  			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3165  			BPF_STMT(BPF_LD | BPF_H | BPF_IND, MAX_K),
3166  			BPF_STMT(BPF_RET | BPF_K, 1)
3167  		},
3168  		CLASSIC,
3169  		{ },
3170  		{ { 1, 0 }, { 10, 0 }, { 60, 0 } },
3171  	},
3172  	{
3173  		"LD_ABS",
3174  		.u.insns = {
3175  			BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1000),
3176  			BPF_STMT(BPF_RET | BPF_K, 1)
3177  		},
3178  		CLASSIC,
3179  		{ },
3180  		{ { 1, 0 }, { 10, 0 }, { 60, 0 } },
3181  	},
3182  	{
3183  		"LD_ABS_LL",
3184  		.u.insns = {
3185  			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF),
3186  			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3187  			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF + 1),
3188  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3189  			BPF_STMT(BPF_RET | BPF_A, 0)
3190  		},
3191  		CLASSIC,
3192  		{ 1, 2, 3 },
3193  		{ { 1, 0 }, { 2, 3 } },
3194  	},
3195  	{
3196  		"LD_IND_LL",
3197  		.u.insns = {
3198  			BPF_STMT(BPF_LD | BPF_IMM, SKF_LL_OFF - 1),
3199  			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3200  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3201  			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3202  			BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
3203  			BPF_STMT(BPF_RET | BPF_A, 0)
3204  		},
3205  		CLASSIC,
3206  		{ 1, 2, 3, 0xff },
3207  		{ { 1, 1 }, { 3, 3 }, { 4, 0xff } },
3208  	},
3209  	{
3210  		"LD_ABS_NET",
3211  		.u.insns = {
3212  			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF),
3213  			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3214  			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF + 1),
3215  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3216  			BPF_STMT(BPF_RET | BPF_A, 0)
3217  		},
3218  		CLASSIC,
3219  		{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
3220  		{ { 15, 0 }, { 16, 3 } },
3221  	},
3222  	{
3223  		"LD_IND_NET",
3224  		.u.insns = {
3225  			BPF_STMT(BPF_LD | BPF_IMM, SKF_NET_OFF - 15),
3226  			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3227  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3228  			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3229  			BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
3230  			BPF_STMT(BPF_RET | BPF_A, 0)
3231  		},
3232  		CLASSIC,
3233  		{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
3234  		{ { 14, 0 }, { 15, 1 }, { 17, 3 } },
3235  	},
3236  	{
3237  		"LD_PKTTYPE",
3238  		.u.insns = {
3239  			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3240  				 SKF_AD_OFF + SKF_AD_PKTTYPE),
3241  			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
3242  			BPF_STMT(BPF_RET | BPF_K, 1),
3243  			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3244  				 SKF_AD_OFF + SKF_AD_PKTTYPE),
3245  			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
3246  			BPF_STMT(BPF_RET | BPF_K, 1),
3247  			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3248  				 SKF_AD_OFF + SKF_AD_PKTTYPE),
3249  			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
3250  			BPF_STMT(BPF_RET | BPF_K, 1),
3251  			BPF_STMT(BPF_RET | BPF_A, 0)
3252  		},
3253  		CLASSIC,
3254  		{ },
3255  		{ { 1, 3 }, { 10, 3 } },
3256  	},
3257  	{
3258  		"LD_MARK",
3259  		.u.insns = {
3260  			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3261  				 SKF_AD_OFF + SKF_AD_MARK),
3262  			BPF_STMT(BPF_RET | BPF_A, 0)
3263  		},
3264  		CLASSIC,
3265  		{ },
3266  		{ { 1, SKB_MARK}, { 10, SKB_MARK} },
3267  	},
3268  	{
3269  		"LD_RXHASH",
3270  		.u.insns = {
3271  			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3272  				 SKF_AD_OFF + SKF_AD_RXHASH),
3273  			BPF_STMT(BPF_RET | BPF_A, 0)
3274  		},
3275  		CLASSIC,
3276  		{ },
3277  		{ { 1, SKB_HASH}, { 10, SKB_HASH} },
3278  	},
3279  	{
3280  		"LD_QUEUE",
3281  		.u.insns = {
3282  			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3283  				 SKF_AD_OFF + SKF_AD_QUEUE),
3284  			BPF_STMT(BPF_RET | BPF_A, 0)
3285  		},
3286  		CLASSIC,
3287  		{ },
3288  		{ { 1, SKB_QUEUE_MAP }, { 10, SKB_QUEUE_MAP } },
3289  	},
3290  	{
3291  		"LD_PROTOCOL",
3292  		.u.insns = {
3293  			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 1),
3294  			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 20, 1, 0),
3295  			BPF_STMT(BPF_RET | BPF_K, 0),
3296  			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3297  				 SKF_AD_OFF + SKF_AD_PROTOCOL),
3298  			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3299  			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
3300  			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 30, 1, 0),
3301  			BPF_STMT(BPF_RET | BPF_K, 0),
3302  			BPF_STMT(BPF_MISC | BPF_TXA, 0),
3303  			BPF_STMT(BPF_RET | BPF_A, 0)
3304  		},
3305  		CLASSIC,
3306  		{ 10, 20, 30 },
3307  		{ { 10, ETH_P_IP }, { 100, ETH_P_IP } },
3308  	},
3309  	{
3310  		"LD_VLAN_TAG",
3311  		.u.insns = {
3312  			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3313  				 SKF_AD_OFF + SKF_AD_VLAN_TAG),
3314  			BPF_STMT(BPF_RET | BPF_A, 0)
3315  		},
3316  		CLASSIC,
3317  		{ },
3318  		{
3319  			{ 1, SKB_VLAN_TCI },
3320  			{ 10, SKB_VLAN_TCI }
3321  		},
3322  	},
3323  	{
3324  		"LD_VLAN_TAG_PRESENT",
3325  		.u.insns = {
3326  			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3327  				 SKF_AD_OFF + SKF_AD_VLAN_TAG_PRESENT),
3328  			BPF_STMT(BPF_RET | BPF_A, 0)
3329  		},
3330  		CLASSIC,
3331  		{ },
3332  		{
3333  			{ 1, SKB_VLAN_PRESENT },
3334  			{ 10, SKB_VLAN_PRESENT }
3335  		},
3336  	},
3337  	{
3338  		"LD_IFINDEX",
3339  		.u.insns = {
3340  			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3341  				 SKF_AD_OFF + SKF_AD_IFINDEX),
3342  			BPF_STMT(BPF_RET | BPF_A, 0)
3343  		},
3344  		CLASSIC,
3345  		{ },
3346  		{ { 1, SKB_DEV_IFINDEX }, { 10, SKB_DEV_IFINDEX } },
3347  	},
3348  	{
3349  		"LD_HATYPE",
3350  		.u.insns = {
3351  			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3352  				 SKF_AD_OFF + SKF_AD_HATYPE),
3353  			BPF_STMT(BPF_RET | BPF_A, 0)
3354  		},
3355  		CLASSIC,
3356  		{ },
3357  		{ { 1, SKB_DEV_TYPE }, { 10, SKB_DEV_TYPE } },
3358  	},
3359  	{
3360  		"LD_CPU",
3361  		.u.insns = {
3362  			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3363  				 SKF_AD_OFF + SKF_AD_CPU),
3364  			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3365  			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3366  				 SKF_AD_OFF + SKF_AD_CPU),
3367  			BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
3368  			BPF_STMT(BPF_RET | BPF_A, 0)
3369  		},
3370  		CLASSIC,
3371  		{ },
3372  		{ { 1, 0 }, { 10, 0 } },
3373  	},
3374  	{
3375  		"LD_NLATTR",
3376  		.u.insns = {
3377  			BPF_STMT(BPF_LDX | BPF_IMM, 2),
3378  			BPF_STMT(BPF_MISC | BPF_TXA, 0),
3379  			BPF_STMT(BPF_LDX | BPF_IMM, 3),
3380  			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3381  				 SKF_AD_OFF + SKF_AD_NLATTR),
3382  			BPF_STMT(BPF_RET | BPF_A, 0)
3383  		},
3384  		CLASSIC,
3385  #ifdef __BIG_ENDIAN
3386  		{ 0xff, 0xff, 0, 4, 0, 2, 0, 4, 0, 3 },
3387  #else
3388  		{ 0xff, 0xff, 4, 0, 2, 0, 4, 0, 3, 0 },
3389  #endif
3390  		{ { 4, 0 }, { 20, 6 } },
3391  	},
3392  	{
3393  		"LD_NLATTR_NEST",
3394  		.u.insns = {
3395  			BPF_STMT(BPF_LD | BPF_IMM, 2),
3396  			BPF_STMT(BPF_LDX | BPF_IMM, 3),
3397  			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3398  				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3399  			BPF_STMT(BPF_LD | BPF_IMM, 2),
3400  			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3401  				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3402  			BPF_STMT(BPF_LD | BPF_IMM, 2),
3403  			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3404  				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3405  			BPF_STMT(BPF_LD | BPF_IMM, 2),
3406  			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3407  				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3408  			BPF_STMT(BPF_LD | BPF_IMM, 2),
3409  			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3410  				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3411  			BPF_STMT(BPF_LD | BPF_IMM, 2),
3412  			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3413  				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3414  			BPF_STMT(BPF_LD | BPF_IMM, 2),
3415  			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3416  				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3417  			BPF_STMT(BPF_LD | BPF_IMM, 2),
3418  			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3419  				 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3420  			BPF_STMT(BPF_RET | BPF_A, 0)
3421  		},
3422  		CLASSIC,
3423  #ifdef __BIG_ENDIAN
3424  		{ 0xff, 0xff, 0, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3 },
3425  #else
3426  		{ 0xff, 0xff, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3, 0 },
3427  #endif
3428  		{ { 4, 0 }, { 20, 10 } },
3429  	},
3430  	{
3431  		"LD_PAYLOAD_OFF",
3432  		.u.insns = {
3433  			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3434  				 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
3435  			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3436  				 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
3437  			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3438  				 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
3439  			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3440  				 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
3441  			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3442  				 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
3443  			BPF_STMT(BPF_RET | BPF_A, 0)
3444  		},
3445  		CLASSIC,
3446  		/* 00:00:00:00:00:00 > 00:00:00:00:00:00, ethtype IPv4 (0x0800),
3447  		 * length 98: 127.0.0.1 > 127.0.0.1: ICMP echo request,
3448  		 * id 9737, seq 1, length 64
3449  		 */
3450  		{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3451  		  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3452  		  0x08, 0x00,
3453  		  0x45, 0x00, 0x00, 0x54, 0xac, 0x8b, 0x40, 0x00, 0x40,
3454  		  0x01, 0x90, 0x1b, 0x7f, 0x00, 0x00, 0x01 },
3455  		{ { 30, 0 }, { 100, 42 } },
3456  	},
3457  	{
3458  		"LD_ANC_XOR",
3459  		.u.insns = {
3460  			BPF_STMT(BPF_LD | BPF_IMM, 10),
3461  			BPF_STMT(BPF_LDX | BPF_IMM, 300),
3462  			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3463  				 SKF_AD_OFF + SKF_AD_ALU_XOR_X),
3464  			BPF_STMT(BPF_RET | BPF_A, 0)
3465  		},
3466  		CLASSIC,
3467  		{ },
3468  		{ { 4, 0xA ^ 300 }, { 20, 0xA ^ 300 } },
3469  	},
3470  	{
3471  		"SPILL_FILL",
3472  		.u.insns = {
3473  			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3474  			BPF_STMT(BPF_LD | BPF_IMM, 2),
3475  			BPF_STMT(BPF_ALU | BPF_RSH, 1),
3476  			BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
3477  			BPF_STMT(BPF_ST, 1), /* M1 = 1 ^ len */
3478  			BPF_STMT(BPF_ALU | BPF_XOR | BPF_K, 0x80000000),
3479  			BPF_STMT(BPF_ST, 2), /* M2 = 1 ^ len ^ 0x80000000 */
3480  			BPF_STMT(BPF_STX, 15), /* M3 = len */
3481  			BPF_STMT(BPF_LDX | BPF_MEM, 1),
3482  			BPF_STMT(BPF_LD | BPF_MEM, 2),
3483  			BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
3484  			BPF_STMT(BPF_LDX | BPF_MEM, 15),
3485  			BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
3486  			BPF_STMT(BPF_RET | BPF_A, 0)
3487  		},
3488  		CLASSIC,
3489  		{ },
3490  		{ { 1, 0x80000001 }, { 2, 0x80000002 }, { 60, 0x80000000 ^ 60 } }
3491  	},
3492  	{
3493  		"JEQ",
3494  		.u.insns = {
3495  			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3496  			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
3497  			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 0, 1),
3498  			BPF_STMT(BPF_RET | BPF_K, 1),
3499  			BPF_STMT(BPF_RET | BPF_K, MAX_K)
3500  		},
3501  		CLASSIC,
3502  		{ 3, 3, 3, 3, 3 },
3503  		{ { 1, 0 }, { 3, 1 }, { 4, MAX_K } },
3504  	},
3505  	{
3506  		"JGT",
3507  		.u.insns = {
3508  			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3509  			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
3510  			BPF_JUMP(BPF_JMP | BPF_JGT | BPF_X, 0, 0, 1),
3511  			BPF_STMT(BPF_RET | BPF_K, 1),
3512  			BPF_STMT(BPF_RET | BPF_K, MAX_K)
3513  		},
3514  		CLASSIC,
3515  		{ 4, 4, 4, 3, 3 },
3516  		{ { 2, 0 }, { 3, 1 }, { 4, MAX_K } },
3517  	},
3518  	{
3519  		"JGE (jt 0), test 1",
3520  		.u.insns = {
3521  			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3522  			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
3523  			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 1),
3524  			BPF_STMT(BPF_RET | BPF_K, 1),
3525  			BPF_STMT(BPF_RET | BPF_K, MAX_K)
3526  		},
3527  		CLASSIC,
3528  		{ 4, 4, 4, 3, 3 },
3529  		{ { 2, 0 }, { 3, 1 }, { 4, 1 } },
3530  	},
3531  	{
3532  		"JGE (jt 0), test 2",
3533  		.u.insns = {
3534  			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3535  			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
3536  			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 1),
3537  			BPF_STMT(BPF_RET | BPF_K, 1),
3538  			BPF_STMT(BPF_RET | BPF_K, MAX_K)
3539  		},
3540  		CLASSIC,
3541  		{ 4, 4, 5, 3, 3 },
3542  		{ { 4, 1 }, { 5, 1 }, { 6, MAX_K } },
3543  	},
3544  	{
3545  		"JGE",
3546  		.u.insns = {
3547  			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3548  			BPF_STMT(BPF_LD | BPF_B | BPF_IND, MAX_K),
3549  			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 1, 1, 0),
3550  			BPF_STMT(BPF_RET | BPF_K, 10),
3551  			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 2, 1, 0),
3552  			BPF_STMT(BPF_RET | BPF_K, 20),
3553  			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 3, 1, 0),
3554  			BPF_STMT(BPF_RET | BPF_K, 30),
3555  			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 4, 1, 0),
3556  			BPF_STMT(BPF_RET | BPF_K, 40),
3557  			BPF_STMT(BPF_RET | BPF_K, MAX_K)
3558  		},
3559  		CLASSIC,
3560  		{ 1, 2, 3, 4, 5 },
3561  		{ { 1, 20 }, { 3, 40 }, { 5, MAX_K } },
3562  	},
3563  	{
3564  		"JSET",
3565  		.u.insns = {
3566  			BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
3567  			BPF_JUMP(BPF_JMP | BPF_JA, 1, 1, 1),
3568  			BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
3569  			BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
3570  			BPF_STMT(BPF_LDX | BPF_LEN, 0),
3571  			BPF_STMT(BPF_MISC | BPF_TXA, 0),
3572  			BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, 4),
3573  			BPF_STMT(BPF_MISC | BPF_TAX, 0),
3574  			BPF_STMT(BPF_LD | BPF_W | BPF_IND, 0),
3575  			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 1, 0, 1),
3576  			BPF_STMT(BPF_RET | BPF_K, 10),
3577  			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x80000000, 0, 1),
3578  			BPF_STMT(BPF_RET | BPF_K, 20),
3579  			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
3580  			BPF_STMT(BPF_RET | BPF_K, 30),
3581  			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
3582  			BPF_STMT(BPF_RET | BPF_K, 30),
3583  			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
3584  			BPF_STMT(BPF_RET | BPF_K, 30),
3585  			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
3586  			BPF_STMT(BPF_RET | BPF_K, 30),
3587  			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
3588  			BPF_STMT(BPF_RET | BPF_K, 30),
3589  			BPF_STMT(BPF_RET | BPF_K, MAX_K)
3590  		},
3591  		CLASSIC,
3592  		{ 0, 0xAA, 0x55, 1 },
3593  		{ { 4, 10 }, { 5, 20 }, { 6, MAX_K } },
3594  	},
3595  	{
3596  		"tcpdump port 22",
3597  		.u.insns = {
3598  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
3599  			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 0, 8), /* IPv6 */
3600  			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 20),
3601  			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
3602  			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
3603  			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 17),
3604  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 54),
3605  			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 14, 0),
3606  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 56),
3607  			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 12, 13),
3608  			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0800, 0, 12), /* IPv4 */
3609  			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
3610  			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
3611  			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
3612  			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 8),
3613  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
3614  			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 6, 0),
3615  			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
3616  			BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
3617  			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
3618  			BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
3619  			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 1),
3620  			BPF_STMT(BPF_RET | BPF_K, 0xffff),
3621  			BPF_STMT(BPF_RET | BPF_K, 0),
3622  		},
3623  		CLASSIC,
3624  		/* 3c:07:54:43:e5:76 > 10:bf:48:d6:43:d6, ethertype IPv4(0x0800)
3625  		 * length 114: 10.1.1.149.49700 > 10.1.2.10.22: Flags [P.],
3626  		 * seq 1305692979:1305693027, ack 3650467037, win 65535,
3627  		 * options [nop,nop,TS val 2502645400 ecr 3971138], length 48
3628  		 */
3629  		{ 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
3630  		  0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
3631  		  0x08, 0x00,
3632  		  0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
3633  		  0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
3634  		  0x0a, 0x01, 0x01, 0x95, /* ip src */
3635  		  0x0a, 0x01, 0x02, 0x0a, /* ip dst */
3636  		  0xc2, 0x24,
3637  		  0x00, 0x16 /* dst port */ },
3638  		{ { 10, 0 }, { 30, 0 }, { 100, 65535 } },
3639  	},
3640  	{
3641  		"tcpdump complex",
3642  		.u.insns = {
3643  			/* tcpdump -nei eth0 'tcp port 22 and (((ip[2:2] -
3644  			 * ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0) and
3645  			 * (len > 115 or len < 30000000000)' -d
3646  			 */
3647  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
3648  			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 30, 0),
3649  			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x800, 0, 29),
3650  			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
3651  			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 0, 27),
3652  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
3653  			BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 25, 0),
3654  			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
3655  			BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
3656  			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
3657  			BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
3658  			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 20),
3659  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 16),
3660  			BPF_STMT(BPF_ST, 1),
3661  			BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 14),
3662  			BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf),
3663  			BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 2),
3664  			BPF_STMT(BPF_MISC | BPF_TAX, 0x5), /* libpcap emits K on TAX */
3665  			BPF_STMT(BPF_LD | BPF_MEM, 1),
3666  			BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
3667  			BPF_STMT(BPF_ST, 5),
3668  			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
3669  			BPF_STMT(BPF_LD | BPF_B | BPF_IND, 26),
3670  			BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
3671  			BPF_STMT(BPF_ALU | BPF_RSH | BPF_K, 2),
3672  			BPF_STMT(BPF_MISC | BPF_TAX, 0x9), /* libpcap emits K on TAX */
3673  			BPF_STMT(BPF_LD | BPF_MEM, 5),
3674  			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 4, 0),
3675  			BPF_STMT(BPF_LD | BPF_LEN, 0),
3676  			BPF_JUMP(BPF_JMP | BPF_JGT | BPF_K, 0x73, 1, 0),
3677  			BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 0xfc23ac00, 1, 0),
3678  			BPF_STMT(BPF_RET | BPF_K, 0xffff),
3679  			BPF_STMT(BPF_RET | BPF_K, 0),
3680  		},
3681  		CLASSIC,
3682  		{ 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
3683  		  0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
3684  		  0x08, 0x00,
3685  		  0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
3686  		  0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
3687  		  0x0a, 0x01, 0x01, 0x95, /* ip src */
3688  		  0x0a, 0x01, 0x02, 0x0a, /* ip dst */
3689  		  0xc2, 0x24,
3690  		  0x00, 0x16 /* dst port */ },
3691  		{ { 10, 0 }, { 30, 0 }, { 100, 65535 } },
3692  	},
3693  	{
3694  		"RET_A",
3695  		.u.insns = {
3696  			/* check that uninitialized X and A contain zeros */
3697  			BPF_STMT(BPF_MISC | BPF_TXA, 0),
3698  			BPF_STMT(BPF_RET | BPF_A, 0)
3699  		},
3700  		CLASSIC,
3701  		{ },
3702  		{ {1, 0}, {2, 0} },
3703  	},
3704  	{
3705  		"INT: ADD trivial",
3706  		.u.insns_int = {
3707  			BPF_ALU64_IMM(BPF_MOV, R1, 1),
3708  			BPF_ALU64_IMM(BPF_ADD, R1, 2),
3709  			BPF_ALU64_IMM(BPF_MOV, R2, 3),
3710  			BPF_ALU64_REG(BPF_SUB, R1, R2),
3711  			BPF_ALU64_IMM(BPF_ADD, R1, -1),
3712  			BPF_ALU64_IMM(BPF_MUL, R1, 3),
3713  			BPF_ALU64_REG(BPF_MOV, R0, R1),
3714  			BPF_EXIT_INSN(),
3715  		},
3716  		INTERNAL,
3717  		{ },
3718  		{ { 0, 0xfffffffd } }
3719  	},
3720  	{
3721  		"INT: MUL_X",
3722  		.u.insns_int = {
3723  			BPF_ALU64_IMM(BPF_MOV, R0, -1),
3724  			BPF_ALU64_IMM(BPF_MOV, R1, -1),
3725  			BPF_ALU64_IMM(BPF_MOV, R2, 3),
3726  			BPF_ALU64_REG(BPF_MUL, R1, R2),
3727  			BPF_JMP_IMM(BPF_JEQ, R1, 0xfffffffd, 1),
3728  			BPF_EXIT_INSN(),
3729  			BPF_ALU64_IMM(BPF_MOV, R0, 1),
3730  			BPF_EXIT_INSN(),
3731  		},
3732  		INTERNAL,
3733  		{ },
3734  		{ { 0, 1 } }
3735  	},
3736  	{
3737  		"INT: MUL_X2",
3738  		.u.insns_int = {
3739  			BPF_ALU32_IMM(BPF_MOV, R0, -1),
3740  			BPF_ALU32_IMM(BPF_MOV, R1, -1),
3741  			BPF_ALU32_IMM(BPF_MOV, R2, 3),
3742  			BPF_ALU64_REG(BPF_MUL, R1, R2),
3743  			BPF_ALU64_IMM(BPF_RSH, R1, 8),
3744  			BPF_JMP_IMM(BPF_JEQ, R1, 0x2ffffff, 1),
3745  			BPF_EXIT_INSN(),
3746  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
3747  			BPF_EXIT_INSN(),
3748  		},
3749  		INTERNAL,
3750  		{ },
3751  		{ { 0, 1 } }
3752  	},
3753  	{
3754  		"INT: MUL32_X",
3755  		.u.insns_int = {
3756  			BPF_ALU32_IMM(BPF_MOV, R0, -1),
3757  			BPF_ALU64_IMM(BPF_MOV, R1, -1),
3758  			BPF_ALU32_IMM(BPF_MOV, R2, 3),
3759  			BPF_ALU32_REG(BPF_MUL, R1, R2),
3760  			BPF_ALU64_IMM(BPF_RSH, R1, 8),
3761  			BPF_JMP_IMM(BPF_JEQ, R1, 0xffffff, 1),
3762  			BPF_EXIT_INSN(),
3763  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
3764  			BPF_EXIT_INSN(),
3765  		},
3766  		INTERNAL,
3767  		{ },
3768  		{ { 0, 1 } }
3769  	},
3770  	{
3771  		/* Have to test all register combinations, since
3772  		 * JITing of different registers will produce
3773  		 * different asm code.
3774  		 */
3775  		"INT: ADD 64-bit",
3776  		.u.insns_int = {
3777  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
3778  			BPF_ALU64_IMM(BPF_MOV, R1, 1),
3779  			BPF_ALU64_IMM(BPF_MOV, R2, 2),
3780  			BPF_ALU64_IMM(BPF_MOV, R3, 3),
3781  			BPF_ALU64_IMM(BPF_MOV, R4, 4),
3782  			BPF_ALU64_IMM(BPF_MOV, R5, 5),
3783  			BPF_ALU64_IMM(BPF_MOV, R6, 6),
3784  			BPF_ALU64_IMM(BPF_MOV, R7, 7),
3785  			BPF_ALU64_IMM(BPF_MOV, R8, 8),
3786  			BPF_ALU64_IMM(BPF_MOV, R9, 9),
3787  			BPF_ALU64_IMM(BPF_ADD, R0, 20),
3788  			BPF_ALU64_IMM(BPF_ADD, R1, 20),
3789  			BPF_ALU64_IMM(BPF_ADD, R2, 20),
3790  			BPF_ALU64_IMM(BPF_ADD, R3, 20),
3791  			BPF_ALU64_IMM(BPF_ADD, R4, 20),
3792  			BPF_ALU64_IMM(BPF_ADD, R5, 20),
3793  			BPF_ALU64_IMM(BPF_ADD, R6, 20),
3794  			BPF_ALU64_IMM(BPF_ADD, R7, 20),
3795  			BPF_ALU64_IMM(BPF_ADD, R8, 20),
3796  			BPF_ALU64_IMM(BPF_ADD, R9, 20),
3797  			BPF_ALU64_IMM(BPF_SUB, R0, 10),
3798  			BPF_ALU64_IMM(BPF_SUB, R1, 10),
3799  			BPF_ALU64_IMM(BPF_SUB, R2, 10),
3800  			BPF_ALU64_IMM(BPF_SUB, R3, 10),
3801  			BPF_ALU64_IMM(BPF_SUB, R4, 10),
3802  			BPF_ALU64_IMM(BPF_SUB, R5, 10),
3803  			BPF_ALU64_IMM(BPF_SUB, R6, 10),
3804  			BPF_ALU64_IMM(BPF_SUB, R7, 10),
3805  			BPF_ALU64_IMM(BPF_SUB, R8, 10),
3806  			BPF_ALU64_IMM(BPF_SUB, R9, 10),
3807  			BPF_ALU64_REG(BPF_ADD, R0, R0),
3808  			BPF_ALU64_REG(BPF_ADD, R0, R1),
3809  			BPF_ALU64_REG(BPF_ADD, R0, R2),
3810  			BPF_ALU64_REG(BPF_ADD, R0, R3),
3811  			BPF_ALU64_REG(BPF_ADD, R0, R4),
3812  			BPF_ALU64_REG(BPF_ADD, R0, R5),
3813  			BPF_ALU64_REG(BPF_ADD, R0, R6),
3814  			BPF_ALU64_REG(BPF_ADD, R0, R7),
3815  			BPF_ALU64_REG(BPF_ADD, R0, R8),
3816  			BPF_ALU64_REG(BPF_ADD, R0, R9), /* R0 == 155 */
3817  			BPF_JMP_IMM(BPF_JEQ, R0, 155, 1),
3818  			BPF_EXIT_INSN(),
3819  			BPF_ALU64_REG(BPF_ADD, R1, R0),
3820  			BPF_ALU64_REG(BPF_ADD, R1, R1),
3821  			BPF_ALU64_REG(BPF_ADD, R1, R2),
3822  			BPF_ALU64_REG(BPF_ADD, R1, R3),
3823  			BPF_ALU64_REG(BPF_ADD, R1, R4),
3824  			BPF_ALU64_REG(BPF_ADD, R1, R5),
3825  			BPF_ALU64_REG(BPF_ADD, R1, R6),
3826  			BPF_ALU64_REG(BPF_ADD, R1, R7),
3827  			BPF_ALU64_REG(BPF_ADD, R1, R8),
3828  			BPF_ALU64_REG(BPF_ADD, R1, R9), /* R1 == 456 */
3829  			BPF_JMP_IMM(BPF_JEQ, R1, 456, 1),
3830  			BPF_EXIT_INSN(),
3831  			BPF_ALU64_REG(BPF_ADD, R2, R0),
3832  			BPF_ALU64_REG(BPF_ADD, R2, R1),
3833  			BPF_ALU64_REG(BPF_ADD, R2, R2),
3834  			BPF_ALU64_REG(BPF_ADD, R2, R3),
3835  			BPF_ALU64_REG(BPF_ADD, R2, R4),
3836  			BPF_ALU64_REG(BPF_ADD, R2, R5),
3837  			BPF_ALU64_REG(BPF_ADD, R2, R6),
3838  			BPF_ALU64_REG(BPF_ADD, R2, R7),
3839  			BPF_ALU64_REG(BPF_ADD, R2, R8),
3840  			BPF_ALU64_REG(BPF_ADD, R2, R9), /* R2 == 1358 */
3841  			BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1),
3842  			BPF_EXIT_INSN(),
3843  			BPF_ALU64_REG(BPF_ADD, R3, R0),
3844  			BPF_ALU64_REG(BPF_ADD, R3, R1),
3845  			BPF_ALU64_REG(BPF_ADD, R3, R2),
3846  			BPF_ALU64_REG(BPF_ADD, R3, R3),
3847  			BPF_ALU64_REG(BPF_ADD, R3, R4),
3848  			BPF_ALU64_REG(BPF_ADD, R3, R5),
3849  			BPF_ALU64_REG(BPF_ADD, R3, R6),
3850  			BPF_ALU64_REG(BPF_ADD, R3, R7),
3851  			BPF_ALU64_REG(BPF_ADD, R3, R8),
3852  			BPF_ALU64_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
3853  			BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
3854  			BPF_EXIT_INSN(),
3855  			BPF_ALU64_REG(BPF_ADD, R4, R0),
3856  			BPF_ALU64_REG(BPF_ADD, R4, R1),
3857  			BPF_ALU64_REG(BPF_ADD, R4, R2),
3858  			BPF_ALU64_REG(BPF_ADD, R4, R3),
3859  			BPF_ALU64_REG(BPF_ADD, R4, R4),
3860  			BPF_ALU64_REG(BPF_ADD, R4, R5),
3861  			BPF_ALU64_REG(BPF_ADD, R4, R6),
3862  			BPF_ALU64_REG(BPF_ADD, R4, R7),
3863  			BPF_ALU64_REG(BPF_ADD, R4, R8),
3864  			BPF_ALU64_REG(BPF_ADD, R4, R9), /* R4 == 12177 */
3865  			BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1),
3866  			BPF_EXIT_INSN(),
3867  			BPF_ALU64_REG(BPF_ADD, R5, R0),
3868  			BPF_ALU64_REG(BPF_ADD, R5, R1),
3869  			BPF_ALU64_REG(BPF_ADD, R5, R2),
3870  			BPF_ALU64_REG(BPF_ADD, R5, R3),
3871  			BPF_ALU64_REG(BPF_ADD, R5, R4),
3872  			BPF_ALU64_REG(BPF_ADD, R5, R5),
3873  			BPF_ALU64_REG(BPF_ADD, R5, R6),
3874  			BPF_ALU64_REG(BPF_ADD, R5, R7),
3875  			BPF_ALU64_REG(BPF_ADD, R5, R8),
3876  			BPF_ALU64_REG(BPF_ADD, R5, R9), /* R5 == 36518 */
3877  			BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1),
3878  			BPF_EXIT_INSN(),
3879  			BPF_ALU64_REG(BPF_ADD, R6, R0),
3880  			BPF_ALU64_REG(BPF_ADD, R6, R1),
3881  			BPF_ALU64_REG(BPF_ADD, R6, R2),
3882  			BPF_ALU64_REG(BPF_ADD, R6, R3),
3883  			BPF_ALU64_REG(BPF_ADD, R6, R4),
3884  			BPF_ALU64_REG(BPF_ADD, R6, R5),
3885  			BPF_ALU64_REG(BPF_ADD, R6, R6),
3886  			BPF_ALU64_REG(BPF_ADD, R6, R7),
3887  			BPF_ALU64_REG(BPF_ADD, R6, R8),
3888  			BPF_ALU64_REG(BPF_ADD, R6, R9), /* R6 == 109540 */
3889  			BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1),
3890  			BPF_EXIT_INSN(),
3891  			BPF_ALU64_REG(BPF_ADD, R7, R0),
3892  			BPF_ALU64_REG(BPF_ADD, R7, R1),
3893  			BPF_ALU64_REG(BPF_ADD, R7, R2),
3894  			BPF_ALU64_REG(BPF_ADD, R7, R3),
3895  			BPF_ALU64_REG(BPF_ADD, R7, R4),
3896  			BPF_ALU64_REG(BPF_ADD, R7, R5),
3897  			BPF_ALU64_REG(BPF_ADD, R7, R6),
3898  			BPF_ALU64_REG(BPF_ADD, R7, R7),
3899  			BPF_ALU64_REG(BPF_ADD, R7, R8),
3900  			BPF_ALU64_REG(BPF_ADD, R7, R9), /* R7 == 328605 */
3901  			BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1),
3902  			BPF_EXIT_INSN(),
3903  			BPF_ALU64_REG(BPF_ADD, R8, R0),
3904  			BPF_ALU64_REG(BPF_ADD, R8, R1),
3905  			BPF_ALU64_REG(BPF_ADD, R8, R2),
3906  			BPF_ALU64_REG(BPF_ADD, R8, R3),
3907  			BPF_ALU64_REG(BPF_ADD, R8, R4),
3908  			BPF_ALU64_REG(BPF_ADD, R8, R5),
3909  			BPF_ALU64_REG(BPF_ADD, R8, R6),
3910  			BPF_ALU64_REG(BPF_ADD, R8, R7),
3911  			BPF_ALU64_REG(BPF_ADD, R8, R8),
3912  			BPF_ALU64_REG(BPF_ADD, R8, R9), /* R8 == 985799 */
3913  			BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1),
3914  			BPF_EXIT_INSN(),
3915  			BPF_ALU64_REG(BPF_ADD, R9, R0),
3916  			BPF_ALU64_REG(BPF_ADD, R9, R1),
3917  			BPF_ALU64_REG(BPF_ADD, R9, R2),
3918  			BPF_ALU64_REG(BPF_ADD, R9, R3),
3919  			BPF_ALU64_REG(BPF_ADD, R9, R4),
3920  			BPF_ALU64_REG(BPF_ADD, R9, R5),
3921  			BPF_ALU64_REG(BPF_ADD, R9, R6),
3922  			BPF_ALU64_REG(BPF_ADD, R9, R7),
3923  			BPF_ALU64_REG(BPF_ADD, R9, R8),
3924  			BPF_ALU64_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */
3925  			BPF_ALU64_REG(BPF_MOV, R0, R9),
3926  			BPF_EXIT_INSN(),
3927  		},
3928  		INTERNAL,
3929  		{ },
3930  		{ { 0, 2957380 } }
3931  	},
3932  	{
3933  		"INT: ADD 32-bit",
3934  		.u.insns_int = {
3935  			BPF_ALU32_IMM(BPF_MOV, R0, 20),
3936  			BPF_ALU32_IMM(BPF_MOV, R1, 1),
3937  			BPF_ALU32_IMM(BPF_MOV, R2, 2),
3938  			BPF_ALU32_IMM(BPF_MOV, R3, 3),
3939  			BPF_ALU32_IMM(BPF_MOV, R4, 4),
3940  			BPF_ALU32_IMM(BPF_MOV, R5, 5),
3941  			BPF_ALU32_IMM(BPF_MOV, R6, 6),
3942  			BPF_ALU32_IMM(BPF_MOV, R7, 7),
3943  			BPF_ALU32_IMM(BPF_MOV, R8, 8),
3944  			BPF_ALU32_IMM(BPF_MOV, R9, 9),
3945  			BPF_ALU64_IMM(BPF_ADD, R1, 10),
3946  			BPF_ALU64_IMM(BPF_ADD, R2, 10),
3947  			BPF_ALU64_IMM(BPF_ADD, R3, 10),
3948  			BPF_ALU64_IMM(BPF_ADD, R4, 10),
3949  			BPF_ALU64_IMM(BPF_ADD, R5, 10),
3950  			BPF_ALU64_IMM(BPF_ADD, R6, 10),
3951  			BPF_ALU64_IMM(BPF_ADD, R7, 10),
3952  			BPF_ALU64_IMM(BPF_ADD, R8, 10),
3953  			BPF_ALU64_IMM(BPF_ADD, R9, 10),
3954  			BPF_ALU32_REG(BPF_ADD, R0, R1),
3955  			BPF_ALU32_REG(BPF_ADD, R0, R2),
3956  			BPF_ALU32_REG(BPF_ADD, R0, R3),
3957  			BPF_ALU32_REG(BPF_ADD, R0, R4),
3958  			BPF_ALU32_REG(BPF_ADD, R0, R5),
3959  			BPF_ALU32_REG(BPF_ADD, R0, R6),
3960  			BPF_ALU32_REG(BPF_ADD, R0, R7),
3961  			BPF_ALU32_REG(BPF_ADD, R0, R8),
3962  			BPF_ALU32_REG(BPF_ADD, R0, R9), /* R0 == 155 */
3963  			BPF_JMP_IMM(BPF_JEQ, R0, 155, 1),
3964  			BPF_EXIT_INSN(),
3965  			BPF_ALU32_REG(BPF_ADD, R1, R0),
3966  			BPF_ALU32_REG(BPF_ADD, R1, R1),
3967  			BPF_ALU32_REG(BPF_ADD, R1, R2),
3968  			BPF_ALU32_REG(BPF_ADD, R1, R3),
3969  			BPF_ALU32_REG(BPF_ADD, R1, R4),
3970  			BPF_ALU32_REG(BPF_ADD, R1, R5),
3971  			BPF_ALU32_REG(BPF_ADD, R1, R6),
3972  			BPF_ALU32_REG(BPF_ADD, R1, R7),
3973  			BPF_ALU32_REG(BPF_ADD, R1, R8),
3974  			BPF_ALU32_REG(BPF_ADD, R1, R9), /* R1 == 456 */
3975  			BPF_JMP_IMM(BPF_JEQ, R1, 456, 1),
3976  			BPF_EXIT_INSN(),
3977  			BPF_ALU32_REG(BPF_ADD, R2, R0),
3978  			BPF_ALU32_REG(BPF_ADD, R2, R1),
3979  			BPF_ALU32_REG(BPF_ADD, R2, R2),
3980  			BPF_ALU32_REG(BPF_ADD, R2, R3),
3981  			BPF_ALU32_REG(BPF_ADD, R2, R4),
3982  			BPF_ALU32_REG(BPF_ADD, R2, R5),
3983  			BPF_ALU32_REG(BPF_ADD, R2, R6),
3984  			BPF_ALU32_REG(BPF_ADD, R2, R7),
3985  			BPF_ALU32_REG(BPF_ADD, R2, R8),
3986  			BPF_ALU32_REG(BPF_ADD, R2, R9), /* R2 == 1358 */
3987  			BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1),
3988  			BPF_EXIT_INSN(),
3989  			BPF_ALU32_REG(BPF_ADD, R3, R0),
3990  			BPF_ALU32_REG(BPF_ADD, R3, R1),
3991  			BPF_ALU32_REG(BPF_ADD, R3, R2),
3992  			BPF_ALU32_REG(BPF_ADD, R3, R3),
3993  			BPF_ALU32_REG(BPF_ADD, R3, R4),
3994  			BPF_ALU32_REG(BPF_ADD, R3, R5),
3995  			BPF_ALU32_REG(BPF_ADD, R3, R6),
3996  			BPF_ALU32_REG(BPF_ADD, R3, R7),
3997  			BPF_ALU32_REG(BPF_ADD, R3, R8),
3998  			BPF_ALU32_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
3999  			BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
4000  			BPF_EXIT_INSN(),
4001  			BPF_ALU32_REG(BPF_ADD, R4, R0),
4002  			BPF_ALU32_REG(BPF_ADD, R4, R1),
4003  			BPF_ALU32_REG(BPF_ADD, R4, R2),
4004  			BPF_ALU32_REG(BPF_ADD, R4, R3),
4005  			BPF_ALU32_REG(BPF_ADD, R4, R4),
4006  			BPF_ALU32_REG(BPF_ADD, R4, R5),
4007  			BPF_ALU32_REG(BPF_ADD, R4, R6),
4008  			BPF_ALU32_REG(BPF_ADD, R4, R7),
4009  			BPF_ALU32_REG(BPF_ADD, R4, R8),
4010  			BPF_ALU32_REG(BPF_ADD, R4, R9), /* R4 == 12177 */
4011  			BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1),
4012  			BPF_EXIT_INSN(),
4013  			BPF_ALU32_REG(BPF_ADD, R5, R0),
4014  			BPF_ALU32_REG(BPF_ADD, R5, R1),
4015  			BPF_ALU32_REG(BPF_ADD, R5, R2),
4016  			BPF_ALU32_REG(BPF_ADD, R5, R3),
4017  			BPF_ALU32_REG(BPF_ADD, R5, R4),
4018  			BPF_ALU32_REG(BPF_ADD, R5, R5),
4019  			BPF_ALU32_REG(BPF_ADD, R5, R6),
4020  			BPF_ALU32_REG(BPF_ADD, R5, R7),
4021  			BPF_ALU32_REG(BPF_ADD, R5, R8),
4022  			BPF_ALU32_REG(BPF_ADD, R5, R9), /* R5 == 36518 */
4023  			BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1),
4024  			BPF_EXIT_INSN(),
4025  			BPF_ALU32_REG(BPF_ADD, R6, R0),
4026  			BPF_ALU32_REG(BPF_ADD, R6, R1),
4027  			BPF_ALU32_REG(BPF_ADD, R6, R2),
4028  			BPF_ALU32_REG(BPF_ADD, R6, R3),
4029  			BPF_ALU32_REG(BPF_ADD, R6, R4),
4030  			BPF_ALU32_REG(BPF_ADD, R6, R5),
4031  			BPF_ALU32_REG(BPF_ADD, R6, R6),
4032  			BPF_ALU32_REG(BPF_ADD, R6, R7),
4033  			BPF_ALU32_REG(BPF_ADD, R6, R8),
4034  			BPF_ALU32_REG(BPF_ADD, R6, R9), /* R6 == 109540 */
4035  			BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1),
4036  			BPF_EXIT_INSN(),
4037  			BPF_ALU32_REG(BPF_ADD, R7, R0),
4038  			BPF_ALU32_REG(BPF_ADD, R7, R1),
4039  			BPF_ALU32_REG(BPF_ADD, R7, R2),
4040  			BPF_ALU32_REG(BPF_ADD, R7, R3),
4041  			BPF_ALU32_REG(BPF_ADD, R7, R4),
4042  			BPF_ALU32_REG(BPF_ADD, R7, R5),
4043  			BPF_ALU32_REG(BPF_ADD, R7, R6),
4044  			BPF_ALU32_REG(BPF_ADD, R7, R7),
4045  			BPF_ALU32_REG(BPF_ADD, R7, R8),
4046  			BPF_ALU32_REG(BPF_ADD, R7, R9), /* R7 == 328605 */
4047  			BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1),
4048  			BPF_EXIT_INSN(),
4049  			BPF_ALU32_REG(BPF_ADD, R8, R0),
4050  			BPF_ALU32_REG(BPF_ADD, R8, R1),
4051  			BPF_ALU32_REG(BPF_ADD, R8, R2),
4052  			BPF_ALU32_REG(BPF_ADD, R8, R3),
4053  			BPF_ALU32_REG(BPF_ADD, R8, R4),
4054  			BPF_ALU32_REG(BPF_ADD, R8, R5),
4055  			BPF_ALU32_REG(BPF_ADD, R8, R6),
4056  			BPF_ALU32_REG(BPF_ADD, R8, R7),
4057  			BPF_ALU32_REG(BPF_ADD, R8, R8),
4058  			BPF_ALU32_REG(BPF_ADD, R8, R9), /* R8 == 985799 */
4059  			BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1),
4060  			BPF_EXIT_INSN(),
4061  			BPF_ALU32_REG(BPF_ADD, R9, R0),
4062  			BPF_ALU32_REG(BPF_ADD, R9, R1),
4063  			BPF_ALU32_REG(BPF_ADD, R9, R2),
4064  			BPF_ALU32_REG(BPF_ADD, R9, R3),
4065  			BPF_ALU32_REG(BPF_ADD, R9, R4),
4066  			BPF_ALU32_REG(BPF_ADD, R9, R5),
4067  			BPF_ALU32_REG(BPF_ADD, R9, R6),
4068  			BPF_ALU32_REG(BPF_ADD, R9, R7),
4069  			BPF_ALU32_REG(BPF_ADD, R9, R8),
4070  			BPF_ALU32_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */
4071  			BPF_ALU32_REG(BPF_MOV, R0, R9),
4072  			BPF_EXIT_INSN(),
4073  		},
4074  		INTERNAL,
4075  		{ },
4076  		{ { 0, 2957380 } }
4077  	},
4078  	{	/* Mainly checking JIT here. */
4079  		"INT: SUB",
4080  		.u.insns_int = {
4081  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
4082  			BPF_ALU64_IMM(BPF_MOV, R1, 1),
4083  			BPF_ALU64_IMM(BPF_MOV, R2, 2),
4084  			BPF_ALU64_IMM(BPF_MOV, R3, 3),
4085  			BPF_ALU64_IMM(BPF_MOV, R4, 4),
4086  			BPF_ALU64_IMM(BPF_MOV, R5, 5),
4087  			BPF_ALU64_IMM(BPF_MOV, R6, 6),
4088  			BPF_ALU64_IMM(BPF_MOV, R7, 7),
4089  			BPF_ALU64_IMM(BPF_MOV, R8, 8),
4090  			BPF_ALU64_IMM(BPF_MOV, R9, 9),
4091  			BPF_ALU64_REG(BPF_SUB, R0, R0),
4092  			BPF_ALU64_REG(BPF_SUB, R0, R1),
4093  			BPF_ALU64_REG(BPF_SUB, R0, R2),
4094  			BPF_ALU64_REG(BPF_SUB, R0, R3),
4095  			BPF_ALU64_REG(BPF_SUB, R0, R4),
4096  			BPF_ALU64_REG(BPF_SUB, R0, R5),
4097  			BPF_ALU64_REG(BPF_SUB, R0, R6),
4098  			BPF_ALU64_REG(BPF_SUB, R0, R7),
4099  			BPF_ALU64_REG(BPF_SUB, R0, R8),
4100  			BPF_ALU64_REG(BPF_SUB, R0, R9),
4101  			BPF_ALU64_IMM(BPF_SUB, R0, 10),
4102  			BPF_JMP_IMM(BPF_JEQ, R0, -55, 1),
4103  			BPF_EXIT_INSN(),
4104  			BPF_ALU64_REG(BPF_SUB, R1, R0),
4105  			BPF_ALU64_REG(BPF_SUB, R1, R2),
4106  			BPF_ALU64_REG(BPF_SUB, R1, R3),
4107  			BPF_ALU64_REG(BPF_SUB, R1, R4),
4108  			BPF_ALU64_REG(BPF_SUB, R1, R5),
4109  			BPF_ALU64_REG(BPF_SUB, R1, R6),
4110  			BPF_ALU64_REG(BPF_SUB, R1, R7),
4111  			BPF_ALU64_REG(BPF_SUB, R1, R8),
4112  			BPF_ALU64_REG(BPF_SUB, R1, R9),
4113  			BPF_ALU64_IMM(BPF_SUB, R1, 10),
4114  			BPF_ALU64_REG(BPF_SUB, R2, R0),
4115  			BPF_ALU64_REG(BPF_SUB, R2, R1),
4116  			BPF_ALU64_REG(BPF_SUB, R2, R3),
4117  			BPF_ALU64_REG(BPF_SUB, R2, R4),
4118  			BPF_ALU64_REG(BPF_SUB, R2, R5),
4119  			BPF_ALU64_REG(BPF_SUB, R2, R6),
4120  			BPF_ALU64_REG(BPF_SUB, R2, R7),
4121  			BPF_ALU64_REG(BPF_SUB, R2, R8),
4122  			BPF_ALU64_REG(BPF_SUB, R2, R9),
4123  			BPF_ALU64_IMM(BPF_SUB, R2, 10),
4124  			BPF_ALU64_REG(BPF_SUB, R3, R0),
4125  			BPF_ALU64_REG(BPF_SUB, R3, R1),
4126  			BPF_ALU64_REG(BPF_SUB, R3, R2),
4127  			BPF_ALU64_REG(BPF_SUB, R3, R4),
4128  			BPF_ALU64_REG(BPF_SUB, R3, R5),
4129  			BPF_ALU64_REG(BPF_SUB, R3, R6),
4130  			BPF_ALU64_REG(BPF_SUB, R3, R7),
4131  			BPF_ALU64_REG(BPF_SUB, R3, R8),
4132  			BPF_ALU64_REG(BPF_SUB, R3, R9),
4133  			BPF_ALU64_IMM(BPF_SUB, R3, 10),
4134  			BPF_ALU64_REG(BPF_SUB, R4, R0),
4135  			BPF_ALU64_REG(BPF_SUB, R4, R1),
4136  			BPF_ALU64_REG(BPF_SUB, R4, R2),
4137  			BPF_ALU64_REG(BPF_SUB, R4, R3),
4138  			BPF_ALU64_REG(BPF_SUB, R4, R5),
4139  			BPF_ALU64_REG(BPF_SUB, R4, R6),
4140  			BPF_ALU64_REG(BPF_SUB, R4, R7),
4141  			BPF_ALU64_REG(BPF_SUB, R4, R8),
4142  			BPF_ALU64_REG(BPF_SUB, R4, R9),
4143  			BPF_ALU64_IMM(BPF_SUB, R4, 10),
4144  			BPF_ALU64_REG(BPF_SUB, R5, R0),
4145  			BPF_ALU64_REG(BPF_SUB, R5, R1),
4146  			BPF_ALU64_REG(BPF_SUB, R5, R2),
4147  			BPF_ALU64_REG(BPF_SUB, R5, R3),
4148  			BPF_ALU64_REG(BPF_SUB, R5, R4),
4149  			BPF_ALU64_REG(BPF_SUB, R5, R6),
4150  			BPF_ALU64_REG(BPF_SUB, R5, R7),
4151  			BPF_ALU64_REG(BPF_SUB, R5, R8),
4152  			BPF_ALU64_REG(BPF_SUB, R5, R9),
4153  			BPF_ALU64_IMM(BPF_SUB, R5, 10),
4154  			BPF_ALU64_REG(BPF_SUB, R6, R0),
4155  			BPF_ALU64_REG(BPF_SUB, R6, R1),
4156  			BPF_ALU64_REG(BPF_SUB, R6, R2),
4157  			BPF_ALU64_REG(BPF_SUB, R6, R3),
4158  			BPF_ALU64_REG(BPF_SUB, R6, R4),
4159  			BPF_ALU64_REG(BPF_SUB, R6, R5),
4160  			BPF_ALU64_REG(BPF_SUB, R6, R7),
4161  			BPF_ALU64_REG(BPF_SUB, R6, R8),
4162  			BPF_ALU64_REG(BPF_SUB, R6, R9),
4163  			BPF_ALU64_IMM(BPF_SUB, R6, 10),
4164  			BPF_ALU64_REG(BPF_SUB, R7, R0),
4165  			BPF_ALU64_REG(BPF_SUB, R7, R1),
4166  			BPF_ALU64_REG(BPF_SUB, R7, R2),
4167  			BPF_ALU64_REG(BPF_SUB, R7, R3),
4168  			BPF_ALU64_REG(BPF_SUB, R7, R4),
4169  			BPF_ALU64_REG(BPF_SUB, R7, R5),
4170  			BPF_ALU64_REG(BPF_SUB, R7, R6),
4171  			BPF_ALU64_REG(BPF_SUB, R7, R8),
4172  			BPF_ALU64_REG(BPF_SUB, R7, R9),
4173  			BPF_ALU64_IMM(BPF_SUB, R7, 10),
4174  			BPF_ALU64_REG(BPF_SUB, R8, R0),
4175  			BPF_ALU64_REG(BPF_SUB, R8, R1),
4176  			BPF_ALU64_REG(BPF_SUB, R8, R2),
4177  			BPF_ALU64_REG(BPF_SUB, R8, R3),
4178  			BPF_ALU64_REG(BPF_SUB, R8, R4),
4179  			BPF_ALU64_REG(BPF_SUB, R8, R5),
4180  			BPF_ALU64_REG(BPF_SUB, R8, R6),
4181  			BPF_ALU64_REG(BPF_SUB, R8, R7),
4182  			BPF_ALU64_REG(BPF_SUB, R8, R9),
4183  			BPF_ALU64_IMM(BPF_SUB, R8, 10),
4184  			BPF_ALU64_REG(BPF_SUB, R9, R0),
4185  			BPF_ALU64_REG(BPF_SUB, R9, R1),
4186  			BPF_ALU64_REG(BPF_SUB, R9, R2),
4187  			BPF_ALU64_REG(BPF_SUB, R9, R3),
4188  			BPF_ALU64_REG(BPF_SUB, R9, R4),
4189  			BPF_ALU64_REG(BPF_SUB, R9, R5),
4190  			BPF_ALU64_REG(BPF_SUB, R9, R6),
4191  			BPF_ALU64_REG(BPF_SUB, R9, R7),
4192  			BPF_ALU64_REG(BPF_SUB, R9, R8),
4193  			BPF_ALU64_IMM(BPF_SUB, R9, 10),
4194  			BPF_ALU64_IMM(BPF_SUB, R0, 10),
4195  			BPF_ALU64_IMM(BPF_NEG, R0, 0),
4196  			BPF_ALU64_REG(BPF_SUB, R0, R1),
4197  			BPF_ALU64_REG(BPF_SUB, R0, R2),
4198  			BPF_ALU64_REG(BPF_SUB, R0, R3),
4199  			BPF_ALU64_REG(BPF_SUB, R0, R4),
4200  			BPF_ALU64_REG(BPF_SUB, R0, R5),
4201  			BPF_ALU64_REG(BPF_SUB, R0, R6),
4202  			BPF_ALU64_REG(BPF_SUB, R0, R7),
4203  			BPF_ALU64_REG(BPF_SUB, R0, R8),
4204  			BPF_ALU64_REG(BPF_SUB, R0, R9),
4205  			BPF_EXIT_INSN(),
4206  		},
4207  		INTERNAL,
4208  		{ },
4209  		{ { 0, 11 } }
4210  	},
4211  	{	/* Mainly checking JIT here. */
4212  		"INT: XOR",
4213  		.u.insns_int = {
4214  			BPF_ALU64_REG(BPF_SUB, R0, R0),
4215  			BPF_ALU64_REG(BPF_XOR, R1, R1),
4216  			BPF_JMP_REG(BPF_JEQ, R0, R1, 1),
4217  			BPF_EXIT_INSN(),
4218  			BPF_ALU64_IMM(BPF_MOV, R0, 10),
4219  			BPF_ALU64_IMM(BPF_MOV, R1, -1),
4220  			BPF_ALU64_REG(BPF_SUB, R1, R1),
4221  			BPF_ALU64_REG(BPF_XOR, R2, R2),
4222  			BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
4223  			BPF_EXIT_INSN(),
4224  			BPF_ALU64_REG(BPF_SUB, R2, R2),
4225  			BPF_ALU64_REG(BPF_XOR, R3, R3),
4226  			BPF_ALU64_IMM(BPF_MOV, R0, 10),
4227  			BPF_ALU64_IMM(BPF_MOV, R1, -1),
4228  			BPF_JMP_REG(BPF_JEQ, R2, R3, 1),
4229  			BPF_EXIT_INSN(),
4230  			BPF_ALU64_REG(BPF_SUB, R3, R3),
4231  			BPF_ALU64_REG(BPF_XOR, R4, R4),
4232  			BPF_ALU64_IMM(BPF_MOV, R2, 1),
4233  			BPF_ALU64_IMM(BPF_MOV, R5, -1),
4234  			BPF_JMP_REG(BPF_JEQ, R3, R4, 1),
4235  			BPF_EXIT_INSN(),
4236  			BPF_ALU64_REG(BPF_SUB, R4, R4),
4237  			BPF_ALU64_REG(BPF_XOR, R5, R5),
4238  			BPF_ALU64_IMM(BPF_MOV, R3, 1),
4239  			BPF_ALU64_IMM(BPF_MOV, R7, -1),
4240  			BPF_JMP_REG(BPF_JEQ, R5, R4, 1),
4241  			BPF_EXIT_INSN(),
4242  			BPF_ALU64_IMM(BPF_MOV, R5, 1),
4243  			BPF_ALU64_REG(BPF_SUB, R5, R5),
4244  			BPF_ALU64_REG(BPF_XOR, R6, R6),
4245  			BPF_ALU64_IMM(BPF_MOV, R1, 1),
4246  			BPF_ALU64_IMM(BPF_MOV, R8, -1),
4247  			BPF_JMP_REG(BPF_JEQ, R5, R6, 1),
4248  			BPF_EXIT_INSN(),
4249  			BPF_ALU64_REG(BPF_SUB, R6, R6),
4250  			BPF_ALU64_REG(BPF_XOR, R7, R7),
4251  			BPF_JMP_REG(BPF_JEQ, R7, R6, 1),
4252  			BPF_EXIT_INSN(),
4253  			BPF_ALU64_REG(BPF_SUB, R7, R7),
4254  			BPF_ALU64_REG(BPF_XOR, R8, R8),
4255  			BPF_JMP_REG(BPF_JEQ, R7, R8, 1),
4256  			BPF_EXIT_INSN(),
4257  			BPF_ALU64_REG(BPF_SUB, R8, R8),
4258  			BPF_ALU64_REG(BPF_XOR, R9, R9),
4259  			BPF_JMP_REG(BPF_JEQ, R9, R8, 1),
4260  			BPF_EXIT_INSN(),
4261  			BPF_ALU64_REG(BPF_SUB, R9, R9),
4262  			BPF_ALU64_REG(BPF_XOR, R0, R0),
4263  			BPF_JMP_REG(BPF_JEQ, R9, R0, 1),
4264  			BPF_EXIT_INSN(),
4265  			BPF_ALU64_REG(BPF_SUB, R1, R1),
4266  			BPF_ALU64_REG(BPF_XOR, R0, R0),
4267  			BPF_JMP_REG(BPF_JEQ, R9, R0, 2),
4268  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
4269  			BPF_EXIT_INSN(),
4270  			BPF_ALU64_IMM(BPF_MOV, R0, 1),
4271  			BPF_EXIT_INSN(),
4272  		},
4273  		INTERNAL,
4274  		{ },
4275  		{ { 0, 1 } }
4276  	},
4277  	{	/* Mainly checking JIT here. */
4278  		"INT: MUL",
4279  		.u.insns_int = {
4280  			BPF_ALU64_IMM(BPF_MOV, R0, 11),
4281  			BPF_ALU64_IMM(BPF_MOV, R1, 1),
4282  			BPF_ALU64_IMM(BPF_MOV, R2, 2),
4283  			BPF_ALU64_IMM(BPF_MOV, R3, 3),
4284  			BPF_ALU64_IMM(BPF_MOV, R4, 4),
4285  			BPF_ALU64_IMM(BPF_MOV, R5, 5),
4286  			BPF_ALU64_IMM(BPF_MOV, R6, 6),
4287  			BPF_ALU64_IMM(BPF_MOV, R7, 7),
4288  			BPF_ALU64_IMM(BPF_MOV, R8, 8),
4289  			BPF_ALU64_IMM(BPF_MOV, R9, 9),
4290  			BPF_ALU64_REG(BPF_MUL, R0, R0),
4291  			BPF_ALU64_REG(BPF_MUL, R0, R1),
4292  			BPF_ALU64_REG(BPF_MUL, R0, R2),
4293  			BPF_ALU64_REG(BPF_MUL, R0, R3),
4294  			BPF_ALU64_REG(BPF_MUL, R0, R4),
4295  			BPF_ALU64_REG(BPF_MUL, R0, R5),
4296  			BPF_ALU64_REG(BPF_MUL, R0, R6),
4297  			BPF_ALU64_REG(BPF_MUL, R0, R7),
4298  			BPF_ALU64_REG(BPF_MUL, R0, R8),
4299  			BPF_ALU64_REG(BPF_MUL, R0, R9),
4300  			BPF_ALU64_IMM(BPF_MUL, R0, 10),
4301  			BPF_JMP_IMM(BPF_JEQ, R0, 439084800, 1),
4302  			BPF_EXIT_INSN(),
4303  			BPF_ALU64_REG(BPF_MUL, R1, R0),
4304  			BPF_ALU64_REG(BPF_MUL, R1, R2),
4305  			BPF_ALU64_REG(BPF_MUL, R1, R3),
4306  			BPF_ALU64_REG(BPF_MUL, R1, R4),
4307  			BPF_ALU64_REG(BPF_MUL, R1, R5),
4308  			BPF_ALU64_REG(BPF_MUL, R1, R6),
4309  			BPF_ALU64_REG(BPF_MUL, R1, R7),
4310  			BPF_ALU64_REG(BPF_MUL, R1, R8),
4311  			BPF_ALU64_REG(BPF_MUL, R1, R9),
4312  			BPF_ALU64_IMM(BPF_MUL, R1, 10),
4313  			BPF_ALU64_REG(BPF_MOV, R2, R1),
4314  			BPF_ALU64_IMM(BPF_RSH, R2, 32),
4315  			BPF_JMP_IMM(BPF_JEQ, R2, 0x5a924, 1),
4316  			BPF_EXIT_INSN(),
4317  			BPF_ALU64_IMM(BPF_LSH, R1, 32),
4318  			BPF_ALU64_IMM(BPF_ARSH, R1, 32),
4319  			BPF_JMP_IMM(BPF_JEQ, R1, 0xebb90000, 1),
4320  			BPF_EXIT_INSN(),
4321  			BPF_ALU64_REG(BPF_MUL, R2, R0),
4322  			BPF_ALU64_REG(BPF_MUL, R2, R1),
4323  			BPF_ALU64_REG(BPF_MUL, R2, R3),
4324  			BPF_ALU64_REG(BPF_MUL, R2, R4),
4325  			BPF_ALU64_REG(BPF_MUL, R2, R5),
4326  			BPF_ALU64_REG(BPF_MUL, R2, R6),
4327  			BPF_ALU64_REG(BPF_MUL, R2, R7),
4328  			BPF_ALU64_REG(BPF_MUL, R2, R8),
4329  			BPF_ALU64_REG(BPF_MUL, R2, R9),
4330  			BPF_ALU64_IMM(BPF_MUL, R2, 10),
4331  			BPF_ALU64_IMM(BPF_RSH, R2, 32),
4332  			BPF_ALU64_REG(BPF_MOV, R0, R2),
4333  			BPF_EXIT_INSN(),
4334  		},
4335  		INTERNAL,
4336  		{ },
4337  		{ { 0, 0x35d97ef2 } }
4338  	},
4339  	{	/* Mainly checking JIT here. */
4340  		"MOV REG64",
4341  		.u.insns_int = {
4342  			BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
4343  			BPF_MOV64_REG(R1, R0),
4344  			BPF_MOV64_REG(R2, R1),
4345  			BPF_MOV64_REG(R3, R2),
4346  			BPF_MOV64_REG(R4, R3),
4347  			BPF_MOV64_REG(R5, R4),
4348  			BPF_MOV64_REG(R6, R5),
4349  			BPF_MOV64_REG(R7, R6),
4350  			BPF_MOV64_REG(R8, R7),
4351  			BPF_MOV64_REG(R9, R8),
4352  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
4353  			BPF_ALU64_IMM(BPF_MOV, R1, 0),
4354  			BPF_ALU64_IMM(BPF_MOV, R2, 0),
4355  			BPF_ALU64_IMM(BPF_MOV, R3, 0),
4356  			BPF_ALU64_IMM(BPF_MOV, R4, 0),
4357  			BPF_ALU64_IMM(BPF_MOV, R5, 0),
4358  			BPF_ALU64_IMM(BPF_MOV, R6, 0),
4359  			BPF_ALU64_IMM(BPF_MOV, R7, 0),
4360  			BPF_ALU64_IMM(BPF_MOV, R8, 0),
4361  			BPF_ALU64_IMM(BPF_MOV, R9, 0),
4362  			BPF_ALU64_REG(BPF_ADD, R0, R0),
4363  			BPF_ALU64_REG(BPF_ADD, R0, R1),
4364  			BPF_ALU64_REG(BPF_ADD, R0, R2),
4365  			BPF_ALU64_REG(BPF_ADD, R0, R3),
4366  			BPF_ALU64_REG(BPF_ADD, R0, R4),
4367  			BPF_ALU64_REG(BPF_ADD, R0, R5),
4368  			BPF_ALU64_REG(BPF_ADD, R0, R6),
4369  			BPF_ALU64_REG(BPF_ADD, R0, R7),
4370  			BPF_ALU64_REG(BPF_ADD, R0, R8),
4371  			BPF_ALU64_REG(BPF_ADD, R0, R9),
4372  			BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
4373  			BPF_EXIT_INSN(),
4374  		},
4375  		INTERNAL,
4376  		{ },
4377  		{ { 0, 0xfefe } }
4378  	},
4379  	{	/* Mainly checking JIT here. */
4380  		"MOV REG32",
4381  		.u.insns_int = {
4382  			BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
4383  			BPF_MOV64_REG(R1, R0),
4384  			BPF_MOV64_REG(R2, R1),
4385  			BPF_MOV64_REG(R3, R2),
4386  			BPF_MOV64_REG(R4, R3),
4387  			BPF_MOV64_REG(R5, R4),
4388  			BPF_MOV64_REG(R6, R5),
4389  			BPF_MOV64_REG(R7, R6),
4390  			BPF_MOV64_REG(R8, R7),
4391  			BPF_MOV64_REG(R9, R8),
4392  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
4393  			BPF_ALU32_IMM(BPF_MOV, R1, 0),
4394  			BPF_ALU32_IMM(BPF_MOV, R2, 0),
4395  			BPF_ALU32_IMM(BPF_MOV, R3, 0),
4396  			BPF_ALU32_IMM(BPF_MOV, R4, 0),
4397  			BPF_ALU32_IMM(BPF_MOV, R5, 0),
4398  			BPF_ALU32_IMM(BPF_MOV, R6, 0),
4399  			BPF_ALU32_IMM(BPF_MOV, R7, 0),
4400  			BPF_ALU32_IMM(BPF_MOV, R8, 0),
4401  			BPF_ALU32_IMM(BPF_MOV, R9, 0),
4402  			BPF_ALU64_REG(BPF_ADD, R0, R0),
4403  			BPF_ALU64_REG(BPF_ADD, R0, R1),
4404  			BPF_ALU64_REG(BPF_ADD, R0, R2),
4405  			BPF_ALU64_REG(BPF_ADD, R0, R3),
4406  			BPF_ALU64_REG(BPF_ADD, R0, R4),
4407  			BPF_ALU64_REG(BPF_ADD, R0, R5),
4408  			BPF_ALU64_REG(BPF_ADD, R0, R6),
4409  			BPF_ALU64_REG(BPF_ADD, R0, R7),
4410  			BPF_ALU64_REG(BPF_ADD, R0, R8),
4411  			BPF_ALU64_REG(BPF_ADD, R0, R9),
4412  			BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
4413  			BPF_EXIT_INSN(),
4414  		},
4415  		INTERNAL,
4416  		{ },
4417  		{ { 0, 0xfefe } }
4418  	},
4419  	{	/* Mainly checking JIT here. */
4420  		"LD IMM64",
4421  		.u.insns_int = {
4422  			BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
4423  			BPF_MOV64_REG(R1, R0),
4424  			BPF_MOV64_REG(R2, R1),
4425  			BPF_MOV64_REG(R3, R2),
4426  			BPF_MOV64_REG(R4, R3),
4427  			BPF_MOV64_REG(R5, R4),
4428  			BPF_MOV64_REG(R6, R5),
4429  			BPF_MOV64_REG(R7, R6),
4430  			BPF_MOV64_REG(R8, R7),
4431  			BPF_MOV64_REG(R9, R8),
4432  			BPF_LD_IMM64(R0, 0x0LL),
4433  			BPF_LD_IMM64(R1, 0x0LL),
4434  			BPF_LD_IMM64(R2, 0x0LL),
4435  			BPF_LD_IMM64(R3, 0x0LL),
4436  			BPF_LD_IMM64(R4, 0x0LL),
4437  			BPF_LD_IMM64(R5, 0x0LL),
4438  			BPF_LD_IMM64(R6, 0x0LL),
4439  			BPF_LD_IMM64(R7, 0x0LL),
4440  			BPF_LD_IMM64(R8, 0x0LL),
4441  			BPF_LD_IMM64(R9, 0x0LL),
4442  			BPF_ALU64_REG(BPF_ADD, R0, R0),
4443  			BPF_ALU64_REG(BPF_ADD, R0, R1),
4444  			BPF_ALU64_REG(BPF_ADD, R0, R2),
4445  			BPF_ALU64_REG(BPF_ADD, R0, R3),
4446  			BPF_ALU64_REG(BPF_ADD, R0, R4),
4447  			BPF_ALU64_REG(BPF_ADD, R0, R5),
4448  			BPF_ALU64_REG(BPF_ADD, R0, R6),
4449  			BPF_ALU64_REG(BPF_ADD, R0, R7),
4450  			BPF_ALU64_REG(BPF_ADD, R0, R8),
4451  			BPF_ALU64_REG(BPF_ADD, R0, R9),
4452  			BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
4453  			BPF_EXIT_INSN(),
4454  		},
4455  		INTERNAL,
4456  		{ },
4457  		{ { 0, 0xfefe } }
4458  	},
4459  	{
4460  		"INT: ALU MIX",
4461  		.u.insns_int = {
4462  			BPF_ALU64_IMM(BPF_MOV, R0, 11),
4463  			BPF_ALU64_IMM(BPF_ADD, R0, -1),
4464  			BPF_ALU64_IMM(BPF_MOV, R2, 2),
4465  			BPF_ALU64_IMM(BPF_XOR, R2, 3),
4466  			BPF_ALU64_REG(BPF_DIV, R0, R2),
4467  			BPF_JMP_IMM(BPF_JEQ, R0, 10, 1),
4468  			BPF_EXIT_INSN(),
4469  			BPF_ALU64_IMM(BPF_MOD, R0, 3),
4470  			BPF_JMP_IMM(BPF_JEQ, R0, 1, 1),
4471  			BPF_EXIT_INSN(),
4472  			BPF_ALU64_IMM(BPF_MOV, R0, -1),
4473  			BPF_EXIT_INSN(),
4474  		},
4475  		INTERNAL,
4476  		{ },
4477  		{ { 0, -1 } }
4478  	},
4479  	{
4480  		"INT: shifts by register",
4481  		.u.insns_int = {
4482  			BPF_MOV64_IMM(R0, -1234),
4483  			BPF_MOV64_IMM(R1, 1),
4484  			BPF_ALU32_REG(BPF_RSH, R0, R1),
4485  			BPF_JMP_IMM(BPF_JEQ, R0, 0x7ffffd97, 1),
4486  			BPF_EXIT_INSN(),
4487  			BPF_MOV64_IMM(R2, 1),
4488  			BPF_ALU64_REG(BPF_LSH, R0, R2),
4489  			BPF_MOV32_IMM(R4, -1234),
4490  			BPF_JMP_REG(BPF_JEQ, R0, R4, 1),
4491  			BPF_EXIT_INSN(),
4492  			BPF_ALU64_IMM(BPF_AND, R4, 63),
4493  			BPF_ALU64_REG(BPF_LSH, R0, R4), /* R0 <= 46 */
4494  			BPF_MOV64_IMM(R3, 47),
4495  			BPF_ALU64_REG(BPF_ARSH, R0, R3),
4496  			BPF_JMP_IMM(BPF_JEQ, R0, -617, 1),
4497  			BPF_EXIT_INSN(),
4498  			BPF_MOV64_IMM(R2, 1),
4499  			BPF_ALU64_REG(BPF_LSH, R4, R2), /* R4 = 46 << 1 */
4500  			BPF_JMP_IMM(BPF_JEQ, R4, 92, 1),
4501  			BPF_EXIT_INSN(),
4502  			BPF_MOV64_IMM(R4, 4),
4503  			BPF_ALU64_REG(BPF_LSH, R4, R4), /* R4 = 4 << 4 */
4504  			BPF_JMP_IMM(BPF_JEQ, R4, 64, 1),
4505  			BPF_EXIT_INSN(),
4506  			BPF_MOV64_IMM(R4, 5),
4507  			BPF_ALU32_REG(BPF_LSH, R4, R4), /* R4 = 5 << 5 */
4508  			BPF_JMP_IMM(BPF_JEQ, R4, 160, 1),
4509  			BPF_EXIT_INSN(),
4510  			BPF_MOV64_IMM(R0, -1),
4511  			BPF_EXIT_INSN(),
4512  		},
4513  		INTERNAL,
4514  		{ },
4515  		{ { 0, -1 } }
4516  	},
4517  #ifdef CONFIG_32BIT
4518  	{
4519  		"INT: 32-bit context pointer word order and zero-extension",
4520  		.u.insns_int = {
4521  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
4522  			BPF_JMP32_IMM(BPF_JEQ, R1, 0, 3),
4523  			BPF_ALU64_IMM(BPF_RSH, R1, 32),
4524  			BPF_JMP32_IMM(BPF_JNE, R1, 0, 1),
4525  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
4526  			BPF_EXIT_INSN(),
4527  		},
4528  		INTERNAL,
4529  		{ },
4530  		{ { 0, 1 } }
4531  	},
4532  #endif
4533  	{
4534  		"check: missing ret",
4535  		.u.insns = {
4536  			BPF_STMT(BPF_LD | BPF_IMM, 1),
4537  		},
4538  		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4539  		{ },
4540  		{ },
4541  		.fill_helper = NULL,
4542  		.expected_errcode = -EINVAL,
4543  	},
4544  	{
4545  		"check: div_k_0",
4546  		.u.insns = {
4547  			BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0),
4548  			BPF_STMT(BPF_RET | BPF_K, 0)
4549  		},
4550  		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4551  		{ },
4552  		{ },
4553  		.fill_helper = NULL,
4554  		.expected_errcode = -EINVAL,
4555  	},
4556  	{
4557  		"check: unknown insn",
4558  		.u.insns = {
4559  			/* seccomp insn, rejected in socket filter */
4560  			BPF_STMT(BPF_LDX | BPF_W | BPF_ABS, 0),
4561  			BPF_STMT(BPF_RET | BPF_K, 0)
4562  		},
4563  		CLASSIC | FLAG_EXPECTED_FAIL,
4564  		{ },
4565  		{ },
4566  		.fill_helper = NULL,
4567  		.expected_errcode = -EINVAL,
4568  	},
4569  	{
4570  		"check: out of range spill/fill",
4571  		.u.insns = {
4572  			BPF_STMT(BPF_STX, 16),
4573  			BPF_STMT(BPF_RET | BPF_K, 0)
4574  		},
4575  		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4576  		{ },
4577  		{ },
4578  		.fill_helper = NULL,
4579  		.expected_errcode = -EINVAL,
4580  	},
4581  	{
4582  		"JUMPS + HOLES",
4583  		.u.insns = {
4584  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4585  			BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 15),
4586  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4587  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4588  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4589  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4590  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4591  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4592  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4593  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4594  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4595  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4596  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4597  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4598  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4599  			BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 3, 4),
4600  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4601  			BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 1, 2),
4602  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4603  			BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
4604  			BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
4605  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4606  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4607  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4608  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4609  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4610  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4611  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4612  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4613  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4614  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4615  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4616  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4617  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4618  			BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 2, 3),
4619  			BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 1, 2),
4620  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4621  			BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
4622  			BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
4623  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4624  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4625  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4626  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4627  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4628  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4629  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4630  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4631  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4632  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4633  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4634  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4635  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4636  			BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 2, 3),
4637  			BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 1, 2),
4638  			BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4639  			BPF_STMT(BPF_RET | BPF_A, 0),
4640  			BPF_STMT(BPF_RET | BPF_A, 0),
4641  		},
4642  		CLASSIC,
4643  		{ 0x00, 0x1b, 0x21, 0x3c, 0x9d, 0xf8,
4644  		  0x90, 0xe2, 0xba, 0x0a, 0x56, 0xb4,
4645  		  0x08, 0x00,
4646  		  0x45, 0x00, 0x00, 0x28, 0x00, 0x00,
4647  		  0x20, 0x00, 0x40, 0x11, 0x00, 0x00, /* IP header */
4648  		  0xc0, 0xa8, 0x33, 0x01,
4649  		  0xc0, 0xa8, 0x33, 0x02,
4650  		  0xbb, 0xb6,
4651  		  0xa9, 0xfa,
4652  		  0x00, 0x14, 0x00, 0x00,
4653  		  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4654  		  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4655  		  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4656  		  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4657  		  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4658  		  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4659  		  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4660  		  0xcc, 0xcc, 0xcc, 0xcc },
4661  		{ { 88, 0x001b } }
4662  	},
4663  	{
4664  		"check: RET X",
4665  		.u.insns = {
4666  			BPF_STMT(BPF_RET | BPF_X, 0),
4667  		},
4668  		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4669  		{ },
4670  		{ },
4671  		.fill_helper = NULL,
4672  		.expected_errcode = -EINVAL,
4673  	},
4674  	{
4675  		"check: LDX + RET X",
4676  		.u.insns = {
4677  			BPF_STMT(BPF_LDX | BPF_IMM, 42),
4678  			BPF_STMT(BPF_RET | BPF_X, 0),
4679  		},
4680  		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4681  		{ },
4682  		{ },
4683  		.fill_helper = NULL,
4684  		.expected_errcode = -EINVAL,
4685  	},
4686  	{	/* Mainly checking JIT here. */
4687  		"M[]: alt STX + LDX",
4688  		.u.insns = {
4689  			BPF_STMT(BPF_LDX | BPF_IMM, 100),
4690  			BPF_STMT(BPF_STX, 0),
4691  			BPF_STMT(BPF_LDX | BPF_MEM, 0),
4692  			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4693  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4694  			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4695  			BPF_STMT(BPF_STX, 1),
4696  			BPF_STMT(BPF_LDX | BPF_MEM, 1),
4697  			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4698  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4699  			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4700  			BPF_STMT(BPF_STX, 2),
4701  			BPF_STMT(BPF_LDX | BPF_MEM, 2),
4702  			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4703  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4704  			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4705  			BPF_STMT(BPF_STX, 3),
4706  			BPF_STMT(BPF_LDX | BPF_MEM, 3),
4707  			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4708  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4709  			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4710  			BPF_STMT(BPF_STX, 4),
4711  			BPF_STMT(BPF_LDX | BPF_MEM, 4),
4712  			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4713  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4714  			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4715  			BPF_STMT(BPF_STX, 5),
4716  			BPF_STMT(BPF_LDX | BPF_MEM, 5),
4717  			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4718  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4719  			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4720  			BPF_STMT(BPF_STX, 6),
4721  			BPF_STMT(BPF_LDX | BPF_MEM, 6),
4722  			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4723  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4724  			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4725  			BPF_STMT(BPF_STX, 7),
4726  			BPF_STMT(BPF_LDX | BPF_MEM, 7),
4727  			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4728  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4729  			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4730  			BPF_STMT(BPF_STX, 8),
4731  			BPF_STMT(BPF_LDX | BPF_MEM, 8),
4732  			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4733  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4734  			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4735  			BPF_STMT(BPF_STX, 9),
4736  			BPF_STMT(BPF_LDX | BPF_MEM, 9),
4737  			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4738  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4739  			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4740  			BPF_STMT(BPF_STX, 10),
4741  			BPF_STMT(BPF_LDX | BPF_MEM, 10),
4742  			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4743  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4744  			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4745  			BPF_STMT(BPF_STX, 11),
4746  			BPF_STMT(BPF_LDX | BPF_MEM, 11),
4747  			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4748  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4749  			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4750  			BPF_STMT(BPF_STX, 12),
4751  			BPF_STMT(BPF_LDX | BPF_MEM, 12),
4752  			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4753  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4754  			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4755  			BPF_STMT(BPF_STX, 13),
4756  			BPF_STMT(BPF_LDX | BPF_MEM, 13),
4757  			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4758  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4759  			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4760  			BPF_STMT(BPF_STX, 14),
4761  			BPF_STMT(BPF_LDX | BPF_MEM, 14),
4762  			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4763  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4764  			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4765  			BPF_STMT(BPF_STX, 15),
4766  			BPF_STMT(BPF_LDX | BPF_MEM, 15),
4767  			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4768  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4769  			BPF_STMT(BPF_MISC | BPF_TAX, 0),
4770  			BPF_STMT(BPF_RET | BPF_A, 0),
4771  		},
4772  		CLASSIC | FLAG_NO_DATA,
4773  		{ },
4774  		{ { 0, 116 } },
4775  	},
4776  	{	/* Mainly checking JIT here. */
4777  		"M[]: full STX + full LDX",
4778  		.u.insns = {
4779  			BPF_STMT(BPF_LDX | BPF_IMM, 0xbadfeedb),
4780  			BPF_STMT(BPF_STX, 0),
4781  			BPF_STMT(BPF_LDX | BPF_IMM, 0xecabedae),
4782  			BPF_STMT(BPF_STX, 1),
4783  			BPF_STMT(BPF_LDX | BPF_IMM, 0xafccfeaf),
4784  			BPF_STMT(BPF_STX, 2),
4785  			BPF_STMT(BPF_LDX | BPF_IMM, 0xbffdcedc),
4786  			BPF_STMT(BPF_STX, 3),
4787  			BPF_STMT(BPF_LDX | BPF_IMM, 0xfbbbdccb),
4788  			BPF_STMT(BPF_STX, 4),
4789  			BPF_STMT(BPF_LDX | BPF_IMM, 0xfbabcbda),
4790  			BPF_STMT(BPF_STX, 5),
4791  			BPF_STMT(BPF_LDX | BPF_IMM, 0xaedecbdb),
4792  			BPF_STMT(BPF_STX, 6),
4793  			BPF_STMT(BPF_LDX | BPF_IMM, 0xadebbade),
4794  			BPF_STMT(BPF_STX, 7),
4795  			BPF_STMT(BPF_LDX | BPF_IMM, 0xfcfcfaec),
4796  			BPF_STMT(BPF_STX, 8),
4797  			BPF_STMT(BPF_LDX | BPF_IMM, 0xbcdddbdc),
4798  			BPF_STMT(BPF_STX, 9),
4799  			BPF_STMT(BPF_LDX | BPF_IMM, 0xfeefdfac),
4800  			BPF_STMT(BPF_STX, 10),
4801  			BPF_STMT(BPF_LDX | BPF_IMM, 0xcddcdeea),
4802  			BPF_STMT(BPF_STX, 11),
4803  			BPF_STMT(BPF_LDX | BPF_IMM, 0xaccfaebb),
4804  			BPF_STMT(BPF_STX, 12),
4805  			BPF_STMT(BPF_LDX | BPF_IMM, 0xbdcccdcf),
4806  			BPF_STMT(BPF_STX, 13),
4807  			BPF_STMT(BPF_LDX | BPF_IMM, 0xaaedecde),
4808  			BPF_STMT(BPF_STX, 14),
4809  			BPF_STMT(BPF_LDX | BPF_IMM, 0xfaeacdad),
4810  			BPF_STMT(BPF_STX, 15),
4811  			BPF_STMT(BPF_LDX | BPF_MEM, 0),
4812  			BPF_STMT(BPF_MISC | BPF_TXA, 0),
4813  			BPF_STMT(BPF_LDX | BPF_MEM, 1),
4814  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4815  			BPF_STMT(BPF_LDX | BPF_MEM, 2),
4816  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4817  			BPF_STMT(BPF_LDX | BPF_MEM, 3),
4818  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4819  			BPF_STMT(BPF_LDX | BPF_MEM, 4),
4820  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4821  			BPF_STMT(BPF_LDX | BPF_MEM, 5),
4822  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4823  			BPF_STMT(BPF_LDX | BPF_MEM, 6),
4824  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4825  			BPF_STMT(BPF_LDX | BPF_MEM, 7),
4826  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4827  			BPF_STMT(BPF_LDX | BPF_MEM, 8),
4828  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4829  			BPF_STMT(BPF_LDX | BPF_MEM, 9),
4830  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4831  			BPF_STMT(BPF_LDX | BPF_MEM, 10),
4832  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4833  			BPF_STMT(BPF_LDX | BPF_MEM, 11),
4834  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4835  			BPF_STMT(BPF_LDX | BPF_MEM, 12),
4836  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4837  			BPF_STMT(BPF_LDX | BPF_MEM, 13),
4838  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4839  			BPF_STMT(BPF_LDX | BPF_MEM, 14),
4840  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4841  			BPF_STMT(BPF_LDX | BPF_MEM, 15),
4842  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4843  			BPF_STMT(BPF_RET | BPF_A, 0),
4844  		},
4845  		CLASSIC | FLAG_NO_DATA,
4846  		{ },
4847  		{ { 0, 0x2a5a5e5 } },
4848  	},
4849  	{
4850  		"check: SKF_AD_MAX",
4851  		.u.insns = {
4852  			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
4853  				 SKF_AD_OFF + SKF_AD_MAX),
4854  			BPF_STMT(BPF_RET | BPF_A, 0),
4855  		},
4856  		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4857  		{ },
4858  		{ },
4859  		.fill_helper = NULL,
4860  		.expected_errcode = -EINVAL,
4861  	},
4862  	{	/* Passes checker but fails during runtime. */
4863  		"LD [SKF_AD_OFF-1]",
4864  		.u.insns = {
4865  			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
4866  				 SKF_AD_OFF - 1),
4867  			BPF_STMT(BPF_RET | BPF_K, 1),
4868  		},
4869  		CLASSIC,
4870  		{ },
4871  		{ { 1, 0 } },
4872  	},
4873  	{
4874  		"load 64-bit immediate",
4875  		.u.insns_int = {
4876  			BPF_LD_IMM64(R1, 0x567800001234LL),
4877  			BPF_MOV64_REG(R2, R1),
4878  			BPF_MOV64_REG(R3, R2),
4879  			BPF_ALU64_IMM(BPF_RSH, R2, 32),
4880  			BPF_ALU64_IMM(BPF_LSH, R3, 32),
4881  			BPF_ALU64_IMM(BPF_RSH, R3, 32),
4882  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
4883  			BPF_JMP_IMM(BPF_JEQ, R2, 0x5678, 1),
4884  			BPF_EXIT_INSN(),
4885  			BPF_JMP_IMM(BPF_JEQ, R3, 0x1234, 1),
4886  			BPF_EXIT_INSN(),
4887  			BPF_LD_IMM64(R0, 0x1ffffffffLL),
4888  			BPF_ALU64_IMM(BPF_RSH, R0, 32), /* R0 = 1 */
4889  			BPF_EXIT_INSN(),
4890  		},
4891  		INTERNAL,
4892  		{ },
4893  		{ { 0, 1 } }
4894  	},
4895  	/* BPF_ALU | BPF_MOV | BPF_X */
4896  	{
4897  		"ALU_MOV_X: dst = 2",
4898  		.u.insns_int = {
4899  			BPF_ALU32_IMM(BPF_MOV, R1, 2),
4900  			BPF_ALU32_REG(BPF_MOV, R0, R1),
4901  			BPF_EXIT_INSN(),
4902  		},
4903  		INTERNAL,
4904  		{ },
4905  		{ { 0, 2 } },
4906  	},
4907  	{
4908  		"ALU_MOV_X: dst = 4294967295",
4909  		.u.insns_int = {
4910  			BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
4911  			BPF_ALU32_REG(BPF_MOV, R0, R1),
4912  			BPF_EXIT_INSN(),
4913  		},
4914  		INTERNAL,
4915  		{ },
4916  		{ { 0, 4294967295U } },
4917  	},
4918  	{
4919  		"ALU64_MOV_X: dst = 2",
4920  		.u.insns_int = {
4921  			BPF_ALU32_IMM(BPF_MOV, R1, 2),
4922  			BPF_ALU64_REG(BPF_MOV, R0, R1),
4923  			BPF_EXIT_INSN(),
4924  		},
4925  		INTERNAL,
4926  		{ },
4927  		{ { 0, 2 } },
4928  	},
4929  	{
4930  		"ALU64_MOV_X: dst = 4294967295",
4931  		.u.insns_int = {
4932  			BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
4933  			BPF_ALU64_REG(BPF_MOV, R0, R1),
4934  			BPF_EXIT_INSN(),
4935  		},
4936  		INTERNAL,
4937  		{ },
4938  		{ { 0, 4294967295U } },
4939  	},
4940  	/* BPF_ALU | BPF_MOV | BPF_K */
4941  	{
4942  		"ALU_MOV_K: dst = 2",
4943  		.u.insns_int = {
4944  			BPF_ALU32_IMM(BPF_MOV, R0, 2),
4945  			BPF_EXIT_INSN(),
4946  		},
4947  		INTERNAL,
4948  		{ },
4949  		{ { 0, 2 } },
4950  	},
4951  	{
4952  		"ALU_MOV_K: dst = 4294967295",
4953  		.u.insns_int = {
4954  			BPF_ALU32_IMM(BPF_MOV, R0, 4294967295U),
4955  			BPF_EXIT_INSN(),
4956  		},
4957  		INTERNAL,
4958  		{ },
4959  		{ { 0, 4294967295U } },
4960  	},
4961  	{
4962  		"ALU_MOV_K: 0x0000ffffffff0000 = 0x00000000ffffffff",
4963  		.u.insns_int = {
4964  			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
4965  			BPF_LD_IMM64(R3, 0x00000000ffffffffLL),
4966  			BPF_ALU32_IMM(BPF_MOV, R2, 0xffffffff),
4967  			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4968  			BPF_MOV32_IMM(R0, 2),
4969  			BPF_EXIT_INSN(),
4970  			BPF_MOV32_IMM(R0, 1),
4971  			BPF_EXIT_INSN(),
4972  		},
4973  		INTERNAL,
4974  		{ },
4975  		{ { 0, 0x1 } },
4976  	},
4977  	{
4978  		"ALU_MOV_K: small negative",
4979  		.u.insns_int = {
4980  			BPF_ALU32_IMM(BPF_MOV, R0, -123),
4981  			BPF_EXIT_INSN(),
4982  		},
4983  		INTERNAL,
4984  		{ },
4985  		{ { 0, -123 } }
4986  	},
4987  	{
4988  		"ALU_MOV_K: small negative zero extension",
4989  		.u.insns_int = {
4990  			BPF_ALU32_IMM(BPF_MOV, R0, -123),
4991  			BPF_ALU64_IMM(BPF_RSH, R0, 32),
4992  			BPF_EXIT_INSN(),
4993  		},
4994  		INTERNAL,
4995  		{ },
4996  		{ { 0, 0 } }
4997  	},
4998  	{
4999  		"ALU_MOV_K: large negative",
5000  		.u.insns_int = {
5001  			BPF_ALU32_IMM(BPF_MOV, R0, -123456789),
5002  			BPF_EXIT_INSN(),
5003  		},
5004  		INTERNAL,
5005  		{ },
5006  		{ { 0, -123456789 } }
5007  	},
5008  	{
5009  		"ALU_MOV_K: large negative zero extension",
5010  		.u.insns_int = {
5011  			BPF_ALU32_IMM(BPF_MOV, R0, -123456789),
5012  			BPF_ALU64_IMM(BPF_RSH, R0, 32),
5013  			BPF_EXIT_INSN(),
5014  		},
5015  		INTERNAL,
5016  		{ },
5017  		{ { 0, 0 } }
5018  	},
5019  	{
5020  		"ALU64_MOV_K: dst = 2",
5021  		.u.insns_int = {
5022  			BPF_ALU64_IMM(BPF_MOV, R0, 2),
5023  			BPF_EXIT_INSN(),
5024  		},
5025  		INTERNAL,
5026  		{ },
5027  		{ { 0, 2 } },
5028  	},
5029  	{
5030  		"ALU64_MOV_K: dst = 2147483647",
5031  		.u.insns_int = {
5032  			BPF_ALU64_IMM(BPF_MOV, R0, 2147483647),
5033  			BPF_EXIT_INSN(),
5034  		},
5035  		INTERNAL,
5036  		{ },
5037  		{ { 0, 2147483647 } },
5038  	},
5039  	{
5040  		"ALU64_OR_K: dst = 0x0",
5041  		.u.insns_int = {
5042  			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
5043  			BPF_LD_IMM64(R3, 0x0),
5044  			BPF_ALU64_IMM(BPF_MOV, R2, 0x0),
5045  			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5046  			BPF_MOV32_IMM(R0, 2),
5047  			BPF_EXIT_INSN(),
5048  			BPF_MOV32_IMM(R0, 1),
5049  			BPF_EXIT_INSN(),
5050  		},
5051  		INTERNAL,
5052  		{ },
5053  		{ { 0, 0x1 } },
5054  	},
5055  	{
5056  		"ALU64_MOV_K: dst = -1",
5057  		.u.insns_int = {
5058  			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
5059  			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
5060  			BPF_ALU64_IMM(BPF_MOV, R2, 0xffffffff),
5061  			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5062  			BPF_MOV32_IMM(R0, 2),
5063  			BPF_EXIT_INSN(),
5064  			BPF_MOV32_IMM(R0, 1),
5065  			BPF_EXIT_INSN(),
5066  		},
5067  		INTERNAL,
5068  		{ },
5069  		{ { 0, 0x1 } },
5070  	},
5071  	{
5072  		"ALU64_MOV_K: small negative",
5073  		.u.insns_int = {
5074  			BPF_ALU64_IMM(BPF_MOV, R0, -123),
5075  			BPF_EXIT_INSN(),
5076  		},
5077  		INTERNAL,
5078  		{ },
5079  		{ { 0, -123 } }
5080  	},
5081  	{
5082  		"ALU64_MOV_K: small negative sign extension",
5083  		.u.insns_int = {
5084  			BPF_ALU64_IMM(BPF_MOV, R0, -123),
5085  			BPF_ALU64_IMM(BPF_RSH, R0, 32),
5086  			BPF_EXIT_INSN(),
5087  		},
5088  		INTERNAL,
5089  		{ },
5090  		{ { 0, 0xffffffff } }
5091  	},
5092  	{
5093  		"ALU64_MOV_K: large negative",
5094  		.u.insns_int = {
5095  			BPF_ALU64_IMM(BPF_MOV, R0, -123456789),
5096  			BPF_EXIT_INSN(),
5097  		},
5098  		INTERNAL,
5099  		{ },
5100  		{ { 0, -123456789 } }
5101  	},
5102  	{
5103  		"ALU64_MOV_K: large negative sign extension",
5104  		.u.insns_int = {
5105  			BPF_ALU64_IMM(BPF_MOV, R0, -123456789),
5106  			BPF_ALU64_IMM(BPF_RSH, R0, 32),
5107  			BPF_EXIT_INSN(),
5108  		},
5109  		INTERNAL,
5110  		{ },
5111  		{ { 0, 0xffffffff } }
5112  	},
5113  	/* BPF_ALU | BPF_ADD | BPF_X */
5114  	{
5115  		"ALU_ADD_X: 1 + 2 = 3",
5116  		.u.insns_int = {
5117  			BPF_LD_IMM64(R0, 1),
5118  			BPF_ALU32_IMM(BPF_MOV, R1, 2),
5119  			BPF_ALU32_REG(BPF_ADD, R0, R1),
5120  			BPF_EXIT_INSN(),
5121  		},
5122  		INTERNAL,
5123  		{ },
5124  		{ { 0, 3 } },
5125  	},
5126  	{
5127  		"ALU_ADD_X: 1 + 4294967294 = 4294967295",
5128  		.u.insns_int = {
5129  			BPF_LD_IMM64(R0, 1),
5130  			BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
5131  			BPF_ALU32_REG(BPF_ADD, R0, R1),
5132  			BPF_EXIT_INSN(),
5133  		},
5134  		INTERNAL,
5135  		{ },
5136  		{ { 0, 4294967295U } },
5137  	},
5138  	{
5139  		"ALU_ADD_X: 2 + 4294967294 = 0",
5140  		.u.insns_int = {
5141  			BPF_LD_IMM64(R0, 2),
5142  			BPF_LD_IMM64(R1, 4294967294U),
5143  			BPF_ALU32_REG(BPF_ADD, R0, R1),
5144  			BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
5145  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
5146  			BPF_EXIT_INSN(),
5147  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
5148  			BPF_EXIT_INSN(),
5149  		},
5150  		INTERNAL,
5151  		{ },
5152  		{ { 0, 1 } },
5153  	},
5154  	{
5155  		"ALU64_ADD_X: 1 + 2 = 3",
5156  		.u.insns_int = {
5157  			BPF_LD_IMM64(R0, 1),
5158  			BPF_ALU32_IMM(BPF_MOV, R1, 2),
5159  			BPF_ALU64_REG(BPF_ADD, R0, R1),
5160  			BPF_EXIT_INSN(),
5161  		},
5162  		INTERNAL,
5163  		{ },
5164  		{ { 0, 3 } },
5165  	},
5166  	{
5167  		"ALU64_ADD_X: 1 + 4294967294 = 4294967295",
5168  		.u.insns_int = {
5169  			BPF_LD_IMM64(R0, 1),
5170  			BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
5171  			BPF_ALU64_REG(BPF_ADD, R0, R1),
5172  			BPF_EXIT_INSN(),
5173  		},
5174  		INTERNAL,
5175  		{ },
5176  		{ { 0, 4294967295U } },
5177  	},
5178  	{
5179  		"ALU64_ADD_X: 2 + 4294967294 = 4294967296",
5180  		.u.insns_int = {
5181  			BPF_LD_IMM64(R0, 2),
5182  			BPF_LD_IMM64(R1, 4294967294U),
5183  			BPF_LD_IMM64(R2, 4294967296ULL),
5184  			BPF_ALU64_REG(BPF_ADD, R0, R1),
5185  			BPF_JMP_REG(BPF_JEQ, R0, R2, 2),
5186  			BPF_MOV32_IMM(R0, 0),
5187  			BPF_EXIT_INSN(),
5188  			BPF_MOV32_IMM(R0, 1),
5189  			BPF_EXIT_INSN(),
5190  		},
5191  		INTERNAL,
5192  		{ },
5193  		{ { 0, 1 } },
5194  	},
5195  	/* BPF_ALU | BPF_ADD | BPF_K */
5196  	{
5197  		"ALU_ADD_K: 1 + 2 = 3",
5198  		.u.insns_int = {
5199  			BPF_LD_IMM64(R0, 1),
5200  			BPF_ALU32_IMM(BPF_ADD, R0, 2),
5201  			BPF_EXIT_INSN(),
5202  		},
5203  		INTERNAL,
5204  		{ },
5205  		{ { 0, 3 } },
5206  	},
5207  	{
5208  		"ALU_ADD_K: 3 + 0 = 3",
5209  		.u.insns_int = {
5210  			BPF_LD_IMM64(R0, 3),
5211  			BPF_ALU32_IMM(BPF_ADD, R0, 0),
5212  			BPF_EXIT_INSN(),
5213  		},
5214  		INTERNAL,
5215  		{ },
5216  		{ { 0, 3 } },
5217  	},
5218  	{
5219  		"ALU_ADD_K: 1 + 4294967294 = 4294967295",
5220  		.u.insns_int = {
5221  			BPF_LD_IMM64(R0, 1),
5222  			BPF_ALU32_IMM(BPF_ADD, R0, 4294967294U),
5223  			BPF_EXIT_INSN(),
5224  		},
5225  		INTERNAL,
5226  		{ },
5227  		{ { 0, 4294967295U } },
5228  	},
5229  	{
5230  		"ALU_ADD_K: 4294967294 + 2 = 0",
5231  		.u.insns_int = {
5232  			BPF_LD_IMM64(R0, 4294967294U),
5233  			BPF_ALU32_IMM(BPF_ADD, R0, 2),
5234  			BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
5235  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
5236  			BPF_EXIT_INSN(),
5237  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
5238  			BPF_EXIT_INSN(),
5239  		},
5240  		INTERNAL,
5241  		{ },
5242  		{ { 0, 1 } },
5243  	},
5244  	{
5245  		"ALU_ADD_K: 0 + (-1) = 0x00000000ffffffff",
5246  		.u.insns_int = {
5247  			BPF_LD_IMM64(R2, 0x0),
5248  			BPF_LD_IMM64(R3, 0x00000000ffffffff),
5249  			BPF_ALU32_IMM(BPF_ADD, R2, 0xffffffff),
5250  			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5251  			BPF_MOV32_IMM(R0, 2),
5252  			BPF_EXIT_INSN(),
5253  			BPF_MOV32_IMM(R0, 1),
5254  			BPF_EXIT_INSN(),
5255  		},
5256  		INTERNAL,
5257  		{ },
5258  		{ { 0, 0x1 } },
5259  	},
5260  	{
5261  		"ALU_ADD_K: 0 + 0xffff = 0xffff",
5262  		.u.insns_int = {
5263  			BPF_LD_IMM64(R2, 0x0),
5264  			BPF_LD_IMM64(R3, 0xffff),
5265  			BPF_ALU32_IMM(BPF_ADD, R2, 0xffff),
5266  			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5267  			BPF_MOV32_IMM(R0, 2),
5268  			BPF_EXIT_INSN(),
5269  			BPF_MOV32_IMM(R0, 1),
5270  			BPF_EXIT_INSN(),
5271  		},
5272  		INTERNAL,
5273  		{ },
5274  		{ { 0, 0x1 } },
5275  	},
5276  	{
5277  		"ALU_ADD_K: 0 + 0x7fffffff = 0x7fffffff",
5278  		.u.insns_int = {
5279  			BPF_LD_IMM64(R2, 0x0),
5280  			BPF_LD_IMM64(R3, 0x7fffffff),
5281  			BPF_ALU32_IMM(BPF_ADD, R2, 0x7fffffff),
5282  			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5283  			BPF_MOV32_IMM(R0, 2),
5284  			BPF_EXIT_INSN(),
5285  			BPF_MOV32_IMM(R0, 1),
5286  			BPF_EXIT_INSN(),
5287  		},
5288  		INTERNAL,
5289  		{ },
5290  		{ { 0, 0x1 } },
5291  	},
5292  	{
5293  		"ALU_ADD_K: 0 + 0x80000000 = 0x80000000",
5294  		.u.insns_int = {
5295  			BPF_LD_IMM64(R2, 0x0),
5296  			BPF_LD_IMM64(R3, 0x80000000),
5297  			BPF_ALU32_IMM(BPF_ADD, R2, 0x80000000),
5298  			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5299  			BPF_MOV32_IMM(R0, 2),
5300  			BPF_EXIT_INSN(),
5301  			BPF_MOV32_IMM(R0, 1),
5302  			BPF_EXIT_INSN(),
5303  		},
5304  		INTERNAL,
5305  		{ },
5306  		{ { 0, 0x1 } },
5307  	},
5308  	{
5309  		"ALU_ADD_K: 0 + 0x80008000 = 0x80008000",
5310  		.u.insns_int = {
5311  			BPF_LD_IMM64(R2, 0x0),
5312  			BPF_LD_IMM64(R3, 0x80008000),
5313  			BPF_ALU32_IMM(BPF_ADD, R2, 0x80008000),
5314  			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5315  			BPF_MOV32_IMM(R0, 2),
5316  			BPF_EXIT_INSN(),
5317  			BPF_MOV32_IMM(R0, 1),
5318  			BPF_EXIT_INSN(),
5319  		},
5320  		INTERNAL,
5321  		{ },
5322  		{ { 0, 0x1 } },
5323  	},
5324  	{
5325  		"ALU64_ADD_K: 1 + 2 = 3",
5326  		.u.insns_int = {
5327  			BPF_LD_IMM64(R0, 1),
5328  			BPF_ALU64_IMM(BPF_ADD, R0, 2),
5329  			BPF_EXIT_INSN(),
5330  		},
5331  		INTERNAL,
5332  		{ },
5333  		{ { 0, 3 } },
5334  	},
5335  	{
5336  		"ALU64_ADD_K: 3 + 0 = 3",
5337  		.u.insns_int = {
5338  			BPF_LD_IMM64(R0, 3),
5339  			BPF_ALU64_IMM(BPF_ADD, R0, 0),
5340  			BPF_EXIT_INSN(),
5341  		},
5342  		INTERNAL,
5343  		{ },
5344  		{ { 0, 3 } },
5345  	},
5346  	{
5347  		"ALU64_ADD_K: 1 + 2147483646 = 2147483647",
5348  		.u.insns_int = {
5349  			BPF_LD_IMM64(R0, 1),
5350  			BPF_ALU64_IMM(BPF_ADD, R0, 2147483646),
5351  			BPF_EXIT_INSN(),
5352  		},
5353  		INTERNAL,
5354  		{ },
5355  		{ { 0, 2147483647 } },
5356  	},
5357  	{
5358  		"ALU64_ADD_K: 4294967294 + 2 = 4294967296",
5359  		.u.insns_int = {
5360  			BPF_LD_IMM64(R0, 4294967294U),
5361  			BPF_LD_IMM64(R1, 4294967296ULL),
5362  			BPF_ALU64_IMM(BPF_ADD, R0, 2),
5363  			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
5364  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
5365  			BPF_EXIT_INSN(),
5366  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
5367  			BPF_EXIT_INSN(),
5368  		},
5369  		INTERNAL,
5370  		{ },
5371  		{ { 0, 1 } },
5372  	},
5373  	{
5374  		"ALU64_ADD_K: 2147483646 + -2147483647 = -1",
5375  		.u.insns_int = {
5376  			BPF_LD_IMM64(R0, 2147483646),
5377  			BPF_ALU64_IMM(BPF_ADD, R0, -2147483647),
5378  			BPF_EXIT_INSN(),
5379  		},
5380  		INTERNAL,
5381  		{ },
5382  		{ { 0, -1 } },
5383  	},
5384  	{
5385  		"ALU64_ADD_K: 1 + 0 = 1",
5386  		.u.insns_int = {
5387  			BPF_LD_IMM64(R2, 0x1),
5388  			BPF_LD_IMM64(R3, 0x1),
5389  			BPF_ALU64_IMM(BPF_ADD, R2, 0x0),
5390  			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5391  			BPF_MOV32_IMM(R0, 2),
5392  			BPF_EXIT_INSN(),
5393  			BPF_MOV32_IMM(R0, 1),
5394  			BPF_EXIT_INSN(),
5395  		},
5396  		INTERNAL,
5397  		{ },
5398  		{ { 0, 0x1 } },
5399  	},
5400  	{
5401  		"ALU64_ADD_K: 0 + (-1) = 0xffffffffffffffff",
5402  		.u.insns_int = {
5403  			BPF_LD_IMM64(R2, 0x0),
5404  			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
5405  			BPF_ALU64_IMM(BPF_ADD, R2, 0xffffffff),
5406  			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5407  			BPF_MOV32_IMM(R0, 2),
5408  			BPF_EXIT_INSN(),
5409  			BPF_MOV32_IMM(R0, 1),
5410  			BPF_EXIT_INSN(),
5411  		},
5412  		INTERNAL,
5413  		{ },
5414  		{ { 0, 0x1 } },
5415  	},
5416  	{
5417  		"ALU64_ADD_K: 0 + 0xffff = 0xffff",
5418  		.u.insns_int = {
5419  			BPF_LD_IMM64(R2, 0x0),
5420  			BPF_LD_IMM64(R3, 0xffff),
5421  			BPF_ALU64_IMM(BPF_ADD, R2, 0xffff),
5422  			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5423  			BPF_MOV32_IMM(R0, 2),
5424  			BPF_EXIT_INSN(),
5425  			BPF_MOV32_IMM(R0, 1),
5426  			BPF_EXIT_INSN(),
5427  		},
5428  		INTERNAL,
5429  		{ },
5430  		{ { 0, 0x1 } },
5431  	},
5432  	{
5433  		"ALU64_ADD_K: 0 + 0x7fffffff = 0x7fffffff",
5434  		.u.insns_int = {
5435  			BPF_LD_IMM64(R2, 0x0),
5436  			BPF_LD_IMM64(R3, 0x7fffffff),
5437  			BPF_ALU64_IMM(BPF_ADD, R2, 0x7fffffff),
5438  			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5439  			BPF_MOV32_IMM(R0, 2),
5440  			BPF_EXIT_INSN(),
5441  			BPF_MOV32_IMM(R0, 1),
5442  			BPF_EXIT_INSN(),
5443  		},
5444  		INTERNAL,
5445  		{ },
5446  		{ { 0, 0x1 } },
5447  	},
5448  	{
5449  		"ALU64_ADD_K: 0 + 0x80000000 = 0xffffffff80000000",
5450  		.u.insns_int = {
5451  			BPF_LD_IMM64(R2, 0x0),
5452  			BPF_LD_IMM64(R3, 0xffffffff80000000LL),
5453  			BPF_ALU64_IMM(BPF_ADD, R2, 0x80000000),
5454  			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5455  			BPF_MOV32_IMM(R0, 2),
5456  			BPF_EXIT_INSN(),
5457  			BPF_MOV32_IMM(R0, 1),
5458  			BPF_EXIT_INSN(),
5459  		},
5460  		INTERNAL,
5461  		{ },
5462  		{ { 0, 0x1 } },
5463  	},
5464  	{
5465  		"ALU_ADD_K: 0 + 0x80008000 = 0xffffffff80008000",
5466  		.u.insns_int = {
5467  			BPF_LD_IMM64(R2, 0x0),
5468  			BPF_LD_IMM64(R3, 0xffffffff80008000LL),
5469  			BPF_ALU64_IMM(BPF_ADD, R2, 0x80008000),
5470  			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5471  			BPF_MOV32_IMM(R0, 2),
5472  			BPF_EXIT_INSN(),
5473  			BPF_MOV32_IMM(R0, 1),
5474  			BPF_EXIT_INSN(),
5475  		},
5476  		INTERNAL,
5477  		{ },
5478  		{ { 0, 0x1 } },
5479  	},
5480  	/* BPF_ALU | BPF_SUB | BPF_X */
5481  	{
5482  		"ALU_SUB_X: 3 - 1 = 2",
5483  		.u.insns_int = {
5484  			BPF_LD_IMM64(R0, 3),
5485  			BPF_ALU32_IMM(BPF_MOV, R1, 1),
5486  			BPF_ALU32_REG(BPF_SUB, R0, R1),
5487  			BPF_EXIT_INSN(),
5488  		},
5489  		INTERNAL,
5490  		{ },
5491  		{ { 0, 2 } },
5492  	},
5493  	{
5494  		"ALU_SUB_X: 4294967295 - 4294967294 = 1",
5495  		.u.insns_int = {
5496  			BPF_LD_IMM64(R0, 4294967295U),
5497  			BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
5498  			BPF_ALU32_REG(BPF_SUB, R0, R1),
5499  			BPF_EXIT_INSN(),
5500  		},
5501  		INTERNAL,
5502  		{ },
5503  		{ { 0, 1 } },
5504  	},
5505  	{
5506  		"ALU64_SUB_X: 3 - 1 = 2",
5507  		.u.insns_int = {
5508  			BPF_LD_IMM64(R0, 3),
5509  			BPF_ALU32_IMM(BPF_MOV, R1, 1),
5510  			BPF_ALU64_REG(BPF_SUB, R0, R1),
5511  			BPF_EXIT_INSN(),
5512  		},
5513  		INTERNAL,
5514  		{ },
5515  		{ { 0, 2 } },
5516  	},
5517  	{
5518  		"ALU64_SUB_X: 4294967295 - 4294967294 = 1",
5519  		.u.insns_int = {
5520  			BPF_LD_IMM64(R0, 4294967295U),
5521  			BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
5522  			BPF_ALU64_REG(BPF_SUB, R0, R1),
5523  			BPF_EXIT_INSN(),
5524  		},
5525  		INTERNAL,
5526  		{ },
5527  		{ { 0, 1 } },
5528  	},
5529  	/* BPF_ALU | BPF_SUB | BPF_K */
5530  	{
5531  		"ALU_SUB_K: 3 - 1 = 2",
5532  		.u.insns_int = {
5533  			BPF_LD_IMM64(R0, 3),
5534  			BPF_ALU32_IMM(BPF_SUB, R0, 1),
5535  			BPF_EXIT_INSN(),
5536  		},
5537  		INTERNAL,
5538  		{ },
5539  		{ { 0, 2 } },
5540  	},
5541  	{
5542  		"ALU_SUB_K: 3 - 0 = 3",
5543  		.u.insns_int = {
5544  			BPF_LD_IMM64(R0, 3),
5545  			BPF_ALU32_IMM(BPF_SUB, R0, 0),
5546  			BPF_EXIT_INSN(),
5547  		},
5548  		INTERNAL,
5549  		{ },
5550  		{ { 0, 3 } },
5551  	},
5552  	{
5553  		"ALU_SUB_K: 4294967295 - 4294967294 = 1",
5554  		.u.insns_int = {
5555  			BPF_LD_IMM64(R0, 4294967295U),
5556  			BPF_ALU32_IMM(BPF_SUB, R0, 4294967294U),
5557  			BPF_EXIT_INSN(),
5558  		},
5559  		INTERNAL,
5560  		{ },
5561  		{ { 0, 1 } },
5562  	},
5563  	{
5564  		"ALU64_SUB_K: 3 - 1 = 2",
5565  		.u.insns_int = {
5566  			BPF_LD_IMM64(R0, 3),
5567  			BPF_ALU64_IMM(BPF_SUB, R0, 1),
5568  			BPF_EXIT_INSN(),
5569  		},
5570  		INTERNAL,
5571  		{ },
5572  		{ { 0, 2 } },
5573  	},
5574  	{
5575  		"ALU64_SUB_K: 3 - 0 = 3",
5576  		.u.insns_int = {
5577  			BPF_LD_IMM64(R0, 3),
5578  			BPF_ALU64_IMM(BPF_SUB, R0, 0),
5579  			BPF_EXIT_INSN(),
5580  		},
5581  		INTERNAL,
5582  		{ },
5583  		{ { 0, 3 } },
5584  	},
5585  	{
5586  		"ALU64_SUB_K: 4294967294 - 4294967295 = -1",
5587  		.u.insns_int = {
5588  			BPF_LD_IMM64(R0, 4294967294U),
5589  			BPF_ALU64_IMM(BPF_SUB, R0, 4294967295U),
5590  			BPF_EXIT_INSN(),
5591  		},
5592  		INTERNAL,
5593  		{ },
5594  		{ { 0, -1 } },
5595  	},
5596  	{
5597  		"ALU64_ADD_K: 2147483646 - 2147483647 = -1",
5598  		.u.insns_int = {
5599  			BPF_LD_IMM64(R0, 2147483646),
5600  			BPF_ALU64_IMM(BPF_SUB, R0, 2147483647),
5601  			BPF_EXIT_INSN(),
5602  		},
5603  		INTERNAL,
5604  		{ },
5605  		{ { 0, -1 } },
5606  	},
5607  	/* BPF_ALU | BPF_MUL | BPF_X */
5608  	{
5609  		"ALU_MUL_X: 2 * 3 = 6",
5610  		.u.insns_int = {
5611  			BPF_LD_IMM64(R0, 2),
5612  			BPF_ALU32_IMM(BPF_MOV, R1, 3),
5613  			BPF_ALU32_REG(BPF_MUL, R0, R1),
5614  			BPF_EXIT_INSN(),
5615  		},
5616  		INTERNAL,
5617  		{ },
5618  		{ { 0, 6 } },
5619  	},
5620  	{
5621  		"ALU_MUL_X: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
5622  		.u.insns_int = {
5623  			BPF_LD_IMM64(R0, 2),
5624  			BPF_ALU32_IMM(BPF_MOV, R1, 0x7FFFFFF8),
5625  			BPF_ALU32_REG(BPF_MUL, R0, R1),
5626  			BPF_EXIT_INSN(),
5627  		},
5628  		INTERNAL,
5629  		{ },
5630  		{ { 0, 0xFFFFFFF0 } },
5631  	},
5632  	{
5633  		"ALU_MUL_X: -1 * -1 = 1",
5634  		.u.insns_int = {
5635  			BPF_LD_IMM64(R0, -1),
5636  			BPF_ALU32_IMM(BPF_MOV, R1, -1),
5637  			BPF_ALU32_REG(BPF_MUL, R0, R1),
5638  			BPF_EXIT_INSN(),
5639  		},
5640  		INTERNAL,
5641  		{ },
5642  		{ { 0, 1 } },
5643  	},
5644  	{
5645  		"ALU64_MUL_X: 2 * 3 = 6",
5646  		.u.insns_int = {
5647  			BPF_LD_IMM64(R0, 2),
5648  			BPF_ALU32_IMM(BPF_MOV, R1, 3),
5649  			BPF_ALU64_REG(BPF_MUL, R0, R1),
5650  			BPF_EXIT_INSN(),
5651  		},
5652  		INTERNAL,
5653  		{ },
5654  		{ { 0, 6 } },
5655  	},
5656  	{
5657  		"ALU64_MUL_X: 1 * 2147483647 = 2147483647",
5658  		.u.insns_int = {
5659  			BPF_LD_IMM64(R0, 1),
5660  			BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
5661  			BPF_ALU64_REG(BPF_MUL, R0, R1),
5662  			BPF_EXIT_INSN(),
5663  		},
5664  		INTERNAL,
5665  		{ },
5666  		{ { 0, 2147483647 } },
5667  	},
5668  	{
5669  		"ALU64_MUL_X: 64x64 multiply, low word",
5670  		.u.insns_int = {
5671  			BPF_LD_IMM64(R0, 0x0fedcba987654321LL),
5672  			BPF_LD_IMM64(R1, 0x123456789abcdef0LL),
5673  			BPF_ALU64_REG(BPF_MUL, R0, R1),
5674  			BPF_EXIT_INSN(),
5675  		},
5676  		INTERNAL,
5677  		{ },
5678  		{ { 0, 0xe5618cf0 } }
5679  	},
5680  	{
5681  		"ALU64_MUL_X: 64x64 multiply, high word",
5682  		.u.insns_int = {
5683  			BPF_LD_IMM64(R0, 0x0fedcba987654321LL),
5684  			BPF_LD_IMM64(R1, 0x123456789abcdef0LL),
5685  			BPF_ALU64_REG(BPF_MUL, R0, R1),
5686  			BPF_ALU64_IMM(BPF_RSH, R0, 32),
5687  			BPF_EXIT_INSN(),
5688  		},
5689  		INTERNAL,
5690  		{ },
5691  		{ { 0, 0x2236d88f } }
5692  	},
5693  	/* BPF_ALU | BPF_MUL | BPF_K */
5694  	{
5695  		"ALU_MUL_K: 2 * 3 = 6",
5696  		.u.insns_int = {
5697  			BPF_LD_IMM64(R0, 2),
5698  			BPF_ALU32_IMM(BPF_MUL, R0, 3),
5699  			BPF_EXIT_INSN(),
5700  		},
5701  		INTERNAL,
5702  		{ },
5703  		{ { 0, 6 } },
5704  	},
5705  	{
5706  		"ALU_MUL_K: 3 * 1 = 3",
5707  		.u.insns_int = {
5708  			BPF_LD_IMM64(R0, 3),
5709  			BPF_ALU32_IMM(BPF_MUL, R0, 1),
5710  			BPF_EXIT_INSN(),
5711  		},
5712  		INTERNAL,
5713  		{ },
5714  		{ { 0, 3 } },
5715  	},
5716  	{
5717  		"ALU_MUL_K: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
5718  		.u.insns_int = {
5719  			BPF_LD_IMM64(R0, 2),
5720  			BPF_ALU32_IMM(BPF_MUL, R0, 0x7FFFFFF8),
5721  			BPF_EXIT_INSN(),
5722  		},
5723  		INTERNAL,
5724  		{ },
5725  		{ { 0, 0xFFFFFFF0 } },
5726  	},
5727  	{
5728  		"ALU_MUL_K: 1 * (-1) = 0x00000000ffffffff",
5729  		.u.insns_int = {
5730  			BPF_LD_IMM64(R2, 0x1),
5731  			BPF_LD_IMM64(R3, 0x00000000ffffffff),
5732  			BPF_ALU32_IMM(BPF_MUL, R2, 0xffffffff),
5733  			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5734  			BPF_MOV32_IMM(R0, 2),
5735  			BPF_EXIT_INSN(),
5736  			BPF_MOV32_IMM(R0, 1),
5737  			BPF_EXIT_INSN(),
5738  		},
5739  		INTERNAL,
5740  		{ },
5741  		{ { 0, 0x1 } },
5742  	},
5743  	{
5744  		"ALU64_MUL_K: 2 * 3 = 6",
5745  		.u.insns_int = {
5746  			BPF_LD_IMM64(R0, 2),
5747  			BPF_ALU64_IMM(BPF_MUL, R0, 3),
5748  			BPF_EXIT_INSN(),
5749  		},
5750  		INTERNAL,
5751  		{ },
5752  		{ { 0, 6 } },
5753  	},
5754  	{
5755  		"ALU64_MUL_K: 3 * 1 = 3",
5756  		.u.insns_int = {
5757  			BPF_LD_IMM64(R0, 3),
5758  			BPF_ALU64_IMM(BPF_MUL, R0, 1),
5759  			BPF_EXIT_INSN(),
5760  		},
5761  		INTERNAL,
5762  		{ },
5763  		{ { 0, 3 } },
5764  	},
5765  	{
5766  		"ALU64_MUL_K: 1 * 2147483647 = 2147483647",
5767  		.u.insns_int = {
5768  			BPF_LD_IMM64(R0, 1),
5769  			BPF_ALU64_IMM(BPF_MUL, R0, 2147483647),
5770  			BPF_EXIT_INSN(),
5771  		},
5772  		INTERNAL,
5773  		{ },
5774  		{ { 0, 2147483647 } },
5775  	},
5776  	{
5777  		"ALU64_MUL_K: 1 * -2147483647 = -2147483647",
5778  		.u.insns_int = {
5779  			BPF_LD_IMM64(R0, 1),
5780  			BPF_ALU64_IMM(BPF_MUL, R0, -2147483647),
5781  			BPF_EXIT_INSN(),
5782  		},
5783  		INTERNAL,
5784  		{ },
5785  		{ { 0, -2147483647 } },
5786  	},
5787  	{
5788  		"ALU64_MUL_K: 1 * (-1) = 0xffffffffffffffff",
5789  		.u.insns_int = {
5790  			BPF_LD_IMM64(R2, 0x1),
5791  			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
5792  			BPF_ALU64_IMM(BPF_MUL, R2, 0xffffffff),
5793  			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5794  			BPF_MOV32_IMM(R0, 2),
5795  			BPF_EXIT_INSN(),
5796  			BPF_MOV32_IMM(R0, 1),
5797  			BPF_EXIT_INSN(),
5798  		},
5799  		INTERNAL,
5800  		{ },
5801  		{ { 0, 0x1 } },
5802  	},
5803  	{
5804  		"ALU64_MUL_K: 64x32 multiply, low word",
5805  		.u.insns_int = {
5806  			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5807  			BPF_ALU64_IMM(BPF_MUL, R0, 0x12345678),
5808  			BPF_EXIT_INSN(),
5809  		},
5810  		INTERNAL,
5811  		{ },
5812  		{ { 0, 0xe242d208 } }
5813  	},
5814  	{
5815  		"ALU64_MUL_K: 64x32 multiply, high word",
5816  		.u.insns_int = {
5817  			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5818  			BPF_ALU64_IMM(BPF_MUL, R0, 0x12345678),
5819  			BPF_ALU64_IMM(BPF_RSH, R0, 32),
5820  			BPF_EXIT_INSN(),
5821  		},
5822  		INTERNAL,
5823  		{ },
5824  		{ { 0, 0xc28f5c28 } }
5825  	},
5826  	/* BPF_ALU | BPF_DIV | BPF_X */
5827  	{
5828  		"ALU_DIV_X: 6 / 2 = 3",
5829  		.u.insns_int = {
5830  			BPF_LD_IMM64(R0, 6),
5831  			BPF_ALU32_IMM(BPF_MOV, R1, 2),
5832  			BPF_ALU32_REG(BPF_DIV, R0, R1),
5833  			BPF_EXIT_INSN(),
5834  		},
5835  		INTERNAL,
5836  		{ },
5837  		{ { 0, 3 } },
5838  	},
5839  	{
5840  		"ALU_DIV_X: 4294967295 / 4294967295 = 1",
5841  		.u.insns_int = {
5842  			BPF_LD_IMM64(R0, 4294967295U),
5843  			BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
5844  			BPF_ALU32_REG(BPF_DIV, R0, R1),
5845  			BPF_EXIT_INSN(),
5846  		},
5847  		INTERNAL,
5848  		{ },
5849  		{ { 0, 1 } },
5850  	},
5851  	{
5852  		"ALU64_DIV_X: 6 / 2 = 3",
5853  		.u.insns_int = {
5854  			BPF_LD_IMM64(R0, 6),
5855  			BPF_ALU32_IMM(BPF_MOV, R1, 2),
5856  			BPF_ALU64_REG(BPF_DIV, R0, R1),
5857  			BPF_EXIT_INSN(),
5858  		},
5859  		INTERNAL,
5860  		{ },
5861  		{ { 0, 3 } },
5862  	},
5863  	{
5864  		"ALU64_DIV_X: 2147483647 / 2147483647 = 1",
5865  		.u.insns_int = {
5866  			BPF_LD_IMM64(R0, 2147483647),
5867  			BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
5868  			BPF_ALU64_REG(BPF_DIV, R0, R1),
5869  			BPF_EXIT_INSN(),
5870  		},
5871  		INTERNAL,
5872  		{ },
5873  		{ { 0, 1 } },
5874  	},
5875  	{
5876  		"ALU64_DIV_X: 0xffffffffffffffff / (-1) = 0x0000000000000001",
5877  		.u.insns_int = {
5878  			BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
5879  			BPF_LD_IMM64(R4, 0xffffffffffffffffLL),
5880  			BPF_LD_IMM64(R3, 0x0000000000000001LL),
5881  			BPF_ALU64_REG(BPF_DIV, R2, R4),
5882  			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5883  			BPF_MOV32_IMM(R0, 2),
5884  			BPF_EXIT_INSN(),
5885  			BPF_MOV32_IMM(R0, 1),
5886  			BPF_EXIT_INSN(),
5887  		},
5888  		INTERNAL,
5889  		{ },
5890  		{ { 0, 0x1 } },
5891  	},
5892  	/* BPF_ALU | BPF_DIV | BPF_K */
5893  	{
5894  		"ALU_DIV_K: 6 / 2 = 3",
5895  		.u.insns_int = {
5896  			BPF_LD_IMM64(R0, 6),
5897  			BPF_ALU32_IMM(BPF_DIV, R0, 2),
5898  			BPF_EXIT_INSN(),
5899  		},
5900  		INTERNAL,
5901  		{ },
5902  		{ { 0, 3 } },
5903  	},
5904  	{
5905  		"ALU_DIV_K: 3 / 1 = 3",
5906  		.u.insns_int = {
5907  			BPF_LD_IMM64(R0, 3),
5908  			BPF_ALU32_IMM(BPF_DIV, R0, 1),
5909  			BPF_EXIT_INSN(),
5910  		},
5911  		INTERNAL,
5912  		{ },
5913  		{ { 0, 3 } },
5914  	},
5915  	{
5916  		"ALU_DIV_K: 4294967295 / 4294967295 = 1",
5917  		.u.insns_int = {
5918  			BPF_LD_IMM64(R0, 4294967295U),
5919  			BPF_ALU32_IMM(BPF_DIV, R0, 4294967295U),
5920  			BPF_EXIT_INSN(),
5921  		},
5922  		INTERNAL,
5923  		{ },
5924  		{ { 0, 1 } },
5925  	},
5926  	{
5927  		"ALU_DIV_K: 0xffffffffffffffff / (-1) = 0x1",
5928  		.u.insns_int = {
5929  			BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
5930  			BPF_LD_IMM64(R3, 0x1UL),
5931  			BPF_ALU32_IMM(BPF_DIV, R2, 0xffffffff),
5932  			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5933  			BPF_MOV32_IMM(R0, 2),
5934  			BPF_EXIT_INSN(),
5935  			BPF_MOV32_IMM(R0, 1),
5936  			BPF_EXIT_INSN(),
5937  		},
5938  		INTERNAL,
5939  		{ },
5940  		{ { 0, 0x1 } },
5941  	},
5942  	{
5943  		"ALU64_DIV_K: 6 / 2 = 3",
5944  		.u.insns_int = {
5945  			BPF_LD_IMM64(R0, 6),
5946  			BPF_ALU64_IMM(BPF_DIV, R0, 2),
5947  			BPF_EXIT_INSN(),
5948  		},
5949  		INTERNAL,
5950  		{ },
5951  		{ { 0, 3 } },
5952  	},
5953  	{
5954  		"ALU64_DIV_K: 3 / 1 = 3",
5955  		.u.insns_int = {
5956  			BPF_LD_IMM64(R0, 3),
5957  			BPF_ALU64_IMM(BPF_DIV, R0, 1),
5958  			BPF_EXIT_INSN(),
5959  		},
5960  		INTERNAL,
5961  		{ },
5962  		{ { 0, 3 } },
5963  	},
5964  	{
5965  		"ALU64_DIV_K: 2147483647 / 2147483647 = 1",
5966  		.u.insns_int = {
5967  			BPF_LD_IMM64(R0, 2147483647),
5968  			BPF_ALU64_IMM(BPF_DIV, R0, 2147483647),
5969  			BPF_EXIT_INSN(),
5970  		},
5971  		INTERNAL,
5972  		{ },
5973  		{ { 0, 1 } },
5974  	},
5975  	{
5976  		"ALU64_DIV_K: 0xffffffffffffffff / (-1) = 0x0000000000000001",
5977  		.u.insns_int = {
5978  			BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
5979  			BPF_LD_IMM64(R3, 0x0000000000000001LL),
5980  			BPF_ALU64_IMM(BPF_DIV, R2, 0xffffffff),
5981  			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5982  			BPF_MOV32_IMM(R0, 2),
5983  			BPF_EXIT_INSN(),
5984  			BPF_MOV32_IMM(R0, 1),
5985  			BPF_EXIT_INSN(),
5986  		},
5987  		INTERNAL,
5988  		{ },
5989  		{ { 0, 0x1 } },
5990  	},
5991  	/* BPF_ALU | BPF_MOD | BPF_X */
5992  	{
5993  		"ALU_MOD_X: 3 % 2 = 1",
5994  		.u.insns_int = {
5995  			BPF_LD_IMM64(R0, 3),
5996  			BPF_ALU32_IMM(BPF_MOV, R1, 2),
5997  			BPF_ALU32_REG(BPF_MOD, R0, R1),
5998  			BPF_EXIT_INSN(),
5999  		},
6000  		INTERNAL,
6001  		{ },
6002  		{ { 0, 1 } },
6003  	},
6004  	{
6005  		"ALU_MOD_X: 4294967295 % 4294967293 = 2",
6006  		.u.insns_int = {
6007  			BPF_LD_IMM64(R0, 4294967295U),
6008  			BPF_ALU32_IMM(BPF_MOV, R1, 4294967293U),
6009  			BPF_ALU32_REG(BPF_MOD, R0, R1),
6010  			BPF_EXIT_INSN(),
6011  		},
6012  		INTERNAL,
6013  		{ },
6014  		{ { 0, 2 } },
6015  	},
6016  	{
6017  		"ALU64_MOD_X: 3 % 2 = 1",
6018  		.u.insns_int = {
6019  			BPF_LD_IMM64(R0, 3),
6020  			BPF_ALU32_IMM(BPF_MOV, R1, 2),
6021  			BPF_ALU64_REG(BPF_MOD, R0, R1),
6022  			BPF_EXIT_INSN(),
6023  		},
6024  		INTERNAL,
6025  		{ },
6026  		{ { 0, 1 } },
6027  	},
6028  	{
6029  		"ALU64_MOD_X: 2147483647 % 2147483645 = 2",
6030  		.u.insns_int = {
6031  			BPF_LD_IMM64(R0, 2147483647),
6032  			BPF_ALU32_IMM(BPF_MOV, R1, 2147483645),
6033  			BPF_ALU64_REG(BPF_MOD, R0, R1),
6034  			BPF_EXIT_INSN(),
6035  		},
6036  		INTERNAL,
6037  		{ },
6038  		{ { 0, 2 } },
6039  	},
6040  	/* BPF_ALU | BPF_MOD | BPF_K */
6041  	{
6042  		"ALU_MOD_K: 3 % 2 = 1",
6043  		.u.insns_int = {
6044  			BPF_LD_IMM64(R0, 3),
6045  			BPF_ALU32_IMM(BPF_MOD, R0, 2),
6046  			BPF_EXIT_INSN(),
6047  		},
6048  		INTERNAL,
6049  		{ },
6050  		{ { 0, 1 } },
6051  	},
6052  	{
6053  		"ALU_MOD_K: 3 % 1 = 0",
6054  		.u.insns_int = {
6055  			BPF_LD_IMM64(R0, 3),
6056  			BPF_ALU32_IMM(BPF_MOD, R0, 1),
6057  			BPF_EXIT_INSN(),
6058  		},
6059  		INTERNAL,
6060  		{ },
6061  		{ { 0, 0 } },
6062  	},
6063  	{
6064  		"ALU_MOD_K: 4294967295 % 4294967293 = 2",
6065  		.u.insns_int = {
6066  			BPF_LD_IMM64(R0, 4294967295U),
6067  			BPF_ALU32_IMM(BPF_MOD, R0, 4294967293U),
6068  			BPF_EXIT_INSN(),
6069  		},
6070  		INTERNAL,
6071  		{ },
6072  		{ { 0, 2 } },
6073  	},
6074  	{
6075  		"ALU64_MOD_K: 3 % 2 = 1",
6076  		.u.insns_int = {
6077  			BPF_LD_IMM64(R0, 3),
6078  			BPF_ALU64_IMM(BPF_MOD, R0, 2),
6079  			BPF_EXIT_INSN(),
6080  		},
6081  		INTERNAL,
6082  		{ },
6083  		{ { 0, 1 } },
6084  	},
6085  	{
6086  		"ALU64_MOD_K: 3 % 1 = 0",
6087  		.u.insns_int = {
6088  			BPF_LD_IMM64(R0, 3),
6089  			BPF_ALU64_IMM(BPF_MOD, R0, 1),
6090  			BPF_EXIT_INSN(),
6091  		},
6092  		INTERNAL,
6093  		{ },
6094  		{ { 0, 0 } },
6095  	},
6096  	{
6097  		"ALU64_MOD_K: 2147483647 % 2147483645 = 2",
6098  		.u.insns_int = {
6099  			BPF_LD_IMM64(R0, 2147483647),
6100  			BPF_ALU64_IMM(BPF_MOD, R0, 2147483645),
6101  			BPF_EXIT_INSN(),
6102  		},
6103  		INTERNAL,
6104  		{ },
6105  		{ { 0, 2 } },
6106  	},
6107  	/* BPF_ALU | BPF_AND | BPF_X */
6108  	{
6109  		"ALU_AND_X: 3 & 2 = 2",
6110  		.u.insns_int = {
6111  			BPF_LD_IMM64(R0, 3),
6112  			BPF_ALU32_IMM(BPF_MOV, R1, 2),
6113  			BPF_ALU32_REG(BPF_AND, R0, R1),
6114  			BPF_EXIT_INSN(),
6115  		},
6116  		INTERNAL,
6117  		{ },
6118  		{ { 0, 2 } },
6119  	},
6120  	{
6121  		"ALU_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
6122  		.u.insns_int = {
6123  			BPF_LD_IMM64(R0, 0xffffffff),
6124  			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6125  			BPF_ALU32_REG(BPF_AND, R0, R1),
6126  			BPF_EXIT_INSN(),
6127  		},
6128  		INTERNAL,
6129  		{ },
6130  		{ { 0, 0xffffffff } },
6131  	},
6132  	{
6133  		"ALU64_AND_X: 3 & 2 = 2",
6134  		.u.insns_int = {
6135  			BPF_LD_IMM64(R0, 3),
6136  			BPF_ALU32_IMM(BPF_MOV, R1, 2),
6137  			BPF_ALU64_REG(BPF_AND, R0, R1),
6138  			BPF_EXIT_INSN(),
6139  		},
6140  		INTERNAL,
6141  		{ },
6142  		{ { 0, 2 } },
6143  	},
6144  	{
6145  		"ALU64_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
6146  		.u.insns_int = {
6147  			BPF_LD_IMM64(R0, 0xffffffff),
6148  			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6149  			BPF_ALU64_REG(BPF_AND, R0, R1),
6150  			BPF_EXIT_INSN(),
6151  		},
6152  		INTERNAL,
6153  		{ },
6154  		{ { 0, 0xffffffff } },
6155  	},
6156  	/* BPF_ALU | BPF_AND | BPF_K */
6157  	{
6158  		"ALU_AND_K: 3 & 2 = 2",
6159  		.u.insns_int = {
6160  			BPF_LD_IMM64(R0, 3),
6161  			BPF_ALU32_IMM(BPF_AND, R0, 2),
6162  			BPF_EXIT_INSN(),
6163  		},
6164  		INTERNAL,
6165  		{ },
6166  		{ { 0, 2 } },
6167  	},
6168  	{
6169  		"ALU_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
6170  		.u.insns_int = {
6171  			BPF_LD_IMM64(R0, 0xffffffff),
6172  			BPF_ALU32_IMM(BPF_AND, R0, 0xffffffff),
6173  			BPF_EXIT_INSN(),
6174  		},
6175  		INTERNAL,
6176  		{ },
6177  		{ { 0, 0xffffffff } },
6178  	},
6179  	{
6180  		"ALU_AND_K: Small immediate",
6181  		.u.insns_int = {
6182  			BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
6183  			BPF_ALU32_IMM(BPF_AND, R0, 15),
6184  			BPF_EXIT_INSN(),
6185  		},
6186  		INTERNAL,
6187  		{ },
6188  		{ { 0, 4 } }
6189  	},
6190  	{
6191  		"ALU_AND_K: Large immediate",
6192  		.u.insns_int = {
6193  			BPF_ALU32_IMM(BPF_MOV, R0, 0xf1f2f3f4),
6194  			BPF_ALU32_IMM(BPF_AND, R0, 0xafbfcfdf),
6195  			BPF_EXIT_INSN(),
6196  		},
6197  		INTERNAL,
6198  		{ },
6199  		{ { 0, 0xa1b2c3d4 } }
6200  	},
6201  	{
6202  		"ALU_AND_K: Zero extension",
6203  		.u.insns_int = {
6204  			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6205  			BPF_LD_IMM64(R1, 0x0000000080a0c0e0LL),
6206  			BPF_ALU32_IMM(BPF_AND, R0, 0xf0f0f0f0),
6207  			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6208  			BPF_MOV32_IMM(R0, 2),
6209  			BPF_EXIT_INSN(),
6210  			BPF_MOV32_IMM(R0, 1),
6211  			BPF_EXIT_INSN(),
6212  		},
6213  		INTERNAL,
6214  		{ },
6215  		{ { 0, 1 } }
6216  	},
6217  	{
6218  		"ALU64_AND_K: 3 & 2 = 2",
6219  		.u.insns_int = {
6220  			BPF_LD_IMM64(R0, 3),
6221  			BPF_ALU64_IMM(BPF_AND, R0, 2),
6222  			BPF_EXIT_INSN(),
6223  		},
6224  		INTERNAL,
6225  		{ },
6226  		{ { 0, 2 } },
6227  	},
6228  	{
6229  		"ALU64_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
6230  		.u.insns_int = {
6231  			BPF_LD_IMM64(R0, 0xffffffff),
6232  			BPF_ALU64_IMM(BPF_AND, R0, 0xffffffff),
6233  			BPF_EXIT_INSN(),
6234  		},
6235  		INTERNAL,
6236  		{ },
6237  		{ { 0, 0xffffffff } },
6238  	},
6239  	{
6240  		"ALU64_AND_K: 0x0000ffffffff0000 & 0x0 = 0x0000000000000000",
6241  		.u.insns_int = {
6242  			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6243  			BPF_LD_IMM64(R3, 0x0000000000000000LL),
6244  			BPF_ALU64_IMM(BPF_AND, R2, 0x0),
6245  			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6246  			BPF_MOV32_IMM(R0, 2),
6247  			BPF_EXIT_INSN(),
6248  			BPF_MOV32_IMM(R0, 1),
6249  			BPF_EXIT_INSN(),
6250  		},
6251  		INTERNAL,
6252  		{ },
6253  		{ { 0, 0x1 } },
6254  	},
6255  	{
6256  		"ALU64_AND_K: 0x0000ffffffff0000 & -1 = 0x0000ffffffff0000",
6257  		.u.insns_int = {
6258  			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6259  			BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
6260  			BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
6261  			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6262  			BPF_MOV32_IMM(R0, 2),
6263  			BPF_EXIT_INSN(),
6264  			BPF_MOV32_IMM(R0, 1),
6265  			BPF_EXIT_INSN(),
6266  		},
6267  		INTERNAL,
6268  		{ },
6269  		{ { 0, 0x1 } },
6270  	},
6271  	{
6272  		"ALU64_AND_K: 0xffffffffffffffff & -1 = 0xffffffffffffffff",
6273  		.u.insns_int = {
6274  			BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
6275  			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
6276  			BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
6277  			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6278  			BPF_MOV32_IMM(R0, 2),
6279  			BPF_EXIT_INSN(),
6280  			BPF_MOV32_IMM(R0, 1),
6281  			BPF_EXIT_INSN(),
6282  		},
6283  		INTERNAL,
6284  		{ },
6285  		{ { 0, 0x1 } },
6286  	},
6287  	{
6288  		"ALU64_AND_K: Sign extension 1",
6289  		.u.insns_int = {
6290  			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6291  			BPF_LD_IMM64(R1, 0x00000000090b0d0fLL),
6292  			BPF_ALU64_IMM(BPF_AND, R0, 0x0f0f0f0f),
6293  			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6294  			BPF_MOV32_IMM(R0, 2),
6295  			BPF_EXIT_INSN(),
6296  			BPF_MOV32_IMM(R0, 1),
6297  			BPF_EXIT_INSN(),
6298  		},
6299  		INTERNAL,
6300  		{ },
6301  		{ { 0, 1 } }
6302  	},
6303  	{
6304  		"ALU64_AND_K: Sign extension 2",
6305  		.u.insns_int = {
6306  			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6307  			BPF_LD_IMM64(R1, 0x0123456780a0c0e0LL),
6308  			BPF_ALU64_IMM(BPF_AND, R0, 0xf0f0f0f0),
6309  			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6310  			BPF_MOV32_IMM(R0, 2),
6311  			BPF_EXIT_INSN(),
6312  			BPF_MOV32_IMM(R0, 1),
6313  			BPF_EXIT_INSN(),
6314  		},
6315  		INTERNAL,
6316  		{ },
6317  		{ { 0, 1 } }
6318  	},
6319  	/* BPF_ALU | BPF_OR | BPF_X */
6320  	{
6321  		"ALU_OR_X: 1 | 2 = 3",
6322  		.u.insns_int = {
6323  			BPF_LD_IMM64(R0, 1),
6324  			BPF_ALU32_IMM(BPF_MOV, R1, 2),
6325  			BPF_ALU32_REG(BPF_OR, R0, R1),
6326  			BPF_EXIT_INSN(),
6327  		},
6328  		INTERNAL,
6329  		{ },
6330  		{ { 0, 3 } },
6331  	},
6332  	{
6333  		"ALU_OR_X: 0x0 | 0xffffffff = 0xffffffff",
6334  		.u.insns_int = {
6335  			BPF_LD_IMM64(R0, 0),
6336  			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6337  			BPF_ALU32_REG(BPF_OR, R0, R1),
6338  			BPF_EXIT_INSN(),
6339  		},
6340  		INTERNAL,
6341  		{ },
6342  		{ { 0, 0xffffffff } },
6343  	},
6344  	{
6345  		"ALU64_OR_X: 1 | 2 = 3",
6346  		.u.insns_int = {
6347  			BPF_LD_IMM64(R0, 1),
6348  			BPF_ALU32_IMM(BPF_MOV, R1, 2),
6349  			BPF_ALU64_REG(BPF_OR, R0, R1),
6350  			BPF_EXIT_INSN(),
6351  		},
6352  		INTERNAL,
6353  		{ },
6354  		{ { 0, 3 } },
6355  	},
6356  	{
6357  		"ALU64_OR_X: 0 | 0xffffffff = 0xffffffff",
6358  		.u.insns_int = {
6359  			BPF_LD_IMM64(R0, 0),
6360  			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6361  			BPF_ALU64_REG(BPF_OR, R0, R1),
6362  			BPF_EXIT_INSN(),
6363  		},
6364  		INTERNAL,
6365  		{ },
6366  		{ { 0, 0xffffffff } },
6367  	},
6368  	/* BPF_ALU | BPF_OR | BPF_K */
6369  	{
6370  		"ALU_OR_K: 1 | 2 = 3",
6371  		.u.insns_int = {
6372  			BPF_LD_IMM64(R0, 1),
6373  			BPF_ALU32_IMM(BPF_OR, R0, 2),
6374  			BPF_EXIT_INSN(),
6375  		},
6376  		INTERNAL,
6377  		{ },
6378  		{ { 0, 3 } },
6379  	},
6380  	{
6381  		"ALU_OR_K: 0 & 0xffffffff = 0xffffffff",
6382  		.u.insns_int = {
6383  			BPF_LD_IMM64(R0, 0),
6384  			BPF_ALU32_IMM(BPF_OR, R0, 0xffffffff),
6385  			BPF_EXIT_INSN(),
6386  		},
6387  		INTERNAL,
6388  		{ },
6389  		{ { 0, 0xffffffff } },
6390  	},
6391  	{
6392  		"ALU_OR_K: Small immediate",
6393  		.u.insns_int = {
6394  			BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
6395  			BPF_ALU32_IMM(BPF_OR, R0, 1),
6396  			BPF_EXIT_INSN(),
6397  		},
6398  		INTERNAL,
6399  		{ },
6400  		{ { 0, 0x01020305 } }
6401  	},
6402  	{
6403  		"ALU_OR_K: Large immediate",
6404  		.u.insns_int = {
6405  			BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
6406  			BPF_ALU32_IMM(BPF_OR, R0, 0xa0b0c0d0),
6407  			BPF_EXIT_INSN(),
6408  		},
6409  		INTERNAL,
6410  		{ },
6411  		{ { 0, 0xa1b2c3d4 } }
6412  	},
6413  	{
6414  		"ALU_OR_K: Zero extension",
6415  		.u.insns_int = {
6416  			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6417  			BPF_LD_IMM64(R1, 0x00000000f9fbfdffLL),
6418  			BPF_ALU32_IMM(BPF_OR, R0, 0xf0f0f0f0),
6419  			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6420  			BPF_MOV32_IMM(R0, 2),
6421  			BPF_EXIT_INSN(),
6422  			BPF_MOV32_IMM(R0, 1),
6423  			BPF_EXIT_INSN(),
6424  		},
6425  		INTERNAL,
6426  		{ },
6427  		{ { 0, 1 } }
6428  	},
6429  	{
6430  		"ALU64_OR_K: 1 | 2 = 3",
6431  		.u.insns_int = {
6432  			BPF_LD_IMM64(R0, 1),
6433  			BPF_ALU64_IMM(BPF_OR, R0, 2),
6434  			BPF_EXIT_INSN(),
6435  		},
6436  		INTERNAL,
6437  		{ },
6438  		{ { 0, 3 } },
6439  	},
6440  	{
6441  		"ALU64_OR_K: 0 & 0xffffffff = 0xffffffff",
6442  		.u.insns_int = {
6443  			BPF_LD_IMM64(R0, 0),
6444  			BPF_ALU64_IMM(BPF_OR, R0, 0xffffffff),
6445  			BPF_EXIT_INSN(),
6446  		},
6447  		INTERNAL,
6448  		{ },
6449  		{ { 0, 0xffffffff } },
6450  	},
6451  	{
6452  		"ALU64_OR_K: 0x0000ffffffff0000 | 0x0 = 0x0000ffffffff0000",
6453  		.u.insns_int = {
6454  			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6455  			BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
6456  			BPF_ALU64_IMM(BPF_OR, R2, 0x0),
6457  			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6458  			BPF_MOV32_IMM(R0, 2),
6459  			BPF_EXIT_INSN(),
6460  			BPF_MOV32_IMM(R0, 1),
6461  			BPF_EXIT_INSN(),
6462  		},
6463  		INTERNAL,
6464  		{ },
6465  		{ { 0, 0x1 } },
6466  	},
6467  	{
6468  		"ALU64_OR_K: 0x0000ffffffff0000 | -1 = 0xffffffffffffffff",
6469  		.u.insns_int = {
6470  			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6471  			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
6472  			BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
6473  			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6474  			BPF_MOV32_IMM(R0, 2),
6475  			BPF_EXIT_INSN(),
6476  			BPF_MOV32_IMM(R0, 1),
6477  			BPF_EXIT_INSN(),
6478  		},
6479  		INTERNAL,
6480  		{ },
6481  		{ { 0, 0x1 } },
6482  	},
6483  	{
6484  		"ALU64_OR_K: 0x000000000000000 | -1 = 0xffffffffffffffff",
6485  		.u.insns_int = {
6486  			BPF_LD_IMM64(R2, 0x0000000000000000LL),
6487  			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
6488  			BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
6489  			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6490  			BPF_MOV32_IMM(R0, 2),
6491  			BPF_EXIT_INSN(),
6492  			BPF_MOV32_IMM(R0, 1),
6493  			BPF_EXIT_INSN(),
6494  		},
6495  		INTERNAL,
6496  		{ },
6497  		{ { 0, 0x1 } },
6498  	},
6499  	{
6500  		"ALU64_OR_K: Sign extension 1",
6501  		.u.insns_int = {
6502  			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6503  			BPF_LD_IMM64(R1, 0x012345678fafcfefLL),
6504  			BPF_ALU64_IMM(BPF_OR, R0, 0x0f0f0f0f),
6505  			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6506  			BPF_MOV32_IMM(R0, 2),
6507  			BPF_EXIT_INSN(),
6508  			BPF_MOV32_IMM(R0, 1),
6509  			BPF_EXIT_INSN(),
6510  		},
6511  		INTERNAL,
6512  		{ },
6513  		{ { 0, 1 } }
6514  	},
6515  	{
6516  		"ALU64_OR_K: Sign extension 2",
6517  		.u.insns_int = {
6518  			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6519  			BPF_LD_IMM64(R1, 0xfffffffff9fbfdffLL),
6520  			BPF_ALU64_IMM(BPF_OR, R0, 0xf0f0f0f0),
6521  			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6522  			BPF_MOV32_IMM(R0, 2),
6523  			BPF_EXIT_INSN(),
6524  			BPF_MOV32_IMM(R0, 1),
6525  			BPF_EXIT_INSN(),
6526  		},
6527  		INTERNAL,
6528  		{ },
6529  		{ { 0, 1 } }
6530  	},
6531  	/* BPF_ALU | BPF_XOR | BPF_X */
6532  	{
6533  		"ALU_XOR_X: 5 ^ 6 = 3",
6534  		.u.insns_int = {
6535  			BPF_LD_IMM64(R0, 5),
6536  			BPF_ALU32_IMM(BPF_MOV, R1, 6),
6537  			BPF_ALU32_REG(BPF_XOR, R0, R1),
6538  			BPF_EXIT_INSN(),
6539  		},
6540  		INTERNAL,
6541  		{ },
6542  		{ { 0, 3 } },
6543  	},
6544  	{
6545  		"ALU_XOR_X: 0x1 ^ 0xffffffff = 0xfffffffe",
6546  		.u.insns_int = {
6547  			BPF_LD_IMM64(R0, 1),
6548  			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6549  			BPF_ALU32_REG(BPF_XOR, R0, R1),
6550  			BPF_EXIT_INSN(),
6551  		},
6552  		INTERNAL,
6553  		{ },
6554  		{ { 0, 0xfffffffe } },
6555  	},
6556  	{
6557  		"ALU64_XOR_X: 5 ^ 6 = 3",
6558  		.u.insns_int = {
6559  			BPF_LD_IMM64(R0, 5),
6560  			BPF_ALU32_IMM(BPF_MOV, R1, 6),
6561  			BPF_ALU64_REG(BPF_XOR, R0, R1),
6562  			BPF_EXIT_INSN(),
6563  		},
6564  		INTERNAL,
6565  		{ },
6566  		{ { 0, 3 } },
6567  	},
6568  	{
6569  		"ALU64_XOR_X: 1 ^ 0xffffffff = 0xfffffffe",
6570  		.u.insns_int = {
6571  			BPF_LD_IMM64(R0, 1),
6572  			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6573  			BPF_ALU64_REG(BPF_XOR, R0, R1),
6574  			BPF_EXIT_INSN(),
6575  		},
6576  		INTERNAL,
6577  		{ },
6578  		{ { 0, 0xfffffffe } },
6579  	},
6580  	/* BPF_ALU | BPF_XOR | BPF_K */
6581  	{
6582  		"ALU_XOR_K: 5 ^ 6 = 3",
6583  		.u.insns_int = {
6584  			BPF_LD_IMM64(R0, 5),
6585  			BPF_ALU32_IMM(BPF_XOR, R0, 6),
6586  			BPF_EXIT_INSN(),
6587  		},
6588  		INTERNAL,
6589  		{ },
6590  		{ { 0, 3 } },
6591  	},
6592  	{
6593  		"ALU_XOR_K: 1 ^ 0xffffffff = 0xfffffffe",
6594  		.u.insns_int = {
6595  			BPF_LD_IMM64(R0, 1),
6596  			BPF_ALU32_IMM(BPF_XOR, R0, 0xffffffff),
6597  			BPF_EXIT_INSN(),
6598  		},
6599  		INTERNAL,
6600  		{ },
6601  		{ { 0, 0xfffffffe } },
6602  	},
6603  	{
6604  		"ALU_XOR_K: Small immediate",
6605  		.u.insns_int = {
6606  			BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
6607  			BPF_ALU32_IMM(BPF_XOR, R0, 15),
6608  			BPF_EXIT_INSN(),
6609  		},
6610  		INTERNAL,
6611  		{ },
6612  		{ { 0, 0x0102030b } }
6613  	},
6614  	{
6615  		"ALU_XOR_K: Large immediate",
6616  		.u.insns_int = {
6617  			BPF_ALU32_IMM(BPF_MOV, R0, 0xf1f2f3f4),
6618  			BPF_ALU32_IMM(BPF_XOR, R0, 0xafbfcfdf),
6619  			BPF_EXIT_INSN(),
6620  		},
6621  		INTERNAL,
6622  		{ },
6623  		{ { 0, 0x5e4d3c2b } }
6624  	},
6625  	{
6626  		"ALU_XOR_K: Zero extension",
6627  		.u.insns_int = {
6628  			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6629  			BPF_LD_IMM64(R1, 0x00000000795b3d1fLL),
6630  			BPF_ALU32_IMM(BPF_XOR, R0, 0xf0f0f0f0),
6631  			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6632  			BPF_MOV32_IMM(R0, 2),
6633  			BPF_EXIT_INSN(),
6634  			BPF_MOV32_IMM(R0, 1),
6635  			BPF_EXIT_INSN(),
6636  		},
6637  		INTERNAL,
6638  		{ },
6639  		{ { 0, 1 } }
6640  	},
6641  	{
6642  		"ALU64_XOR_K: 5 ^ 6 = 3",
6643  		.u.insns_int = {
6644  			BPF_LD_IMM64(R0, 5),
6645  			BPF_ALU64_IMM(BPF_XOR, R0, 6),
6646  			BPF_EXIT_INSN(),
6647  		},
6648  		INTERNAL,
6649  		{ },
6650  		{ { 0, 3 } },
6651  	},
6652  	{
6653  		"ALU64_XOR_K: 1 ^ 0xffffffff = 0xfffffffe",
6654  		.u.insns_int = {
6655  			BPF_LD_IMM64(R0, 1),
6656  			BPF_ALU64_IMM(BPF_XOR, R0, 0xffffffff),
6657  			BPF_EXIT_INSN(),
6658  		},
6659  		INTERNAL,
6660  		{ },
6661  		{ { 0, 0xfffffffe } },
6662  	},
6663  	{
6664  		"ALU64_XOR_K: 0x0000ffffffff0000 ^ 0x0 = 0x0000ffffffff0000",
6665  		.u.insns_int = {
6666  			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6667  			BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
6668  			BPF_ALU64_IMM(BPF_XOR, R2, 0x0),
6669  			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6670  			BPF_MOV32_IMM(R0, 2),
6671  			BPF_EXIT_INSN(),
6672  			BPF_MOV32_IMM(R0, 1),
6673  			BPF_EXIT_INSN(),
6674  		},
6675  		INTERNAL,
6676  		{ },
6677  		{ { 0, 0x1 } },
6678  	},
6679  	{
6680  		"ALU64_XOR_K: 0x0000ffffffff0000 ^ -1 = 0xffff00000000ffff",
6681  		.u.insns_int = {
6682  			BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6683  			BPF_LD_IMM64(R3, 0xffff00000000ffffLL),
6684  			BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
6685  			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6686  			BPF_MOV32_IMM(R0, 2),
6687  			BPF_EXIT_INSN(),
6688  			BPF_MOV32_IMM(R0, 1),
6689  			BPF_EXIT_INSN(),
6690  		},
6691  		INTERNAL,
6692  		{ },
6693  		{ { 0, 0x1 } },
6694  	},
6695  	{
6696  		"ALU64_XOR_K: 0x000000000000000 ^ -1 = 0xffffffffffffffff",
6697  		.u.insns_int = {
6698  			BPF_LD_IMM64(R2, 0x0000000000000000LL),
6699  			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
6700  			BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
6701  			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6702  			BPF_MOV32_IMM(R0, 2),
6703  			BPF_EXIT_INSN(),
6704  			BPF_MOV32_IMM(R0, 1),
6705  			BPF_EXIT_INSN(),
6706  		},
6707  		INTERNAL,
6708  		{ },
6709  		{ { 0, 0x1 } },
6710  	},
6711  	{
6712  		"ALU64_XOR_K: Sign extension 1",
6713  		.u.insns_int = {
6714  			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6715  			BPF_LD_IMM64(R1, 0x0123456786a4c2e0LL),
6716  			BPF_ALU64_IMM(BPF_XOR, R0, 0x0f0f0f0f),
6717  			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6718  			BPF_MOV32_IMM(R0, 2),
6719  			BPF_EXIT_INSN(),
6720  			BPF_MOV32_IMM(R0, 1),
6721  			BPF_EXIT_INSN(),
6722  		},
6723  		INTERNAL,
6724  		{ },
6725  		{ { 0, 1 } }
6726  	},
6727  	{
6728  		"ALU64_XOR_K: Sign extension 2",
6729  		.u.insns_int = {
6730  			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6731  			BPF_LD_IMM64(R1, 0xfedcba98795b3d1fLL),
6732  			BPF_ALU64_IMM(BPF_XOR, R0, 0xf0f0f0f0),
6733  			BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6734  			BPF_MOV32_IMM(R0, 2),
6735  			BPF_EXIT_INSN(),
6736  			BPF_MOV32_IMM(R0, 1),
6737  			BPF_EXIT_INSN(),
6738  		},
6739  		INTERNAL,
6740  		{ },
6741  		{ { 0, 1 } }
6742  	},
6743  	/* BPF_ALU | BPF_LSH | BPF_X */
6744  	{
6745  		"ALU_LSH_X: 1 << 1 = 2",
6746  		.u.insns_int = {
6747  			BPF_LD_IMM64(R0, 1),
6748  			BPF_ALU32_IMM(BPF_MOV, R1, 1),
6749  			BPF_ALU32_REG(BPF_LSH, R0, R1),
6750  			BPF_EXIT_INSN(),
6751  		},
6752  		INTERNAL,
6753  		{ },
6754  		{ { 0, 2 } },
6755  	},
6756  	{
6757  		"ALU_LSH_X: 1 << 31 = 0x80000000",
6758  		.u.insns_int = {
6759  			BPF_LD_IMM64(R0, 1),
6760  			BPF_ALU32_IMM(BPF_MOV, R1, 31),
6761  			BPF_ALU32_REG(BPF_LSH, R0, R1),
6762  			BPF_EXIT_INSN(),
6763  		},
6764  		INTERNAL,
6765  		{ },
6766  		{ { 0, 0x80000000 } },
6767  	},
6768  	{
6769  		"ALU_LSH_X: 0x12345678 << 12 = 0x45678000",
6770  		.u.insns_int = {
6771  			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
6772  			BPF_ALU32_IMM(BPF_MOV, R1, 12),
6773  			BPF_ALU32_REG(BPF_LSH, R0, R1),
6774  			BPF_EXIT_INSN(),
6775  		},
6776  		INTERNAL,
6777  		{ },
6778  		{ { 0, 0x45678000 } }
6779  	},
6780  	{
6781  		"ALU64_LSH_X: 1 << 1 = 2",
6782  		.u.insns_int = {
6783  			BPF_LD_IMM64(R0, 1),
6784  			BPF_ALU32_IMM(BPF_MOV, R1, 1),
6785  			BPF_ALU64_REG(BPF_LSH, R0, R1),
6786  			BPF_EXIT_INSN(),
6787  		},
6788  		INTERNAL,
6789  		{ },
6790  		{ { 0, 2 } },
6791  	},
6792  	{
6793  		"ALU64_LSH_X: 1 << 31 = 0x80000000",
6794  		.u.insns_int = {
6795  			BPF_LD_IMM64(R0, 1),
6796  			BPF_ALU32_IMM(BPF_MOV, R1, 31),
6797  			BPF_ALU64_REG(BPF_LSH, R0, R1),
6798  			BPF_EXIT_INSN(),
6799  		},
6800  		INTERNAL,
6801  		{ },
6802  		{ { 0, 0x80000000 } },
6803  	},
6804  	{
6805  		"ALU64_LSH_X: Shift < 32, low word",
6806  		.u.insns_int = {
6807  			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6808  			BPF_ALU32_IMM(BPF_MOV, R1, 12),
6809  			BPF_ALU64_REG(BPF_LSH, R0, R1),
6810  			BPF_EXIT_INSN(),
6811  		},
6812  		INTERNAL,
6813  		{ },
6814  		{ { 0, 0xbcdef000 } }
6815  	},
6816  	{
6817  		"ALU64_LSH_X: Shift < 32, high word",
6818  		.u.insns_int = {
6819  			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6820  			BPF_ALU32_IMM(BPF_MOV, R1, 12),
6821  			BPF_ALU64_REG(BPF_LSH, R0, R1),
6822  			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6823  			BPF_EXIT_INSN(),
6824  		},
6825  		INTERNAL,
6826  		{ },
6827  		{ { 0, 0x3456789a } }
6828  	},
6829  	{
6830  		"ALU64_LSH_X: Shift > 32, low word",
6831  		.u.insns_int = {
6832  			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6833  			BPF_ALU32_IMM(BPF_MOV, R1, 36),
6834  			BPF_ALU64_REG(BPF_LSH, R0, R1),
6835  			BPF_EXIT_INSN(),
6836  		},
6837  		INTERNAL,
6838  		{ },
6839  		{ { 0, 0 } }
6840  	},
6841  	{
6842  		"ALU64_LSH_X: Shift > 32, high word",
6843  		.u.insns_int = {
6844  			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6845  			BPF_ALU32_IMM(BPF_MOV, R1, 36),
6846  			BPF_ALU64_REG(BPF_LSH, R0, R1),
6847  			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6848  			BPF_EXIT_INSN(),
6849  		},
6850  		INTERNAL,
6851  		{ },
6852  		{ { 0, 0x9abcdef0 } }
6853  	},
6854  	{
6855  		"ALU64_LSH_X: Shift == 32, low word",
6856  		.u.insns_int = {
6857  			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6858  			BPF_ALU32_IMM(BPF_MOV, R1, 32),
6859  			BPF_ALU64_REG(BPF_LSH, R0, R1),
6860  			BPF_EXIT_INSN(),
6861  		},
6862  		INTERNAL,
6863  		{ },
6864  		{ { 0, 0 } }
6865  	},
6866  	{
6867  		"ALU64_LSH_X: Shift == 32, high word",
6868  		.u.insns_int = {
6869  			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6870  			BPF_ALU32_IMM(BPF_MOV, R1, 32),
6871  			BPF_ALU64_REG(BPF_LSH, R0, R1),
6872  			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6873  			BPF_EXIT_INSN(),
6874  		},
6875  		INTERNAL,
6876  		{ },
6877  		{ { 0, 0x89abcdef } }
6878  	},
6879  	{
6880  		"ALU64_LSH_X: Zero shift, low word",
6881  		.u.insns_int = {
6882  			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6883  			BPF_ALU32_IMM(BPF_MOV, R1, 0),
6884  			BPF_ALU64_REG(BPF_LSH, R0, R1),
6885  			BPF_EXIT_INSN(),
6886  		},
6887  		INTERNAL,
6888  		{ },
6889  		{ { 0, 0x89abcdef } }
6890  	},
6891  	{
6892  		"ALU64_LSH_X: Zero shift, high word",
6893  		.u.insns_int = {
6894  			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6895  			BPF_ALU32_IMM(BPF_MOV, R1, 0),
6896  			BPF_ALU64_REG(BPF_LSH, R0, R1),
6897  			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6898  			BPF_EXIT_INSN(),
6899  		},
6900  		INTERNAL,
6901  		{ },
6902  		{ { 0, 0x01234567 } }
6903  	},
6904  	/* BPF_ALU | BPF_LSH | BPF_K */
6905  	{
6906  		"ALU_LSH_K: 1 << 1 = 2",
6907  		.u.insns_int = {
6908  			BPF_LD_IMM64(R0, 1),
6909  			BPF_ALU32_IMM(BPF_LSH, R0, 1),
6910  			BPF_EXIT_INSN(),
6911  		},
6912  		INTERNAL,
6913  		{ },
6914  		{ { 0, 2 } },
6915  	},
6916  	{
6917  		"ALU_LSH_K: 1 << 31 = 0x80000000",
6918  		.u.insns_int = {
6919  			BPF_LD_IMM64(R0, 1),
6920  			BPF_ALU32_IMM(BPF_LSH, R0, 31),
6921  			BPF_EXIT_INSN(),
6922  		},
6923  		INTERNAL,
6924  		{ },
6925  		{ { 0, 0x80000000 } },
6926  	},
6927  	{
6928  		"ALU_LSH_K: 0x12345678 << 12 = 0x45678000",
6929  		.u.insns_int = {
6930  			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
6931  			BPF_ALU32_IMM(BPF_LSH, R0, 12),
6932  			BPF_EXIT_INSN(),
6933  		},
6934  		INTERNAL,
6935  		{ },
6936  		{ { 0, 0x45678000 } }
6937  	},
6938  	{
6939  		"ALU_LSH_K: 0x12345678 << 0 = 0x12345678",
6940  		.u.insns_int = {
6941  			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
6942  			BPF_ALU32_IMM(BPF_LSH, R0, 0),
6943  			BPF_EXIT_INSN(),
6944  		},
6945  		INTERNAL,
6946  		{ },
6947  		{ { 0, 0x12345678 } }
6948  	},
6949  	{
6950  		"ALU64_LSH_K: 1 << 1 = 2",
6951  		.u.insns_int = {
6952  			BPF_LD_IMM64(R0, 1),
6953  			BPF_ALU64_IMM(BPF_LSH, R0, 1),
6954  			BPF_EXIT_INSN(),
6955  		},
6956  		INTERNAL,
6957  		{ },
6958  		{ { 0, 2 } },
6959  	},
6960  	{
6961  		"ALU64_LSH_K: 1 << 31 = 0x80000000",
6962  		.u.insns_int = {
6963  			BPF_LD_IMM64(R0, 1),
6964  			BPF_ALU64_IMM(BPF_LSH, R0, 31),
6965  			BPF_EXIT_INSN(),
6966  		},
6967  		INTERNAL,
6968  		{ },
6969  		{ { 0, 0x80000000 } },
6970  	},
6971  	{
6972  		"ALU64_LSH_K: Shift < 32, low word",
6973  		.u.insns_int = {
6974  			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6975  			BPF_ALU64_IMM(BPF_LSH, R0, 12),
6976  			BPF_EXIT_INSN(),
6977  		},
6978  		INTERNAL,
6979  		{ },
6980  		{ { 0, 0xbcdef000 } }
6981  	},
6982  	{
6983  		"ALU64_LSH_K: Shift < 32, high word",
6984  		.u.insns_int = {
6985  			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6986  			BPF_ALU64_IMM(BPF_LSH, R0, 12),
6987  			BPF_ALU64_IMM(BPF_RSH, R0, 32),
6988  			BPF_EXIT_INSN(),
6989  		},
6990  		INTERNAL,
6991  		{ },
6992  		{ { 0, 0x3456789a } }
6993  	},
6994  	{
6995  		"ALU64_LSH_K: Shift > 32, low word",
6996  		.u.insns_int = {
6997  			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6998  			BPF_ALU64_IMM(BPF_LSH, R0, 36),
6999  			BPF_EXIT_INSN(),
7000  		},
7001  		INTERNAL,
7002  		{ },
7003  		{ { 0, 0 } }
7004  	},
7005  	{
7006  		"ALU64_LSH_K: Shift > 32, high word",
7007  		.u.insns_int = {
7008  			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7009  			BPF_ALU64_IMM(BPF_LSH, R0, 36),
7010  			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7011  			BPF_EXIT_INSN(),
7012  		},
7013  		INTERNAL,
7014  		{ },
7015  		{ { 0, 0x9abcdef0 } }
7016  	},
7017  	{
7018  		"ALU64_LSH_K: Shift == 32, low word",
7019  		.u.insns_int = {
7020  			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7021  			BPF_ALU64_IMM(BPF_LSH, R0, 32),
7022  			BPF_EXIT_INSN(),
7023  		},
7024  		INTERNAL,
7025  		{ },
7026  		{ { 0, 0 } }
7027  	},
7028  	{
7029  		"ALU64_LSH_K: Shift == 32, high word",
7030  		.u.insns_int = {
7031  			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7032  			BPF_ALU64_IMM(BPF_LSH, R0, 32),
7033  			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7034  			BPF_EXIT_INSN(),
7035  		},
7036  		INTERNAL,
7037  		{ },
7038  		{ { 0, 0x89abcdef } }
7039  	},
7040  	{
7041  		"ALU64_LSH_K: Zero shift",
7042  		.u.insns_int = {
7043  			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7044  			BPF_ALU64_IMM(BPF_LSH, R0, 0),
7045  			BPF_EXIT_INSN(),
7046  		},
7047  		INTERNAL,
7048  		{ },
7049  		{ { 0, 0x89abcdef } }
7050  	},
7051  	/* BPF_ALU | BPF_RSH | BPF_X */
7052  	{
7053  		"ALU_RSH_X: 2 >> 1 = 1",
7054  		.u.insns_int = {
7055  			BPF_LD_IMM64(R0, 2),
7056  			BPF_ALU32_IMM(BPF_MOV, R1, 1),
7057  			BPF_ALU32_REG(BPF_RSH, R0, R1),
7058  			BPF_EXIT_INSN(),
7059  		},
7060  		INTERNAL,
7061  		{ },
7062  		{ { 0, 1 } },
7063  	},
7064  	{
7065  		"ALU_RSH_X: 0x80000000 >> 31 = 1",
7066  		.u.insns_int = {
7067  			BPF_LD_IMM64(R0, 0x80000000),
7068  			BPF_ALU32_IMM(BPF_MOV, R1, 31),
7069  			BPF_ALU32_REG(BPF_RSH, R0, R1),
7070  			BPF_EXIT_INSN(),
7071  		},
7072  		INTERNAL,
7073  		{ },
7074  		{ { 0, 1 } },
7075  	},
7076  	{
7077  		"ALU_RSH_X: 0x12345678 >> 20 = 0x123",
7078  		.u.insns_int = {
7079  			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
7080  			BPF_ALU32_IMM(BPF_MOV, R1, 20),
7081  			BPF_ALU32_REG(BPF_RSH, R0, R1),
7082  			BPF_EXIT_INSN(),
7083  		},
7084  		INTERNAL,
7085  		{ },
7086  		{ { 0, 0x123 } }
7087  	},
7088  	{
7089  		"ALU64_RSH_X: 2 >> 1 = 1",
7090  		.u.insns_int = {
7091  			BPF_LD_IMM64(R0, 2),
7092  			BPF_ALU32_IMM(BPF_MOV, R1, 1),
7093  			BPF_ALU64_REG(BPF_RSH, R0, R1),
7094  			BPF_EXIT_INSN(),
7095  		},
7096  		INTERNAL,
7097  		{ },
7098  		{ { 0, 1 } },
7099  	},
7100  	{
7101  		"ALU64_RSH_X: 0x80000000 >> 31 = 1",
7102  		.u.insns_int = {
7103  			BPF_LD_IMM64(R0, 0x80000000),
7104  			BPF_ALU32_IMM(BPF_MOV, R1, 31),
7105  			BPF_ALU64_REG(BPF_RSH, R0, R1),
7106  			BPF_EXIT_INSN(),
7107  		},
7108  		INTERNAL,
7109  		{ },
7110  		{ { 0, 1 } },
7111  	},
7112  	{
7113  		"ALU64_RSH_X: Shift < 32, low word",
7114  		.u.insns_int = {
7115  			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7116  			BPF_ALU32_IMM(BPF_MOV, R1, 12),
7117  			BPF_ALU64_REG(BPF_RSH, R0, R1),
7118  			BPF_EXIT_INSN(),
7119  		},
7120  		INTERNAL,
7121  		{ },
7122  		{ { 0, 0x56789abc } }
7123  	},
7124  	{
7125  		"ALU64_RSH_X: Shift < 32, high word",
7126  		.u.insns_int = {
7127  			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7128  			BPF_ALU32_IMM(BPF_MOV, R1, 12),
7129  			BPF_ALU64_REG(BPF_RSH, R0, R1),
7130  			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7131  			BPF_EXIT_INSN(),
7132  		},
7133  		INTERNAL,
7134  		{ },
7135  		{ { 0, 0x00081234 } }
7136  	},
7137  	{
7138  		"ALU64_RSH_X: Shift > 32, low word",
7139  		.u.insns_int = {
7140  			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7141  			BPF_ALU32_IMM(BPF_MOV, R1, 36),
7142  			BPF_ALU64_REG(BPF_RSH, R0, R1),
7143  			BPF_EXIT_INSN(),
7144  		},
7145  		INTERNAL,
7146  		{ },
7147  		{ { 0, 0x08123456 } }
7148  	},
7149  	{
7150  		"ALU64_RSH_X: Shift > 32, high word",
7151  		.u.insns_int = {
7152  			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7153  			BPF_ALU32_IMM(BPF_MOV, R1, 36),
7154  			BPF_ALU64_REG(BPF_RSH, R0, R1),
7155  			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7156  			BPF_EXIT_INSN(),
7157  		},
7158  		INTERNAL,
7159  		{ },
7160  		{ { 0, 0 } }
7161  	},
7162  	{
7163  		"ALU64_RSH_X: Shift == 32, low word",
7164  		.u.insns_int = {
7165  			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7166  			BPF_ALU32_IMM(BPF_MOV, R1, 32),
7167  			BPF_ALU64_REG(BPF_RSH, R0, R1),
7168  			BPF_EXIT_INSN(),
7169  		},
7170  		INTERNAL,
7171  		{ },
7172  		{ { 0, 0x81234567 } }
7173  	},
7174  	{
7175  		"ALU64_RSH_X: Shift == 32, high word",
7176  		.u.insns_int = {
7177  			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7178  			BPF_ALU32_IMM(BPF_MOV, R1, 32),
7179  			BPF_ALU64_REG(BPF_RSH, R0, R1),
7180  			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7181  			BPF_EXIT_INSN(),
7182  		},
7183  		INTERNAL,
7184  		{ },
7185  		{ { 0, 0 } }
7186  	},
7187  	{
7188  		"ALU64_RSH_X: Zero shift, low word",
7189  		.u.insns_int = {
7190  			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7191  			BPF_ALU32_IMM(BPF_MOV, R1, 0),
7192  			BPF_ALU64_REG(BPF_RSH, R0, R1),
7193  			BPF_EXIT_INSN(),
7194  		},
7195  		INTERNAL,
7196  		{ },
7197  		{ { 0, 0x89abcdef } }
7198  	},
7199  	{
7200  		"ALU64_RSH_X: Zero shift, high word",
7201  		.u.insns_int = {
7202  			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7203  			BPF_ALU32_IMM(BPF_MOV, R1, 0),
7204  			BPF_ALU64_REG(BPF_RSH, R0, R1),
7205  			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7206  			BPF_EXIT_INSN(),
7207  		},
7208  		INTERNAL,
7209  		{ },
7210  		{ { 0, 0x81234567 } }
7211  	},
7212  	/* BPF_ALU | BPF_RSH | BPF_K */
7213  	{
7214  		"ALU_RSH_K: 2 >> 1 = 1",
7215  		.u.insns_int = {
7216  			BPF_LD_IMM64(R0, 2),
7217  			BPF_ALU32_IMM(BPF_RSH, R0, 1),
7218  			BPF_EXIT_INSN(),
7219  		},
7220  		INTERNAL,
7221  		{ },
7222  		{ { 0, 1 } },
7223  	},
7224  	{
7225  		"ALU_RSH_K: 0x80000000 >> 31 = 1",
7226  		.u.insns_int = {
7227  			BPF_LD_IMM64(R0, 0x80000000),
7228  			BPF_ALU32_IMM(BPF_RSH, R0, 31),
7229  			BPF_EXIT_INSN(),
7230  		},
7231  		INTERNAL,
7232  		{ },
7233  		{ { 0, 1 } },
7234  	},
7235  	{
7236  		"ALU_RSH_K: 0x12345678 >> 20 = 0x123",
7237  		.u.insns_int = {
7238  			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
7239  			BPF_ALU32_IMM(BPF_RSH, R0, 20),
7240  			BPF_EXIT_INSN(),
7241  		},
7242  		INTERNAL,
7243  		{ },
7244  		{ { 0, 0x123 } }
7245  	},
7246  	{
7247  		"ALU_RSH_K: 0x12345678 >> 0 = 0x12345678",
7248  		.u.insns_int = {
7249  			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
7250  			BPF_ALU32_IMM(BPF_RSH, R0, 0),
7251  			BPF_EXIT_INSN(),
7252  		},
7253  		INTERNAL,
7254  		{ },
7255  		{ { 0, 0x12345678 } }
7256  	},
7257  	{
7258  		"ALU64_RSH_K: 2 >> 1 = 1",
7259  		.u.insns_int = {
7260  			BPF_LD_IMM64(R0, 2),
7261  			BPF_ALU64_IMM(BPF_RSH, R0, 1),
7262  			BPF_EXIT_INSN(),
7263  		},
7264  		INTERNAL,
7265  		{ },
7266  		{ { 0, 1 } },
7267  	},
7268  	{
7269  		"ALU64_RSH_K: 0x80000000 >> 31 = 1",
7270  		.u.insns_int = {
7271  			BPF_LD_IMM64(R0, 0x80000000),
7272  			BPF_ALU64_IMM(BPF_RSH, R0, 31),
7273  			BPF_EXIT_INSN(),
7274  		},
7275  		INTERNAL,
7276  		{ },
7277  		{ { 0, 1 } },
7278  	},
7279  	{
7280  		"ALU64_RSH_K: Shift < 32, low word",
7281  		.u.insns_int = {
7282  			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7283  			BPF_ALU64_IMM(BPF_RSH, R0, 12),
7284  			BPF_EXIT_INSN(),
7285  		},
7286  		INTERNAL,
7287  		{ },
7288  		{ { 0, 0x56789abc } }
7289  	},
7290  	{
7291  		"ALU64_RSH_K: Shift < 32, high word",
7292  		.u.insns_int = {
7293  			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7294  			BPF_ALU64_IMM(BPF_RSH, R0, 12),
7295  			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7296  			BPF_EXIT_INSN(),
7297  		},
7298  		INTERNAL,
7299  		{ },
7300  		{ { 0, 0x00081234 } }
7301  	},
7302  	{
7303  		"ALU64_RSH_K: Shift > 32, low word",
7304  		.u.insns_int = {
7305  			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7306  			BPF_ALU64_IMM(BPF_RSH, R0, 36),
7307  			BPF_EXIT_INSN(),
7308  		},
7309  		INTERNAL,
7310  		{ },
7311  		{ { 0, 0x08123456 } }
7312  	},
7313  	{
7314  		"ALU64_RSH_K: Shift > 32, high word",
7315  		.u.insns_int = {
7316  			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7317  			BPF_ALU64_IMM(BPF_RSH, R0, 36),
7318  			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7319  			BPF_EXIT_INSN(),
7320  		},
7321  		INTERNAL,
7322  		{ },
7323  		{ { 0, 0 } }
7324  	},
7325  	{
7326  		"ALU64_RSH_K: Shift == 32, low word",
7327  		.u.insns_int = {
7328  			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7329  			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7330  			BPF_EXIT_INSN(),
7331  		},
7332  		INTERNAL,
7333  		{ },
7334  		{ { 0, 0x81234567 } }
7335  	},
7336  	{
7337  		"ALU64_RSH_K: Shift == 32, high word",
7338  		.u.insns_int = {
7339  			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7340  			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7341  			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7342  			BPF_EXIT_INSN(),
7343  		},
7344  		INTERNAL,
7345  		{ },
7346  		{ { 0, 0 } }
7347  	},
7348  	{
7349  		"ALU64_RSH_K: Zero shift",
7350  		.u.insns_int = {
7351  			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7352  			BPF_ALU64_IMM(BPF_RSH, R0, 0),
7353  			BPF_EXIT_INSN(),
7354  		},
7355  		INTERNAL,
7356  		{ },
7357  		{ { 0, 0x89abcdef } }
7358  	},
7359  	/* BPF_ALU | BPF_ARSH | BPF_X */
7360  	{
7361  		"ALU32_ARSH_X: -1234 >> 7 = -10",
7362  		.u.insns_int = {
7363  			BPF_ALU32_IMM(BPF_MOV, R0, -1234),
7364  			BPF_ALU32_IMM(BPF_MOV, R1, 7),
7365  			BPF_ALU32_REG(BPF_ARSH, R0, R1),
7366  			BPF_EXIT_INSN(),
7367  		},
7368  		INTERNAL,
7369  		{ },
7370  		{ { 0, -10 } }
7371  	},
7372  	{
7373  		"ALU64_ARSH_X: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
7374  		.u.insns_int = {
7375  			BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
7376  			BPF_ALU32_IMM(BPF_MOV, R1, 40),
7377  			BPF_ALU64_REG(BPF_ARSH, R0, R1),
7378  			BPF_EXIT_INSN(),
7379  		},
7380  		INTERNAL,
7381  		{ },
7382  		{ { 0, 0xffff00ff } },
7383  	},
7384  	{
7385  		"ALU64_ARSH_X: Shift < 32, low word",
7386  		.u.insns_int = {
7387  			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7388  			BPF_ALU32_IMM(BPF_MOV, R1, 12),
7389  			BPF_ALU64_REG(BPF_ARSH, R0, R1),
7390  			BPF_EXIT_INSN(),
7391  		},
7392  		INTERNAL,
7393  		{ },
7394  		{ { 0, 0x56789abc } }
7395  	},
7396  	{
7397  		"ALU64_ARSH_X: Shift < 32, high word",
7398  		.u.insns_int = {
7399  			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7400  			BPF_ALU32_IMM(BPF_MOV, R1, 12),
7401  			BPF_ALU64_REG(BPF_ARSH, R0, R1),
7402  			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7403  			BPF_EXIT_INSN(),
7404  		},
7405  		INTERNAL,
7406  		{ },
7407  		{ { 0, 0xfff81234 } }
7408  	},
7409  	{
7410  		"ALU64_ARSH_X: Shift > 32, low word",
7411  		.u.insns_int = {
7412  			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7413  			BPF_ALU32_IMM(BPF_MOV, R1, 36),
7414  			BPF_ALU64_REG(BPF_ARSH, R0, R1),
7415  			BPF_EXIT_INSN(),
7416  		},
7417  		INTERNAL,
7418  		{ },
7419  		{ { 0, 0xf8123456 } }
7420  	},
7421  	{
7422  		"ALU64_ARSH_X: Shift > 32, high word",
7423  		.u.insns_int = {
7424  			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7425  			BPF_ALU32_IMM(BPF_MOV, R1, 36),
7426  			BPF_ALU64_REG(BPF_ARSH, R0, R1),
7427  			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7428  			BPF_EXIT_INSN(),
7429  		},
7430  		INTERNAL,
7431  		{ },
7432  		{ { 0, -1 } }
7433  	},
7434  	{
7435  		"ALU64_ARSH_X: Shift == 32, low word",
7436  		.u.insns_int = {
7437  			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7438  			BPF_ALU32_IMM(BPF_MOV, R1, 32),
7439  			BPF_ALU64_REG(BPF_ARSH, R0, R1),
7440  			BPF_EXIT_INSN(),
7441  		},
7442  		INTERNAL,
7443  		{ },
7444  		{ { 0, 0x81234567 } }
7445  	},
7446  	{
7447  		"ALU64_ARSH_X: Shift == 32, high word",
7448  		.u.insns_int = {
7449  			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7450  			BPF_ALU32_IMM(BPF_MOV, R1, 32),
7451  			BPF_ALU64_REG(BPF_ARSH, R0, R1),
7452  			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7453  			BPF_EXIT_INSN(),
7454  		},
7455  		INTERNAL,
7456  		{ },
7457  		{ { 0, -1 } }
7458  	},
7459  	{
7460  		"ALU64_ARSH_X: Zero shift, low word",
7461  		.u.insns_int = {
7462  			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7463  			BPF_ALU32_IMM(BPF_MOV, R1, 0),
7464  			BPF_ALU64_REG(BPF_ARSH, R0, R1),
7465  			BPF_EXIT_INSN(),
7466  		},
7467  		INTERNAL,
7468  		{ },
7469  		{ { 0, 0x89abcdef } }
7470  	},
7471  	{
7472  		"ALU64_ARSH_X: Zero shift, high word",
7473  		.u.insns_int = {
7474  			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7475  			BPF_ALU32_IMM(BPF_MOV, R1, 0),
7476  			BPF_ALU64_REG(BPF_ARSH, R0, R1),
7477  			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7478  			BPF_EXIT_INSN(),
7479  		},
7480  		INTERNAL,
7481  		{ },
7482  		{ { 0, 0x81234567 } }
7483  	},
7484  	/* BPF_ALU | BPF_ARSH | BPF_K */
7485  	{
7486  		"ALU32_ARSH_K: -1234 >> 7 = -10",
7487  		.u.insns_int = {
7488  			BPF_ALU32_IMM(BPF_MOV, R0, -1234),
7489  			BPF_ALU32_IMM(BPF_ARSH, R0, 7),
7490  			BPF_EXIT_INSN(),
7491  		},
7492  		INTERNAL,
7493  		{ },
7494  		{ { 0, -10 } }
7495  	},
7496  	{
7497  		"ALU32_ARSH_K: -1234 >> 0 = -1234",
7498  		.u.insns_int = {
7499  			BPF_ALU32_IMM(BPF_MOV, R0, -1234),
7500  			BPF_ALU32_IMM(BPF_ARSH, R0, 0),
7501  			BPF_EXIT_INSN(),
7502  		},
7503  		INTERNAL,
7504  		{ },
7505  		{ { 0, -1234 } }
7506  	},
7507  	{
7508  		"ALU64_ARSH_K: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
7509  		.u.insns_int = {
7510  			BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
7511  			BPF_ALU64_IMM(BPF_ARSH, R0, 40),
7512  			BPF_EXIT_INSN(),
7513  		},
7514  		INTERNAL,
7515  		{ },
7516  		{ { 0, 0xffff00ff } },
7517  	},
7518  	{
7519  		"ALU64_ARSH_K: Shift < 32, low word",
7520  		.u.insns_int = {
7521  			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7522  			BPF_ALU64_IMM(BPF_RSH, R0, 12),
7523  			BPF_EXIT_INSN(),
7524  		},
7525  		INTERNAL,
7526  		{ },
7527  		{ { 0, 0x56789abc } }
7528  	},
7529  	{
7530  		"ALU64_ARSH_K: Shift < 32, high word",
7531  		.u.insns_int = {
7532  			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7533  			BPF_ALU64_IMM(BPF_ARSH, R0, 12),
7534  			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7535  			BPF_EXIT_INSN(),
7536  		},
7537  		INTERNAL,
7538  		{ },
7539  		{ { 0, 0xfff81234 } }
7540  	},
7541  	{
7542  		"ALU64_ARSH_K: Shift > 32, low word",
7543  		.u.insns_int = {
7544  			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7545  			BPF_ALU64_IMM(BPF_ARSH, R0, 36),
7546  			BPF_EXIT_INSN(),
7547  		},
7548  		INTERNAL,
7549  		{ },
7550  		{ { 0, 0xf8123456 } }
7551  	},
7552  	{
7553  		"ALU64_ARSH_K: Shift > 32, high word",
7554  		.u.insns_int = {
7555  			BPF_LD_IMM64(R0, 0xf123456789abcdefLL),
7556  			BPF_ALU64_IMM(BPF_ARSH, R0, 36),
7557  			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7558  			BPF_EXIT_INSN(),
7559  		},
7560  		INTERNAL,
7561  		{ },
7562  		{ { 0, -1 } }
7563  	},
7564  	{
7565  		"ALU64_ARSH_K: Shift == 32, low word",
7566  		.u.insns_int = {
7567  			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7568  			BPF_ALU64_IMM(BPF_ARSH, R0, 32),
7569  			BPF_EXIT_INSN(),
7570  		},
7571  		INTERNAL,
7572  		{ },
7573  		{ { 0, 0x81234567 } }
7574  	},
7575  	{
7576  		"ALU64_ARSH_K: Shift == 32, high word",
7577  		.u.insns_int = {
7578  			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7579  			BPF_ALU64_IMM(BPF_ARSH, R0, 32),
7580  			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7581  			BPF_EXIT_INSN(),
7582  		},
7583  		INTERNAL,
7584  		{ },
7585  		{ { 0, -1 } }
7586  	},
7587  	{
7588  		"ALU64_ARSH_K: Zero shift",
7589  		.u.insns_int = {
7590  			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7591  			BPF_ALU64_IMM(BPF_ARSH, R0, 0),
7592  			BPF_EXIT_INSN(),
7593  		},
7594  		INTERNAL,
7595  		{ },
7596  		{ { 0, 0x89abcdef } }
7597  	},
7598  	/* BPF_ALU | BPF_NEG */
7599  	{
7600  		"ALU_NEG: -(3) = -3",
7601  		.u.insns_int = {
7602  			BPF_ALU32_IMM(BPF_MOV, R0, 3),
7603  			BPF_ALU32_IMM(BPF_NEG, R0, 0),
7604  			BPF_EXIT_INSN(),
7605  		},
7606  		INTERNAL,
7607  		{ },
7608  		{ { 0, -3 } },
7609  	},
7610  	{
7611  		"ALU_NEG: -(-3) = 3",
7612  		.u.insns_int = {
7613  			BPF_ALU32_IMM(BPF_MOV, R0, -3),
7614  			BPF_ALU32_IMM(BPF_NEG, R0, 0),
7615  			BPF_EXIT_INSN(),
7616  		},
7617  		INTERNAL,
7618  		{ },
7619  		{ { 0, 3 } },
7620  	},
7621  	{
7622  		"ALU64_NEG: -(3) = -3",
7623  		.u.insns_int = {
7624  			BPF_LD_IMM64(R0, 3),
7625  			BPF_ALU64_IMM(BPF_NEG, R0, 0),
7626  			BPF_EXIT_INSN(),
7627  		},
7628  		INTERNAL,
7629  		{ },
7630  		{ { 0, -3 } },
7631  	},
7632  	{
7633  		"ALU64_NEG: -(-3) = 3",
7634  		.u.insns_int = {
7635  			BPF_LD_IMM64(R0, -3),
7636  			BPF_ALU64_IMM(BPF_NEG, R0, 0),
7637  			BPF_EXIT_INSN(),
7638  		},
7639  		INTERNAL,
7640  		{ },
7641  		{ { 0, 3 } },
7642  	},
7643  	/* BPF_ALU | BPF_END | BPF_FROM_BE */
7644  	{
7645  		"ALU_END_FROM_BE 16: 0x0123456789abcdef -> 0xcdef",
7646  		.u.insns_int = {
7647  			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7648  			BPF_ENDIAN(BPF_FROM_BE, R0, 16),
7649  			BPF_EXIT_INSN(),
7650  		},
7651  		INTERNAL,
7652  		{ },
7653  		{ { 0,  cpu_to_be16(0xcdef) } },
7654  	},
7655  	{
7656  		"ALU_END_FROM_BE 32: 0x0123456789abcdef -> 0x89abcdef",
7657  		.u.insns_int = {
7658  			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7659  			BPF_ENDIAN(BPF_FROM_BE, R0, 32),
7660  			BPF_ALU64_REG(BPF_MOV, R1, R0),
7661  			BPF_ALU64_IMM(BPF_RSH, R1, 32),
7662  			BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
7663  			BPF_EXIT_INSN(),
7664  		},
7665  		INTERNAL,
7666  		{ },
7667  		{ { 0, cpu_to_be32(0x89abcdef) } },
7668  	},
7669  	{
7670  		"ALU_END_FROM_BE 64: 0x0123456789abcdef -> 0x89abcdef",
7671  		.u.insns_int = {
7672  			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7673  			BPF_ENDIAN(BPF_FROM_BE, R0, 64),
7674  			BPF_EXIT_INSN(),
7675  		},
7676  		INTERNAL,
7677  		{ },
7678  		{ { 0, (u32) cpu_to_be64(0x0123456789abcdefLL) } },
7679  	},
7680  	{
7681  		"ALU_END_FROM_BE 64: 0x0123456789abcdef >> 32 -> 0x01234567",
7682  		.u.insns_int = {
7683  			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7684  			BPF_ENDIAN(BPF_FROM_BE, R0, 64),
7685  			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7686  			BPF_EXIT_INSN(),
7687  		},
7688  		INTERNAL,
7689  		{ },
7690  		{ { 0, (u32) (cpu_to_be64(0x0123456789abcdefLL) >> 32) } },
7691  	},
7692  	/* BPF_ALU | BPF_END | BPF_FROM_BE, reversed */
7693  	{
7694  		"ALU_END_FROM_BE 16: 0xfedcba9876543210 -> 0x3210",
7695  		.u.insns_int = {
7696  			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7697  			BPF_ENDIAN(BPF_FROM_BE, R0, 16),
7698  			BPF_EXIT_INSN(),
7699  		},
7700  		INTERNAL,
7701  		{ },
7702  		{ { 0,  cpu_to_be16(0x3210) } },
7703  	},
7704  	{
7705  		"ALU_END_FROM_BE 32: 0xfedcba9876543210 -> 0x76543210",
7706  		.u.insns_int = {
7707  			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7708  			BPF_ENDIAN(BPF_FROM_BE, R0, 32),
7709  			BPF_ALU64_REG(BPF_MOV, R1, R0),
7710  			BPF_ALU64_IMM(BPF_RSH, R1, 32),
7711  			BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
7712  			BPF_EXIT_INSN(),
7713  		},
7714  		INTERNAL,
7715  		{ },
7716  		{ { 0, cpu_to_be32(0x76543210) } },
7717  	},
7718  	{
7719  		"ALU_END_FROM_BE 64: 0xfedcba9876543210 -> 0x76543210",
7720  		.u.insns_int = {
7721  			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7722  			BPF_ENDIAN(BPF_FROM_BE, R0, 64),
7723  			BPF_EXIT_INSN(),
7724  		},
7725  		INTERNAL,
7726  		{ },
7727  		{ { 0, (u32) cpu_to_be64(0xfedcba9876543210ULL) } },
7728  	},
7729  	{
7730  		"ALU_END_FROM_BE 64: 0xfedcba9876543210 >> 32 -> 0xfedcba98",
7731  		.u.insns_int = {
7732  			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7733  			BPF_ENDIAN(BPF_FROM_BE, R0, 64),
7734  			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7735  			BPF_EXIT_INSN(),
7736  		},
7737  		INTERNAL,
7738  		{ },
7739  		{ { 0, (u32) (cpu_to_be64(0xfedcba9876543210ULL) >> 32) } },
7740  	},
7741  	/* BPF_ALU | BPF_END | BPF_FROM_LE */
7742  	{
7743  		"ALU_END_FROM_LE 16: 0x0123456789abcdef -> 0xefcd",
7744  		.u.insns_int = {
7745  			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7746  			BPF_ENDIAN(BPF_FROM_LE, R0, 16),
7747  			BPF_EXIT_INSN(),
7748  		},
7749  		INTERNAL,
7750  		{ },
7751  		{ { 0, cpu_to_le16(0xcdef) } },
7752  	},
7753  	{
7754  		"ALU_END_FROM_LE 32: 0x0123456789abcdef -> 0xefcdab89",
7755  		.u.insns_int = {
7756  			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7757  			BPF_ENDIAN(BPF_FROM_LE, R0, 32),
7758  			BPF_ALU64_REG(BPF_MOV, R1, R0),
7759  			BPF_ALU64_IMM(BPF_RSH, R1, 32),
7760  			BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
7761  			BPF_EXIT_INSN(),
7762  		},
7763  		INTERNAL,
7764  		{ },
7765  		{ { 0, cpu_to_le32(0x89abcdef) } },
7766  	},
7767  	{
7768  		"ALU_END_FROM_LE 64: 0x0123456789abcdef -> 0x67452301",
7769  		.u.insns_int = {
7770  			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7771  			BPF_ENDIAN(BPF_FROM_LE, R0, 64),
7772  			BPF_EXIT_INSN(),
7773  		},
7774  		INTERNAL,
7775  		{ },
7776  		{ { 0, (u32) cpu_to_le64(0x0123456789abcdefLL) } },
7777  	},
7778  	{
7779  		"ALU_END_FROM_LE 64: 0x0123456789abcdef >> 32 -> 0xefcdab89",
7780  		.u.insns_int = {
7781  			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7782  			BPF_ENDIAN(BPF_FROM_LE, R0, 64),
7783  			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7784  			BPF_EXIT_INSN(),
7785  		},
7786  		INTERNAL,
7787  		{ },
7788  		{ { 0, (u32) (cpu_to_le64(0x0123456789abcdefLL) >> 32) } },
7789  	},
7790  	/* BPF_ALU | BPF_END | BPF_FROM_LE, reversed */
7791  	{
7792  		"ALU_END_FROM_LE 16: 0xfedcba9876543210 -> 0x1032",
7793  		.u.insns_int = {
7794  			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7795  			BPF_ENDIAN(BPF_FROM_LE, R0, 16),
7796  			BPF_EXIT_INSN(),
7797  		},
7798  		INTERNAL,
7799  		{ },
7800  		{ { 0,  cpu_to_le16(0x3210) } },
7801  	},
7802  	{
7803  		"ALU_END_FROM_LE 32: 0xfedcba9876543210 -> 0x10325476",
7804  		.u.insns_int = {
7805  			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7806  			BPF_ENDIAN(BPF_FROM_LE, R0, 32),
7807  			BPF_ALU64_REG(BPF_MOV, R1, R0),
7808  			BPF_ALU64_IMM(BPF_RSH, R1, 32),
7809  			BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
7810  			BPF_EXIT_INSN(),
7811  		},
7812  		INTERNAL,
7813  		{ },
7814  		{ { 0, cpu_to_le32(0x76543210) } },
7815  	},
7816  	{
7817  		"ALU_END_FROM_LE 64: 0xfedcba9876543210 -> 0x10325476",
7818  		.u.insns_int = {
7819  			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7820  			BPF_ENDIAN(BPF_FROM_LE, R0, 64),
7821  			BPF_EXIT_INSN(),
7822  		},
7823  		INTERNAL,
7824  		{ },
7825  		{ { 0, (u32) cpu_to_le64(0xfedcba9876543210ULL) } },
7826  	},
7827  	{
7828  		"ALU_END_FROM_LE 64: 0xfedcba9876543210 >> 32 -> 0x98badcfe",
7829  		.u.insns_int = {
7830  			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7831  			BPF_ENDIAN(BPF_FROM_LE, R0, 64),
7832  			BPF_ALU64_IMM(BPF_RSH, R0, 32),
7833  			BPF_EXIT_INSN(),
7834  		},
7835  		INTERNAL,
7836  		{ },
7837  		{ { 0, (u32) (cpu_to_le64(0xfedcba9876543210ULL) >> 32) } },
7838  	},
7839  	/* BPF_LDX_MEM B/H/W/DW */
7840  	{
7841  		"BPF_LDX_MEM | BPF_B",
7842  		.u.insns_int = {
7843  			BPF_LD_IMM64(R1, 0x0102030405060708ULL),
7844  			BPF_LD_IMM64(R2, 0x0000000000000008ULL),
7845  			BPF_STX_MEM(BPF_DW, R10, R1, -8),
7846  #ifdef __BIG_ENDIAN
7847  			BPF_LDX_MEM(BPF_B, R0, R10, -1),
7848  #else
7849  			BPF_LDX_MEM(BPF_B, R0, R10, -8),
7850  #endif
7851  			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
7852  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7853  			BPF_EXIT_INSN(),
7854  		},
7855  		INTERNAL,
7856  		{ },
7857  		{ { 0, 0 } },
7858  		.stack_depth = 8,
7859  	},
7860  	{
7861  		"BPF_LDX_MEM | BPF_B, MSB set",
7862  		.u.insns_int = {
7863  			BPF_LD_IMM64(R1, 0x8182838485868788ULL),
7864  			BPF_LD_IMM64(R2, 0x0000000000000088ULL),
7865  			BPF_STX_MEM(BPF_DW, R10, R1, -8),
7866  #ifdef __BIG_ENDIAN
7867  			BPF_LDX_MEM(BPF_B, R0, R10, -1),
7868  #else
7869  			BPF_LDX_MEM(BPF_B, R0, R10, -8),
7870  #endif
7871  			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
7872  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7873  			BPF_EXIT_INSN(),
7874  		},
7875  		INTERNAL,
7876  		{ },
7877  		{ { 0, 0 } },
7878  		.stack_depth = 8,
7879  	},
7880  	{
7881  		"BPF_LDX_MEM | BPF_H",
7882  		.u.insns_int = {
7883  			BPF_LD_IMM64(R1, 0x0102030405060708ULL),
7884  			BPF_LD_IMM64(R2, 0x0000000000000708ULL),
7885  			BPF_STX_MEM(BPF_DW, R10, R1, -8),
7886  #ifdef __BIG_ENDIAN
7887  			BPF_LDX_MEM(BPF_H, R0, R10, -2),
7888  #else
7889  			BPF_LDX_MEM(BPF_H, R0, R10, -8),
7890  #endif
7891  			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
7892  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7893  			BPF_EXIT_INSN(),
7894  		},
7895  		INTERNAL,
7896  		{ },
7897  		{ { 0, 0 } },
7898  		.stack_depth = 8,
7899  	},
7900  	{
7901  		"BPF_LDX_MEM | BPF_H, MSB set",
7902  		.u.insns_int = {
7903  			BPF_LD_IMM64(R1, 0x8182838485868788ULL),
7904  			BPF_LD_IMM64(R2, 0x0000000000008788ULL),
7905  			BPF_STX_MEM(BPF_DW, R10, R1, -8),
7906  #ifdef __BIG_ENDIAN
7907  			BPF_LDX_MEM(BPF_H, R0, R10, -2),
7908  #else
7909  			BPF_LDX_MEM(BPF_H, R0, R10, -8),
7910  #endif
7911  			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
7912  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7913  			BPF_EXIT_INSN(),
7914  		},
7915  		INTERNAL,
7916  		{ },
7917  		{ { 0, 0 } },
7918  		.stack_depth = 8,
7919  	},
7920  	{
7921  		"BPF_LDX_MEM | BPF_W",
7922  		.u.insns_int = {
7923  			BPF_LD_IMM64(R1, 0x0102030405060708ULL),
7924  			BPF_LD_IMM64(R2, 0x0000000005060708ULL),
7925  			BPF_STX_MEM(BPF_DW, R10, R1, -8),
7926  #ifdef __BIG_ENDIAN
7927  			BPF_LDX_MEM(BPF_W, R0, R10, -4),
7928  #else
7929  			BPF_LDX_MEM(BPF_W, R0, R10, -8),
7930  #endif
7931  			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
7932  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7933  			BPF_EXIT_INSN(),
7934  		},
7935  		INTERNAL,
7936  		{ },
7937  		{ { 0, 0 } },
7938  		.stack_depth = 8,
7939  	},
7940  	{
7941  		"BPF_LDX_MEM | BPF_W, MSB set",
7942  		.u.insns_int = {
7943  			BPF_LD_IMM64(R1, 0x8182838485868788ULL),
7944  			BPF_LD_IMM64(R2, 0x0000000085868788ULL),
7945  			BPF_STX_MEM(BPF_DW, R10, R1, -8),
7946  #ifdef __BIG_ENDIAN
7947  			BPF_LDX_MEM(BPF_W, R0, R10, -4),
7948  #else
7949  			BPF_LDX_MEM(BPF_W, R0, R10, -8),
7950  #endif
7951  			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
7952  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7953  			BPF_EXIT_INSN(),
7954  		},
7955  		INTERNAL,
7956  		{ },
7957  		{ { 0, 0 } },
7958  		.stack_depth = 8,
7959  	},
7960  	/* BPF_STX_MEM B/H/W/DW */
7961  	{
7962  		"BPF_STX_MEM | BPF_B",
7963  		.u.insns_int = {
7964  			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
7965  			BPF_LD_IMM64(R2, 0x0102030405060708ULL),
7966  			BPF_LD_IMM64(R3, 0x8090a0b0c0d0e008ULL),
7967  			BPF_STX_MEM(BPF_DW, R10, R1, -8),
7968  #ifdef __BIG_ENDIAN
7969  			BPF_STX_MEM(BPF_B, R10, R2, -1),
7970  #else
7971  			BPF_STX_MEM(BPF_B, R10, R2, -8),
7972  #endif
7973  			BPF_LDX_MEM(BPF_DW, R0, R10, -8),
7974  			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
7975  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7976  			BPF_EXIT_INSN(),
7977  		},
7978  		INTERNAL,
7979  		{ },
7980  		{ { 0, 0 } },
7981  		.stack_depth = 8,
7982  	},
7983  	{
7984  		"BPF_STX_MEM | BPF_B, MSB set",
7985  		.u.insns_int = {
7986  			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
7987  			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
7988  			BPF_LD_IMM64(R3, 0x8090a0b0c0d0e088ULL),
7989  			BPF_STX_MEM(BPF_DW, R10, R1, -8),
7990  #ifdef __BIG_ENDIAN
7991  			BPF_STX_MEM(BPF_B, R10, R2, -1),
7992  #else
7993  			BPF_STX_MEM(BPF_B, R10, R2, -8),
7994  #endif
7995  			BPF_LDX_MEM(BPF_DW, R0, R10, -8),
7996  			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
7997  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
7998  			BPF_EXIT_INSN(),
7999  		},
8000  		INTERNAL,
8001  		{ },
8002  		{ { 0, 0 } },
8003  		.stack_depth = 8,
8004  	},
8005  	{
8006  		"BPF_STX_MEM | BPF_H",
8007  		.u.insns_int = {
8008  			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8009  			BPF_LD_IMM64(R2, 0x0102030405060708ULL),
8010  			BPF_LD_IMM64(R3, 0x8090a0b0c0d00708ULL),
8011  			BPF_STX_MEM(BPF_DW, R10, R1, -8),
8012  #ifdef __BIG_ENDIAN
8013  			BPF_STX_MEM(BPF_H, R10, R2, -2),
8014  #else
8015  			BPF_STX_MEM(BPF_H, R10, R2, -8),
8016  #endif
8017  			BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8018  			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8019  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8020  			BPF_EXIT_INSN(),
8021  		},
8022  		INTERNAL,
8023  		{ },
8024  		{ { 0, 0 } },
8025  		.stack_depth = 8,
8026  	},
8027  	{
8028  		"BPF_STX_MEM | BPF_H, MSB set",
8029  		.u.insns_int = {
8030  			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8031  			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8032  			BPF_LD_IMM64(R3, 0x8090a0b0c0d08788ULL),
8033  			BPF_STX_MEM(BPF_DW, R10, R1, -8),
8034  #ifdef __BIG_ENDIAN
8035  			BPF_STX_MEM(BPF_H, R10, R2, -2),
8036  #else
8037  			BPF_STX_MEM(BPF_H, R10, R2, -8),
8038  #endif
8039  			BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8040  			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8041  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8042  			BPF_EXIT_INSN(),
8043  		},
8044  		INTERNAL,
8045  		{ },
8046  		{ { 0, 0 } },
8047  		.stack_depth = 8,
8048  	},
8049  	{
8050  		"BPF_STX_MEM | BPF_W",
8051  		.u.insns_int = {
8052  			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8053  			BPF_LD_IMM64(R2, 0x0102030405060708ULL),
8054  			BPF_LD_IMM64(R3, 0x8090a0b005060708ULL),
8055  			BPF_STX_MEM(BPF_DW, R10, R1, -8),
8056  #ifdef __BIG_ENDIAN
8057  			BPF_STX_MEM(BPF_W, R10, R2, -4),
8058  #else
8059  			BPF_STX_MEM(BPF_W, R10, R2, -8),
8060  #endif
8061  			BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8062  			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8063  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8064  			BPF_EXIT_INSN(),
8065  		},
8066  		INTERNAL,
8067  		{ },
8068  		{ { 0, 0 } },
8069  		.stack_depth = 8,
8070  	},
8071  	{
8072  		"BPF_STX_MEM | BPF_W, MSB set",
8073  		.u.insns_int = {
8074  			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8075  			BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8076  			BPF_LD_IMM64(R3, 0x8090a0b085868788ULL),
8077  			BPF_STX_MEM(BPF_DW, R10, R1, -8),
8078  #ifdef __BIG_ENDIAN
8079  			BPF_STX_MEM(BPF_W, R10, R2, -4),
8080  #else
8081  			BPF_STX_MEM(BPF_W, R10, R2, -8),
8082  #endif
8083  			BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8084  			BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8085  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
8086  			BPF_EXIT_INSN(),
8087  		},
8088  		INTERNAL,
8089  		{ },
8090  		{ { 0, 0 } },
8091  		.stack_depth = 8,
8092  	},
8093  	/* BPF_ST(X) | BPF_MEM | BPF_B/H/W/DW */
8094  	{
8095  		"ST_MEM_B: Store/Load byte: max negative",
8096  		.u.insns_int = {
8097  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8098  			BPF_ST_MEM(BPF_B, R10, -40, 0xff),
8099  			BPF_LDX_MEM(BPF_B, R0, R10, -40),
8100  			BPF_EXIT_INSN(),
8101  		},
8102  		INTERNAL,
8103  		{ },
8104  		{ { 0, 0xff } },
8105  		.stack_depth = 40,
8106  	},
8107  	{
8108  		"ST_MEM_B: Store/Load byte: max positive",
8109  		.u.insns_int = {
8110  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8111  			BPF_ST_MEM(BPF_H, R10, -40, 0x7f),
8112  			BPF_LDX_MEM(BPF_H, R0, R10, -40),
8113  			BPF_EXIT_INSN(),
8114  		},
8115  		INTERNAL,
8116  		{ },
8117  		{ { 0, 0x7f } },
8118  		.stack_depth = 40,
8119  	},
8120  	{
8121  		"STX_MEM_B: Store/Load byte: max negative",
8122  		.u.insns_int = {
8123  			BPF_LD_IMM64(R0, 0),
8124  			BPF_LD_IMM64(R1, 0xffLL),
8125  			BPF_STX_MEM(BPF_B, R10, R1, -40),
8126  			BPF_LDX_MEM(BPF_B, R0, R10, -40),
8127  			BPF_EXIT_INSN(),
8128  		},
8129  		INTERNAL,
8130  		{ },
8131  		{ { 0, 0xff } },
8132  		.stack_depth = 40,
8133  	},
8134  	{
8135  		"ST_MEM_H: Store/Load half word: max negative",
8136  		.u.insns_int = {
8137  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8138  			BPF_ST_MEM(BPF_H, R10, -40, 0xffff),
8139  			BPF_LDX_MEM(BPF_H, R0, R10, -40),
8140  			BPF_EXIT_INSN(),
8141  		},
8142  		INTERNAL,
8143  		{ },
8144  		{ { 0, 0xffff } },
8145  		.stack_depth = 40,
8146  	},
8147  	{
8148  		"ST_MEM_H: Store/Load half word: max positive",
8149  		.u.insns_int = {
8150  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8151  			BPF_ST_MEM(BPF_H, R10, -40, 0x7fff),
8152  			BPF_LDX_MEM(BPF_H, R0, R10, -40),
8153  			BPF_EXIT_INSN(),
8154  		},
8155  		INTERNAL,
8156  		{ },
8157  		{ { 0, 0x7fff } },
8158  		.stack_depth = 40,
8159  	},
8160  	{
8161  		"STX_MEM_H: Store/Load half word: max negative",
8162  		.u.insns_int = {
8163  			BPF_LD_IMM64(R0, 0),
8164  			BPF_LD_IMM64(R1, 0xffffLL),
8165  			BPF_STX_MEM(BPF_H, R10, R1, -40),
8166  			BPF_LDX_MEM(BPF_H, R0, R10, -40),
8167  			BPF_EXIT_INSN(),
8168  		},
8169  		INTERNAL,
8170  		{ },
8171  		{ { 0, 0xffff } },
8172  		.stack_depth = 40,
8173  	},
8174  	{
8175  		"ST_MEM_W: Store/Load word: max negative",
8176  		.u.insns_int = {
8177  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8178  			BPF_ST_MEM(BPF_W, R10, -40, 0xffffffff),
8179  			BPF_LDX_MEM(BPF_W, R0, R10, -40),
8180  			BPF_EXIT_INSN(),
8181  		},
8182  		INTERNAL,
8183  		{ },
8184  		{ { 0, 0xffffffff } },
8185  		.stack_depth = 40,
8186  	},
8187  	{
8188  		"ST_MEM_W: Store/Load word: max positive",
8189  		.u.insns_int = {
8190  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8191  			BPF_ST_MEM(BPF_W, R10, -40, 0x7fffffff),
8192  			BPF_LDX_MEM(BPF_W, R0, R10, -40),
8193  			BPF_EXIT_INSN(),
8194  		},
8195  		INTERNAL,
8196  		{ },
8197  		{ { 0, 0x7fffffff } },
8198  		.stack_depth = 40,
8199  	},
8200  	{
8201  		"STX_MEM_W: Store/Load word: max negative",
8202  		.u.insns_int = {
8203  			BPF_LD_IMM64(R0, 0),
8204  			BPF_LD_IMM64(R1, 0xffffffffLL),
8205  			BPF_STX_MEM(BPF_W, R10, R1, -40),
8206  			BPF_LDX_MEM(BPF_W, R0, R10, -40),
8207  			BPF_EXIT_INSN(),
8208  		},
8209  		INTERNAL,
8210  		{ },
8211  		{ { 0, 0xffffffff } },
8212  		.stack_depth = 40,
8213  	},
8214  	{
8215  		"ST_MEM_DW: Store/Load double word: max negative",
8216  		.u.insns_int = {
8217  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8218  			BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
8219  			BPF_LDX_MEM(BPF_DW, R0, R10, -40),
8220  			BPF_EXIT_INSN(),
8221  		},
8222  		INTERNAL,
8223  		{ },
8224  		{ { 0, 0xffffffff } },
8225  		.stack_depth = 40,
8226  	},
8227  	{
8228  		"ST_MEM_DW: Store/Load double word: max negative 2",
8229  		.u.insns_int = {
8230  			BPF_LD_IMM64(R2, 0xffff00000000ffffLL),
8231  			BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
8232  			BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
8233  			BPF_LDX_MEM(BPF_DW, R2, R10, -40),
8234  			BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
8235  			BPF_MOV32_IMM(R0, 2),
8236  			BPF_EXIT_INSN(),
8237  			BPF_MOV32_IMM(R0, 1),
8238  			BPF_EXIT_INSN(),
8239  		},
8240  		INTERNAL,
8241  		{ },
8242  		{ { 0, 0x1 } },
8243  		.stack_depth = 40,
8244  	},
8245  	{
8246  		"ST_MEM_DW: Store/Load double word: max positive",
8247  		.u.insns_int = {
8248  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8249  			BPF_ST_MEM(BPF_DW, R10, -40, 0x7fffffff),
8250  			BPF_LDX_MEM(BPF_DW, R0, R10, -40),
8251  			BPF_EXIT_INSN(),
8252  		},
8253  		INTERNAL,
8254  		{ },
8255  		{ { 0, 0x7fffffff } },
8256  		.stack_depth = 40,
8257  	},
8258  	{
8259  		"STX_MEM_DW: Store/Load double word: max negative",
8260  		.u.insns_int = {
8261  			BPF_LD_IMM64(R0, 0),
8262  			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
8263  			BPF_STX_MEM(BPF_DW, R10, R1, -40),
8264  			BPF_LDX_MEM(BPF_DW, R0, R10, -40),
8265  			BPF_EXIT_INSN(),
8266  		},
8267  		INTERNAL,
8268  		{ },
8269  		{ { 0, 0xffffffff } },
8270  		.stack_depth = 40,
8271  	},
8272  	{
8273  		"STX_MEM_DW: Store double word: first word in memory",
8274  		.u.insns_int = {
8275  			BPF_LD_IMM64(R0, 0),
8276  			BPF_LD_IMM64(R1, 0x0123456789abcdefLL),
8277  			BPF_STX_MEM(BPF_DW, R10, R1, -40),
8278  			BPF_LDX_MEM(BPF_W, R0, R10, -40),
8279  			BPF_EXIT_INSN(),
8280  		},
8281  		INTERNAL,
8282  		{ },
8283  #ifdef __BIG_ENDIAN
8284  		{ { 0, 0x01234567 } },
8285  #else
8286  		{ { 0, 0x89abcdef } },
8287  #endif
8288  		.stack_depth = 40,
8289  	},
8290  	{
8291  		"STX_MEM_DW: Store double word: second word in memory",
8292  		.u.insns_int = {
8293  			BPF_LD_IMM64(R0, 0),
8294  			BPF_LD_IMM64(R1, 0x0123456789abcdefLL),
8295  			BPF_STX_MEM(BPF_DW, R10, R1, -40),
8296  			BPF_LDX_MEM(BPF_W, R0, R10, -36),
8297  			BPF_EXIT_INSN(),
8298  		},
8299  		INTERNAL,
8300  		{ },
8301  #ifdef __BIG_ENDIAN
8302  		{ { 0, 0x89abcdef } },
8303  #else
8304  		{ { 0, 0x01234567 } },
8305  #endif
8306  		.stack_depth = 40,
8307  	},
8308  	/* BPF_STX | BPF_ATOMIC | BPF_W/DW */
8309  	{
8310  		"STX_XADD_W: X + 1 + 1 + 1 + ...",
8311  		{ },
8312  		INTERNAL,
8313  		{ },
8314  		{ { 0, 4134 } },
8315  		.fill_helper = bpf_fill_stxw,
8316  	},
8317  	{
8318  		"STX_XADD_DW: X + 1 + 1 + 1 + ...",
8319  		{ },
8320  		INTERNAL,
8321  		{ },
8322  		{ { 0, 4134 } },
8323  		.fill_helper = bpf_fill_stxdw,
8324  	},
8325  	/*
8326  	 * Exhaustive tests of atomic operation variants.
8327  	 * Individual tests are expanded from template macros for all
8328  	 * combinations of ALU operation, word size and fetching.
8329  	 */
8330  #define BPF_ATOMIC_POISON(width) ((width) == BPF_W ? (0xbaadf00dULL << 32) : 0)
8331  
8332  #define BPF_ATOMIC_OP_TEST1(width, op, logic, old, update, result)	\
8333  {									\
8334  	"BPF_ATOMIC | " #width ", " #op ": Test: "			\
8335  		#old " " #logic " " #update " = " #result,		\
8336  	.u.insns_int = {						\
8337  		BPF_LD_IMM64(R5, (update) | BPF_ATOMIC_POISON(width)),	\
8338  		BPF_ST_MEM(width, R10, -40, old),			\
8339  		BPF_ATOMIC_OP(width, op, R10, R5, -40),			\
8340  		BPF_LDX_MEM(width, R0, R10, -40),			\
8341  		BPF_ALU64_REG(BPF_MOV, R1, R0),				\
8342  		BPF_ALU64_IMM(BPF_RSH, R1, 32),				\
8343  		BPF_ALU64_REG(BPF_OR, R0, R1),				\
8344  		BPF_EXIT_INSN(),					\
8345  	},								\
8346  	INTERNAL,							\
8347  	{ },								\
8348  	{ { 0, result } },						\
8349  	.stack_depth = 40,						\
8350  }
8351  #define BPF_ATOMIC_OP_TEST2(width, op, logic, old, update, result)	\
8352  {									\
8353  	"BPF_ATOMIC | " #width ", " #op ": Test side effects, r10: "	\
8354  		#old " " #logic " " #update " = " #result,		\
8355  	.u.insns_int = {						\
8356  		BPF_ALU64_REG(BPF_MOV, R1, R10),			\
8357  		BPF_LD_IMM64(R0, (update) | BPF_ATOMIC_POISON(width)),	\
8358  		BPF_ST_MEM(BPF_W, R10, -40, old),			\
8359  		BPF_ATOMIC_OP(width, op, R10, R0, -40),			\
8360  		BPF_ALU64_REG(BPF_MOV, R0, R10),			\
8361  		BPF_ALU64_REG(BPF_SUB, R0, R1),				\
8362  		BPF_ALU64_REG(BPF_MOV, R1, R0),				\
8363  		BPF_ALU64_IMM(BPF_RSH, R1, 32),				\
8364  		BPF_ALU64_REG(BPF_OR, R0, R1),				\
8365  		BPF_EXIT_INSN(),					\
8366  	},								\
8367  	INTERNAL,							\
8368  	{ },								\
8369  	{ { 0, 0 } },							\
8370  	.stack_depth = 40,						\
8371  }
8372  #define BPF_ATOMIC_OP_TEST3(width, op, logic, old, update, result)	\
8373  {									\
8374  	"BPF_ATOMIC | " #width ", " #op ": Test side effects, r0: "	\
8375  		#old " " #logic " " #update " = " #result,		\
8376  	.u.insns_int = {						\
8377  		BPF_ALU64_REG(BPF_MOV, R0, R10),			\
8378  		BPF_LD_IMM64(R1, (update) | BPF_ATOMIC_POISON(width)),	\
8379  		BPF_ST_MEM(width, R10, -40, old),			\
8380  		BPF_ATOMIC_OP(width, op, R10, R1, -40),			\
8381  		BPF_ALU64_REG(BPF_SUB, R0, R10),			\
8382  		BPF_ALU64_REG(BPF_MOV, R1, R0),				\
8383  		BPF_ALU64_IMM(BPF_RSH, R1, 32),				\
8384  		BPF_ALU64_REG(BPF_OR, R0, R1),				\
8385  		BPF_EXIT_INSN(),					\
8386  	},								\
8387  	INTERNAL,                                                       \
8388  	{ },                                                            \
8389  	{ { 0, 0 } },                                                   \
8390  	.stack_depth = 40,                                              \
8391  }
8392  #define BPF_ATOMIC_OP_TEST4(width, op, logic, old, update, result)	\
8393  {									\
8394  	"BPF_ATOMIC | " #width ", " #op ": Test fetch: "		\
8395  		#old " " #logic " " #update " = " #result,		\
8396  	.u.insns_int = {						\
8397  		BPF_LD_IMM64(R3, (update) | BPF_ATOMIC_POISON(width)),	\
8398  		BPF_ST_MEM(width, R10, -40, old),			\
8399  		BPF_ATOMIC_OP(width, op, R10, R3, -40),			\
8400  		BPF_ALU32_REG(BPF_MOV, R0, R3),                         \
8401  		BPF_EXIT_INSN(),					\
8402  	},								\
8403  	INTERNAL,                                                       \
8404  	{ },                                                            \
8405  	{ { 0, (op) & BPF_FETCH ? old : update } },			\
8406  	.stack_depth = 40,                                              \
8407  }
8408  	/* BPF_ATOMIC | BPF_W: BPF_ADD */
8409  	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
8410  	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
8411  	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
8412  	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
8413  	/* BPF_ATOMIC | BPF_W: BPF_ADD | BPF_FETCH */
8414  	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
8415  	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
8416  	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
8417  	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
8418  	/* BPF_ATOMIC | BPF_DW: BPF_ADD */
8419  	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
8420  	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
8421  	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
8422  	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
8423  	/* BPF_ATOMIC | BPF_DW: BPF_ADD | BPF_FETCH */
8424  	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
8425  	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
8426  	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
8427  	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
8428  	/* BPF_ATOMIC | BPF_W: BPF_AND */
8429  	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
8430  	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
8431  	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
8432  	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
8433  	/* BPF_ATOMIC | BPF_W: BPF_AND | BPF_FETCH */
8434  	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
8435  	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
8436  	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
8437  	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
8438  	/* BPF_ATOMIC | BPF_DW: BPF_AND */
8439  	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
8440  	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
8441  	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
8442  	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
8443  	/* BPF_ATOMIC | BPF_DW: BPF_AND | BPF_FETCH */
8444  	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
8445  	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
8446  	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
8447  	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
8448  	/* BPF_ATOMIC | BPF_W: BPF_OR */
8449  	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
8450  	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
8451  	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
8452  	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
8453  	/* BPF_ATOMIC | BPF_W: BPF_OR | BPF_FETCH */
8454  	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
8455  	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
8456  	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
8457  	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
8458  	/* BPF_ATOMIC | BPF_DW: BPF_OR */
8459  	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
8460  	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
8461  	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
8462  	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
8463  	/* BPF_ATOMIC | BPF_DW: BPF_OR | BPF_FETCH */
8464  	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
8465  	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
8466  	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
8467  	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
8468  	/* BPF_ATOMIC | BPF_W: BPF_XOR */
8469  	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
8470  	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
8471  	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
8472  	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
8473  	/* BPF_ATOMIC | BPF_W: BPF_XOR | BPF_FETCH */
8474  	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
8475  	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
8476  	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
8477  	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
8478  	/* BPF_ATOMIC | BPF_DW: BPF_XOR */
8479  	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
8480  	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
8481  	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
8482  	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
8483  	/* BPF_ATOMIC | BPF_DW: BPF_XOR | BPF_FETCH */
8484  	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
8485  	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
8486  	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
8487  	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
8488  	/* BPF_ATOMIC | BPF_W: BPF_XCHG */
8489  	BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
8490  	BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
8491  	BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
8492  	BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
8493  	/* BPF_ATOMIC | BPF_DW: BPF_XCHG */
8494  	BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
8495  	BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
8496  	BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
8497  	BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
8498  #undef BPF_ATOMIC_POISON
8499  #undef BPF_ATOMIC_OP_TEST1
8500  #undef BPF_ATOMIC_OP_TEST2
8501  #undef BPF_ATOMIC_OP_TEST3
8502  #undef BPF_ATOMIC_OP_TEST4
8503  	/* BPF_ATOMIC | BPF_W, BPF_CMPXCHG */
8504  	{
8505  		"BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test successful return",
8506  		.u.insns_int = {
8507  			BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
8508  			BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
8509  			BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
8510  			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
8511  			BPF_EXIT_INSN(),
8512  		},
8513  		INTERNAL,
8514  		{ },
8515  		{ { 0, 0x01234567 } },
8516  		.stack_depth = 40,
8517  	},
8518  	{
8519  		"BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test successful store",
8520  		.u.insns_int = {
8521  			BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
8522  			BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
8523  			BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
8524  			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
8525  			BPF_LDX_MEM(BPF_W, R0, R10, -40),
8526  			BPF_EXIT_INSN(),
8527  		},
8528  		INTERNAL,
8529  		{ },
8530  		{ { 0, 0x89abcdef } },
8531  		.stack_depth = 40,
8532  	},
8533  	{
8534  		"BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test failure return",
8535  		.u.insns_int = {
8536  			BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
8537  			BPF_ALU32_IMM(BPF_MOV, R0, 0x76543210),
8538  			BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
8539  			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
8540  			BPF_EXIT_INSN(),
8541  		},
8542  		INTERNAL,
8543  		{ },
8544  		{ { 0, 0x01234567 } },
8545  		.stack_depth = 40,
8546  	},
8547  	{
8548  		"BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test failure store",
8549  		.u.insns_int = {
8550  			BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
8551  			BPF_ALU32_IMM(BPF_MOV, R0, 0x76543210),
8552  			BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
8553  			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
8554  			BPF_LDX_MEM(BPF_W, R0, R10, -40),
8555  			BPF_EXIT_INSN(),
8556  		},
8557  		INTERNAL,
8558  		{ },
8559  		{ { 0, 0x01234567 } },
8560  		.stack_depth = 40,
8561  	},
8562  	{
8563  		"BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test side effects",
8564  		.u.insns_int = {
8565  			BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
8566  			BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
8567  			BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
8568  			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
8569  			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
8570  			BPF_ALU32_REG(BPF_MOV, R0, R3),
8571  			BPF_EXIT_INSN(),
8572  		},
8573  		INTERNAL,
8574  		{ },
8575  		{ { 0, 0x89abcdef } },
8576  		.stack_depth = 40,
8577  	},
8578  	/* BPF_ATOMIC | BPF_DW, BPF_CMPXCHG */
8579  	{
8580  		"BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test successful return",
8581  		.u.insns_int = {
8582  			BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
8583  			BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
8584  			BPF_ALU64_REG(BPF_MOV, R0, R1),
8585  			BPF_STX_MEM(BPF_DW, R10, R1, -40),
8586  			BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
8587  			BPF_JMP_REG(BPF_JNE, R0, R1, 1),
8588  			BPF_ALU64_REG(BPF_SUB, R0, R1),
8589  			BPF_EXIT_INSN(),
8590  		},
8591  		INTERNAL,
8592  		{ },
8593  		{ { 0, 0 } },
8594  		.stack_depth = 40,
8595  	},
8596  	{
8597  		"BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test successful store",
8598  		.u.insns_int = {
8599  			BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
8600  			BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
8601  			BPF_ALU64_REG(BPF_MOV, R0, R1),
8602  			BPF_STX_MEM(BPF_DW, R10, R0, -40),
8603  			BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
8604  			BPF_LDX_MEM(BPF_DW, R0, R10, -40),
8605  			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8606  			BPF_ALU64_REG(BPF_SUB, R0, R2),
8607  			BPF_EXIT_INSN(),
8608  		},
8609  		INTERNAL,
8610  		{ },
8611  		{ { 0, 0 } },
8612  		.stack_depth = 40,
8613  	},
8614  	{
8615  		"BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test failure return",
8616  		.u.insns_int = {
8617  			BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
8618  			BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
8619  			BPF_ALU64_REG(BPF_MOV, R0, R1),
8620  			BPF_ALU64_IMM(BPF_ADD, R0, 1),
8621  			BPF_STX_MEM(BPF_DW, R10, R1, -40),
8622  			BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
8623  			BPF_JMP_REG(BPF_JNE, R0, R1, 1),
8624  			BPF_ALU64_REG(BPF_SUB, R0, R1),
8625  			BPF_EXIT_INSN(),
8626  		},
8627  		INTERNAL,
8628  		{ },
8629  		{ { 0, 0 } },
8630  		.stack_depth = 40,
8631  	},
8632  	{
8633  		"BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test failure store",
8634  		.u.insns_int = {
8635  			BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
8636  			BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
8637  			BPF_ALU64_REG(BPF_MOV, R0, R1),
8638  			BPF_ALU64_IMM(BPF_ADD, R0, 1),
8639  			BPF_STX_MEM(BPF_DW, R10, R1, -40),
8640  			BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
8641  			BPF_LDX_MEM(BPF_DW, R0, R10, -40),
8642  			BPF_JMP_REG(BPF_JNE, R0, R1, 1),
8643  			BPF_ALU64_REG(BPF_SUB, R0, R1),
8644  			BPF_EXIT_INSN(),
8645  		},
8646  		INTERNAL,
8647  		{ },
8648  		{ { 0, 0 } },
8649  		.stack_depth = 40,
8650  	},
8651  	{
8652  		"BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test side effects",
8653  		.u.insns_int = {
8654  			BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
8655  			BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
8656  			BPF_ALU64_REG(BPF_MOV, R0, R1),
8657  			BPF_STX_MEM(BPF_DW, R10, R1, -40),
8658  			BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
8659  			BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
8660  			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8661  			BPF_ALU64_REG(BPF_SUB, R0, R2),
8662  			BPF_EXIT_INSN(),
8663  		},
8664  		INTERNAL,
8665  		{ },
8666  		{ { 0, 0 } },
8667  		.stack_depth = 40,
8668  	},
8669  	/* BPF_JMP32 | BPF_JEQ | BPF_K */
8670  	{
8671  		"JMP32_JEQ_K: Small immediate",
8672  		.u.insns_int = {
8673  			BPF_ALU32_IMM(BPF_MOV, R0, 123),
8674  			BPF_JMP32_IMM(BPF_JEQ, R0, 321, 1),
8675  			BPF_JMP32_IMM(BPF_JEQ, R0, 123, 1),
8676  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8677  			BPF_EXIT_INSN(),
8678  		},
8679  		INTERNAL,
8680  		{ },
8681  		{ { 0, 123 } }
8682  	},
8683  	{
8684  		"JMP32_JEQ_K: Large immediate",
8685  		.u.insns_int = {
8686  			BPF_ALU32_IMM(BPF_MOV, R0, 12345678),
8687  			BPF_JMP32_IMM(BPF_JEQ, R0, 12345678 & 0xffff, 1),
8688  			BPF_JMP32_IMM(BPF_JEQ, R0, 12345678, 1),
8689  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8690  			BPF_EXIT_INSN(),
8691  		},
8692  		INTERNAL,
8693  		{ },
8694  		{ { 0, 12345678 } }
8695  	},
8696  	{
8697  		"JMP32_JEQ_K: negative immediate",
8698  		.u.insns_int = {
8699  			BPF_ALU32_IMM(BPF_MOV, R0, -123),
8700  			BPF_JMP32_IMM(BPF_JEQ, R0,  123, 1),
8701  			BPF_JMP32_IMM(BPF_JEQ, R0, -123, 1),
8702  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8703  			BPF_EXIT_INSN(),
8704  		},
8705  		INTERNAL,
8706  		{ },
8707  		{ { 0, -123 } }
8708  	},
8709  	/* BPF_JMP32 | BPF_JEQ | BPF_X */
8710  	{
8711  		"JMP32_JEQ_X",
8712  		.u.insns_int = {
8713  			BPF_ALU32_IMM(BPF_MOV, R0, 1234),
8714  			BPF_ALU32_IMM(BPF_MOV, R1, 4321),
8715  			BPF_JMP32_REG(BPF_JEQ, R0, R1, 2),
8716  			BPF_ALU32_IMM(BPF_MOV, R1, 1234),
8717  			BPF_JMP32_REG(BPF_JEQ, R0, R1, 1),
8718  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8719  			BPF_EXIT_INSN(),
8720  		},
8721  		INTERNAL,
8722  		{ },
8723  		{ { 0, 1234 } }
8724  	},
8725  	/* BPF_JMP32 | BPF_JNE | BPF_K */
8726  	{
8727  		"JMP32_JNE_K: Small immediate",
8728  		.u.insns_int = {
8729  			BPF_ALU32_IMM(BPF_MOV, R0, 123),
8730  			BPF_JMP32_IMM(BPF_JNE, R0, 123, 1),
8731  			BPF_JMP32_IMM(BPF_JNE, R0, 321, 1),
8732  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8733  			BPF_EXIT_INSN(),
8734  		},
8735  		INTERNAL,
8736  		{ },
8737  		{ { 0, 123 } }
8738  	},
8739  	{
8740  		"JMP32_JNE_K: Large immediate",
8741  		.u.insns_int = {
8742  			BPF_ALU32_IMM(BPF_MOV, R0, 12345678),
8743  			BPF_JMP32_IMM(BPF_JNE, R0, 12345678, 1),
8744  			BPF_JMP32_IMM(BPF_JNE, R0, 12345678 & 0xffff, 1),
8745  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8746  			BPF_EXIT_INSN(),
8747  		},
8748  		INTERNAL,
8749  		{ },
8750  		{ { 0, 12345678 } }
8751  	},
8752  	{
8753  		"JMP32_JNE_K: negative immediate",
8754  		.u.insns_int = {
8755  			BPF_ALU32_IMM(BPF_MOV, R0, -123),
8756  			BPF_JMP32_IMM(BPF_JNE, R0, -123, 1),
8757  			BPF_JMP32_IMM(BPF_JNE, R0,  123, 1),
8758  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8759  			BPF_EXIT_INSN(),
8760  		},
8761  		INTERNAL,
8762  		{ },
8763  		{ { 0, -123 } }
8764  	},
8765  	/* BPF_JMP32 | BPF_JNE | BPF_X */
8766  	{
8767  		"JMP32_JNE_X",
8768  		.u.insns_int = {
8769  			BPF_ALU32_IMM(BPF_MOV, R0, 1234),
8770  			BPF_ALU32_IMM(BPF_MOV, R1, 1234),
8771  			BPF_JMP32_REG(BPF_JNE, R0, R1, 2),
8772  			BPF_ALU32_IMM(BPF_MOV, R1, 4321),
8773  			BPF_JMP32_REG(BPF_JNE, R0, R1, 1),
8774  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8775  			BPF_EXIT_INSN(),
8776  		},
8777  		INTERNAL,
8778  		{ },
8779  		{ { 0, 1234 } }
8780  	},
8781  	/* BPF_JMP32 | BPF_JSET | BPF_K */
8782  	{
8783  		"JMP32_JSET_K: Small immediate",
8784  		.u.insns_int = {
8785  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8786  			BPF_JMP32_IMM(BPF_JSET, R0, 2, 1),
8787  			BPF_JMP32_IMM(BPF_JSET, R0, 3, 1),
8788  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8789  			BPF_EXIT_INSN(),
8790  		},
8791  		INTERNAL,
8792  		{ },
8793  		{ { 0, 1 } }
8794  	},
8795  	{
8796  		"JMP32_JSET_K: Large immediate",
8797  		.u.insns_int = {
8798  			BPF_ALU32_IMM(BPF_MOV, R0, 0x40000000),
8799  			BPF_JMP32_IMM(BPF_JSET, R0, 0x3fffffff, 1),
8800  			BPF_JMP32_IMM(BPF_JSET, R0, 0x60000000, 1),
8801  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8802  			BPF_EXIT_INSN(),
8803  		},
8804  		INTERNAL,
8805  		{ },
8806  		{ { 0, 0x40000000 } }
8807  	},
8808  	{
8809  		"JMP32_JSET_K: negative immediate",
8810  		.u.insns_int = {
8811  			BPF_ALU32_IMM(BPF_MOV, R0, -123),
8812  			BPF_JMP32_IMM(BPF_JSET, R0, -1, 1),
8813  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8814  			BPF_EXIT_INSN(),
8815  		},
8816  		INTERNAL,
8817  		{ },
8818  		{ { 0, -123 } }
8819  	},
8820  	/* BPF_JMP32 | BPF_JSET | BPF_X */
8821  	{
8822  		"JMP32_JSET_X",
8823  		.u.insns_int = {
8824  			BPF_ALU32_IMM(BPF_MOV, R0, 8),
8825  			BPF_ALU32_IMM(BPF_MOV, R1, 7),
8826  			BPF_JMP32_REG(BPF_JSET, R0, R1, 2),
8827  			BPF_ALU32_IMM(BPF_MOV, R1, 8 | 2),
8828  			BPF_JMP32_REG(BPF_JNE, R0, R1, 1),
8829  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8830  			BPF_EXIT_INSN(),
8831  		},
8832  		INTERNAL,
8833  		{ },
8834  		{ { 0, 8 } }
8835  	},
8836  	/* BPF_JMP32 | BPF_JGT | BPF_K */
8837  	{
8838  		"JMP32_JGT_K: Small immediate",
8839  		.u.insns_int = {
8840  			BPF_ALU32_IMM(BPF_MOV, R0, 123),
8841  			BPF_JMP32_IMM(BPF_JGT, R0, 123, 1),
8842  			BPF_JMP32_IMM(BPF_JGT, R0, 122, 1),
8843  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8844  			BPF_EXIT_INSN(),
8845  		},
8846  		INTERNAL,
8847  		{ },
8848  		{ { 0, 123 } }
8849  	},
8850  	{
8851  		"JMP32_JGT_K: Large immediate",
8852  		.u.insns_int = {
8853  			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
8854  			BPF_JMP32_IMM(BPF_JGT, R0, 0xffffffff, 1),
8855  			BPF_JMP32_IMM(BPF_JGT, R0, 0xfffffffd, 1),
8856  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8857  			BPF_EXIT_INSN(),
8858  		},
8859  		INTERNAL,
8860  		{ },
8861  		{ { 0, 0xfffffffe } }
8862  	},
8863  	/* BPF_JMP32 | BPF_JGT | BPF_X */
8864  	{
8865  		"JMP32_JGT_X",
8866  		.u.insns_int = {
8867  			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
8868  			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
8869  			BPF_JMP32_REG(BPF_JGT, R0, R1, 2),
8870  			BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
8871  			BPF_JMP32_REG(BPF_JGT, R0, R1, 1),
8872  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8873  			BPF_EXIT_INSN(),
8874  		},
8875  		INTERNAL,
8876  		{ },
8877  		{ { 0, 0xfffffffe } }
8878  	},
8879  	/* BPF_JMP32 | BPF_JGE | BPF_K */
8880  	{
8881  		"JMP32_JGE_K: Small immediate",
8882  		.u.insns_int = {
8883  			BPF_ALU32_IMM(BPF_MOV, R0, 123),
8884  			BPF_JMP32_IMM(BPF_JGE, R0, 124, 1),
8885  			BPF_JMP32_IMM(BPF_JGE, R0, 123, 1),
8886  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8887  			BPF_EXIT_INSN(),
8888  		},
8889  		INTERNAL,
8890  		{ },
8891  		{ { 0, 123 } }
8892  	},
8893  	{
8894  		"JMP32_JGE_K: Large immediate",
8895  		.u.insns_int = {
8896  			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
8897  			BPF_JMP32_IMM(BPF_JGE, R0, 0xffffffff, 1),
8898  			BPF_JMP32_IMM(BPF_JGE, R0, 0xfffffffe, 1),
8899  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8900  			BPF_EXIT_INSN(),
8901  		},
8902  		INTERNAL,
8903  		{ },
8904  		{ { 0, 0xfffffffe } }
8905  	},
8906  	/* BPF_JMP32 | BPF_JGE | BPF_X */
8907  	{
8908  		"JMP32_JGE_X",
8909  		.u.insns_int = {
8910  			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
8911  			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
8912  			BPF_JMP32_REG(BPF_JGE, R0, R1, 2),
8913  			BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffe),
8914  			BPF_JMP32_REG(BPF_JGE, R0, R1, 1),
8915  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8916  			BPF_EXIT_INSN(),
8917  		},
8918  		INTERNAL,
8919  		{ },
8920  		{ { 0, 0xfffffffe } }
8921  	},
8922  	/* BPF_JMP32 | BPF_JLT | BPF_K */
8923  	{
8924  		"JMP32_JLT_K: Small immediate",
8925  		.u.insns_int = {
8926  			BPF_ALU32_IMM(BPF_MOV, R0, 123),
8927  			BPF_JMP32_IMM(BPF_JLT, R0, 123, 1),
8928  			BPF_JMP32_IMM(BPF_JLT, R0, 124, 1),
8929  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8930  			BPF_EXIT_INSN(),
8931  		},
8932  		INTERNAL,
8933  		{ },
8934  		{ { 0, 123 } }
8935  	},
8936  	{
8937  		"JMP32_JLT_K: Large immediate",
8938  		.u.insns_int = {
8939  			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
8940  			BPF_JMP32_IMM(BPF_JLT, R0, 0xfffffffd, 1),
8941  			BPF_JMP32_IMM(BPF_JLT, R0, 0xffffffff, 1),
8942  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8943  			BPF_EXIT_INSN(),
8944  		},
8945  		INTERNAL,
8946  		{ },
8947  		{ { 0, 0xfffffffe } }
8948  	},
8949  	/* BPF_JMP32 | BPF_JLT | BPF_X */
8950  	{
8951  		"JMP32_JLT_X",
8952  		.u.insns_int = {
8953  			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
8954  			BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
8955  			BPF_JMP32_REG(BPF_JLT, R0, R1, 2),
8956  			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
8957  			BPF_JMP32_REG(BPF_JLT, R0, R1, 1),
8958  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8959  			BPF_EXIT_INSN(),
8960  		},
8961  		INTERNAL,
8962  		{ },
8963  		{ { 0, 0xfffffffe } }
8964  	},
8965  	/* BPF_JMP32 | BPF_JLE | BPF_K */
8966  	{
8967  		"JMP32_JLE_K: Small immediate",
8968  		.u.insns_int = {
8969  			BPF_ALU32_IMM(BPF_MOV, R0, 123),
8970  			BPF_JMP32_IMM(BPF_JLE, R0, 122, 1),
8971  			BPF_JMP32_IMM(BPF_JLE, R0, 123, 1),
8972  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8973  			BPF_EXIT_INSN(),
8974  		},
8975  		INTERNAL,
8976  		{ },
8977  		{ { 0, 123 } }
8978  	},
8979  	{
8980  		"JMP32_JLE_K: Large immediate",
8981  		.u.insns_int = {
8982  			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
8983  			BPF_JMP32_IMM(BPF_JLE, R0, 0xfffffffd, 1),
8984  			BPF_JMP32_IMM(BPF_JLE, R0, 0xfffffffe, 1),
8985  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
8986  			BPF_EXIT_INSN(),
8987  		},
8988  		INTERNAL,
8989  		{ },
8990  		{ { 0, 0xfffffffe } }
8991  	},
8992  	/* BPF_JMP32 | BPF_JLE | BPF_X */
8993  	{
8994  		"JMP32_JLE_X",
8995  		.u.insns_int = {
8996  			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
8997  			BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
8998  			BPF_JMP32_REG(BPF_JLE, R0, R1, 2),
8999  			BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffe),
9000  			BPF_JMP32_REG(BPF_JLE, R0, R1, 1),
9001  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9002  			BPF_EXIT_INSN(),
9003  		},
9004  		INTERNAL,
9005  		{ },
9006  		{ { 0, 0xfffffffe } }
9007  	},
9008  	/* BPF_JMP32 | BPF_JSGT | BPF_K */
9009  	{
9010  		"JMP32_JSGT_K: Small immediate",
9011  		.u.insns_int = {
9012  			BPF_ALU32_IMM(BPF_MOV, R0, -123),
9013  			BPF_JMP32_IMM(BPF_JSGT, R0, -123, 1),
9014  			BPF_JMP32_IMM(BPF_JSGT, R0, -124, 1),
9015  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9016  			BPF_EXIT_INSN(),
9017  		},
9018  		INTERNAL,
9019  		{ },
9020  		{ { 0, -123 } }
9021  	},
9022  	{
9023  		"JMP32_JSGT_K: Large immediate",
9024  		.u.insns_int = {
9025  			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9026  			BPF_JMP32_IMM(BPF_JSGT, R0, -12345678, 1),
9027  			BPF_JMP32_IMM(BPF_JSGT, R0, -12345679, 1),
9028  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9029  			BPF_EXIT_INSN(),
9030  		},
9031  		INTERNAL,
9032  		{ },
9033  		{ { 0, -12345678 } }
9034  	},
9035  	/* BPF_JMP32 | BPF_JSGT | BPF_X */
9036  	{
9037  		"JMP32_JSGT_X",
9038  		.u.insns_int = {
9039  			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9040  			BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
9041  			BPF_JMP32_REG(BPF_JSGT, R0, R1, 2),
9042  			BPF_ALU32_IMM(BPF_MOV, R1, -12345679),
9043  			BPF_JMP32_REG(BPF_JSGT, R0, R1, 1),
9044  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9045  			BPF_EXIT_INSN(),
9046  		},
9047  		INTERNAL,
9048  		{ },
9049  		{ { 0, -12345678 } }
9050  	},
9051  	/* BPF_JMP32 | BPF_JSGE | BPF_K */
9052  	{
9053  		"JMP32_JSGE_K: Small immediate",
9054  		.u.insns_int = {
9055  			BPF_ALU32_IMM(BPF_MOV, R0, -123),
9056  			BPF_JMP32_IMM(BPF_JSGE, R0, -122, 1),
9057  			BPF_JMP32_IMM(BPF_JSGE, R0, -123, 1),
9058  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9059  			BPF_EXIT_INSN(),
9060  		},
9061  		INTERNAL,
9062  		{ },
9063  		{ { 0, -123 } }
9064  	},
9065  	{
9066  		"JMP32_JSGE_K: Large immediate",
9067  		.u.insns_int = {
9068  			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9069  			BPF_JMP32_IMM(BPF_JSGE, R0, -12345677, 1),
9070  			BPF_JMP32_IMM(BPF_JSGE, R0, -12345678, 1),
9071  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9072  			BPF_EXIT_INSN(),
9073  		},
9074  		INTERNAL,
9075  		{ },
9076  		{ { 0, -12345678 } }
9077  	},
9078  	/* BPF_JMP32 | BPF_JSGE | BPF_X */
9079  	{
9080  		"JMP32_JSGE_X",
9081  		.u.insns_int = {
9082  			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9083  			BPF_ALU32_IMM(BPF_MOV, R1, -12345677),
9084  			BPF_JMP32_REG(BPF_JSGE, R0, R1, 2),
9085  			BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
9086  			BPF_JMP32_REG(BPF_JSGE, R0, R1, 1),
9087  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9088  			BPF_EXIT_INSN(),
9089  		},
9090  		INTERNAL,
9091  		{ },
9092  		{ { 0, -12345678 } }
9093  	},
9094  	/* BPF_JMP32 | BPF_JSLT | BPF_K */
9095  	{
9096  		"JMP32_JSLT_K: Small immediate",
9097  		.u.insns_int = {
9098  			BPF_ALU32_IMM(BPF_MOV, R0, -123),
9099  			BPF_JMP32_IMM(BPF_JSLT, R0, -123, 1),
9100  			BPF_JMP32_IMM(BPF_JSLT, R0, -122, 1),
9101  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9102  			BPF_EXIT_INSN(),
9103  		},
9104  		INTERNAL,
9105  		{ },
9106  		{ { 0, -123 } }
9107  	},
9108  	{
9109  		"JMP32_JSLT_K: Large immediate",
9110  		.u.insns_int = {
9111  			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9112  			BPF_JMP32_IMM(BPF_JSLT, R0, -12345678, 1),
9113  			BPF_JMP32_IMM(BPF_JSLT, R0, -12345677, 1),
9114  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9115  			BPF_EXIT_INSN(),
9116  		},
9117  		INTERNAL,
9118  		{ },
9119  		{ { 0, -12345678 } }
9120  	},
9121  	/* BPF_JMP32 | BPF_JSLT | BPF_X */
9122  	{
9123  		"JMP32_JSLT_X",
9124  		.u.insns_int = {
9125  			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9126  			BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
9127  			BPF_JMP32_REG(BPF_JSLT, R0, R1, 2),
9128  			BPF_ALU32_IMM(BPF_MOV, R1, -12345677),
9129  			BPF_JMP32_REG(BPF_JSLT, R0, R1, 1),
9130  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9131  			BPF_EXIT_INSN(),
9132  		},
9133  		INTERNAL,
9134  		{ },
9135  		{ { 0, -12345678 } }
9136  	},
9137  	/* BPF_JMP32 | BPF_JSLE | BPF_K */
9138  	{
9139  		"JMP32_JSLE_K: Small immediate",
9140  		.u.insns_int = {
9141  			BPF_ALU32_IMM(BPF_MOV, R0, -123),
9142  			BPF_JMP32_IMM(BPF_JSLE, R0, -124, 1),
9143  			BPF_JMP32_IMM(BPF_JSLE, R0, -123, 1),
9144  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9145  			BPF_EXIT_INSN(),
9146  		},
9147  		INTERNAL,
9148  		{ },
9149  		{ { 0, -123 } }
9150  	},
9151  	{
9152  		"JMP32_JSLE_K: Large immediate",
9153  		.u.insns_int = {
9154  			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9155  			BPF_JMP32_IMM(BPF_JSLE, R0, -12345679, 1),
9156  			BPF_JMP32_IMM(BPF_JSLE, R0, -12345678, 1),
9157  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9158  			BPF_EXIT_INSN(),
9159  		},
9160  		INTERNAL,
9161  		{ },
9162  		{ { 0, -12345678 } }
9163  	},
9164  	/* BPF_JMP32 | BPF_JSLE | BPF_K */
9165  	{
9166  		"JMP32_JSLE_X",
9167  		.u.insns_int = {
9168  			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9169  			BPF_ALU32_IMM(BPF_MOV, R1, -12345679),
9170  			BPF_JMP32_REG(BPF_JSLE, R0, R1, 2),
9171  			BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
9172  			BPF_JMP32_REG(BPF_JSLE, R0, R1, 1),
9173  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9174  			BPF_EXIT_INSN(),
9175  		},
9176  		INTERNAL,
9177  		{ },
9178  		{ { 0, -12345678 } }
9179  	},
9180  	/* BPF_JMP | BPF_EXIT */
9181  	{
9182  		"JMP_EXIT",
9183  		.u.insns_int = {
9184  			BPF_ALU32_IMM(BPF_MOV, R0, 0x4711),
9185  			BPF_EXIT_INSN(),
9186  			BPF_ALU32_IMM(BPF_MOV, R0, 0x4712),
9187  		},
9188  		INTERNAL,
9189  		{ },
9190  		{ { 0, 0x4711 } },
9191  	},
9192  	/* BPF_JMP | BPF_JA */
9193  	{
9194  		"JMP_JA: Unconditional jump: if (true) return 1",
9195  		.u.insns_int = {
9196  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9197  			BPF_JMP_IMM(BPF_JA, 0, 0, 1),
9198  			BPF_EXIT_INSN(),
9199  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9200  			BPF_EXIT_INSN(),
9201  		},
9202  		INTERNAL,
9203  		{ },
9204  		{ { 0, 1 } },
9205  	},
9206  	/* BPF_JMP | BPF_JSLT | BPF_K */
9207  	{
9208  		"JMP_JSLT_K: Signed jump: if (-2 < -1) return 1",
9209  		.u.insns_int = {
9210  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9211  			BPF_LD_IMM64(R1, 0xfffffffffffffffeLL),
9212  			BPF_JMP_IMM(BPF_JSLT, R1, -1, 1),
9213  			BPF_EXIT_INSN(),
9214  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9215  			BPF_EXIT_INSN(),
9216  		},
9217  		INTERNAL,
9218  		{ },
9219  		{ { 0, 1 } },
9220  	},
9221  	{
9222  		"JMP_JSLT_K: Signed jump: if (-1 < -1) return 0",
9223  		.u.insns_int = {
9224  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9225  			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9226  			BPF_JMP_IMM(BPF_JSLT, R1, -1, 1),
9227  			BPF_EXIT_INSN(),
9228  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9229  			BPF_EXIT_INSN(),
9230  		},
9231  		INTERNAL,
9232  		{ },
9233  		{ { 0, 1 } },
9234  	},
9235  	/* BPF_JMP | BPF_JSGT | BPF_K */
9236  	{
9237  		"JMP_JSGT_K: Signed jump: if (-1 > -2) return 1",
9238  		.u.insns_int = {
9239  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9240  			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9241  			BPF_JMP_IMM(BPF_JSGT, R1, -2, 1),
9242  			BPF_EXIT_INSN(),
9243  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9244  			BPF_EXIT_INSN(),
9245  		},
9246  		INTERNAL,
9247  		{ },
9248  		{ { 0, 1 } },
9249  	},
9250  	{
9251  		"JMP_JSGT_K: Signed jump: if (-1 > -1) return 0",
9252  		.u.insns_int = {
9253  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9254  			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9255  			BPF_JMP_IMM(BPF_JSGT, R1, -1, 1),
9256  			BPF_EXIT_INSN(),
9257  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9258  			BPF_EXIT_INSN(),
9259  		},
9260  		INTERNAL,
9261  		{ },
9262  		{ { 0, 1 } },
9263  	},
9264  	/* BPF_JMP | BPF_JSLE | BPF_K */
9265  	{
9266  		"JMP_JSLE_K: Signed jump: if (-2 <= -1) return 1",
9267  		.u.insns_int = {
9268  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9269  			BPF_LD_IMM64(R1, 0xfffffffffffffffeLL),
9270  			BPF_JMP_IMM(BPF_JSLE, R1, -1, 1),
9271  			BPF_EXIT_INSN(),
9272  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9273  			BPF_EXIT_INSN(),
9274  		},
9275  		INTERNAL,
9276  		{ },
9277  		{ { 0, 1 } },
9278  	},
9279  	{
9280  		"JMP_JSLE_K: Signed jump: if (-1 <= -1) return 1",
9281  		.u.insns_int = {
9282  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9283  			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9284  			BPF_JMP_IMM(BPF_JSLE, R1, -1, 1),
9285  			BPF_EXIT_INSN(),
9286  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9287  			BPF_EXIT_INSN(),
9288  		},
9289  		INTERNAL,
9290  		{ },
9291  		{ { 0, 1 } },
9292  	},
9293  	{
9294  		"JMP_JSLE_K: Signed jump: value walk 1",
9295  		.u.insns_int = {
9296  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9297  			BPF_LD_IMM64(R1, 3),
9298  			BPF_JMP_IMM(BPF_JSLE, R1, 0, 6),
9299  			BPF_ALU64_IMM(BPF_SUB, R1, 1),
9300  			BPF_JMP_IMM(BPF_JSLE, R1, 0, 4),
9301  			BPF_ALU64_IMM(BPF_SUB, R1, 1),
9302  			BPF_JMP_IMM(BPF_JSLE, R1, 0, 2),
9303  			BPF_ALU64_IMM(BPF_SUB, R1, 1),
9304  			BPF_JMP_IMM(BPF_JSLE, R1, 0, 1),
9305  			BPF_EXIT_INSN(),		/* bad exit */
9306  			BPF_ALU32_IMM(BPF_MOV, R0, 1),	/* good exit */
9307  			BPF_EXIT_INSN(),
9308  		},
9309  		INTERNAL,
9310  		{ },
9311  		{ { 0, 1 } },
9312  	},
9313  	{
9314  		"JMP_JSLE_K: Signed jump: value walk 2",
9315  		.u.insns_int = {
9316  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9317  			BPF_LD_IMM64(R1, 3),
9318  			BPF_JMP_IMM(BPF_JSLE, R1, 0, 4),
9319  			BPF_ALU64_IMM(BPF_SUB, R1, 2),
9320  			BPF_JMP_IMM(BPF_JSLE, R1, 0, 2),
9321  			BPF_ALU64_IMM(BPF_SUB, R1, 2),
9322  			BPF_JMP_IMM(BPF_JSLE, R1, 0, 1),
9323  			BPF_EXIT_INSN(),		/* bad exit */
9324  			BPF_ALU32_IMM(BPF_MOV, R0, 1),	/* good exit */
9325  			BPF_EXIT_INSN(),
9326  		},
9327  		INTERNAL,
9328  		{ },
9329  		{ { 0, 1 } },
9330  	},
9331  	/* BPF_JMP | BPF_JSGE | BPF_K */
9332  	{
9333  		"JMP_JSGE_K: Signed jump: if (-1 >= -2) return 1",
9334  		.u.insns_int = {
9335  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9336  			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9337  			BPF_JMP_IMM(BPF_JSGE, R1, -2, 1),
9338  			BPF_EXIT_INSN(),
9339  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9340  			BPF_EXIT_INSN(),
9341  		},
9342  		INTERNAL,
9343  		{ },
9344  		{ { 0, 1 } },
9345  	},
9346  	{
9347  		"JMP_JSGE_K: Signed jump: if (-1 >= -1) return 1",
9348  		.u.insns_int = {
9349  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9350  			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9351  			BPF_JMP_IMM(BPF_JSGE, R1, -1, 1),
9352  			BPF_EXIT_INSN(),
9353  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9354  			BPF_EXIT_INSN(),
9355  		},
9356  		INTERNAL,
9357  		{ },
9358  		{ { 0, 1 } },
9359  	},
9360  	{
9361  		"JMP_JSGE_K: Signed jump: value walk 1",
9362  		.u.insns_int = {
9363  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9364  			BPF_LD_IMM64(R1, -3),
9365  			BPF_JMP_IMM(BPF_JSGE, R1, 0, 6),
9366  			BPF_ALU64_IMM(BPF_ADD, R1, 1),
9367  			BPF_JMP_IMM(BPF_JSGE, R1, 0, 4),
9368  			BPF_ALU64_IMM(BPF_ADD, R1, 1),
9369  			BPF_JMP_IMM(BPF_JSGE, R1, 0, 2),
9370  			BPF_ALU64_IMM(BPF_ADD, R1, 1),
9371  			BPF_JMP_IMM(BPF_JSGE, R1, 0, 1),
9372  			BPF_EXIT_INSN(),		/* bad exit */
9373  			BPF_ALU32_IMM(BPF_MOV, R0, 1),	/* good exit */
9374  			BPF_EXIT_INSN(),
9375  		},
9376  		INTERNAL,
9377  		{ },
9378  		{ { 0, 1 } },
9379  	},
9380  	{
9381  		"JMP_JSGE_K: Signed jump: value walk 2",
9382  		.u.insns_int = {
9383  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9384  			BPF_LD_IMM64(R1, -3),
9385  			BPF_JMP_IMM(BPF_JSGE, R1, 0, 4),
9386  			BPF_ALU64_IMM(BPF_ADD, R1, 2),
9387  			BPF_JMP_IMM(BPF_JSGE, R1, 0, 2),
9388  			BPF_ALU64_IMM(BPF_ADD, R1, 2),
9389  			BPF_JMP_IMM(BPF_JSGE, R1, 0, 1),
9390  			BPF_EXIT_INSN(),		/* bad exit */
9391  			BPF_ALU32_IMM(BPF_MOV, R0, 1),	/* good exit */
9392  			BPF_EXIT_INSN(),
9393  		},
9394  		INTERNAL,
9395  		{ },
9396  		{ { 0, 1 } },
9397  	},
9398  	/* BPF_JMP | BPF_JGT | BPF_K */
9399  	{
9400  		"JMP_JGT_K: if (3 > 2) return 1",
9401  		.u.insns_int = {
9402  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9403  			BPF_LD_IMM64(R1, 3),
9404  			BPF_JMP_IMM(BPF_JGT, R1, 2, 1),
9405  			BPF_EXIT_INSN(),
9406  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9407  			BPF_EXIT_INSN(),
9408  		},
9409  		INTERNAL,
9410  		{ },
9411  		{ { 0, 1 } },
9412  	},
9413  	{
9414  		"JMP_JGT_K: Unsigned jump: if (-1 > 1) return 1",
9415  		.u.insns_int = {
9416  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9417  			BPF_LD_IMM64(R1, -1),
9418  			BPF_JMP_IMM(BPF_JGT, R1, 1, 1),
9419  			BPF_EXIT_INSN(),
9420  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9421  			BPF_EXIT_INSN(),
9422  		},
9423  		INTERNAL,
9424  		{ },
9425  		{ { 0, 1 } },
9426  	},
9427  	/* BPF_JMP | BPF_JLT | BPF_K */
9428  	{
9429  		"JMP_JLT_K: if (2 < 3) return 1",
9430  		.u.insns_int = {
9431  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9432  			BPF_LD_IMM64(R1, 2),
9433  			BPF_JMP_IMM(BPF_JLT, R1, 3, 1),
9434  			BPF_EXIT_INSN(),
9435  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9436  			BPF_EXIT_INSN(),
9437  		},
9438  		INTERNAL,
9439  		{ },
9440  		{ { 0, 1 } },
9441  	},
9442  	{
9443  		"JMP_JGT_K: Unsigned jump: if (1 < -1) return 1",
9444  		.u.insns_int = {
9445  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9446  			BPF_LD_IMM64(R1, 1),
9447  			BPF_JMP_IMM(BPF_JLT, R1, -1, 1),
9448  			BPF_EXIT_INSN(),
9449  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9450  			BPF_EXIT_INSN(),
9451  		},
9452  		INTERNAL,
9453  		{ },
9454  		{ { 0, 1 } },
9455  	},
9456  	/* BPF_JMP | BPF_JGE | BPF_K */
9457  	{
9458  		"JMP_JGE_K: if (3 >= 2) return 1",
9459  		.u.insns_int = {
9460  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9461  			BPF_LD_IMM64(R1, 3),
9462  			BPF_JMP_IMM(BPF_JGE, R1, 2, 1),
9463  			BPF_EXIT_INSN(),
9464  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9465  			BPF_EXIT_INSN(),
9466  		},
9467  		INTERNAL,
9468  		{ },
9469  		{ { 0, 1 } },
9470  	},
9471  	/* BPF_JMP | BPF_JLE | BPF_K */
9472  	{
9473  		"JMP_JLE_K: if (2 <= 3) return 1",
9474  		.u.insns_int = {
9475  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9476  			BPF_LD_IMM64(R1, 2),
9477  			BPF_JMP_IMM(BPF_JLE, R1, 3, 1),
9478  			BPF_EXIT_INSN(),
9479  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9480  			BPF_EXIT_INSN(),
9481  		},
9482  		INTERNAL,
9483  		{ },
9484  		{ { 0, 1 } },
9485  	},
9486  	/* BPF_JMP | BPF_JGT | BPF_K jump backwards */
9487  	{
9488  		"JMP_JGT_K: if (3 > 2) return 1 (jump backwards)",
9489  		.u.insns_int = {
9490  			BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
9491  			BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */
9492  			BPF_EXIT_INSN(),
9493  			BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
9494  			BPF_LD_IMM64(R1, 3), /* note: this takes 2 insns */
9495  			BPF_JMP_IMM(BPF_JGT, R1, 2, -6), /* goto out */
9496  			BPF_EXIT_INSN(),
9497  		},
9498  		INTERNAL,
9499  		{ },
9500  		{ { 0, 1 } },
9501  	},
9502  	{
9503  		"JMP_JGE_K: if (3 >= 3) return 1",
9504  		.u.insns_int = {
9505  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9506  			BPF_LD_IMM64(R1, 3),
9507  			BPF_JMP_IMM(BPF_JGE, R1, 3, 1),
9508  			BPF_EXIT_INSN(),
9509  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9510  			BPF_EXIT_INSN(),
9511  		},
9512  		INTERNAL,
9513  		{ },
9514  		{ { 0, 1 } },
9515  	},
9516  	/* BPF_JMP | BPF_JLT | BPF_K jump backwards */
9517  	{
9518  		"JMP_JGT_K: if (2 < 3) return 1 (jump backwards)",
9519  		.u.insns_int = {
9520  			BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
9521  			BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */
9522  			BPF_EXIT_INSN(),
9523  			BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
9524  			BPF_LD_IMM64(R1, 2), /* note: this takes 2 insns */
9525  			BPF_JMP_IMM(BPF_JLT, R1, 3, -6), /* goto out */
9526  			BPF_EXIT_INSN(),
9527  		},
9528  		INTERNAL,
9529  		{ },
9530  		{ { 0, 1 } },
9531  	},
9532  	{
9533  		"JMP_JLE_K: if (3 <= 3) return 1",
9534  		.u.insns_int = {
9535  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9536  			BPF_LD_IMM64(R1, 3),
9537  			BPF_JMP_IMM(BPF_JLE, R1, 3, 1),
9538  			BPF_EXIT_INSN(),
9539  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9540  			BPF_EXIT_INSN(),
9541  		},
9542  		INTERNAL,
9543  		{ },
9544  		{ { 0, 1 } },
9545  	},
9546  	/* BPF_JMP | BPF_JNE | BPF_K */
9547  	{
9548  		"JMP_JNE_K: if (3 != 2) return 1",
9549  		.u.insns_int = {
9550  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9551  			BPF_LD_IMM64(R1, 3),
9552  			BPF_JMP_IMM(BPF_JNE, R1, 2, 1),
9553  			BPF_EXIT_INSN(),
9554  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9555  			BPF_EXIT_INSN(),
9556  		},
9557  		INTERNAL,
9558  		{ },
9559  		{ { 0, 1 } },
9560  	},
9561  	/* BPF_JMP | BPF_JEQ | BPF_K */
9562  	{
9563  		"JMP_JEQ_K: if (3 == 3) return 1",
9564  		.u.insns_int = {
9565  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9566  			BPF_LD_IMM64(R1, 3),
9567  			BPF_JMP_IMM(BPF_JEQ, R1, 3, 1),
9568  			BPF_EXIT_INSN(),
9569  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9570  			BPF_EXIT_INSN(),
9571  		},
9572  		INTERNAL,
9573  		{ },
9574  		{ { 0, 1 } },
9575  	},
9576  	/* BPF_JMP | BPF_JSET | BPF_K */
9577  	{
9578  		"JMP_JSET_K: if (0x3 & 0x2) return 1",
9579  		.u.insns_int = {
9580  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9581  			BPF_LD_IMM64(R1, 3),
9582  			BPF_JMP_IMM(BPF_JSET, R1, 2, 1),
9583  			BPF_EXIT_INSN(),
9584  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9585  			BPF_EXIT_INSN(),
9586  		},
9587  		INTERNAL,
9588  		{ },
9589  		{ { 0, 1 } },
9590  	},
9591  	{
9592  		"JMP_JSET_K: if (0x3 & 0xffffffff) return 1",
9593  		.u.insns_int = {
9594  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9595  			BPF_LD_IMM64(R1, 3),
9596  			BPF_JMP_IMM(BPF_JSET, R1, 0xffffffff, 1),
9597  			BPF_EXIT_INSN(),
9598  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9599  			BPF_EXIT_INSN(),
9600  		},
9601  		INTERNAL,
9602  		{ },
9603  		{ { 0, 1 } },
9604  	},
9605  	/* BPF_JMP | BPF_JSGT | BPF_X */
9606  	{
9607  		"JMP_JSGT_X: Signed jump: if (-1 > -2) return 1",
9608  		.u.insns_int = {
9609  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9610  			BPF_LD_IMM64(R1, -1),
9611  			BPF_LD_IMM64(R2, -2),
9612  			BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
9613  			BPF_EXIT_INSN(),
9614  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9615  			BPF_EXIT_INSN(),
9616  		},
9617  		INTERNAL,
9618  		{ },
9619  		{ { 0, 1 } },
9620  	},
9621  	{
9622  		"JMP_JSGT_X: Signed jump: if (-1 > -1) return 0",
9623  		.u.insns_int = {
9624  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9625  			BPF_LD_IMM64(R1, -1),
9626  			BPF_LD_IMM64(R2, -1),
9627  			BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
9628  			BPF_EXIT_INSN(),
9629  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9630  			BPF_EXIT_INSN(),
9631  		},
9632  		INTERNAL,
9633  		{ },
9634  		{ { 0, 1 } },
9635  	},
9636  	/* BPF_JMP | BPF_JSLT | BPF_X */
9637  	{
9638  		"JMP_JSLT_X: Signed jump: if (-2 < -1) return 1",
9639  		.u.insns_int = {
9640  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9641  			BPF_LD_IMM64(R1, -1),
9642  			BPF_LD_IMM64(R2, -2),
9643  			BPF_JMP_REG(BPF_JSLT, R2, R1, 1),
9644  			BPF_EXIT_INSN(),
9645  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9646  			BPF_EXIT_INSN(),
9647  		},
9648  		INTERNAL,
9649  		{ },
9650  		{ { 0, 1 } },
9651  	},
9652  	{
9653  		"JMP_JSLT_X: Signed jump: if (-1 < -1) return 0",
9654  		.u.insns_int = {
9655  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9656  			BPF_LD_IMM64(R1, -1),
9657  			BPF_LD_IMM64(R2, -1),
9658  			BPF_JMP_REG(BPF_JSLT, R1, R2, 1),
9659  			BPF_EXIT_INSN(),
9660  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9661  			BPF_EXIT_INSN(),
9662  		},
9663  		INTERNAL,
9664  		{ },
9665  		{ { 0, 1 } },
9666  	},
9667  	/* BPF_JMP | BPF_JSGE | BPF_X */
9668  	{
9669  		"JMP_JSGE_X: Signed jump: if (-1 >= -2) return 1",
9670  		.u.insns_int = {
9671  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9672  			BPF_LD_IMM64(R1, -1),
9673  			BPF_LD_IMM64(R2, -2),
9674  			BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
9675  			BPF_EXIT_INSN(),
9676  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9677  			BPF_EXIT_INSN(),
9678  		},
9679  		INTERNAL,
9680  		{ },
9681  		{ { 0, 1 } },
9682  	},
9683  	{
9684  		"JMP_JSGE_X: Signed jump: if (-1 >= -1) return 1",
9685  		.u.insns_int = {
9686  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9687  			BPF_LD_IMM64(R1, -1),
9688  			BPF_LD_IMM64(R2, -1),
9689  			BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
9690  			BPF_EXIT_INSN(),
9691  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9692  			BPF_EXIT_INSN(),
9693  		},
9694  		INTERNAL,
9695  		{ },
9696  		{ { 0, 1 } },
9697  	},
9698  	/* BPF_JMP | BPF_JSLE | BPF_X */
9699  	{
9700  		"JMP_JSLE_X: Signed jump: if (-2 <= -1) return 1",
9701  		.u.insns_int = {
9702  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9703  			BPF_LD_IMM64(R1, -1),
9704  			BPF_LD_IMM64(R2, -2),
9705  			BPF_JMP_REG(BPF_JSLE, R2, R1, 1),
9706  			BPF_EXIT_INSN(),
9707  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9708  			BPF_EXIT_INSN(),
9709  		},
9710  		INTERNAL,
9711  		{ },
9712  		{ { 0, 1 } },
9713  	},
9714  	{
9715  		"JMP_JSLE_X: Signed jump: if (-1 <= -1) return 1",
9716  		.u.insns_int = {
9717  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9718  			BPF_LD_IMM64(R1, -1),
9719  			BPF_LD_IMM64(R2, -1),
9720  			BPF_JMP_REG(BPF_JSLE, R1, R2, 1),
9721  			BPF_EXIT_INSN(),
9722  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9723  			BPF_EXIT_INSN(),
9724  		},
9725  		INTERNAL,
9726  		{ },
9727  		{ { 0, 1 } },
9728  	},
9729  	/* BPF_JMP | BPF_JGT | BPF_X */
9730  	{
9731  		"JMP_JGT_X: if (3 > 2) return 1",
9732  		.u.insns_int = {
9733  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9734  			BPF_LD_IMM64(R1, 3),
9735  			BPF_LD_IMM64(R2, 2),
9736  			BPF_JMP_REG(BPF_JGT, R1, R2, 1),
9737  			BPF_EXIT_INSN(),
9738  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9739  			BPF_EXIT_INSN(),
9740  		},
9741  		INTERNAL,
9742  		{ },
9743  		{ { 0, 1 } },
9744  	},
9745  	{
9746  		"JMP_JGT_X: Unsigned jump: if (-1 > 1) return 1",
9747  		.u.insns_int = {
9748  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9749  			BPF_LD_IMM64(R1, -1),
9750  			BPF_LD_IMM64(R2, 1),
9751  			BPF_JMP_REG(BPF_JGT, R1, R2, 1),
9752  			BPF_EXIT_INSN(),
9753  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9754  			BPF_EXIT_INSN(),
9755  		},
9756  		INTERNAL,
9757  		{ },
9758  		{ { 0, 1 } },
9759  	},
9760  	/* BPF_JMP | BPF_JLT | BPF_X */
9761  	{
9762  		"JMP_JLT_X: if (2 < 3) return 1",
9763  		.u.insns_int = {
9764  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9765  			BPF_LD_IMM64(R1, 3),
9766  			BPF_LD_IMM64(R2, 2),
9767  			BPF_JMP_REG(BPF_JLT, R2, R1, 1),
9768  			BPF_EXIT_INSN(),
9769  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9770  			BPF_EXIT_INSN(),
9771  		},
9772  		INTERNAL,
9773  		{ },
9774  		{ { 0, 1 } },
9775  	},
9776  	{
9777  		"JMP_JLT_X: Unsigned jump: if (1 < -1) return 1",
9778  		.u.insns_int = {
9779  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9780  			BPF_LD_IMM64(R1, -1),
9781  			BPF_LD_IMM64(R2, 1),
9782  			BPF_JMP_REG(BPF_JLT, R2, R1, 1),
9783  			BPF_EXIT_INSN(),
9784  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9785  			BPF_EXIT_INSN(),
9786  		},
9787  		INTERNAL,
9788  		{ },
9789  		{ { 0, 1 } },
9790  	},
9791  	/* BPF_JMP | BPF_JGE | BPF_X */
9792  	{
9793  		"JMP_JGE_X: if (3 >= 2) return 1",
9794  		.u.insns_int = {
9795  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9796  			BPF_LD_IMM64(R1, 3),
9797  			BPF_LD_IMM64(R2, 2),
9798  			BPF_JMP_REG(BPF_JGE, R1, R2, 1),
9799  			BPF_EXIT_INSN(),
9800  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9801  			BPF_EXIT_INSN(),
9802  		},
9803  		INTERNAL,
9804  		{ },
9805  		{ { 0, 1 } },
9806  	},
9807  	{
9808  		"JMP_JGE_X: if (3 >= 3) return 1",
9809  		.u.insns_int = {
9810  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9811  			BPF_LD_IMM64(R1, 3),
9812  			BPF_LD_IMM64(R2, 3),
9813  			BPF_JMP_REG(BPF_JGE, R1, R2, 1),
9814  			BPF_EXIT_INSN(),
9815  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9816  			BPF_EXIT_INSN(),
9817  		},
9818  		INTERNAL,
9819  		{ },
9820  		{ { 0, 1 } },
9821  	},
9822  	/* BPF_JMP | BPF_JLE | BPF_X */
9823  	{
9824  		"JMP_JLE_X: if (2 <= 3) return 1",
9825  		.u.insns_int = {
9826  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9827  			BPF_LD_IMM64(R1, 3),
9828  			BPF_LD_IMM64(R2, 2),
9829  			BPF_JMP_REG(BPF_JLE, R2, R1, 1),
9830  			BPF_EXIT_INSN(),
9831  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9832  			BPF_EXIT_INSN(),
9833  		},
9834  		INTERNAL,
9835  		{ },
9836  		{ { 0, 1 } },
9837  	},
9838  	{
9839  		"JMP_JLE_X: if (3 <= 3) return 1",
9840  		.u.insns_int = {
9841  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9842  			BPF_LD_IMM64(R1, 3),
9843  			BPF_LD_IMM64(R2, 3),
9844  			BPF_JMP_REG(BPF_JLE, R1, R2, 1),
9845  			BPF_EXIT_INSN(),
9846  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9847  			BPF_EXIT_INSN(),
9848  		},
9849  		INTERNAL,
9850  		{ },
9851  		{ { 0, 1 } },
9852  	},
9853  	{
9854  		/* Mainly testing JIT + imm64 here. */
9855  		"JMP_JGE_X: ldimm64 test 1",
9856  		.u.insns_int = {
9857  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9858  			BPF_LD_IMM64(R1, 3),
9859  			BPF_LD_IMM64(R2, 2),
9860  			BPF_JMP_REG(BPF_JGE, R1, R2, 2),
9861  			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
9862  			BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
9863  			BPF_EXIT_INSN(),
9864  		},
9865  		INTERNAL,
9866  		{ },
9867  		{ { 0, 0xeeeeeeeeU } },
9868  	},
9869  	{
9870  		"JMP_JGE_X: ldimm64 test 2",
9871  		.u.insns_int = {
9872  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9873  			BPF_LD_IMM64(R1, 3),
9874  			BPF_LD_IMM64(R2, 2),
9875  			BPF_JMP_REG(BPF_JGE, R1, R2, 0),
9876  			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
9877  			BPF_EXIT_INSN(),
9878  		},
9879  		INTERNAL,
9880  		{ },
9881  		{ { 0, 0xffffffffU } },
9882  	},
9883  	{
9884  		"JMP_JGE_X: ldimm64 test 3",
9885  		.u.insns_int = {
9886  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9887  			BPF_LD_IMM64(R1, 3),
9888  			BPF_LD_IMM64(R2, 2),
9889  			BPF_JMP_REG(BPF_JGE, R1, R2, 4),
9890  			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
9891  			BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
9892  			BPF_EXIT_INSN(),
9893  		},
9894  		INTERNAL,
9895  		{ },
9896  		{ { 0, 1 } },
9897  	},
9898  	{
9899  		"JMP_JLE_X: ldimm64 test 1",
9900  		.u.insns_int = {
9901  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9902  			BPF_LD_IMM64(R1, 3),
9903  			BPF_LD_IMM64(R2, 2),
9904  			BPF_JMP_REG(BPF_JLE, R2, R1, 2),
9905  			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
9906  			BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
9907  			BPF_EXIT_INSN(),
9908  		},
9909  		INTERNAL,
9910  		{ },
9911  		{ { 0, 0xeeeeeeeeU } },
9912  	},
9913  	{
9914  		"JMP_JLE_X: ldimm64 test 2",
9915  		.u.insns_int = {
9916  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9917  			BPF_LD_IMM64(R1, 3),
9918  			BPF_LD_IMM64(R2, 2),
9919  			BPF_JMP_REG(BPF_JLE, R2, R1, 0),
9920  			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
9921  			BPF_EXIT_INSN(),
9922  		},
9923  		INTERNAL,
9924  		{ },
9925  		{ { 0, 0xffffffffU } },
9926  	},
9927  	{
9928  		"JMP_JLE_X: ldimm64 test 3",
9929  		.u.insns_int = {
9930  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9931  			BPF_LD_IMM64(R1, 3),
9932  			BPF_LD_IMM64(R2, 2),
9933  			BPF_JMP_REG(BPF_JLE, R2, R1, 4),
9934  			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
9935  			BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
9936  			BPF_EXIT_INSN(),
9937  		},
9938  		INTERNAL,
9939  		{ },
9940  		{ { 0, 1 } },
9941  	},
9942  	/* BPF_JMP | BPF_JNE | BPF_X */
9943  	{
9944  		"JMP_JNE_X: if (3 != 2) return 1",
9945  		.u.insns_int = {
9946  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9947  			BPF_LD_IMM64(R1, 3),
9948  			BPF_LD_IMM64(R2, 2),
9949  			BPF_JMP_REG(BPF_JNE, R1, R2, 1),
9950  			BPF_EXIT_INSN(),
9951  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9952  			BPF_EXIT_INSN(),
9953  		},
9954  		INTERNAL,
9955  		{ },
9956  		{ { 0, 1 } },
9957  	},
9958  	/* BPF_JMP | BPF_JEQ | BPF_X */
9959  	{
9960  		"JMP_JEQ_X: if (3 == 3) return 1",
9961  		.u.insns_int = {
9962  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9963  			BPF_LD_IMM64(R1, 3),
9964  			BPF_LD_IMM64(R2, 3),
9965  			BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
9966  			BPF_EXIT_INSN(),
9967  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9968  			BPF_EXIT_INSN(),
9969  		},
9970  		INTERNAL,
9971  		{ },
9972  		{ { 0, 1 } },
9973  	},
9974  	/* BPF_JMP | BPF_JSET | BPF_X */
9975  	{
9976  		"JMP_JSET_X: if (0x3 & 0x2) return 1",
9977  		.u.insns_int = {
9978  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9979  			BPF_LD_IMM64(R1, 3),
9980  			BPF_LD_IMM64(R2, 2),
9981  			BPF_JMP_REG(BPF_JSET, R1, R2, 1),
9982  			BPF_EXIT_INSN(),
9983  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9984  			BPF_EXIT_INSN(),
9985  		},
9986  		INTERNAL,
9987  		{ },
9988  		{ { 0, 1 } },
9989  	},
9990  	{
9991  		"JMP_JSET_X: if (0x3 & 0xffffffff) return 1",
9992  		.u.insns_int = {
9993  			BPF_ALU32_IMM(BPF_MOV, R0, 0),
9994  			BPF_LD_IMM64(R1, 3),
9995  			BPF_LD_IMM64(R2, 0xffffffff),
9996  			BPF_JMP_REG(BPF_JSET, R1, R2, 1),
9997  			BPF_EXIT_INSN(),
9998  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
9999  			BPF_EXIT_INSN(),
10000  		},
10001  		INTERNAL,
10002  		{ },
10003  		{ { 0, 1 } },
10004  	},
10005  	{
10006  		"JMP_JA: Jump, gap, jump, ...",
10007  		{ },
10008  		CLASSIC | FLAG_NO_DATA,
10009  		{ },
10010  		{ { 0, 0xababcbac } },
10011  		.fill_helper = bpf_fill_ja,
10012  	},
10013  	{	/* Mainly checking JIT here. */
10014  		"BPF_MAXINSNS: Maximum possible literals",
10015  		{ },
10016  		CLASSIC | FLAG_NO_DATA,
10017  		{ },
10018  		{ { 0, 0xffffffff } },
10019  		.fill_helper = bpf_fill_maxinsns1,
10020  	},
10021  	{	/* Mainly checking JIT here. */
10022  		"BPF_MAXINSNS: Single literal",
10023  		{ },
10024  		CLASSIC | FLAG_NO_DATA,
10025  		{ },
10026  		{ { 0, 0xfefefefe } },
10027  		.fill_helper = bpf_fill_maxinsns2,
10028  	},
10029  	{	/* Mainly checking JIT here. */
10030  		"BPF_MAXINSNS: Run/add until end",
10031  		{ },
10032  		CLASSIC | FLAG_NO_DATA,
10033  		{ },
10034  		{ { 0, 0x947bf368 } },
10035  		.fill_helper = bpf_fill_maxinsns3,
10036  	},
10037  	{
10038  		"BPF_MAXINSNS: Too many instructions",
10039  		{ },
10040  		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
10041  		{ },
10042  		{ },
10043  		.fill_helper = bpf_fill_maxinsns4,
10044  		.expected_errcode = -EINVAL,
10045  	},
10046  	{	/* Mainly checking JIT here. */
10047  		"BPF_MAXINSNS: Very long jump",
10048  		{ },
10049  		CLASSIC | FLAG_NO_DATA,
10050  		{ },
10051  		{ { 0, 0xabababab } },
10052  		.fill_helper = bpf_fill_maxinsns5,
10053  	},
10054  	{	/* Mainly checking JIT here. */
10055  		"BPF_MAXINSNS: Ctx heavy transformations",
10056  		{ },
10057  		CLASSIC,
10058  		{ },
10059  		{
10060  			{  1, SKB_VLAN_PRESENT },
10061  			{ 10, SKB_VLAN_PRESENT }
10062  		},
10063  		.fill_helper = bpf_fill_maxinsns6,
10064  	},
10065  	{	/* Mainly checking JIT here. */
10066  		"BPF_MAXINSNS: Call heavy transformations",
10067  		{ },
10068  		CLASSIC | FLAG_NO_DATA,
10069  		{ },
10070  		{ { 1, 0 }, { 10, 0 } },
10071  		.fill_helper = bpf_fill_maxinsns7,
10072  	},
10073  	{	/* Mainly checking JIT here. */
10074  		"BPF_MAXINSNS: Jump heavy test",
10075  		{ },
10076  		CLASSIC | FLAG_NO_DATA,
10077  		{ },
10078  		{ { 0, 0xffffffff } },
10079  		.fill_helper = bpf_fill_maxinsns8,
10080  	},
10081  	{	/* Mainly checking JIT here. */
10082  		"BPF_MAXINSNS: Very long jump backwards",
10083  		{ },
10084  		INTERNAL | FLAG_NO_DATA,
10085  		{ },
10086  		{ { 0, 0xcbababab } },
10087  		.fill_helper = bpf_fill_maxinsns9,
10088  	},
10089  	{	/* Mainly checking JIT here. */
10090  		"BPF_MAXINSNS: Edge hopping nuthouse",
10091  		{ },
10092  		INTERNAL | FLAG_NO_DATA,
10093  		{ },
10094  		{ { 0, 0xabababac } },
10095  		.fill_helper = bpf_fill_maxinsns10,
10096  	},
10097  	{
10098  		"BPF_MAXINSNS: Jump, gap, jump, ...",
10099  		{ },
10100  		CLASSIC | FLAG_NO_DATA,
10101  		{ },
10102  		{ { 0, 0xababcbac } },
10103  		.fill_helper = bpf_fill_maxinsns11,
10104  	},
10105  	{
10106  		"BPF_MAXINSNS: jump over MSH",
10107  		{ },
10108  		CLASSIC | FLAG_EXPECTED_FAIL,
10109  		{ 0xfa, 0xfb, 0xfc, 0xfd, },
10110  		{ { 4, 0xabababab } },
10111  		.fill_helper = bpf_fill_maxinsns12,
10112  		.expected_errcode = -EINVAL,
10113  	},
10114  	{
10115  		"BPF_MAXINSNS: exec all MSH",
10116  		{ },
10117  		CLASSIC,
10118  		{ 0xfa, 0xfb, 0xfc, 0xfd, },
10119  		{ { 4, 0xababab83 } },
10120  		.fill_helper = bpf_fill_maxinsns13,
10121  	},
10122  	{
10123  		"BPF_MAXINSNS: ld_abs+get_processor_id",
10124  		{ },
10125  		CLASSIC,
10126  		{ },
10127  		{ { 1, 0xbee } },
10128  		.fill_helper = bpf_fill_ld_abs_get_processor_id,
10129  	},
10130  	/*
10131  	 * LD_IND / LD_ABS on fragmented SKBs
10132  	 */
10133  	{
10134  		"LD_IND byte frag",
10135  		.u.insns = {
10136  			BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
10137  			BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x0),
10138  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10139  		},
10140  		CLASSIC | FLAG_SKB_FRAG,
10141  		{ },
10142  		{ {0x40, 0x42} },
10143  		.frag_data = {
10144  			0x42, 0x00, 0x00, 0x00,
10145  			0x43, 0x44, 0x00, 0x00,
10146  			0x21, 0x07, 0x19, 0x83,
10147  		},
10148  	},
10149  	{
10150  		"LD_IND halfword frag",
10151  		.u.insns = {
10152  			BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
10153  			BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x4),
10154  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10155  		},
10156  		CLASSIC | FLAG_SKB_FRAG,
10157  		{ },
10158  		{ {0x40, 0x4344} },
10159  		.frag_data = {
10160  			0x42, 0x00, 0x00, 0x00,
10161  			0x43, 0x44, 0x00, 0x00,
10162  			0x21, 0x07, 0x19, 0x83,
10163  		},
10164  	},
10165  	{
10166  		"LD_IND word frag",
10167  		.u.insns = {
10168  			BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
10169  			BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x8),
10170  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10171  		},
10172  		CLASSIC | FLAG_SKB_FRAG,
10173  		{ },
10174  		{ {0x40, 0x21071983} },
10175  		.frag_data = {
10176  			0x42, 0x00, 0x00, 0x00,
10177  			0x43, 0x44, 0x00, 0x00,
10178  			0x21, 0x07, 0x19, 0x83,
10179  		},
10180  	},
10181  	{
10182  		"LD_IND halfword mixed head/frag",
10183  		.u.insns = {
10184  			BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
10185  			BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
10186  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10187  		},
10188  		CLASSIC | FLAG_SKB_FRAG,
10189  		{ [0x3e] = 0x25, [0x3f] = 0x05, },
10190  		{ {0x40, 0x0519} },
10191  		.frag_data = { 0x19, 0x82 },
10192  	},
10193  	{
10194  		"LD_IND word mixed head/frag",
10195  		.u.insns = {
10196  			BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
10197  			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
10198  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10199  		},
10200  		CLASSIC | FLAG_SKB_FRAG,
10201  		{ [0x3e] = 0x25, [0x3f] = 0x05, },
10202  		{ {0x40, 0x25051982} },
10203  		.frag_data = { 0x19, 0x82 },
10204  	},
10205  	{
10206  		"LD_ABS byte frag",
10207  		.u.insns = {
10208  			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x40),
10209  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10210  		},
10211  		CLASSIC | FLAG_SKB_FRAG,
10212  		{ },
10213  		{ {0x40, 0x42} },
10214  		.frag_data = {
10215  			0x42, 0x00, 0x00, 0x00,
10216  			0x43, 0x44, 0x00, 0x00,
10217  			0x21, 0x07, 0x19, 0x83,
10218  		},
10219  	},
10220  	{
10221  		"LD_ABS halfword frag",
10222  		.u.insns = {
10223  			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x44),
10224  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10225  		},
10226  		CLASSIC | FLAG_SKB_FRAG,
10227  		{ },
10228  		{ {0x40, 0x4344} },
10229  		.frag_data = {
10230  			0x42, 0x00, 0x00, 0x00,
10231  			0x43, 0x44, 0x00, 0x00,
10232  			0x21, 0x07, 0x19, 0x83,
10233  		},
10234  	},
10235  	{
10236  		"LD_ABS word frag",
10237  		.u.insns = {
10238  			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x48),
10239  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10240  		},
10241  		CLASSIC | FLAG_SKB_FRAG,
10242  		{ },
10243  		{ {0x40, 0x21071983} },
10244  		.frag_data = {
10245  			0x42, 0x00, 0x00, 0x00,
10246  			0x43, 0x44, 0x00, 0x00,
10247  			0x21, 0x07, 0x19, 0x83,
10248  		},
10249  	},
10250  	{
10251  		"LD_ABS halfword mixed head/frag",
10252  		.u.insns = {
10253  			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f),
10254  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10255  		},
10256  		CLASSIC | FLAG_SKB_FRAG,
10257  		{ [0x3e] = 0x25, [0x3f] = 0x05, },
10258  		{ {0x40, 0x0519} },
10259  		.frag_data = { 0x19, 0x82 },
10260  	},
10261  	{
10262  		"LD_ABS word mixed head/frag",
10263  		.u.insns = {
10264  			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3e),
10265  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10266  		},
10267  		CLASSIC | FLAG_SKB_FRAG,
10268  		{ [0x3e] = 0x25, [0x3f] = 0x05, },
10269  		{ {0x40, 0x25051982} },
10270  		.frag_data = { 0x19, 0x82 },
10271  	},
10272  	/*
10273  	 * LD_IND / LD_ABS on non fragmented SKBs
10274  	 */
10275  	{
10276  		/*
10277  		 * this tests that the JIT/interpreter correctly resets X
10278  		 * before using it in an LD_IND instruction.
10279  		 */
10280  		"LD_IND byte default X",
10281  		.u.insns = {
10282  			BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
10283  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10284  		},
10285  		CLASSIC,
10286  		{ [0x1] = 0x42 },
10287  		{ {0x40, 0x42 } },
10288  	},
10289  	{
10290  		"LD_IND byte positive offset",
10291  		.u.insns = {
10292  			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10293  			BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
10294  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10295  		},
10296  		CLASSIC,
10297  		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10298  		{ {0x40, 0x82 } },
10299  	},
10300  	{
10301  		"LD_IND byte negative offset",
10302  		.u.insns = {
10303  			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10304  			BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x1),
10305  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10306  		},
10307  		CLASSIC,
10308  		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10309  		{ {0x40, 0x05 } },
10310  	},
10311  	{
10312  		"LD_IND byte positive offset, all ff",
10313  		.u.insns = {
10314  			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10315  			BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
10316  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10317  		},
10318  		CLASSIC,
10319  		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
10320  		{ {0x40, 0xff } },
10321  	},
10322  	{
10323  		"LD_IND byte positive offset, out of bounds",
10324  		.u.insns = {
10325  			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10326  			BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
10327  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10328  		},
10329  		CLASSIC,
10330  		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10331  		{ {0x3f, 0 }, },
10332  	},
10333  	{
10334  		"LD_IND byte negative offset, out of bounds",
10335  		.u.insns = {
10336  			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10337  			BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x3f),
10338  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10339  		},
10340  		CLASSIC,
10341  		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10342  		{ {0x3f, 0 } },
10343  	},
10344  	{
10345  		"LD_IND byte negative offset, multiple calls",
10346  		.u.insns = {
10347  			BPF_STMT(BPF_LDX | BPF_IMM, 0x3b),
10348  			BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 1),
10349  			BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 2),
10350  			BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 3),
10351  			BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 4),
10352  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10353  		},
10354  		CLASSIC,
10355  		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10356  		{ {0x40, 0x82 }, },
10357  	},
10358  	{
10359  		"LD_IND halfword positive offset",
10360  		.u.insns = {
10361  			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
10362  			BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x2),
10363  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10364  		},
10365  		CLASSIC,
10366  		{
10367  			[0x1c] = 0xaa, [0x1d] = 0x55,
10368  			[0x1e] = 0xbb, [0x1f] = 0x66,
10369  			[0x20] = 0xcc, [0x21] = 0x77,
10370  			[0x22] = 0xdd, [0x23] = 0x88,
10371  		},
10372  		{ {0x40, 0xdd88 } },
10373  	},
10374  	{
10375  		"LD_IND halfword negative offset",
10376  		.u.insns = {
10377  			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
10378  			BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x2),
10379  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10380  		},
10381  		CLASSIC,
10382  		{
10383  			[0x1c] = 0xaa, [0x1d] = 0x55,
10384  			[0x1e] = 0xbb, [0x1f] = 0x66,
10385  			[0x20] = 0xcc, [0x21] = 0x77,
10386  			[0x22] = 0xdd, [0x23] = 0x88,
10387  		},
10388  		{ {0x40, 0xbb66 } },
10389  	},
10390  	{
10391  		"LD_IND halfword unaligned",
10392  		.u.insns = {
10393  			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
10394  			BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
10395  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10396  		},
10397  		CLASSIC,
10398  		{
10399  			[0x1c] = 0xaa, [0x1d] = 0x55,
10400  			[0x1e] = 0xbb, [0x1f] = 0x66,
10401  			[0x20] = 0xcc, [0x21] = 0x77,
10402  			[0x22] = 0xdd, [0x23] = 0x88,
10403  		},
10404  		{ {0x40, 0x66cc } },
10405  	},
10406  	{
10407  		"LD_IND halfword positive offset, all ff",
10408  		.u.insns = {
10409  			BPF_STMT(BPF_LDX | BPF_IMM, 0x3d),
10410  			BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1),
10411  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10412  		},
10413  		CLASSIC,
10414  		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
10415  		{ {0x40, 0xffff } },
10416  	},
10417  	{
10418  		"LD_IND halfword positive offset, out of bounds",
10419  		.u.insns = {
10420  			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10421  			BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1),
10422  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10423  		},
10424  		CLASSIC,
10425  		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10426  		{ {0x3f, 0 }, },
10427  	},
10428  	{
10429  		"LD_IND halfword negative offset, out of bounds",
10430  		.u.insns = {
10431  			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10432  			BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x3f),
10433  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10434  		},
10435  		CLASSIC,
10436  		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10437  		{ {0x3f, 0 } },
10438  	},
10439  	{
10440  		"LD_IND word positive offset",
10441  		.u.insns = {
10442  			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
10443  			BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x4),
10444  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10445  		},
10446  		CLASSIC,
10447  		{
10448  			[0x1c] = 0xaa, [0x1d] = 0x55,
10449  			[0x1e] = 0xbb, [0x1f] = 0x66,
10450  			[0x20] = 0xcc, [0x21] = 0x77,
10451  			[0x22] = 0xdd, [0x23] = 0x88,
10452  			[0x24] = 0xee, [0x25] = 0x99,
10453  			[0x26] = 0xff, [0x27] = 0xaa,
10454  		},
10455  		{ {0x40, 0xee99ffaa } },
10456  	},
10457  	{
10458  		"LD_IND word negative offset",
10459  		.u.insns = {
10460  			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
10461  			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x4),
10462  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10463  		},
10464  		CLASSIC,
10465  		{
10466  			[0x1c] = 0xaa, [0x1d] = 0x55,
10467  			[0x1e] = 0xbb, [0x1f] = 0x66,
10468  			[0x20] = 0xcc, [0x21] = 0x77,
10469  			[0x22] = 0xdd, [0x23] = 0x88,
10470  			[0x24] = 0xee, [0x25] = 0x99,
10471  			[0x26] = 0xff, [0x27] = 0xaa,
10472  		},
10473  		{ {0x40, 0xaa55bb66 } },
10474  	},
10475  	{
10476  		"LD_IND word unaligned (addr & 3 == 2)",
10477  		.u.insns = {
10478  			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
10479  			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
10480  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10481  		},
10482  		CLASSIC,
10483  		{
10484  			[0x1c] = 0xaa, [0x1d] = 0x55,
10485  			[0x1e] = 0xbb, [0x1f] = 0x66,
10486  			[0x20] = 0xcc, [0x21] = 0x77,
10487  			[0x22] = 0xdd, [0x23] = 0x88,
10488  			[0x24] = 0xee, [0x25] = 0x99,
10489  			[0x26] = 0xff, [0x27] = 0xaa,
10490  		},
10491  		{ {0x40, 0xbb66cc77 } },
10492  	},
10493  	{
10494  		"LD_IND word unaligned (addr & 3 == 1)",
10495  		.u.insns = {
10496  			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
10497  			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3),
10498  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10499  		},
10500  		CLASSIC,
10501  		{
10502  			[0x1c] = 0xaa, [0x1d] = 0x55,
10503  			[0x1e] = 0xbb, [0x1f] = 0x66,
10504  			[0x20] = 0xcc, [0x21] = 0x77,
10505  			[0x22] = 0xdd, [0x23] = 0x88,
10506  			[0x24] = 0xee, [0x25] = 0x99,
10507  			[0x26] = 0xff, [0x27] = 0xaa,
10508  		},
10509  		{ {0x40, 0x55bb66cc } },
10510  	},
10511  	{
10512  		"LD_IND word unaligned (addr & 3 == 3)",
10513  		.u.insns = {
10514  			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
10515  			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x1),
10516  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10517  		},
10518  		CLASSIC,
10519  		{
10520  			[0x1c] = 0xaa, [0x1d] = 0x55,
10521  			[0x1e] = 0xbb, [0x1f] = 0x66,
10522  			[0x20] = 0xcc, [0x21] = 0x77,
10523  			[0x22] = 0xdd, [0x23] = 0x88,
10524  			[0x24] = 0xee, [0x25] = 0x99,
10525  			[0x26] = 0xff, [0x27] = 0xaa,
10526  		},
10527  		{ {0x40, 0x66cc77dd } },
10528  	},
10529  	{
10530  		"LD_IND word positive offset, all ff",
10531  		.u.insns = {
10532  			BPF_STMT(BPF_LDX | BPF_IMM, 0x3b),
10533  			BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1),
10534  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10535  		},
10536  		CLASSIC,
10537  		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
10538  		{ {0x40, 0xffffffff } },
10539  	},
10540  	{
10541  		"LD_IND word positive offset, out of bounds",
10542  		.u.insns = {
10543  			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10544  			BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1),
10545  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10546  		},
10547  		CLASSIC,
10548  		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10549  		{ {0x3f, 0 }, },
10550  	},
10551  	{
10552  		"LD_IND word negative offset, out of bounds",
10553  		.u.insns = {
10554  			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10555  			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3f),
10556  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10557  		},
10558  		CLASSIC,
10559  		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10560  		{ {0x3f, 0 } },
10561  	},
10562  	{
10563  		"LD_ABS byte",
10564  		.u.insns = {
10565  			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x20),
10566  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10567  		},
10568  		CLASSIC,
10569  		{
10570  			[0x1c] = 0xaa, [0x1d] = 0x55,
10571  			[0x1e] = 0xbb, [0x1f] = 0x66,
10572  			[0x20] = 0xcc, [0x21] = 0x77,
10573  			[0x22] = 0xdd, [0x23] = 0x88,
10574  			[0x24] = 0xee, [0x25] = 0x99,
10575  			[0x26] = 0xff, [0x27] = 0xaa,
10576  		},
10577  		{ {0x40, 0xcc } },
10578  	},
10579  	{
10580  		"LD_ABS byte positive offset, all ff",
10581  		.u.insns = {
10582  			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f),
10583  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10584  		},
10585  		CLASSIC,
10586  		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
10587  		{ {0x40, 0xff } },
10588  	},
10589  	{
10590  		"LD_ABS byte positive offset, out of bounds",
10591  		.u.insns = {
10592  			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f),
10593  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10594  		},
10595  		CLASSIC,
10596  		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10597  		{ {0x3f, 0 }, },
10598  	},
10599  	{
10600  		"LD_ABS byte negative offset, out of bounds load",
10601  		.u.insns = {
10602  			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, -1),
10603  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10604  		},
10605  		CLASSIC | FLAG_EXPECTED_FAIL,
10606  		.expected_errcode = -EINVAL,
10607  	},
10608  	{
10609  		"LD_ABS byte negative offset, in bounds",
10610  		.u.insns = {
10611  			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
10612  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10613  		},
10614  		CLASSIC,
10615  		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10616  		{ {0x40, 0x82 }, },
10617  	},
10618  	{
10619  		"LD_ABS byte negative offset, out of bounds",
10620  		.u.insns = {
10621  			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
10622  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10623  		},
10624  		CLASSIC,
10625  		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10626  		{ {0x3f, 0 }, },
10627  	},
10628  	{
10629  		"LD_ABS byte negative offset, multiple calls",
10630  		.u.insns = {
10631  			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3c),
10632  			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3d),
10633  			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3e),
10634  			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
10635  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10636  		},
10637  		CLASSIC,
10638  		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10639  		{ {0x40, 0x82 }, },
10640  	},
10641  	{
10642  		"LD_ABS halfword",
10643  		.u.insns = {
10644  			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x22),
10645  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10646  		},
10647  		CLASSIC,
10648  		{
10649  			[0x1c] = 0xaa, [0x1d] = 0x55,
10650  			[0x1e] = 0xbb, [0x1f] = 0x66,
10651  			[0x20] = 0xcc, [0x21] = 0x77,
10652  			[0x22] = 0xdd, [0x23] = 0x88,
10653  			[0x24] = 0xee, [0x25] = 0x99,
10654  			[0x26] = 0xff, [0x27] = 0xaa,
10655  		},
10656  		{ {0x40, 0xdd88 } },
10657  	},
10658  	{
10659  		"LD_ABS halfword unaligned",
10660  		.u.insns = {
10661  			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x25),
10662  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10663  		},
10664  		CLASSIC,
10665  		{
10666  			[0x1c] = 0xaa, [0x1d] = 0x55,
10667  			[0x1e] = 0xbb, [0x1f] = 0x66,
10668  			[0x20] = 0xcc, [0x21] = 0x77,
10669  			[0x22] = 0xdd, [0x23] = 0x88,
10670  			[0x24] = 0xee, [0x25] = 0x99,
10671  			[0x26] = 0xff, [0x27] = 0xaa,
10672  		},
10673  		{ {0x40, 0x99ff } },
10674  	},
10675  	{
10676  		"LD_ABS halfword positive offset, all ff",
10677  		.u.insns = {
10678  			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3e),
10679  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10680  		},
10681  		CLASSIC,
10682  		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
10683  		{ {0x40, 0xffff } },
10684  	},
10685  	{
10686  		"LD_ABS halfword positive offset, out of bounds",
10687  		.u.insns = {
10688  			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f),
10689  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10690  		},
10691  		CLASSIC,
10692  		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10693  		{ {0x3f, 0 }, },
10694  	},
10695  	{
10696  		"LD_ABS halfword negative offset, out of bounds load",
10697  		.u.insns = {
10698  			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, -1),
10699  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10700  		},
10701  		CLASSIC | FLAG_EXPECTED_FAIL,
10702  		.expected_errcode = -EINVAL,
10703  	},
10704  	{
10705  		"LD_ABS halfword negative offset, in bounds",
10706  		.u.insns = {
10707  			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e),
10708  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10709  		},
10710  		CLASSIC,
10711  		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10712  		{ {0x40, 0x1982 }, },
10713  	},
10714  	{
10715  		"LD_ABS halfword negative offset, out of bounds",
10716  		.u.insns = {
10717  			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e),
10718  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10719  		},
10720  		CLASSIC,
10721  		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10722  		{ {0x3f, 0 }, },
10723  	},
10724  	{
10725  		"LD_ABS word",
10726  		.u.insns = {
10727  			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x1c),
10728  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10729  		},
10730  		CLASSIC,
10731  		{
10732  			[0x1c] = 0xaa, [0x1d] = 0x55,
10733  			[0x1e] = 0xbb, [0x1f] = 0x66,
10734  			[0x20] = 0xcc, [0x21] = 0x77,
10735  			[0x22] = 0xdd, [0x23] = 0x88,
10736  			[0x24] = 0xee, [0x25] = 0x99,
10737  			[0x26] = 0xff, [0x27] = 0xaa,
10738  		},
10739  		{ {0x40, 0xaa55bb66 } },
10740  	},
10741  	{
10742  		"LD_ABS word unaligned (addr & 3 == 2)",
10743  		.u.insns = {
10744  			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x22),
10745  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10746  		},
10747  		CLASSIC,
10748  		{
10749  			[0x1c] = 0xaa, [0x1d] = 0x55,
10750  			[0x1e] = 0xbb, [0x1f] = 0x66,
10751  			[0x20] = 0xcc, [0x21] = 0x77,
10752  			[0x22] = 0xdd, [0x23] = 0x88,
10753  			[0x24] = 0xee, [0x25] = 0x99,
10754  			[0x26] = 0xff, [0x27] = 0xaa,
10755  		},
10756  		{ {0x40, 0xdd88ee99 } },
10757  	},
10758  	{
10759  		"LD_ABS word unaligned (addr & 3 == 1)",
10760  		.u.insns = {
10761  			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x21),
10762  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10763  		},
10764  		CLASSIC,
10765  		{
10766  			[0x1c] = 0xaa, [0x1d] = 0x55,
10767  			[0x1e] = 0xbb, [0x1f] = 0x66,
10768  			[0x20] = 0xcc, [0x21] = 0x77,
10769  			[0x22] = 0xdd, [0x23] = 0x88,
10770  			[0x24] = 0xee, [0x25] = 0x99,
10771  			[0x26] = 0xff, [0x27] = 0xaa,
10772  		},
10773  		{ {0x40, 0x77dd88ee } },
10774  	},
10775  	{
10776  		"LD_ABS word unaligned (addr & 3 == 3)",
10777  		.u.insns = {
10778  			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x23),
10779  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10780  		},
10781  		CLASSIC,
10782  		{
10783  			[0x1c] = 0xaa, [0x1d] = 0x55,
10784  			[0x1e] = 0xbb, [0x1f] = 0x66,
10785  			[0x20] = 0xcc, [0x21] = 0x77,
10786  			[0x22] = 0xdd, [0x23] = 0x88,
10787  			[0x24] = 0xee, [0x25] = 0x99,
10788  			[0x26] = 0xff, [0x27] = 0xaa,
10789  		},
10790  		{ {0x40, 0x88ee99ff } },
10791  	},
10792  	{
10793  		"LD_ABS word positive offset, all ff",
10794  		.u.insns = {
10795  			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3c),
10796  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10797  		},
10798  		CLASSIC,
10799  		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
10800  		{ {0x40, 0xffffffff } },
10801  	},
10802  	{
10803  		"LD_ABS word positive offset, out of bounds",
10804  		.u.insns = {
10805  			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3f),
10806  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10807  		},
10808  		CLASSIC,
10809  		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10810  		{ {0x3f, 0 }, },
10811  	},
10812  	{
10813  		"LD_ABS word negative offset, out of bounds load",
10814  		.u.insns = {
10815  			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, -1),
10816  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10817  		},
10818  		CLASSIC | FLAG_EXPECTED_FAIL,
10819  		.expected_errcode = -EINVAL,
10820  	},
10821  	{
10822  		"LD_ABS word negative offset, in bounds",
10823  		.u.insns = {
10824  			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c),
10825  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10826  		},
10827  		CLASSIC,
10828  		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10829  		{ {0x40, 0x25051982 }, },
10830  	},
10831  	{
10832  		"LD_ABS word negative offset, out of bounds",
10833  		.u.insns = {
10834  			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c),
10835  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10836  		},
10837  		CLASSIC,
10838  		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10839  		{ {0x3f, 0 }, },
10840  	},
10841  	{
10842  		"LDX_MSH standalone, preserved A",
10843  		.u.insns = {
10844  			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
10845  			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
10846  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10847  		},
10848  		CLASSIC,
10849  		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10850  		{ {0x40, 0xffeebbaa }, },
10851  	},
10852  	{
10853  		"LDX_MSH standalone, preserved A 2",
10854  		.u.insns = {
10855  			BPF_STMT(BPF_LD | BPF_IMM, 0x175e9d63),
10856  			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
10857  			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3d),
10858  			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e),
10859  			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3f),
10860  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10861  		},
10862  		CLASSIC,
10863  		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10864  		{ {0x40, 0x175e9d63 }, },
10865  	},
10866  	{
10867  		"LDX_MSH standalone, test result 1",
10868  		.u.insns = {
10869  			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
10870  			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
10871  			BPF_STMT(BPF_MISC | BPF_TXA, 0),
10872  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10873  		},
10874  		CLASSIC,
10875  		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10876  		{ {0x40, 0x14 }, },
10877  	},
10878  	{
10879  		"LDX_MSH standalone, test result 2",
10880  		.u.insns = {
10881  			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
10882  			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e),
10883  			BPF_STMT(BPF_MISC | BPF_TXA, 0),
10884  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10885  		},
10886  		CLASSIC,
10887  		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10888  		{ {0x40, 0x24 }, },
10889  	},
10890  	{
10891  		"LDX_MSH standalone, negative offset",
10892  		.u.insns = {
10893  			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
10894  			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, -1),
10895  			BPF_STMT(BPF_MISC | BPF_TXA, 0),
10896  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10897  		},
10898  		CLASSIC,
10899  		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10900  		{ {0x40, 0 }, },
10901  	},
10902  	{
10903  		"LDX_MSH standalone, negative offset 2",
10904  		.u.insns = {
10905  			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
10906  			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, SKF_LL_OFF + 0x3e),
10907  			BPF_STMT(BPF_MISC | BPF_TXA, 0),
10908  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10909  		},
10910  		CLASSIC,
10911  		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10912  		{ {0x40, 0x24 }, },
10913  	},
10914  	{
10915  		"LDX_MSH standalone, out of bounds",
10916  		.u.insns = {
10917  			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
10918  			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x40),
10919  			BPF_STMT(BPF_MISC | BPF_TXA, 0),
10920  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10921  		},
10922  		CLASSIC,
10923  		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10924  		{ {0x40, 0 }, },
10925  	},
10926  	/*
10927  	 * verify that the interpreter or JIT correctly sets A and X
10928  	 * to 0.
10929  	 */
10930  	{
10931  		"ADD default X",
10932  		.u.insns = {
10933  			/*
10934  			 * A = 0x42
10935  			 * A = A + X
10936  			 * ret A
10937  			 */
10938  			BPF_STMT(BPF_LD | BPF_IMM, 0x42),
10939  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
10940  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10941  		},
10942  		CLASSIC | FLAG_NO_DATA,
10943  		{},
10944  		{ {0x1, 0x42 } },
10945  	},
10946  	{
10947  		"ADD default A",
10948  		.u.insns = {
10949  			/*
10950  			 * A = A + 0x42
10951  			 * ret A
10952  			 */
10953  			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0x42),
10954  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10955  		},
10956  		CLASSIC | FLAG_NO_DATA,
10957  		{},
10958  		{ {0x1, 0x42 } },
10959  	},
10960  	{
10961  		"SUB default X",
10962  		.u.insns = {
10963  			/*
10964  			 * A = 0x66
10965  			 * A = A - X
10966  			 * ret A
10967  			 */
10968  			BPF_STMT(BPF_LD | BPF_IMM, 0x66),
10969  			BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
10970  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10971  		},
10972  		CLASSIC | FLAG_NO_DATA,
10973  		{},
10974  		{ {0x1, 0x66 } },
10975  	},
10976  	{
10977  		"SUB default A",
10978  		.u.insns = {
10979  			/*
10980  			 * A = A - -0x66
10981  			 * ret A
10982  			 */
10983  			BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, -0x66),
10984  			BPF_STMT(BPF_RET | BPF_A, 0x0),
10985  		},
10986  		CLASSIC | FLAG_NO_DATA,
10987  		{},
10988  		{ {0x1, 0x66 } },
10989  	},
10990  	{
10991  		"MUL default X",
10992  		.u.insns = {
10993  			/*
10994  			 * A = 0x42
10995  			 * A = A * X
10996  			 * ret A
10997  			 */
10998  			BPF_STMT(BPF_LD | BPF_IMM, 0x42),
10999  			BPF_STMT(BPF_ALU | BPF_MUL | BPF_X, 0),
11000  			BPF_STMT(BPF_RET | BPF_A, 0x0),
11001  		},
11002  		CLASSIC | FLAG_NO_DATA,
11003  		{},
11004  		{ {0x1, 0x0 } },
11005  	},
11006  	{
11007  		"MUL default A",
11008  		.u.insns = {
11009  			/*
11010  			 * A = A * 0x66
11011  			 * ret A
11012  			 */
11013  			BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 0x66),
11014  			BPF_STMT(BPF_RET | BPF_A, 0x0),
11015  		},
11016  		CLASSIC | FLAG_NO_DATA,
11017  		{},
11018  		{ {0x1, 0x0 } },
11019  	},
11020  	{
11021  		"DIV default X",
11022  		.u.insns = {
11023  			/*
11024  			 * A = 0x42
11025  			 * A = A / X ; this halt the filter execution if X is 0
11026  			 * ret 0x42
11027  			 */
11028  			BPF_STMT(BPF_LD | BPF_IMM, 0x42),
11029  			BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
11030  			BPF_STMT(BPF_RET | BPF_K, 0x42),
11031  		},
11032  		CLASSIC | FLAG_NO_DATA,
11033  		{},
11034  		{ {0x1, 0x0 } },
11035  	},
11036  	{
11037  		"DIV default A",
11038  		.u.insns = {
11039  			/*
11040  			 * A = A / 1
11041  			 * ret A
11042  			 */
11043  			BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x1),
11044  			BPF_STMT(BPF_RET | BPF_A, 0x0),
11045  		},
11046  		CLASSIC | FLAG_NO_DATA,
11047  		{},
11048  		{ {0x1, 0x0 } },
11049  	},
11050  	{
11051  		"MOD default X",
11052  		.u.insns = {
11053  			/*
11054  			 * A = 0x42
11055  			 * A = A mod X ; this halt the filter execution if X is 0
11056  			 * ret 0x42
11057  			 */
11058  			BPF_STMT(BPF_LD | BPF_IMM, 0x42),
11059  			BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
11060  			BPF_STMT(BPF_RET | BPF_K, 0x42),
11061  		},
11062  		CLASSIC | FLAG_NO_DATA,
11063  		{},
11064  		{ {0x1, 0x0 } },
11065  	},
11066  	{
11067  		"MOD default A",
11068  		.u.insns = {
11069  			/*
11070  			 * A = A mod 1
11071  			 * ret A
11072  			 */
11073  			BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x1),
11074  			BPF_STMT(BPF_RET | BPF_A, 0x0),
11075  		},
11076  		CLASSIC | FLAG_NO_DATA,
11077  		{},
11078  		{ {0x1, 0x0 } },
11079  	},
11080  	{
11081  		"JMP EQ default A",
11082  		.u.insns = {
11083  			/*
11084  			 * cmp A, 0x0, 0, 1
11085  			 * ret 0x42
11086  			 * ret 0x66
11087  			 */
11088  			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0, 0, 1),
11089  			BPF_STMT(BPF_RET | BPF_K, 0x42),
11090  			BPF_STMT(BPF_RET | BPF_K, 0x66),
11091  		},
11092  		CLASSIC | FLAG_NO_DATA,
11093  		{},
11094  		{ {0x1, 0x42 } },
11095  	},
11096  	{
11097  		"JMP EQ default X",
11098  		.u.insns = {
11099  			/*
11100  			 * A = 0x0
11101  			 * cmp A, X, 0, 1
11102  			 * ret 0x42
11103  			 * ret 0x66
11104  			 */
11105  			BPF_STMT(BPF_LD | BPF_IMM, 0x0),
11106  			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0x0, 0, 1),
11107  			BPF_STMT(BPF_RET | BPF_K, 0x42),
11108  			BPF_STMT(BPF_RET | BPF_K, 0x66),
11109  		},
11110  		CLASSIC | FLAG_NO_DATA,
11111  		{},
11112  		{ {0x1, 0x42 } },
11113  	},
11114  	/* Checking interpreter vs JIT wrt signed extended imms. */
11115  	{
11116  		"JNE signed compare, test 1",
11117  		.u.insns_int = {
11118  			BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
11119  			BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
11120  			BPF_MOV64_REG(R2, R1),
11121  			BPF_ALU64_REG(BPF_AND, R2, R3),
11122  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
11123  			BPF_JMP_IMM(BPF_JNE, R2, -17104896, 1),
11124  			BPF_ALU32_IMM(BPF_MOV, R0, 2),
11125  			BPF_EXIT_INSN(),
11126  		},
11127  		INTERNAL,
11128  		{ },
11129  		{ { 0, 1 } },
11130  	},
11131  	{
11132  		"JNE signed compare, test 2",
11133  		.u.insns_int = {
11134  			BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
11135  			BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
11136  			BPF_MOV64_REG(R2, R1),
11137  			BPF_ALU64_REG(BPF_AND, R2, R3),
11138  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
11139  			BPF_JMP_IMM(BPF_JNE, R2, 0xfefb0000, 1),
11140  			BPF_ALU32_IMM(BPF_MOV, R0, 2),
11141  			BPF_EXIT_INSN(),
11142  		},
11143  		INTERNAL,
11144  		{ },
11145  		{ { 0, 1 } },
11146  	},
11147  	{
11148  		"JNE signed compare, test 3",
11149  		.u.insns_int = {
11150  			BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
11151  			BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
11152  			BPF_ALU32_IMM(BPF_MOV, R4, 0xfefb0000),
11153  			BPF_MOV64_REG(R2, R1),
11154  			BPF_ALU64_REG(BPF_AND, R2, R3),
11155  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
11156  			BPF_JMP_REG(BPF_JNE, R2, R4, 1),
11157  			BPF_ALU32_IMM(BPF_MOV, R0, 2),
11158  			BPF_EXIT_INSN(),
11159  		},
11160  		INTERNAL,
11161  		{ },
11162  		{ { 0, 2 } },
11163  	},
11164  	{
11165  		"JNE signed compare, test 4",
11166  		.u.insns_int = {
11167  			BPF_LD_IMM64(R1, -17104896),
11168  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
11169  			BPF_JMP_IMM(BPF_JNE, R1, -17104896, 1),
11170  			BPF_ALU32_IMM(BPF_MOV, R0, 2),
11171  			BPF_EXIT_INSN(),
11172  		},
11173  		INTERNAL,
11174  		{ },
11175  		{ { 0, 2 } },
11176  	},
11177  	{
11178  		"JNE signed compare, test 5",
11179  		.u.insns_int = {
11180  			BPF_LD_IMM64(R1, 0xfefb0000),
11181  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
11182  			BPF_JMP_IMM(BPF_JNE, R1, 0xfefb0000, 1),
11183  			BPF_ALU32_IMM(BPF_MOV, R0, 2),
11184  			BPF_EXIT_INSN(),
11185  		},
11186  		INTERNAL,
11187  		{ },
11188  		{ { 0, 1 } },
11189  	},
11190  	{
11191  		"JNE signed compare, test 6",
11192  		.u.insns_int = {
11193  			BPF_LD_IMM64(R1, 0x7efb0000),
11194  			BPF_ALU32_IMM(BPF_MOV, R0, 1),
11195  			BPF_JMP_IMM(BPF_JNE, R1, 0x7efb0000, 1),
11196  			BPF_ALU32_IMM(BPF_MOV, R0, 2),
11197  			BPF_EXIT_INSN(),
11198  		},
11199  		INTERNAL,
11200  		{ },
11201  		{ { 0, 2 } },
11202  	},
11203  	{
11204  		"JNE signed compare, test 7",
11205  		.u.insns = {
11206  			BPF_STMT(BPF_LD | BPF_IMM, 0xffff0000),
11207  			BPF_STMT(BPF_MISC | BPF_TAX, 0),
11208  			BPF_STMT(BPF_LD | BPF_IMM, 0xfefbbc12),
11209  			BPF_STMT(BPF_ALU | BPF_AND | BPF_X, 0),
11210  			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0xfefb0000, 1, 0),
11211  			BPF_STMT(BPF_RET | BPF_K, 1),
11212  			BPF_STMT(BPF_RET | BPF_K, 2),
11213  		},
11214  		CLASSIC | FLAG_NO_DATA,
11215  		{},
11216  		{ { 0, 2 } },
11217  	},
11218  	/* BPF_LDX_MEM with operand aliasing */
11219  	{
11220  		"LDX_MEM_B: operand register aliasing",
11221  		.u.insns_int = {
11222  			BPF_ST_MEM(BPF_B, R10, -8, 123),
11223  			BPF_MOV64_REG(R0, R10),
11224  			BPF_LDX_MEM(BPF_B, R0, R0, -8),
11225  			BPF_EXIT_INSN(),
11226  		},
11227  		INTERNAL,
11228  		{ },
11229  		{ { 0, 123 } },
11230  		.stack_depth = 8,
11231  	},
11232  	{
11233  		"LDX_MEM_H: operand register aliasing",
11234  		.u.insns_int = {
11235  			BPF_ST_MEM(BPF_H, R10, -8, 12345),
11236  			BPF_MOV64_REG(R0, R10),
11237  			BPF_LDX_MEM(BPF_H, R0, R0, -8),
11238  			BPF_EXIT_INSN(),
11239  		},
11240  		INTERNAL,
11241  		{ },
11242  		{ { 0, 12345 } },
11243  		.stack_depth = 8,
11244  	},
11245  	{
11246  		"LDX_MEM_W: operand register aliasing",
11247  		.u.insns_int = {
11248  			BPF_ST_MEM(BPF_W, R10, -8, 123456789),
11249  			BPF_MOV64_REG(R0, R10),
11250  			BPF_LDX_MEM(BPF_W, R0, R0, -8),
11251  			BPF_EXIT_INSN(),
11252  		},
11253  		INTERNAL,
11254  		{ },
11255  		{ { 0, 123456789 } },
11256  		.stack_depth = 8,
11257  	},
11258  	{
11259  		"LDX_MEM_DW: operand register aliasing",
11260  		.u.insns_int = {
11261  			BPF_LD_IMM64(R1, 0x123456789abcdefULL),
11262  			BPF_STX_MEM(BPF_DW, R10, R1, -8),
11263  			BPF_MOV64_REG(R0, R10),
11264  			BPF_LDX_MEM(BPF_DW, R0, R0, -8),
11265  			BPF_ALU64_REG(BPF_SUB, R0, R1),
11266  			BPF_MOV64_REG(R1, R0),
11267  			BPF_ALU64_IMM(BPF_RSH, R1, 32),
11268  			BPF_ALU64_REG(BPF_OR, R0, R1),
11269  			BPF_EXIT_INSN(),
11270  		},
11271  		INTERNAL,
11272  		{ },
11273  		{ { 0, 0 } },
11274  		.stack_depth = 8,
11275  	},
11276  	/*
11277  	 * Register (non-)clobbering tests for the case where a JIT implements
11278  	 * complex ALU or ATOMIC operations via function calls. If so, the
11279  	 * function call must be transparent to the eBPF registers. The JIT
11280  	 * must therefore save and restore relevant registers across the call.
11281  	 * The following tests check that the eBPF registers retain their
11282  	 * values after such an operation. Mainly intended for complex ALU
11283  	 * and atomic operation, but we run it for all. You never know...
11284  	 *
11285  	 * Note that each operations should be tested twice with different
11286  	 * destinations, to check preservation for all registers.
11287  	 */
11288  #define BPF_TEST_CLOBBER_ALU(alu, op, dst, src)			\
11289  	{							\
11290  		#alu "_" #op " to " #dst ": no clobbering",	\
11291  		.u.insns_int = {				\
11292  			BPF_ALU64_IMM(BPF_MOV, R0, R0),		\
11293  			BPF_ALU64_IMM(BPF_MOV, R1, R1),		\
11294  			BPF_ALU64_IMM(BPF_MOV, R2, R2),		\
11295  			BPF_ALU64_IMM(BPF_MOV, R3, R3),		\
11296  			BPF_ALU64_IMM(BPF_MOV, R4, R4),		\
11297  			BPF_ALU64_IMM(BPF_MOV, R5, R5),		\
11298  			BPF_ALU64_IMM(BPF_MOV, R6, R6),		\
11299  			BPF_ALU64_IMM(BPF_MOV, R7, R7),		\
11300  			BPF_ALU64_IMM(BPF_MOV, R8, R8),		\
11301  			BPF_ALU64_IMM(BPF_MOV, R9, R9),		\
11302  			BPF_##alu(BPF_ ##op, dst, src),		\
11303  			BPF_ALU32_IMM(BPF_MOV, dst, dst),	\
11304  			BPF_JMP_IMM(BPF_JNE, R0, R0, 10),	\
11305  			BPF_JMP_IMM(BPF_JNE, R1, R1, 9),	\
11306  			BPF_JMP_IMM(BPF_JNE, R2, R2, 8),	\
11307  			BPF_JMP_IMM(BPF_JNE, R3, R3, 7),	\
11308  			BPF_JMP_IMM(BPF_JNE, R4, R4, 6),	\
11309  			BPF_JMP_IMM(BPF_JNE, R5, R5, 5),	\
11310  			BPF_JMP_IMM(BPF_JNE, R6, R6, 4),	\
11311  			BPF_JMP_IMM(BPF_JNE, R7, R7, 3),	\
11312  			BPF_JMP_IMM(BPF_JNE, R8, R8, 2),	\
11313  			BPF_JMP_IMM(BPF_JNE, R9, R9, 1),	\
11314  			BPF_ALU64_IMM(BPF_MOV, R0, 1),		\
11315  			BPF_EXIT_INSN(),			\
11316  		},						\
11317  		INTERNAL,					\
11318  		{ },						\
11319  		{ { 0, 1 } }					\
11320  	}
11321  	/* ALU64 operations, register clobbering */
11322  	BPF_TEST_CLOBBER_ALU(ALU64_IMM, AND, R8, 123456789),
11323  	BPF_TEST_CLOBBER_ALU(ALU64_IMM, AND, R9, 123456789),
11324  	BPF_TEST_CLOBBER_ALU(ALU64_IMM, OR, R8, 123456789),
11325  	BPF_TEST_CLOBBER_ALU(ALU64_IMM, OR, R9, 123456789),
11326  	BPF_TEST_CLOBBER_ALU(ALU64_IMM, XOR, R8, 123456789),
11327  	BPF_TEST_CLOBBER_ALU(ALU64_IMM, XOR, R9, 123456789),
11328  	BPF_TEST_CLOBBER_ALU(ALU64_IMM, LSH, R8, 12),
11329  	BPF_TEST_CLOBBER_ALU(ALU64_IMM, LSH, R9, 12),
11330  	BPF_TEST_CLOBBER_ALU(ALU64_IMM, RSH, R8, 12),
11331  	BPF_TEST_CLOBBER_ALU(ALU64_IMM, RSH, R9, 12),
11332  	BPF_TEST_CLOBBER_ALU(ALU64_IMM, ARSH, R8, 12),
11333  	BPF_TEST_CLOBBER_ALU(ALU64_IMM, ARSH, R9, 12),
11334  	BPF_TEST_CLOBBER_ALU(ALU64_IMM, ADD, R8, 123456789),
11335  	BPF_TEST_CLOBBER_ALU(ALU64_IMM, ADD, R9, 123456789),
11336  	BPF_TEST_CLOBBER_ALU(ALU64_IMM, SUB, R8, 123456789),
11337  	BPF_TEST_CLOBBER_ALU(ALU64_IMM, SUB, R9, 123456789),
11338  	BPF_TEST_CLOBBER_ALU(ALU64_IMM, MUL, R8, 123456789),
11339  	BPF_TEST_CLOBBER_ALU(ALU64_IMM, MUL, R9, 123456789),
11340  	BPF_TEST_CLOBBER_ALU(ALU64_IMM, DIV, R8, 123456789),
11341  	BPF_TEST_CLOBBER_ALU(ALU64_IMM, DIV, R9, 123456789),
11342  	BPF_TEST_CLOBBER_ALU(ALU64_IMM, MOD, R8, 123456789),
11343  	BPF_TEST_CLOBBER_ALU(ALU64_IMM, MOD, R9, 123456789),
11344  	/* ALU32 immediate operations, register clobbering */
11345  	BPF_TEST_CLOBBER_ALU(ALU32_IMM, AND, R8, 123456789),
11346  	BPF_TEST_CLOBBER_ALU(ALU32_IMM, AND, R9, 123456789),
11347  	BPF_TEST_CLOBBER_ALU(ALU32_IMM, OR, R8, 123456789),
11348  	BPF_TEST_CLOBBER_ALU(ALU32_IMM, OR, R9, 123456789),
11349  	BPF_TEST_CLOBBER_ALU(ALU32_IMM, XOR, R8, 123456789),
11350  	BPF_TEST_CLOBBER_ALU(ALU32_IMM, XOR, R9, 123456789),
11351  	BPF_TEST_CLOBBER_ALU(ALU32_IMM, LSH, R8, 12),
11352  	BPF_TEST_CLOBBER_ALU(ALU32_IMM, LSH, R9, 12),
11353  	BPF_TEST_CLOBBER_ALU(ALU32_IMM, RSH, R8, 12),
11354  	BPF_TEST_CLOBBER_ALU(ALU32_IMM, RSH, R9, 12),
11355  	BPF_TEST_CLOBBER_ALU(ALU32_IMM, ARSH, R8, 12),
11356  	BPF_TEST_CLOBBER_ALU(ALU32_IMM, ARSH, R9, 12),
11357  	BPF_TEST_CLOBBER_ALU(ALU32_IMM, ADD, R8, 123456789),
11358  	BPF_TEST_CLOBBER_ALU(ALU32_IMM, ADD, R9, 123456789),
11359  	BPF_TEST_CLOBBER_ALU(ALU32_IMM, SUB, R8, 123456789),
11360  	BPF_TEST_CLOBBER_ALU(ALU32_IMM, SUB, R9, 123456789),
11361  	BPF_TEST_CLOBBER_ALU(ALU32_IMM, MUL, R8, 123456789),
11362  	BPF_TEST_CLOBBER_ALU(ALU32_IMM, MUL, R9, 123456789),
11363  	BPF_TEST_CLOBBER_ALU(ALU32_IMM, DIV, R8, 123456789),
11364  	BPF_TEST_CLOBBER_ALU(ALU32_IMM, DIV, R9, 123456789),
11365  	BPF_TEST_CLOBBER_ALU(ALU32_IMM, MOD, R8, 123456789),
11366  	BPF_TEST_CLOBBER_ALU(ALU32_IMM, MOD, R9, 123456789),
11367  	/* ALU64 register operations, register clobbering */
11368  	BPF_TEST_CLOBBER_ALU(ALU64_REG, AND, R8, R1),
11369  	BPF_TEST_CLOBBER_ALU(ALU64_REG, AND, R9, R1),
11370  	BPF_TEST_CLOBBER_ALU(ALU64_REG, OR, R8, R1),
11371  	BPF_TEST_CLOBBER_ALU(ALU64_REG, OR, R9, R1),
11372  	BPF_TEST_CLOBBER_ALU(ALU64_REG, XOR, R8, R1),
11373  	BPF_TEST_CLOBBER_ALU(ALU64_REG, XOR, R9, R1),
11374  	BPF_TEST_CLOBBER_ALU(ALU64_REG, LSH, R8, R1),
11375  	BPF_TEST_CLOBBER_ALU(ALU64_REG, LSH, R9, R1),
11376  	BPF_TEST_CLOBBER_ALU(ALU64_REG, RSH, R8, R1),
11377  	BPF_TEST_CLOBBER_ALU(ALU64_REG, RSH, R9, R1),
11378  	BPF_TEST_CLOBBER_ALU(ALU64_REG, ARSH, R8, R1),
11379  	BPF_TEST_CLOBBER_ALU(ALU64_REG, ARSH, R9, R1),
11380  	BPF_TEST_CLOBBER_ALU(ALU64_REG, ADD, R8, R1),
11381  	BPF_TEST_CLOBBER_ALU(ALU64_REG, ADD, R9, R1),
11382  	BPF_TEST_CLOBBER_ALU(ALU64_REG, SUB, R8, R1),
11383  	BPF_TEST_CLOBBER_ALU(ALU64_REG, SUB, R9, R1),
11384  	BPF_TEST_CLOBBER_ALU(ALU64_REG, MUL, R8, R1),
11385  	BPF_TEST_CLOBBER_ALU(ALU64_REG, MUL, R9, R1),
11386  	BPF_TEST_CLOBBER_ALU(ALU64_REG, DIV, R8, R1),
11387  	BPF_TEST_CLOBBER_ALU(ALU64_REG, DIV, R9, R1),
11388  	BPF_TEST_CLOBBER_ALU(ALU64_REG, MOD, R8, R1),
11389  	BPF_TEST_CLOBBER_ALU(ALU64_REG, MOD, R9, R1),
11390  	/* ALU32 register operations, register clobbering */
11391  	BPF_TEST_CLOBBER_ALU(ALU32_REG, AND, R8, R1),
11392  	BPF_TEST_CLOBBER_ALU(ALU32_REG, AND, R9, R1),
11393  	BPF_TEST_CLOBBER_ALU(ALU32_REG, OR, R8, R1),
11394  	BPF_TEST_CLOBBER_ALU(ALU32_REG, OR, R9, R1),
11395  	BPF_TEST_CLOBBER_ALU(ALU32_REG, XOR, R8, R1),
11396  	BPF_TEST_CLOBBER_ALU(ALU32_REG, XOR, R9, R1),
11397  	BPF_TEST_CLOBBER_ALU(ALU32_REG, LSH, R8, R1),
11398  	BPF_TEST_CLOBBER_ALU(ALU32_REG, LSH, R9, R1),
11399  	BPF_TEST_CLOBBER_ALU(ALU32_REG, RSH, R8, R1),
11400  	BPF_TEST_CLOBBER_ALU(ALU32_REG, RSH, R9, R1),
11401  	BPF_TEST_CLOBBER_ALU(ALU32_REG, ARSH, R8, R1),
11402  	BPF_TEST_CLOBBER_ALU(ALU32_REG, ARSH, R9, R1),
11403  	BPF_TEST_CLOBBER_ALU(ALU32_REG, ADD, R8, R1),
11404  	BPF_TEST_CLOBBER_ALU(ALU32_REG, ADD, R9, R1),
11405  	BPF_TEST_CLOBBER_ALU(ALU32_REG, SUB, R8, R1),
11406  	BPF_TEST_CLOBBER_ALU(ALU32_REG, SUB, R9, R1),
11407  	BPF_TEST_CLOBBER_ALU(ALU32_REG, MUL, R8, R1),
11408  	BPF_TEST_CLOBBER_ALU(ALU32_REG, MUL, R9, R1),
11409  	BPF_TEST_CLOBBER_ALU(ALU32_REG, DIV, R8, R1),
11410  	BPF_TEST_CLOBBER_ALU(ALU32_REG, DIV, R9, R1),
11411  	BPF_TEST_CLOBBER_ALU(ALU32_REG, MOD, R8, R1),
11412  	BPF_TEST_CLOBBER_ALU(ALU32_REG, MOD, R9, R1),
11413  #undef BPF_TEST_CLOBBER_ALU
11414  #define BPF_TEST_CLOBBER_ATOMIC(width, op)			\
11415  	{							\
11416  		"Atomic_" #width " " #op ": no clobbering",	\
11417  		.u.insns_int = {				\
11418  			BPF_ALU64_IMM(BPF_MOV, R0, 0),		\
11419  			BPF_ALU64_IMM(BPF_MOV, R1, 1),		\
11420  			BPF_ALU64_IMM(BPF_MOV, R2, 2),		\
11421  			BPF_ALU64_IMM(BPF_MOV, R3, 3),		\
11422  			BPF_ALU64_IMM(BPF_MOV, R4, 4),		\
11423  			BPF_ALU64_IMM(BPF_MOV, R5, 5),		\
11424  			BPF_ALU64_IMM(BPF_MOV, R6, 6),		\
11425  			BPF_ALU64_IMM(BPF_MOV, R7, 7),		\
11426  			BPF_ALU64_IMM(BPF_MOV, R8, 8),		\
11427  			BPF_ALU64_IMM(BPF_MOV, R9, 9),		\
11428  			BPF_ST_MEM(width, R10, -8,		\
11429  				   (op) == BPF_CMPXCHG ? 0 :	\
11430  				   (op) & BPF_FETCH ? 1 : 0),	\
11431  			BPF_ATOMIC_OP(width, op, R10, R1, -8),	\
11432  			BPF_JMP_IMM(BPF_JNE, R0, 0, 10),	\
11433  			BPF_JMP_IMM(BPF_JNE, R1, 1, 9),		\
11434  			BPF_JMP_IMM(BPF_JNE, R2, 2, 8),		\
11435  			BPF_JMP_IMM(BPF_JNE, R3, 3, 7),		\
11436  			BPF_JMP_IMM(BPF_JNE, R4, 4, 6),		\
11437  			BPF_JMP_IMM(BPF_JNE, R5, 5, 5),		\
11438  			BPF_JMP_IMM(BPF_JNE, R6, 6, 4),		\
11439  			BPF_JMP_IMM(BPF_JNE, R7, 7, 3),		\
11440  			BPF_JMP_IMM(BPF_JNE, R8, 8, 2),		\
11441  			BPF_JMP_IMM(BPF_JNE, R9, 9, 1),		\
11442  			BPF_ALU64_IMM(BPF_MOV, R0, 1),		\
11443  			BPF_EXIT_INSN(),			\
11444  		},						\
11445  		INTERNAL,					\
11446  		{ },						\
11447  		{ { 0, 1 } },					\
11448  		.stack_depth = 8,				\
11449  	}
11450  	/* 64-bit atomic operations, register clobbering */
11451  	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_ADD),
11452  	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_AND),
11453  	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_OR),
11454  	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_XOR),
11455  	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_ADD | BPF_FETCH),
11456  	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_AND | BPF_FETCH),
11457  	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_OR | BPF_FETCH),
11458  	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_XOR | BPF_FETCH),
11459  	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_XCHG),
11460  	BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_CMPXCHG),
11461  	/* 32-bit atomic operations, register clobbering */
11462  	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_ADD),
11463  	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_AND),
11464  	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_OR),
11465  	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_XOR),
11466  	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_ADD | BPF_FETCH),
11467  	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_AND | BPF_FETCH),
11468  	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_OR | BPF_FETCH),
11469  	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_XOR | BPF_FETCH),
11470  	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_XCHG),
11471  	BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_CMPXCHG),
11472  #undef BPF_TEST_CLOBBER_ATOMIC
11473  	/* Checking that ALU32 src is not zero extended in place */
11474  #define BPF_ALU32_SRC_ZEXT(op)					\
11475  	{							\
11476  		"ALU32_" #op "_X: src preserved in zext",	\
11477  		.u.insns_int = {				\
11478  			BPF_LD_IMM64(R1, 0x0123456789acbdefULL),\
11479  			BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),\
11480  			BPF_ALU64_REG(BPF_MOV, R0, R1),		\
11481  			BPF_ALU32_REG(BPF_##op, R2, R1),	\
11482  			BPF_ALU64_REG(BPF_SUB, R0, R1),		\
11483  			BPF_ALU64_REG(BPF_MOV, R1, R0),		\
11484  			BPF_ALU64_IMM(BPF_RSH, R1, 32),		\
11485  			BPF_ALU64_REG(BPF_OR, R0, R1),		\
11486  			BPF_EXIT_INSN(),			\
11487  		},						\
11488  		INTERNAL,					\
11489  		{ },						\
11490  		{ { 0, 0 } },					\
11491  	}
11492  	BPF_ALU32_SRC_ZEXT(MOV),
11493  	BPF_ALU32_SRC_ZEXT(AND),
11494  	BPF_ALU32_SRC_ZEXT(OR),
11495  	BPF_ALU32_SRC_ZEXT(XOR),
11496  	BPF_ALU32_SRC_ZEXT(ADD),
11497  	BPF_ALU32_SRC_ZEXT(SUB),
11498  	BPF_ALU32_SRC_ZEXT(MUL),
11499  	BPF_ALU32_SRC_ZEXT(DIV),
11500  	BPF_ALU32_SRC_ZEXT(MOD),
11501  #undef BPF_ALU32_SRC_ZEXT
11502  	/* Checking that ATOMIC32 src is not zero extended in place */
11503  #define BPF_ATOMIC32_SRC_ZEXT(op)					\
11504  	{								\
11505  		"ATOMIC_W_" #op ": src preserved in zext",		\
11506  		.u.insns_int = {					\
11507  			BPF_LD_IMM64(R0, 0x0123456789acbdefULL),	\
11508  			BPF_ALU64_REG(BPF_MOV, R1, R0),			\
11509  			BPF_ST_MEM(BPF_W, R10, -4, 0),			\
11510  			BPF_ATOMIC_OP(BPF_W, BPF_##op, R10, R1, -4),	\
11511  			BPF_ALU64_REG(BPF_SUB, R0, R1),			\
11512  			BPF_ALU64_REG(BPF_MOV, R1, R0),			\
11513  			BPF_ALU64_IMM(BPF_RSH, R1, 32),			\
11514  			BPF_ALU64_REG(BPF_OR, R0, R1),			\
11515  			BPF_EXIT_INSN(),				\
11516  		},							\
11517  		INTERNAL,						\
11518  		{ },							\
11519  		{ { 0, 0 } },						\
11520  		.stack_depth = 8,					\
11521  	}
11522  	BPF_ATOMIC32_SRC_ZEXT(ADD),
11523  	BPF_ATOMIC32_SRC_ZEXT(AND),
11524  	BPF_ATOMIC32_SRC_ZEXT(OR),
11525  	BPF_ATOMIC32_SRC_ZEXT(XOR),
11526  #undef BPF_ATOMIC32_SRC_ZEXT
11527  	/* Checking that CMPXCHG32 src is not zero extended in place */
11528  	{
11529  		"ATOMIC_W_CMPXCHG: src preserved in zext",
11530  		.u.insns_int = {
11531  			BPF_LD_IMM64(R1, 0x0123456789acbdefULL),
11532  			BPF_ALU64_REG(BPF_MOV, R2, R1),
11533  			BPF_ALU64_REG(BPF_MOV, R0, 0),
11534  			BPF_ST_MEM(BPF_W, R10, -4, 0),
11535  			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R1, -4),
11536  			BPF_ALU64_REG(BPF_SUB, R1, R2),
11537  			BPF_ALU64_REG(BPF_MOV, R2, R1),
11538  			BPF_ALU64_IMM(BPF_RSH, R2, 32),
11539  			BPF_ALU64_REG(BPF_OR, R1, R2),
11540  			BPF_ALU64_REG(BPF_MOV, R0, R1),
11541  			BPF_EXIT_INSN(),
11542  		},
11543  		INTERNAL,
11544  		{ },
11545  		{ { 0, 0 } },
11546  		.stack_depth = 8,
11547  	},
11548  	/* Checking that JMP32 immediate src is not zero extended in place */
11549  #define BPF_JMP32_IMM_ZEXT(op)					\
11550  	{							\
11551  		"JMP32_" #op "_K: operand preserved in zext",	\
11552  		.u.insns_int = {				\
11553  			BPF_LD_IMM64(R0, 0x0123456789acbdefULL),\
11554  			BPF_ALU64_REG(BPF_MOV, R1, R0),		\
11555  			BPF_JMP32_IMM(BPF_##op, R0, 1234, 1),	\
11556  			BPF_JMP_A(0), /* Nop */			\
11557  			BPF_ALU64_REG(BPF_SUB, R0, R1),		\
11558  			BPF_ALU64_REG(BPF_MOV, R1, R0),		\
11559  			BPF_ALU64_IMM(BPF_RSH, R1, 32),		\
11560  			BPF_ALU64_REG(BPF_OR, R0, R1),		\
11561  			BPF_EXIT_INSN(),			\
11562  		},						\
11563  		INTERNAL,					\
11564  		{ },						\
11565  		{ { 0, 0 } },					\
11566  	}
11567  	BPF_JMP32_IMM_ZEXT(JEQ),
11568  	BPF_JMP32_IMM_ZEXT(JNE),
11569  	BPF_JMP32_IMM_ZEXT(JSET),
11570  	BPF_JMP32_IMM_ZEXT(JGT),
11571  	BPF_JMP32_IMM_ZEXT(JGE),
11572  	BPF_JMP32_IMM_ZEXT(JLT),
11573  	BPF_JMP32_IMM_ZEXT(JLE),
11574  	BPF_JMP32_IMM_ZEXT(JSGT),
11575  	BPF_JMP32_IMM_ZEXT(JSGE),
11576  	BPF_JMP32_IMM_ZEXT(JSGT),
11577  	BPF_JMP32_IMM_ZEXT(JSLT),
11578  	BPF_JMP32_IMM_ZEXT(JSLE),
11579  #undef BPF_JMP2_IMM_ZEXT
11580  	/* Checking that JMP32 dst & src are not zero extended in place */
11581  #define BPF_JMP32_REG_ZEXT(op)					\
11582  	{							\
11583  		"JMP32_" #op "_X: operands preserved in zext",	\
11584  		.u.insns_int = {				\
11585  			BPF_LD_IMM64(R0, 0x0123456789acbdefULL),\
11586  			BPF_LD_IMM64(R1, 0xfedcba9876543210ULL),\
11587  			BPF_ALU64_REG(BPF_MOV, R2, R0),		\
11588  			BPF_ALU64_REG(BPF_MOV, R3, R1),		\
11589  			BPF_JMP32_IMM(BPF_##op, R0, R1, 1),	\
11590  			BPF_JMP_A(0), /* Nop */			\
11591  			BPF_ALU64_REG(BPF_SUB, R0, R2),		\
11592  			BPF_ALU64_REG(BPF_SUB, R1, R3),		\
11593  			BPF_ALU64_REG(BPF_OR, R0, R1),		\
11594  			BPF_ALU64_REG(BPF_MOV, R1, R0),		\
11595  			BPF_ALU64_IMM(BPF_RSH, R1, 32),		\
11596  			BPF_ALU64_REG(BPF_OR, R0, R1),		\
11597  			BPF_EXIT_INSN(),			\
11598  		},						\
11599  		INTERNAL,					\
11600  		{ },						\
11601  		{ { 0, 0 } },					\
11602  	}
11603  	BPF_JMP32_REG_ZEXT(JEQ),
11604  	BPF_JMP32_REG_ZEXT(JNE),
11605  	BPF_JMP32_REG_ZEXT(JSET),
11606  	BPF_JMP32_REG_ZEXT(JGT),
11607  	BPF_JMP32_REG_ZEXT(JGE),
11608  	BPF_JMP32_REG_ZEXT(JLT),
11609  	BPF_JMP32_REG_ZEXT(JLE),
11610  	BPF_JMP32_REG_ZEXT(JSGT),
11611  	BPF_JMP32_REG_ZEXT(JSGE),
11612  	BPF_JMP32_REG_ZEXT(JSGT),
11613  	BPF_JMP32_REG_ZEXT(JSLT),
11614  	BPF_JMP32_REG_ZEXT(JSLE),
11615  #undef BPF_JMP2_REG_ZEXT
11616  	/* ALU64 K register combinations */
11617  	{
11618  		"ALU64_MOV_K: registers",
11619  		{ },
11620  		INTERNAL,
11621  		{ },
11622  		{ { 0, 1 } },
11623  		.fill_helper = bpf_fill_alu64_mov_imm_regs,
11624  	},
11625  	{
11626  		"ALU64_AND_K: registers",
11627  		{ },
11628  		INTERNAL,
11629  		{ },
11630  		{ { 0, 1 } },
11631  		.fill_helper = bpf_fill_alu64_and_imm_regs,
11632  	},
11633  	{
11634  		"ALU64_OR_K: registers",
11635  		{ },
11636  		INTERNAL,
11637  		{ },
11638  		{ { 0, 1 } },
11639  		.fill_helper = bpf_fill_alu64_or_imm_regs,
11640  	},
11641  	{
11642  		"ALU64_XOR_K: registers",
11643  		{ },
11644  		INTERNAL,
11645  		{ },
11646  		{ { 0, 1 } },
11647  		.fill_helper = bpf_fill_alu64_xor_imm_regs,
11648  	},
11649  	{
11650  		"ALU64_LSH_K: registers",
11651  		{ },
11652  		INTERNAL,
11653  		{ },
11654  		{ { 0, 1 } },
11655  		.fill_helper = bpf_fill_alu64_lsh_imm_regs,
11656  	},
11657  	{
11658  		"ALU64_RSH_K: registers",
11659  		{ },
11660  		INTERNAL,
11661  		{ },
11662  		{ { 0, 1 } },
11663  		.fill_helper = bpf_fill_alu64_rsh_imm_regs,
11664  	},
11665  	{
11666  		"ALU64_ARSH_K: registers",
11667  		{ },
11668  		INTERNAL,
11669  		{ },
11670  		{ { 0, 1 } },
11671  		.fill_helper = bpf_fill_alu64_arsh_imm_regs,
11672  	},
11673  	{
11674  		"ALU64_ADD_K: registers",
11675  		{ },
11676  		INTERNAL,
11677  		{ },
11678  		{ { 0, 1 } },
11679  		.fill_helper = bpf_fill_alu64_add_imm_regs,
11680  	},
11681  	{
11682  		"ALU64_SUB_K: registers",
11683  		{ },
11684  		INTERNAL,
11685  		{ },
11686  		{ { 0, 1 } },
11687  		.fill_helper = bpf_fill_alu64_sub_imm_regs,
11688  	},
11689  	{
11690  		"ALU64_MUL_K: registers",
11691  		{ },
11692  		INTERNAL,
11693  		{ },
11694  		{ { 0, 1 } },
11695  		.fill_helper = bpf_fill_alu64_mul_imm_regs,
11696  	},
11697  	{
11698  		"ALU64_DIV_K: registers",
11699  		{ },
11700  		INTERNAL,
11701  		{ },
11702  		{ { 0, 1 } },
11703  		.fill_helper = bpf_fill_alu64_div_imm_regs,
11704  	},
11705  	{
11706  		"ALU64_MOD_K: registers",
11707  		{ },
11708  		INTERNAL,
11709  		{ },
11710  		{ { 0, 1 } },
11711  		.fill_helper = bpf_fill_alu64_mod_imm_regs,
11712  	},
11713  	/* ALU32 K registers */
11714  	{
11715  		"ALU32_MOV_K: registers",
11716  		{ },
11717  		INTERNAL,
11718  		{ },
11719  		{ { 0, 1 } },
11720  		.fill_helper = bpf_fill_alu32_mov_imm_regs,
11721  	},
11722  	{
11723  		"ALU32_AND_K: registers",
11724  		{ },
11725  		INTERNAL,
11726  		{ },
11727  		{ { 0, 1 } },
11728  		.fill_helper = bpf_fill_alu32_and_imm_regs,
11729  	},
11730  	{
11731  		"ALU32_OR_K: registers",
11732  		{ },
11733  		INTERNAL,
11734  		{ },
11735  		{ { 0, 1 } },
11736  		.fill_helper = bpf_fill_alu32_or_imm_regs,
11737  	},
11738  	{
11739  		"ALU32_XOR_K: registers",
11740  		{ },
11741  		INTERNAL,
11742  		{ },
11743  		{ { 0, 1 } },
11744  		.fill_helper = bpf_fill_alu32_xor_imm_regs,
11745  	},
11746  	{
11747  		"ALU32_LSH_K: registers",
11748  		{ },
11749  		INTERNAL,
11750  		{ },
11751  		{ { 0, 1 } },
11752  		.fill_helper = bpf_fill_alu32_lsh_imm_regs,
11753  	},
11754  	{
11755  		"ALU32_RSH_K: registers",
11756  		{ },
11757  		INTERNAL,
11758  		{ },
11759  		{ { 0, 1 } },
11760  		.fill_helper = bpf_fill_alu32_rsh_imm_regs,
11761  	},
11762  	{
11763  		"ALU32_ARSH_K: registers",
11764  		{ },
11765  		INTERNAL,
11766  		{ },
11767  		{ { 0, 1 } },
11768  		.fill_helper = bpf_fill_alu32_arsh_imm_regs,
11769  	},
11770  	{
11771  		"ALU32_ADD_K: registers",
11772  		{ },
11773  		INTERNAL,
11774  		{ },
11775  		{ { 0, 1 } },
11776  		.fill_helper = bpf_fill_alu32_add_imm_regs,
11777  	},
11778  	{
11779  		"ALU32_SUB_K: registers",
11780  		{ },
11781  		INTERNAL,
11782  		{ },
11783  		{ { 0, 1 } },
11784  		.fill_helper = bpf_fill_alu32_sub_imm_regs,
11785  	},
11786  	{
11787  		"ALU32_MUL_K: registers",
11788  		{ },
11789  		INTERNAL,
11790  		{ },
11791  		{ { 0, 1 } },
11792  		.fill_helper = bpf_fill_alu32_mul_imm_regs,
11793  	},
11794  	{
11795  		"ALU32_DIV_K: registers",
11796  		{ },
11797  		INTERNAL,
11798  		{ },
11799  		{ { 0, 1 } },
11800  		.fill_helper = bpf_fill_alu32_div_imm_regs,
11801  	},
11802  	{
11803  		"ALU32_MOD_K: registers",
11804  		{ },
11805  		INTERNAL,
11806  		{ },
11807  		{ { 0, 1 } },
11808  		.fill_helper = bpf_fill_alu32_mod_imm_regs,
11809  	},
11810  	/* ALU64 X register combinations */
11811  	{
11812  		"ALU64_MOV_X: register combinations",
11813  		{ },
11814  		INTERNAL,
11815  		{ },
11816  		{ { 0, 1 } },
11817  		.fill_helper = bpf_fill_alu64_mov_reg_pairs,
11818  	},
11819  	{
11820  		"ALU64_AND_X: register combinations",
11821  		{ },
11822  		INTERNAL,
11823  		{ },
11824  		{ { 0, 1 } },
11825  		.fill_helper = bpf_fill_alu64_and_reg_pairs,
11826  	},
11827  	{
11828  		"ALU64_OR_X: register combinations",
11829  		{ },
11830  		INTERNAL,
11831  		{ },
11832  		{ { 0, 1 } },
11833  		.fill_helper = bpf_fill_alu64_or_reg_pairs,
11834  	},
11835  	{
11836  		"ALU64_XOR_X: register combinations",
11837  		{ },
11838  		INTERNAL,
11839  		{ },
11840  		{ { 0, 1 } },
11841  		.fill_helper = bpf_fill_alu64_xor_reg_pairs,
11842  	},
11843  	{
11844  		"ALU64_LSH_X: register combinations",
11845  		{ },
11846  		INTERNAL,
11847  		{ },
11848  		{ { 0, 1 } },
11849  		.fill_helper = bpf_fill_alu64_lsh_reg_pairs,
11850  	},
11851  	{
11852  		"ALU64_RSH_X: register combinations",
11853  		{ },
11854  		INTERNAL,
11855  		{ },
11856  		{ { 0, 1 } },
11857  		.fill_helper = bpf_fill_alu64_rsh_reg_pairs,
11858  	},
11859  	{
11860  		"ALU64_ARSH_X: register combinations",
11861  		{ },
11862  		INTERNAL,
11863  		{ },
11864  		{ { 0, 1 } },
11865  		.fill_helper = bpf_fill_alu64_arsh_reg_pairs,
11866  	},
11867  	{
11868  		"ALU64_ADD_X: register combinations",
11869  		{ },
11870  		INTERNAL,
11871  		{ },
11872  		{ { 0, 1 } },
11873  		.fill_helper = bpf_fill_alu64_add_reg_pairs,
11874  	},
11875  	{
11876  		"ALU64_SUB_X: register combinations",
11877  		{ },
11878  		INTERNAL,
11879  		{ },
11880  		{ { 0, 1 } },
11881  		.fill_helper = bpf_fill_alu64_sub_reg_pairs,
11882  	},
11883  	{
11884  		"ALU64_MUL_X: register combinations",
11885  		{ },
11886  		INTERNAL,
11887  		{ },
11888  		{ { 0, 1 } },
11889  		.fill_helper = bpf_fill_alu64_mul_reg_pairs,
11890  	},
11891  	{
11892  		"ALU64_DIV_X: register combinations",
11893  		{ },
11894  		INTERNAL,
11895  		{ },
11896  		{ { 0, 1 } },
11897  		.fill_helper = bpf_fill_alu64_div_reg_pairs,
11898  	},
11899  	{
11900  		"ALU64_MOD_X: register combinations",
11901  		{ },
11902  		INTERNAL,
11903  		{ },
11904  		{ { 0, 1 } },
11905  		.fill_helper = bpf_fill_alu64_mod_reg_pairs,
11906  	},
11907  	/* ALU32 X register combinations */
11908  	{
11909  		"ALU32_MOV_X: register combinations",
11910  		{ },
11911  		INTERNAL,
11912  		{ },
11913  		{ { 0, 1 } },
11914  		.fill_helper = bpf_fill_alu32_mov_reg_pairs,
11915  	},
11916  	{
11917  		"ALU32_AND_X: register combinations",
11918  		{ },
11919  		INTERNAL,
11920  		{ },
11921  		{ { 0, 1 } },
11922  		.fill_helper = bpf_fill_alu32_and_reg_pairs,
11923  	},
11924  	{
11925  		"ALU32_OR_X: register combinations",
11926  		{ },
11927  		INTERNAL,
11928  		{ },
11929  		{ { 0, 1 } },
11930  		.fill_helper = bpf_fill_alu32_or_reg_pairs,
11931  	},
11932  	{
11933  		"ALU32_XOR_X: register combinations",
11934  		{ },
11935  		INTERNAL,
11936  		{ },
11937  		{ { 0, 1 } },
11938  		.fill_helper = bpf_fill_alu32_xor_reg_pairs,
11939  	},
11940  	{
11941  		"ALU32_LSH_X: register combinations",
11942  		{ },
11943  		INTERNAL,
11944  		{ },
11945  		{ { 0, 1 } },
11946  		.fill_helper = bpf_fill_alu32_lsh_reg_pairs,
11947  	},
11948  	{
11949  		"ALU32_RSH_X: register combinations",
11950  		{ },
11951  		INTERNAL,
11952  		{ },
11953  		{ { 0, 1 } },
11954  		.fill_helper = bpf_fill_alu32_rsh_reg_pairs,
11955  	},
11956  	{
11957  		"ALU32_ARSH_X: register combinations",
11958  		{ },
11959  		INTERNAL,
11960  		{ },
11961  		{ { 0, 1 } },
11962  		.fill_helper = bpf_fill_alu32_arsh_reg_pairs,
11963  	},
11964  	{
11965  		"ALU32_ADD_X: register combinations",
11966  		{ },
11967  		INTERNAL,
11968  		{ },
11969  		{ { 0, 1 } },
11970  		.fill_helper = bpf_fill_alu32_add_reg_pairs,
11971  	},
11972  	{
11973  		"ALU32_SUB_X: register combinations",
11974  		{ },
11975  		INTERNAL,
11976  		{ },
11977  		{ { 0, 1 } },
11978  		.fill_helper = bpf_fill_alu32_sub_reg_pairs,
11979  	},
11980  	{
11981  		"ALU32_MUL_X: register combinations",
11982  		{ },
11983  		INTERNAL,
11984  		{ },
11985  		{ { 0, 1 } },
11986  		.fill_helper = bpf_fill_alu32_mul_reg_pairs,
11987  	},
11988  	{
11989  		"ALU32_DIV_X: register combinations",
11990  		{ },
11991  		INTERNAL,
11992  		{ },
11993  		{ { 0, 1 } },
11994  		.fill_helper = bpf_fill_alu32_div_reg_pairs,
11995  	},
11996  	{
11997  		"ALU32_MOD_X register combinations",
11998  		{ },
11999  		INTERNAL,
12000  		{ },
12001  		{ { 0, 1 } },
12002  		.fill_helper = bpf_fill_alu32_mod_reg_pairs,
12003  	},
12004  	/* Exhaustive test of ALU64 shift operations */
12005  	{
12006  		"ALU64_LSH_K: all shift values",
12007  		{ },
12008  		INTERNAL | FLAG_NO_DATA,
12009  		{ },
12010  		{ { 0, 1 } },
12011  		.fill_helper = bpf_fill_alu64_lsh_imm,
12012  	},
12013  	{
12014  		"ALU64_RSH_K: all shift values",
12015  		{ },
12016  		INTERNAL | FLAG_NO_DATA,
12017  		{ },
12018  		{ { 0, 1 } },
12019  		.fill_helper = bpf_fill_alu64_rsh_imm,
12020  	},
12021  	{
12022  		"ALU64_ARSH_K: all shift values",
12023  		{ },
12024  		INTERNAL | FLAG_NO_DATA,
12025  		{ },
12026  		{ { 0, 1 } },
12027  		.fill_helper = bpf_fill_alu64_arsh_imm,
12028  	},
12029  	{
12030  		"ALU64_LSH_X: all shift values",
12031  		{ },
12032  		INTERNAL | FLAG_NO_DATA,
12033  		{ },
12034  		{ { 0, 1 } },
12035  		.fill_helper = bpf_fill_alu64_lsh_reg,
12036  	},
12037  	{
12038  		"ALU64_RSH_X: all shift values",
12039  		{ },
12040  		INTERNAL | FLAG_NO_DATA,
12041  		{ },
12042  		{ { 0, 1 } },
12043  		.fill_helper = bpf_fill_alu64_rsh_reg,
12044  	},
12045  	{
12046  		"ALU64_ARSH_X: all shift values",
12047  		{ },
12048  		INTERNAL | FLAG_NO_DATA,
12049  		{ },
12050  		{ { 0, 1 } },
12051  		.fill_helper = bpf_fill_alu64_arsh_reg,
12052  	},
12053  	/* Exhaustive test of ALU32 shift operations */
12054  	{
12055  		"ALU32_LSH_K: all shift values",
12056  		{ },
12057  		INTERNAL | FLAG_NO_DATA,
12058  		{ },
12059  		{ { 0, 1 } },
12060  		.fill_helper = bpf_fill_alu32_lsh_imm,
12061  	},
12062  	{
12063  		"ALU32_RSH_K: all shift values",
12064  		{ },
12065  		INTERNAL | FLAG_NO_DATA,
12066  		{ },
12067  		{ { 0, 1 } },
12068  		.fill_helper = bpf_fill_alu32_rsh_imm,
12069  	},
12070  	{
12071  		"ALU32_ARSH_K: all shift values",
12072  		{ },
12073  		INTERNAL | FLAG_NO_DATA,
12074  		{ },
12075  		{ { 0, 1 } },
12076  		.fill_helper = bpf_fill_alu32_arsh_imm,
12077  	},
12078  	{
12079  		"ALU32_LSH_X: all shift values",
12080  		{ },
12081  		INTERNAL | FLAG_NO_DATA,
12082  		{ },
12083  		{ { 0, 1 } },
12084  		.fill_helper = bpf_fill_alu32_lsh_reg,
12085  	},
12086  	{
12087  		"ALU32_RSH_X: all shift values",
12088  		{ },
12089  		INTERNAL | FLAG_NO_DATA,
12090  		{ },
12091  		{ { 0, 1 } },
12092  		.fill_helper = bpf_fill_alu32_rsh_reg,
12093  	},
12094  	{
12095  		"ALU32_ARSH_X: all shift values",
12096  		{ },
12097  		INTERNAL | FLAG_NO_DATA,
12098  		{ },
12099  		{ { 0, 1 } },
12100  		.fill_helper = bpf_fill_alu32_arsh_reg,
12101  	},
12102  	/*
12103  	 * Exhaustive test of ALU64 shift operations when
12104  	 * source and destination register are the same.
12105  	 */
12106  	{
12107  		"ALU64_LSH_X: all shift values with the same register",
12108  		{ },
12109  		INTERNAL | FLAG_NO_DATA,
12110  		{ },
12111  		{ { 0, 1 } },
12112  		.fill_helper = bpf_fill_alu64_lsh_same_reg,
12113  	},
12114  	{
12115  		"ALU64_RSH_X: all shift values with the same register",
12116  		{ },
12117  		INTERNAL | FLAG_NO_DATA,
12118  		{ },
12119  		{ { 0, 1 } },
12120  		.fill_helper = bpf_fill_alu64_rsh_same_reg,
12121  	},
12122  	{
12123  		"ALU64_ARSH_X: all shift values with the same register",
12124  		{ },
12125  		INTERNAL | FLAG_NO_DATA,
12126  		{ },
12127  		{ { 0, 1 } },
12128  		.fill_helper = bpf_fill_alu64_arsh_same_reg,
12129  	},
12130  	/*
12131  	 * Exhaustive test of ALU32 shift operations when
12132  	 * source and destination register are the same.
12133  	 */
12134  	{
12135  		"ALU32_LSH_X: all shift values with the same register",
12136  		{ },
12137  		INTERNAL | FLAG_NO_DATA,
12138  		{ },
12139  		{ { 0, 1 } },
12140  		.fill_helper = bpf_fill_alu32_lsh_same_reg,
12141  	},
12142  	{
12143  		"ALU32_RSH_X: all shift values with the same register",
12144  		{ },
12145  		INTERNAL | FLAG_NO_DATA,
12146  		{ },
12147  		{ { 0, 1 } },
12148  		.fill_helper = bpf_fill_alu32_rsh_same_reg,
12149  	},
12150  	{
12151  		"ALU32_ARSH_X: all shift values with the same register",
12152  		{ },
12153  		INTERNAL | FLAG_NO_DATA,
12154  		{ },
12155  		{ { 0, 1 } },
12156  		.fill_helper = bpf_fill_alu32_arsh_same_reg,
12157  	},
12158  	/* ALU64 immediate magnitudes */
12159  	{
12160  		"ALU64_MOV_K: all immediate value magnitudes",
12161  		{ },
12162  		INTERNAL | FLAG_NO_DATA,
12163  		{ },
12164  		{ { 0, 1 } },
12165  		.fill_helper = bpf_fill_alu64_mov_imm,
12166  		.nr_testruns = NR_PATTERN_RUNS,
12167  	},
12168  	{
12169  		"ALU64_AND_K: all immediate value magnitudes",
12170  		{ },
12171  		INTERNAL | FLAG_NO_DATA,
12172  		{ },
12173  		{ { 0, 1 } },
12174  		.fill_helper = bpf_fill_alu64_and_imm,
12175  		.nr_testruns = NR_PATTERN_RUNS,
12176  	},
12177  	{
12178  		"ALU64_OR_K: all immediate value magnitudes",
12179  		{ },
12180  		INTERNAL | FLAG_NO_DATA,
12181  		{ },
12182  		{ { 0, 1 } },
12183  		.fill_helper = bpf_fill_alu64_or_imm,
12184  		.nr_testruns = NR_PATTERN_RUNS,
12185  	},
12186  	{
12187  		"ALU64_XOR_K: all immediate value magnitudes",
12188  		{ },
12189  		INTERNAL | FLAG_NO_DATA,
12190  		{ },
12191  		{ { 0, 1 } },
12192  		.fill_helper = bpf_fill_alu64_xor_imm,
12193  		.nr_testruns = NR_PATTERN_RUNS,
12194  	},
12195  	{
12196  		"ALU64_ADD_K: all immediate value magnitudes",
12197  		{ },
12198  		INTERNAL | FLAG_NO_DATA,
12199  		{ },
12200  		{ { 0, 1 } },
12201  		.fill_helper = bpf_fill_alu64_add_imm,
12202  		.nr_testruns = NR_PATTERN_RUNS,
12203  	},
12204  	{
12205  		"ALU64_SUB_K: all immediate value magnitudes",
12206  		{ },
12207  		INTERNAL | FLAG_NO_DATA,
12208  		{ },
12209  		{ { 0, 1 } },
12210  		.fill_helper = bpf_fill_alu64_sub_imm,
12211  		.nr_testruns = NR_PATTERN_RUNS,
12212  	},
12213  	{
12214  		"ALU64_MUL_K: all immediate value magnitudes",
12215  		{ },
12216  		INTERNAL | FLAG_NO_DATA,
12217  		{ },
12218  		{ { 0, 1 } },
12219  		.fill_helper = bpf_fill_alu64_mul_imm,
12220  		.nr_testruns = NR_PATTERN_RUNS,
12221  	},
12222  	{
12223  		"ALU64_DIV_K: all immediate value magnitudes",
12224  		{ },
12225  		INTERNAL | FLAG_NO_DATA,
12226  		{ },
12227  		{ { 0, 1 } },
12228  		.fill_helper = bpf_fill_alu64_div_imm,
12229  		.nr_testruns = NR_PATTERN_RUNS,
12230  	},
12231  	{
12232  		"ALU64_MOD_K: all immediate value magnitudes",
12233  		{ },
12234  		INTERNAL | FLAG_NO_DATA,
12235  		{ },
12236  		{ { 0, 1 } },
12237  		.fill_helper = bpf_fill_alu64_mod_imm,
12238  		.nr_testruns = NR_PATTERN_RUNS,
12239  	},
12240  	/* ALU32 immediate magnitudes */
12241  	{
12242  		"ALU32_MOV_K: all immediate value magnitudes",
12243  		{ },
12244  		INTERNAL | FLAG_NO_DATA,
12245  		{ },
12246  		{ { 0, 1 } },
12247  		.fill_helper = bpf_fill_alu32_mov_imm,
12248  		.nr_testruns = NR_PATTERN_RUNS,
12249  	},
12250  	{
12251  		"ALU32_AND_K: all immediate value magnitudes",
12252  		{ },
12253  		INTERNAL | FLAG_NO_DATA,
12254  		{ },
12255  		{ { 0, 1 } },
12256  		.fill_helper = bpf_fill_alu32_and_imm,
12257  		.nr_testruns = NR_PATTERN_RUNS,
12258  	},
12259  	{
12260  		"ALU32_OR_K: all immediate value magnitudes",
12261  		{ },
12262  		INTERNAL | FLAG_NO_DATA,
12263  		{ },
12264  		{ { 0, 1 } },
12265  		.fill_helper = bpf_fill_alu32_or_imm,
12266  		.nr_testruns = NR_PATTERN_RUNS,
12267  	},
12268  	{
12269  		"ALU32_XOR_K: all immediate value magnitudes",
12270  		{ },
12271  		INTERNAL | FLAG_NO_DATA,
12272  		{ },
12273  		{ { 0, 1 } },
12274  		.fill_helper = bpf_fill_alu32_xor_imm,
12275  		.nr_testruns = NR_PATTERN_RUNS,
12276  	},
12277  	{
12278  		"ALU32_ADD_K: all immediate value magnitudes",
12279  		{ },
12280  		INTERNAL | FLAG_NO_DATA,
12281  		{ },
12282  		{ { 0, 1 } },
12283  		.fill_helper = bpf_fill_alu32_add_imm,
12284  		.nr_testruns = NR_PATTERN_RUNS,
12285  	},
12286  	{
12287  		"ALU32_SUB_K: all immediate value magnitudes",
12288  		{ },
12289  		INTERNAL | FLAG_NO_DATA,
12290  		{ },
12291  		{ { 0, 1 } },
12292  		.fill_helper = bpf_fill_alu32_sub_imm,
12293  		.nr_testruns = NR_PATTERN_RUNS,
12294  	},
12295  	{
12296  		"ALU32_MUL_K: all immediate value magnitudes",
12297  		{ },
12298  		INTERNAL | FLAG_NO_DATA,
12299  		{ },
12300  		{ { 0, 1 } },
12301  		.fill_helper = bpf_fill_alu32_mul_imm,
12302  		.nr_testruns = NR_PATTERN_RUNS,
12303  	},
12304  	{
12305  		"ALU32_DIV_K: all immediate value magnitudes",
12306  		{ },
12307  		INTERNAL | FLAG_NO_DATA,
12308  		{ },
12309  		{ { 0, 1 } },
12310  		.fill_helper = bpf_fill_alu32_div_imm,
12311  		.nr_testruns = NR_PATTERN_RUNS,
12312  	},
12313  	{
12314  		"ALU32_MOD_K: all immediate value magnitudes",
12315  		{ },
12316  		INTERNAL | FLAG_NO_DATA,
12317  		{ },
12318  		{ { 0, 1 } },
12319  		.fill_helper = bpf_fill_alu32_mod_imm,
12320  		.nr_testruns = NR_PATTERN_RUNS,
12321  	},
12322  	/* ALU64 register magnitudes */
12323  	{
12324  		"ALU64_MOV_X: all register value magnitudes",
12325  		{ },
12326  		INTERNAL | FLAG_NO_DATA,
12327  		{ },
12328  		{ { 0, 1 } },
12329  		.fill_helper = bpf_fill_alu64_mov_reg,
12330  		.nr_testruns = NR_PATTERN_RUNS,
12331  	},
12332  	{
12333  		"ALU64_AND_X: all register value magnitudes",
12334  		{ },
12335  		INTERNAL | FLAG_NO_DATA,
12336  		{ },
12337  		{ { 0, 1 } },
12338  		.fill_helper = bpf_fill_alu64_and_reg,
12339  		.nr_testruns = NR_PATTERN_RUNS,
12340  	},
12341  	{
12342  		"ALU64_OR_X: all register value magnitudes",
12343  		{ },
12344  		INTERNAL | FLAG_NO_DATA,
12345  		{ },
12346  		{ { 0, 1 } },
12347  		.fill_helper = bpf_fill_alu64_or_reg,
12348  		.nr_testruns = NR_PATTERN_RUNS,
12349  	},
12350  	{
12351  		"ALU64_XOR_X: all register value magnitudes",
12352  		{ },
12353  		INTERNAL | FLAG_NO_DATA,
12354  		{ },
12355  		{ { 0, 1 } },
12356  		.fill_helper = bpf_fill_alu64_xor_reg,
12357  		.nr_testruns = NR_PATTERN_RUNS,
12358  	},
12359  	{
12360  		"ALU64_ADD_X: all register value magnitudes",
12361  		{ },
12362  		INTERNAL | FLAG_NO_DATA,
12363  		{ },
12364  		{ { 0, 1 } },
12365  		.fill_helper = bpf_fill_alu64_add_reg,
12366  		.nr_testruns = NR_PATTERN_RUNS,
12367  	},
12368  	{
12369  		"ALU64_SUB_X: all register value magnitudes",
12370  		{ },
12371  		INTERNAL | FLAG_NO_DATA,
12372  		{ },
12373  		{ { 0, 1 } },
12374  		.fill_helper = bpf_fill_alu64_sub_reg,
12375  		.nr_testruns = NR_PATTERN_RUNS,
12376  	},
12377  	{
12378  		"ALU64_MUL_X: all register value magnitudes",
12379  		{ },
12380  		INTERNAL | FLAG_NO_DATA,
12381  		{ },
12382  		{ { 0, 1 } },
12383  		.fill_helper = bpf_fill_alu64_mul_reg,
12384  		.nr_testruns = NR_PATTERN_RUNS,
12385  	},
12386  	{
12387  		"ALU64_DIV_X: all register value magnitudes",
12388  		{ },
12389  		INTERNAL | FLAG_NO_DATA,
12390  		{ },
12391  		{ { 0, 1 } },
12392  		.fill_helper = bpf_fill_alu64_div_reg,
12393  		.nr_testruns = NR_PATTERN_RUNS,
12394  	},
12395  	{
12396  		"ALU64_MOD_X: all register value magnitudes",
12397  		{ },
12398  		INTERNAL | FLAG_NO_DATA,
12399  		{ },
12400  		{ { 0, 1 } },
12401  		.fill_helper = bpf_fill_alu64_mod_reg,
12402  		.nr_testruns = NR_PATTERN_RUNS,
12403  	},
12404  	/* ALU32 register magnitudes */
12405  	{
12406  		"ALU32_MOV_X: all register value magnitudes",
12407  		{ },
12408  		INTERNAL | FLAG_NO_DATA,
12409  		{ },
12410  		{ { 0, 1 } },
12411  		.fill_helper = bpf_fill_alu32_mov_reg,
12412  		.nr_testruns = NR_PATTERN_RUNS,
12413  	},
12414  	{
12415  		"ALU32_AND_X: all register value magnitudes",
12416  		{ },
12417  		INTERNAL | FLAG_NO_DATA,
12418  		{ },
12419  		{ { 0, 1 } },
12420  		.fill_helper = bpf_fill_alu32_and_reg,
12421  		.nr_testruns = NR_PATTERN_RUNS,
12422  	},
12423  	{
12424  		"ALU32_OR_X: all register value magnitudes",
12425  		{ },
12426  		INTERNAL | FLAG_NO_DATA,
12427  		{ },
12428  		{ { 0, 1 } },
12429  		.fill_helper = bpf_fill_alu32_or_reg,
12430  		.nr_testruns = NR_PATTERN_RUNS,
12431  	},
12432  	{
12433  		"ALU32_XOR_X: all register value magnitudes",
12434  		{ },
12435  		INTERNAL | FLAG_NO_DATA,
12436  		{ },
12437  		{ { 0, 1 } },
12438  		.fill_helper = bpf_fill_alu32_xor_reg,
12439  		.nr_testruns = NR_PATTERN_RUNS,
12440  	},
12441  	{
12442  		"ALU32_ADD_X: all register value magnitudes",
12443  		{ },
12444  		INTERNAL | FLAG_NO_DATA,
12445  		{ },
12446  		{ { 0, 1 } },
12447  		.fill_helper = bpf_fill_alu32_add_reg,
12448  		.nr_testruns = NR_PATTERN_RUNS,
12449  	},
12450  	{
12451  		"ALU32_SUB_X: all register value magnitudes",
12452  		{ },
12453  		INTERNAL | FLAG_NO_DATA,
12454  		{ },
12455  		{ { 0, 1 } },
12456  		.fill_helper = bpf_fill_alu32_sub_reg,
12457  		.nr_testruns = NR_PATTERN_RUNS,
12458  	},
12459  	{
12460  		"ALU32_MUL_X: all register value magnitudes",
12461  		{ },
12462  		INTERNAL | FLAG_NO_DATA,
12463  		{ },
12464  		{ { 0, 1 } },
12465  		.fill_helper = bpf_fill_alu32_mul_reg,
12466  		.nr_testruns = NR_PATTERN_RUNS,
12467  	},
12468  	{
12469  		"ALU32_DIV_X: all register value magnitudes",
12470  		{ },
12471  		INTERNAL | FLAG_NO_DATA,
12472  		{ },
12473  		{ { 0, 1 } },
12474  		.fill_helper = bpf_fill_alu32_div_reg,
12475  		.nr_testruns = NR_PATTERN_RUNS,
12476  	},
12477  	{
12478  		"ALU32_MOD_X: all register value magnitudes",
12479  		{ },
12480  		INTERNAL | FLAG_NO_DATA,
12481  		{ },
12482  		{ { 0, 1 } },
12483  		.fill_helper = bpf_fill_alu32_mod_reg,
12484  		.nr_testruns = NR_PATTERN_RUNS,
12485  	},
12486  	/* LD_IMM64 immediate magnitudes and byte patterns */
12487  	{
12488  		"LD_IMM64: all immediate value magnitudes",
12489  		{ },
12490  		INTERNAL | FLAG_NO_DATA,
12491  		{ },
12492  		{ { 0, 1 } },
12493  		.fill_helper = bpf_fill_ld_imm64_magn,
12494  	},
12495  	{
12496  		"LD_IMM64: checker byte patterns",
12497  		{ },
12498  		INTERNAL | FLAG_NO_DATA,
12499  		{ },
12500  		{ { 0, 1 } },
12501  		.fill_helper = bpf_fill_ld_imm64_checker,
12502  	},
12503  	{
12504  		"LD_IMM64: random positive and zero byte patterns",
12505  		{ },
12506  		INTERNAL | FLAG_NO_DATA,
12507  		{ },
12508  		{ { 0, 1 } },
12509  		.fill_helper = bpf_fill_ld_imm64_pos_zero,
12510  	},
12511  	{
12512  		"LD_IMM64: random negative and zero byte patterns",
12513  		{ },
12514  		INTERNAL | FLAG_NO_DATA,
12515  		{ },
12516  		{ { 0, 1 } },
12517  		.fill_helper = bpf_fill_ld_imm64_neg_zero,
12518  	},
12519  	{
12520  		"LD_IMM64: random positive and negative byte patterns",
12521  		{ },
12522  		INTERNAL | FLAG_NO_DATA,
12523  		{ },
12524  		{ { 0, 1 } },
12525  		.fill_helper = bpf_fill_ld_imm64_pos_neg,
12526  	},
12527  	/* 64-bit ATOMIC register combinations */
12528  	{
12529  		"ATOMIC_DW_ADD: register combinations",
12530  		{ },
12531  		INTERNAL,
12532  		{ },
12533  		{ { 0, 1 } },
12534  		.fill_helper = bpf_fill_atomic64_add_reg_pairs,
12535  		.stack_depth = 8,
12536  	},
12537  	{
12538  		"ATOMIC_DW_AND: register combinations",
12539  		{ },
12540  		INTERNAL,
12541  		{ },
12542  		{ { 0, 1 } },
12543  		.fill_helper = bpf_fill_atomic64_and_reg_pairs,
12544  		.stack_depth = 8,
12545  	},
12546  	{
12547  		"ATOMIC_DW_OR: register combinations",
12548  		{ },
12549  		INTERNAL,
12550  		{ },
12551  		{ { 0, 1 } },
12552  		.fill_helper = bpf_fill_atomic64_or_reg_pairs,
12553  		.stack_depth = 8,
12554  	},
12555  	{
12556  		"ATOMIC_DW_XOR: register combinations",
12557  		{ },
12558  		INTERNAL,
12559  		{ },
12560  		{ { 0, 1 } },
12561  		.fill_helper = bpf_fill_atomic64_xor_reg_pairs,
12562  		.stack_depth = 8,
12563  	},
12564  	{
12565  		"ATOMIC_DW_ADD_FETCH: register combinations",
12566  		{ },
12567  		INTERNAL,
12568  		{ },
12569  		{ { 0, 1 } },
12570  		.fill_helper = bpf_fill_atomic64_add_fetch_reg_pairs,
12571  		.stack_depth = 8,
12572  	},
12573  	{
12574  		"ATOMIC_DW_AND_FETCH: register combinations",
12575  		{ },
12576  		INTERNAL,
12577  		{ },
12578  		{ { 0, 1 } },
12579  		.fill_helper = bpf_fill_atomic64_and_fetch_reg_pairs,
12580  		.stack_depth = 8,
12581  	},
12582  	{
12583  		"ATOMIC_DW_OR_FETCH: register combinations",
12584  		{ },
12585  		INTERNAL,
12586  		{ },
12587  		{ { 0, 1 } },
12588  		.fill_helper = bpf_fill_atomic64_or_fetch_reg_pairs,
12589  		.stack_depth = 8,
12590  	},
12591  	{
12592  		"ATOMIC_DW_XOR_FETCH: register combinations",
12593  		{ },
12594  		INTERNAL,
12595  		{ },
12596  		{ { 0, 1 } },
12597  		.fill_helper = bpf_fill_atomic64_xor_fetch_reg_pairs,
12598  		.stack_depth = 8,
12599  	},
12600  	{
12601  		"ATOMIC_DW_XCHG: register combinations",
12602  		{ },
12603  		INTERNAL,
12604  		{ },
12605  		{ { 0, 1 } },
12606  		.fill_helper = bpf_fill_atomic64_xchg_reg_pairs,
12607  		.stack_depth = 8,
12608  	},
12609  	{
12610  		"ATOMIC_DW_CMPXCHG: register combinations",
12611  		{ },
12612  		INTERNAL,
12613  		{ },
12614  		{ { 0, 1 } },
12615  		.fill_helper = bpf_fill_atomic64_cmpxchg_reg_pairs,
12616  		.stack_depth = 8,
12617  	},
12618  	/* 32-bit ATOMIC register combinations */
12619  	{
12620  		"ATOMIC_W_ADD: register combinations",
12621  		{ },
12622  		INTERNAL,
12623  		{ },
12624  		{ { 0, 1 } },
12625  		.fill_helper = bpf_fill_atomic32_add_reg_pairs,
12626  		.stack_depth = 8,
12627  	},
12628  	{
12629  		"ATOMIC_W_AND: register combinations",
12630  		{ },
12631  		INTERNAL,
12632  		{ },
12633  		{ { 0, 1 } },
12634  		.fill_helper = bpf_fill_atomic32_and_reg_pairs,
12635  		.stack_depth = 8,
12636  	},
12637  	{
12638  		"ATOMIC_W_OR: register combinations",
12639  		{ },
12640  		INTERNAL,
12641  		{ },
12642  		{ { 0, 1 } },
12643  		.fill_helper = bpf_fill_atomic32_or_reg_pairs,
12644  		.stack_depth = 8,
12645  	},
12646  	{
12647  		"ATOMIC_W_XOR: register combinations",
12648  		{ },
12649  		INTERNAL,
12650  		{ },
12651  		{ { 0, 1 } },
12652  		.fill_helper = bpf_fill_atomic32_xor_reg_pairs,
12653  		.stack_depth = 8,
12654  	},
12655  	{
12656  		"ATOMIC_W_ADD_FETCH: register combinations",
12657  		{ },
12658  		INTERNAL,
12659  		{ },
12660  		{ { 0, 1 } },
12661  		.fill_helper = bpf_fill_atomic32_add_fetch_reg_pairs,
12662  		.stack_depth = 8,
12663  	},
12664  	{
12665  		"ATOMIC_W_AND_FETCH: register combinations",
12666  		{ },
12667  		INTERNAL,
12668  		{ },
12669  		{ { 0, 1 } },
12670  		.fill_helper = bpf_fill_atomic32_and_fetch_reg_pairs,
12671  		.stack_depth = 8,
12672  	},
12673  	{
12674  		"ATOMIC_W_OR_FETCH: register combinations",
12675  		{ },
12676  		INTERNAL,
12677  		{ },
12678  		{ { 0, 1 } },
12679  		.fill_helper = bpf_fill_atomic32_or_fetch_reg_pairs,
12680  		.stack_depth = 8,
12681  	},
12682  	{
12683  		"ATOMIC_W_XOR_FETCH: register combinations",
12684  		{ },
12685  		INTERNAL,
12686  		{ },
12687  		{ { 0, 1 } },
12688  		.fill_helper = bpf_fill_atomic32_xor_fetch_reg_pairs,
12689  		.stack_depth = 8,
12690  	},
12691  	{
12692  		"ATOMIC_W_XCHG: register combinations",
12693  		{ },
12694  		INTERNAL,
12695  		{ },
12696  		{ { 0, 1 } },
12697  		.fill_helper = bpf_fill_atomic32_xchg_reg_pairs,
12698  		.stack_depth = 8,
12699  	},
12700  	{
12701  		"ATOMIC_W_CMPXCHG: register combinations",
12702  		{ },
12703  		INTERNAL,
12704  		{ },
12705  		{ { 0, 1 } },
12706  		.fill_helper = bpf_fill_atomic32_cmpxchg_reg_pairs,
12707  		.stack_depth = 8,
12708  	},
12709  	/* 64-bit ATOMIC magnitudes */
12710  	{
12711  		"ATOMIC_DW_ADD: all operand magnitudes",
12712  		{ },
12713  		INTERNAL | FLAG_NO_DATA,
12714  		{ },
12715  		{ { 0, 1 } },
12716  		.fill_helper = bpf_fill_atomic64_add,
12717  		.stack_depth = 8,
12718  		.nr_testruns = NR_PATTERN_RUNS,
12719  	},
12720  	{
12721  		"ATOMIC_DW_AND: all operand magnitudes",
12722  		{ },
12723  		INTERNAL | FLAG_NO_DATA,
12724  		{ },
12725  		{ { 0, 1 } },
12726  		.fill_helper = bpf_fill_atomic64_and,
12727  		.stack_depth = 8,
12728  		.nr_testruns = NR_PATTERN_RUNS,
12729  	},
12730  	{
12731  		"ATOMIC_DW_OR: all operand magnitudes",
12732  		{ },
12733  		INTERNAL | FLAG_NO_DATA,
12734  		{ },
12735  		{ { 0, 1 } },
12736  		.fill_helper = bpf_fill_atomic64_or,
12737  		.stack_depth = 8,
12738  		.nr_testruns = NR_PATTERN_RUNS,
12739  	},
12740  	{
12741  		"ATOMIC_DW_XOR: all operand magnitudes",
12742  		{ },
12743  		INTERNAL | FLAG_NO_DATA,
12744  		{ },
12745  		{ { 0, 1 } },
12746  		.fill_helper = bpf_fill_atomic64_xor,
12747  		.stack_depth = 8,
12748  		.nr_testruns = NR_PATTERN_RUNS,
12749  	},
12750  	{
12751  		"ATOMIC_DW_ADD_FETCH: all operand magnitudes",
12752  		{ },
12753  		INTERNAL | FLAG_NO_DATA,
12754  		{ },
12755  		{ { 0, 1 } },
12756  		.fill_helper = bpf_fill_atomic64_add_fetch,
12757  		.stack_depth = 8,
12758  		.nr_testruns = NR_PATTERN_RUNS,
12759  	},
12760  	{
12761  		"ATOMIC_DW_AND_FETCH: all operand magnitudes",
12762  		{ },
12763  		INTERNAL | FLAG_NO_DATA,
12764  		{ },
12765  		{ { 0, 1 } },
12766  		.fill_helper = bpf_fill_atomic64_and_fetch,
12767  		.stack_depth = 8,
12768  		.nr_testruns = NR_PATTERN_RUNS,
12769  	},
12770  	{
12771  		"ATOMIC_DW_OR_FETCH: all operand magnitudes",
12772  		{ },
12773  		INTERNAL | FLAG_NO_DATA,
12774  		{ },
12775  		{ { 0, 1 } },
12776  		.fill_helper = bpf_fill_atomic64_or_fetch,
12777  		.stack_depth = 8,
12778  		.nr_testruns = NR_PATTERN_RUNS,
12779  	},
12780  	{
12781  		"ATOMIC_DW_XOR_FETCH: all operand magnitudes",
12782  		{ },
12783  		INTERNAL | FLAG_NO_DATA,
12784  		{ },
12785  		{ { 0, 1 } },
12786  		.fill_helper = bpf_fill_atomic64_xor_fetch,
12787  		.stack_depth = 8,
12788  		.nr_testruns = NR_PATTERN_RUNS,
12789  	},
12790  	{
12791  		"ATOMIC_DW_XCHG: all operand magnitudes",
12792  		{ },
12793  		INTERNAL | FLAG_NO_DATA,
12794  		{ },
12795  		{ { 0, 1 } },
12796  		.fill_helper = bpf_fill_atomic64_xchg,
12797  		.stack_depth = 8,
12798  		.nr_testruns = NR_PATTERN_RUNS,
12799  	},
12800  	{
12801  		"ATOMIC_DW_CMPXCHG: all operand magnitudes",
12802  		{ },
12803  		INTERNAL | FLAG_NO_DATA,
12804  		{ },
12805  		{ { 0, 1 } },
12806  		.fill_helper = bpf_fill_cmpxchg64,
12807  		.stack_depth = 8,
12808  		.nr_testruns = NR_PATTERN_RUNS,
12809  	},
12810  	/* 64-bit atomic magnitudes */
12811  	{
12812  		"ATOMIC_W_ADD: all operand magnitudes",
12813  		{ },
12814  		INTERNAL | FLAG_NO_DATA,
12815  		{ },
12816  		{ { 0, 1 } },
12817  		.fill_helper = bpf_fill_atomic32_add,
12818  		.stack_depth = 8,
12819  		.nr_testruns = NR_PATTERN_RUNS,
12820  	},
12821  	{
12822  		"ATOMIC_W_AND: all operand magnitudes",
12823  		{ },
12824  		INTERNAL | FLAG_NO_DATA,
12825  		{ },
12826  		{ { 0, 1 } },
12827  		.fill_helper = bpf_fill_atomic32_and,
12828  		.stack_depth = 8,
12829  		.nr_testruns = NR_PATTERN_RUNS,
12830  	},
12831  	{
12832  		"ATOMIC_W_OR: all operand magnitudes",
12833  		{ },
12834  		INTERNAL | FLAG_NO_DATA,
12835  		{ },
12836  		{ { 0, 1 } },
12837  		.fill_helper = bpf_fill_atomic32_or,
12838  		.stack_depth = 8,
12839  		.nr_testruns = NR_PATTERN_RUNS,
12840  	},
12841  	{
12842  		"ATOMIC_W_XOR: all operand magnitudes",
12843  		{ },
12844  		INTERNAL | FLAG_NO_DATA,
12845  		{ },
12846  		{ { 0, 1 } },
12847  		.fill_helper = bpf_fill_atomic32_xor,
12848  		.stack_depth = 8,
12849  		.nr_testruns = NR_PATTERN_RUNS,
12850  	},
12851  	{
12852  		"ATOMIC_W_ADD_FETCH: all operand magnitudes",
12853  		{ },
12854  		INTERNAL | FLAG_NO_DATA,
12855  		{ },
12856  		{ { 0, 1 } },
12857  		.fill_helper = bpf_fill_atomic32_add_fetch,
12858  		.stack_depth = 8,
12859  		.nr_testruns = NR_PATTERN_RUNS,
12860  	},
12861  	{
12862  		"ATOMIC_W_AND_FETCH: all operand magnitudes",
12863  		{ },
12864  		INTERNAL | FLAG_NO_DATA,
12865  		{ },
12866  		{ { 0, 1 } },
12867  		.fill_helper = bpf_fill_atomic32_and_fetch,
12868  		.stack_depth = 8,
12869  		.nr_testruns = NR_PATTERN_RUNS,
12870  	},
12871  	{
12872  		"ATOMIC_W_OR_FETCH: all operand magnitudes",
12873  		{ },
12874  		INTERNAL | FLAG_NO_DATA,
12875  		{ },
12876  		{ { 0, 1 } },
12877  		.fill_helper = bpf_fill_atomic32_or_fetch,
12878  		.stack_depth = 8,
12879  		.nr_testruns = NR_PATTERN_RUNS,
12880  	},
12881  	{
12882  		"ATOMIC_W_XOR_FETCH: all operand magnitudes",
12883  		{ },
12884  		INTERNAL | FLAG_NO_DATA,
12885  		{ },
12886  		{ { 0, 1 } },
12887  		.fill_helper = bpf_fill_atomic32_xor_fetch,
12888  		.stack_depth = 8,
12889  		.nr_testruns = NR_PATTERN_RUNS,
12890  	},
12891  	{
12892  		"ATOMIC_W_XCHG: all operand magnitudes",
12893  		{ },
12894  		INTERNAL | FLAG_NO_DATA,
12895  		{ },
12896  		{ { 0, 1 } },
12897  		.fill_helper = bpf_fill_atomic32_xchg,
12898  		.stack_depth = 8,
12899  		.nr_testruns = NR_PATTERN_RUNS,
12900  	},
12901  	{
12902  		"ATOMIC_W_CMPXCHG: all operand magnitudes",
12903  		{ },
12904  		INTERNAL | FLAG_NO_DATA,
12905  		{ },
12906  		{ { 0, 1 } },
12907  		.fill_helper = bpf_fill_cmpxchg32,
12908  		.stack_depth = 8,
12909  		.nr_testruns = NR_PATTERN_RUNS,
12910  	},
12911  	/* JMP immediate magnitudes */
12912  	{
12913  		"JMP_JSET_K: all immediate value magnitudes",
12914  		{ },
12915  		INTERNAL | FLAG_NO_DATA,
12916  		{ },
12917  		{ { 0, 1 } },
12918  		.fill_helper = bpf_fill_jmp_jset_imm,
12919  		.nr_testruns = NR_PATTERN_RUNS,
12920  	},
12921  	{
12922  		"JMP_JEQ_K: all immediate value magnitudes",
12923  		{ },
12924  		INTERNAL | FLAG_NO_DATA,
12925  		{ },
12926  		{ { 0, 1 } },
12927  		.fill_helper = bpf_fill_jmp_jeq_imm,
12928  		.nr_testruns = NR_PATTERN_RUNS,
12929  	},
12930  	{
12931  		"JMP_JNE_K: all immediate value magnitudes",
12932  		{ },
12933  		INTERNAL | FLAG_NO_DATA,
12934  		{ },
12935  		{ { 0, 1 } },
12936  		.fill_helper = bpf_fill_jmp_jne_imm,
12937  		.nr_testruns = NR_PATTERN_RUNS,
12938  	},
12939  	{
12940  		"JMP_JGT_K: all immediate value magnitudes",
12941  		{ },
12942  		INTERNAL | FLAG_NO_DATA,
12943  		{ },
12944  		{ { 0, 1 } },
12945  		.fill_helper = bpf_fill_jmp_jgt_imm,
12946  		.nr_testruns = NR_PATTERN_RUNS,
12947  	},
12948  	{
12949  		"JMP_JGE_K: all immediate value magnitudes",
12950  		{ },
12951  		INTERNAL | FLAG_NO_DATA,
12952  		{ },
12953  		{ { 0, 1 } },
12954  		.fill_helper = bpf_fill_jmp_jge_imm,
12955  		.nr_testruns = NR_PATTERN_RUNS,
12956  	},
12957  	{
12958  		"JMP_JLT_K: all immediate value magnitudes",
12959  		{ },
12960  		INTERNAL | FLAG_NO_DATA,
12961  		{ },
12962  		{ { 0, 1 } },
12963  		.fill_helper = bpf_fill_jmp_jlt_imm,
12964  		.nr_testruns = NR_PATTERN_RUNS,
12965  	},
12966  	{
12967  		"JMP_JLE_K: all immediate value magnitudes",
12968  		{ },
12969  		INTERNAL | FLAG_NO_DATA,
12970  		{ },
12971  		{ { 0, 1 } },
12972  		.fill_helper = bpf_fill_jmp_jle_imm,
12973  		.nr_testruns = NR_PATTERN_RUNS,
12974  	},
12975  	{
12976  		"JMP_JSGT_K: all immediate value magnitudes",
12977  		{ },
12978  		INTERNAL | FLAG_NO_DATA,
12979  		{ },
12980  		{ { 0, 1 } },
12981  		.fill_helper = bpf_fill_jmp_jsgt_imm,
12982  		.nr_testruns = NR_PATTERN_RUNS,
12983  	},
12984  	{
12985  		"JMP_JSGE_K: all immediate value magnitudes",
12986  		{ },
12987  		INTERNAL | FLAG_NO_DATA,
12988  		{ },
12989  		{ { 0, 1 } },
12990  		.fill_helper = bpf_fill_jmp_jsge_imm,
12991  		.nr_testruns = NR_PATTERN_RUNS,
12992  	},
12993  	{
12994  		"JMP_JSLT_K: all immediate value magnitudes",
12995  		{ },
12996  		INTERNAL | FLAG_NO_DATA,
12997  		{ },
12998  		{ { 0, 1 } },
12999  		.fill_helper = bpf_fill_jmp_jslt_imm,
13000  		.nr_testruns = NR_PATTERN_RUNS,
13001  	},
13002  	{
13003  		"JMP_JSLE_K: all immediate value magnitudes",
13004  		{ },
13005  		INTERNAL | FLAG_NO_DATA,
13006  		{ },
13007  		{ { 0, 1 } },
13008  		.fill_helper = bpf_fill_jmp_jsle_imm,
13009  		.nr_testruns = NR_PATTERN_RUNS,
13010  	},
13011  	/* JMP register magnitudes */
13012  	{
13013  		"JMP_JSET_X: all register value magnitudes",
13014  		{ },
13015  		INTERNAL | FLAG_NO_DATA,
13016  		{ },
13017  		{ { 0, 1 } },
13018  		.fill_helper = bpf_fill_jmp_jset_reg,
13019  		.nr_testruns = NR_PATTERN_RUNS,
13020  	},
13021  	{
13022  		"JMP_JEQ_X: all register value magnitudes",
13023  		{ },
13024  		INTERNAL | FLAG_NO_DATA,
13025  		{ },
13026  		{ { 0, 1 } },
13027  		.fill_helper = bpf_fill_jmp_jeq_reg,
13028  		.nr_testruns = NR_PATTERN_RUNS,
13029  	},
13030  	{
13031  		"JMP_JNE_X: all register value magnitudes",
13032  		{ },
13033  		INTERNAL | FLAG_NO_DATA,
13034  		{ },
13035  		{ { 0, 1 } },
13036  		.fill_helper = bpf_fill_jmp_jne_reg,
13037  		.nr_testruns = NR_PATTERN_RUNS,
13038  	},
13039  	{
13040  		"JMP_JGT_X: all register value magnitudes",
13041  		{ },
13042  		INTERNAL | FLAG_NO_DATA,
13043  		{ },
13044  		{ { 0, 1 } },
13045  		.fill_helper = bpf_fill_jmp_jgt_reg,
13046  		.nr_testruns = NR_PATTERN_RUNS,
13047  	},
13048  	{
13049  		"JMP_JGE_X: all register value magnitudes",
13050  		{ },
13051  		INTERNAL | FLAG_NO_DATA,
13052  		{ },
13053  		{ { 0, 1 } },
13054  		.fill_helper = bpf_fill_jmp_jge_reg,
13055  		.nr_testruns = NR_PATTERN_RUNS,
13056  	},
13057  	{
13058  		"JMP_JLT_X: all register value magnitudes",
13059  		{ },
13060  		INTERNAL | FLAG_NO_DATA,
13061  		{ },
13062  		{ { 0, 1 } },
13063  		.fill_helper = bpf_fill_jmp_jlt_reg,
13064  		.nr_testruns = NR_PATTERN_RUNS,
13065  	},
13066  	{
13067  		"JMP_JLE_X: all register value magnitudes",
13068  		{ },
13069  		INTERNAL | FLAG_NO_DATA,
13070  		{ },
13071  		{ { 0, 1 } },
13072  		.fill_helper = bpf_fill_jmp_jle_reg,
13073  		.nr_testruns = NR_PATTERN_RUNS,
13074  	},
13075  	{
13076  		"JMP_JSGT_X: all register value magnitudes",
13077  		{ },
13078  		INTERNAL | FLAG_NO_DATA,
13079  		{ },
13080  		{ { 0, 1 } },
13081  		.fill_helper = bpf_fill_jmp_jsgt_reg,
13082  		.nr_testruns = NR_PATTERN_RUNS,
13083  	},
13084  	{
13085  		"JMP_JSGE_X: all register value magnitudes",
13086  		{ },
13087  		INTERNAL | FLAG_NO_DATA,
13088  		{ },
13089  		{ { 0, 1 } },
13090  		.fill_helper = bpf_fill_jmp_jsge_reg,
13091  		.nr_testruns = NR_PATTERN_RUNS,
13092  	},
13093  	{
13094  		"JMP_JSLT_X: all register value magnitudes",
13095  		{ },
13096  		INTERNAL | FLAG_NO_DATA,
13097  		{ },
13098  		{ { 0, 1 } },
13099  		.fill_helper = bpf_fill_jmp_jslt_reg,
13100  		.nr_testruns = NR_PATTERN_RUNS,
13101  	},
13102  	{
13103  		"JMP_JSLE_X: all register value magnitudes",
13104  		{ },
13105  		INTERNAL | FLAG_NO_DATA,
13106  		{ },
13107  		{ { 0, 1 } },
13108  		.fill_helper = bpf_fill_jmp_jsle_reg,
13109  		.nr_testruns = NR_PATTERN_RUNS,
13110  	},
13111  	/* JMP32 immediate magnitudes */
13112  	{
13113  		"JMP32_JSET_K: all immediate value magnitudes",
13114  		{ },
13115  		INTERNAL | FLAG_NO_DATA,
13116  		{ },
13117  		{ { 0, 1 } },
13118  		.fill_helper = bpf_fill_jmp32_jset_imm,
13119  		.nr_testruns = NR_PATTERN_RUNS,
13120  	},
13121  	{
13122  		"JMP32_JEQ_K: all immediate value magnitudes",
13123  		{ },
13124  		INTERNAL | FLAG_NO_DATA,
13125  		{ },
13126  		{ { 0, 1 } },
13127  		.fill_helper = bpf_fill_jmp32_jeq_imm,
13128  		.nr_testruns = NR_PATTERN_RUNS,
13129  	},
13130  	{
13131  		"JMP32_JNE_K: all immediate value magnitudes",
13132  		{ },
13133  		INTERNAL | FLAG_NO_DATA,
13134  		{ },
13135  		{ { 0, 1 } },
13136  		.fill_helper = bpf_fill_jmp32_jne_imm,
13137  		.nr_testruns = NR_PATTERN_RUNS,
13138  	},
13139  	{
13140  		"JMP32_JGT_K: all immediate value magnitudes",
13141  		{ },
13142  		INTERNAL | FLAG_NO_DATA,
13143  		{ },
13144  		{ { 0, 1 } },
13145  		.fill_helper = bpf_fill_jmp32_jgt_imm,
13146  		.nr_testruns = NR_PATTERN_RUNS,
13147  	},
13148  	{
13149  		"JMP32_JGE_K: all immediate value magnitudes",
13150  		{ },
13151  		INTERNAL | FLAG_NO_DATA,
13152  		{ },
13153  		{ { 0, 1 } },
13154  		.fill_helper = bpf_fill_jmp32_jge_imm,
13155  		.nr_testruns = NR_PATTERN_RUNS,
13156  	},
13157  	{
13158  		"JMP32_JLT_K: all immediate value magnitudes",
13159  		{ },
13160  		INTERNAL | FLAG_NO_DATA,
13161  		{ },
13162  		{ { 0, 1 } },
13163  		.fill_helper = bpf_fill_jmp32_jlt_imm,
13164  		.nr_testruns = NR_PATTERN_RUNS,
13165  	},
13166  	{
13167  		"JMP32_JLE_K: all immediate value magnitudes",
13168  		{ },
13169  		INTERNAL | FLAG_NO_DATA,
13170  		{ },
13171  		{ { 0, 1 } },
13172  		.fill_helper = bpf_fill_jmp32_jle_imm,
13173  		.nr_testruns = NR_PATTERN_RUNS,
13174  	},
13175  	{
13176  		"JMP32_JSGT_K: all immediate value magnitudes",
13177  		{ },
13178  		INTERNAL | FLAG_NO_DATA,
13179  		{ },
13180  		{ { 0, 1 } },
13181  		.fill_helper = bpf_fill_jmp32_jsgt_imm,
13182  		.nr_testruns = NR_PATTERN_RUNS,
13183  	},
13184  	{
13185  		"JMP32_JSGE_K: all immediate value magnitudes",
13186  		{ },
13187  		INTERNAL | FLAG_NO_DATA,
13188  		{ },
13189  		{ { 0, 1 } },
13190  		.fill_helper = bpf_fill_jmp32_jsge_imm,
13191  		.nr_testruns = NR_PATTERN_RUNS,
13192  	},
13193  	{
13194  		"JMP32_JSLT_K: all immediate value magnitudes",
13195  		{ },
13196  		INTERNAL | FLAG_NO_DATA,
13197  		{ },
13198  		{ { 0, 1 } },
13199  		.fill_helper = bpf_fill_jmp32_jslt_imm,
13200  		.nr_testruns = NR_PATTERN_RUNS,
13201  	},
13202  	{
13203  		"JMP32_JSLE_K: all immediate value magnitudes",
13204  		{ },
13205  		INTERNAL | FLAG_NO_DATA,
13206  		{ },
13207  		{ { 0, 1 } },
13208  		.fill_helper = bpf_fill_jmp32_jsle_imm,
13209  		.nr_testruns = NR_PATTERN_RUNS,
13210  	},
13211  	/* JMP32 register magnitudes */
13212  	{
13213  		"JMP32_JSET_X: all register value magnitudes",
13214  		{ },
13215  		INTERNAL | FLAG_NO_DATA,
13216  		{ },
13217  		{ { 0, 1 } },
13218  		.fill_helper = bpf_fill_jmp32_jset_reg,
13219  		.nr_testruns = NR_PATTERN_RUNS,
13220  	},
13221  	{
13222  		"JMP32_JEQ_X: all register value magnitudes",
13223  		{ },
13224  		INTERNAL | FLAG_NO_DATA,
13225  		{ },
13226  		{ { 0, 1 } },
13227  		.fill_helper = bpf_fill_jmp32_jeq_reg,
13228  		.nr_testruns = NR_PATTERN_RUNS,
13229  	},
13230  	{
13231  		"JMP32_JNE_X: all register value magnitudes",
13232  		{ },
13233  		INTERNAL | FLAG_NO_DATA,
13234  		{ },
13235  		{ { 0, 1 } },
13236  		.fill_helper = bpf_fill_jmp32_jne_reg,
13237  		.nr_testruns = NR_PATTERN_RUNS,
13238  	},
13239  	{
13240  		"JMP32_JGT_X: all register value magnitudes",
13241  		{ },
13242  		INTERNAL | FLAG_NO_DATA,
13243  		{ },
13244  		{ { 0, 1 } },
13245  		.fill_helper = bpf_fill_jmp32_jgt_reg,
13246  		.nr_testruns = NR_PATTERN_RUNS,
13247  	},
13248  	{
13249  		"JMP32_JGE_X: all register value magnitudes",
13250  		{ },
13251  		INTERNAL | FLAG_NO_DATA,
13252  		{ },
13253  		{ { 0, 1 } },
13254  		.fill_helper = bpf_fill_jmp32_jge_reg,
13255  		.nr_testruns = NR_PATTERN_RUNS,
13256  	},
13257  	{
13258  		"JMP32_JLT_X: all register value magnitudes",
13259  		{ },
13260  		INTERNAL | FLAG_NO_DATA,
13261  		{ },
13262  		{ { 0, 1 } },
13263  		.fill_helper = bpf_fill_jmp32_jlt_reg,
13264  		.nr_testruns = NR_PATTERN_RUNS,
13265  	},
13266  	{
13267  		"JMP32_JLE_X: all register value magnitudes",
13268  		{ },
13269  		INTERNAL | FLAG_NO_DATA,
13270  		{ },
13271  		{ { 0, 1 } },
13272  		.fill_helper = bpf_fill_jmp32_jle_reg,
13273  		.nr_testruns = NR_PATTERN_RUNS,
13274  	},
13275  	{
13276  		"JMP32_JSGT_X: all register value magnitudes",
13277  		{ },
13278  		INTERNAL | FLAG_NO_DATA,
13279  		{ },
13280  		{ { 0, 1 } },
13281  		.fill_helper = bpf_fill_jmp32_jsgt_reg,
13282  		.nr_testruns = NR_PATTERN_RUNS,
13283  	},
13284  	{
13285  		"JMP32_JSGE_X: all register value magnitudes",
13286  		{ },
13287  		INTERNAL | FLAG_NO_DATA,
13288  		{ },
13289  		{ { 0, 1 } },
13290  		.fill_helper = bpf_fill_jmp32_jsge_reg,
13291  		.nr_testruns = NR_PATTERN_RUNS,
13292  	},
13293  	{
13294  		"JMP32_JSLT_X: all register value magnitudes",
13295  		{ },
13296  		INTERNAL | FLAG_NO_DATA,
13297  		{ },
13298  		{ { 0, 1 } },
13299  		.fill_helper = bpf_fill_jmp32_jslt_reg,
13300  		.nr_testruns = NR_PATTERN_RUNS,
13301  	},
13302  	{
13303  		"JMP32_JSLE_X: all register value magnitudes",
13304  		{ },
13305  		INTERNAL | FLAG_NO_DATA,
13306  		{ },
13307  		{ { 0, 1 } },
13308  		.fill_helper = bpf_fill_jmp32_jsle_reg,
13309  		.nr_testruns = NR_PATTERN_RUNS,
13310  	},
13311  	/* Conditional jumps with constant decision */
13312  	{
13313  		"JMP_JSET_K: imm = 0 -> never taken",
13314  		.u.insns_int = {
13315  			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13316  			BPF_JMP_IMM(BPF_JSET, R1, 0, 1),
13317  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13318  			BPF_EXIT_INSN(),
13319  		},
13320  		INTERNAL | FLAG_NO_DATA,
13321  		{ },
13322  		{ { 0, 0 } },
13323  	},
13324  	{
13325  		"JMP_JLT_K: imm = 0 -> never taken",
13326  		.u.insns_int = {
13327  			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13328  			BPF_JMP_IMM(BPF_JLT, R1, 0, 1),
13329  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13330  			BPF_EXIT_INSN(),
13331  		},
13332  		INTERNAL | FLAG_NO_DATA,
13333  		{ },
13334  		{ { 0, 0 } },
13335  	},
13336  	{
13337  		"JMP_JGE_K: imm = 0 -> always taken",
13338  		.u.insns_int = {
13339  			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13340  			BPF_JMP_IMM(BPF_JGE, R1, 0, 1),
13341  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13342  			BPF_EXIT_INSN(),
13343  		},
13344  		INTERNAL | FLAG_NO_DATA,
13345  		{ },
13346  		{ { 0, 1 } },
13347  	},
13348  	{
13349  		"JMP_JGT_K: imm = 0xffffffff -> never taken",
13350  		.u.insns_int = {
13351  			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13352  			BPF_JMP_IMM(BPF_JGT, R1, U32_MAX, 1),
13353  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13354  			BPF_EXIT_INSN(),
13355  		},
13356  		INTERNAL | FLAG_NO_DATA,
13357  		{ },
13358  		{ { 0, 0 } },
13359  	},
13360  	{
13361  		"JMP_JLE_K: imm = 0xffffffff -> always taken",
13362  		.u.insns_int = {
13363  			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13364  			BPF_JMP_IMM(BPF_JLE, R1, U32_MAX, 1),
13365  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13366  			BPF_EXIT_INSN(),
13367  		},
13368  		INTERNAL | FLAG_NO_DATA,
13369  		{ },
13370  		{ { 0, 1 } },
13371  	},
13372  	{
13373  		"JMP32_JSGT_K: imm = 0x7fffffff -> never taken",
13374  		.u.insns_int = {
13375  			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13376  			BPF_JMP32_IMM(BPF_JSGT, R1, S32_MAX, 1),
13377  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13378  			BPF_EXIT_INSN(),
13379  		},
13380  		INTERNAL | FLAG_NO_DATA,
13381  		{ },
13382  		{ { 0, 0 } },
13383  	},
13384  	{
13385  		"JMP32_JSGE_K: imm = -0x80000000 -> always taken",
13386  		.u.insns_int = {
13387  			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13388  			BPF_JMP32_IMM(BPF_JSGE, R1, S32_MIN, 1),
13389  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13390  			BPF_EXIT_INSN(),
13391  		},
13392  		INTERNAL | FLAG_NO_DATA,
13393  		{ },
13394  		{ { 0, 1 } },
13395  	},
13396  	{
13397  		"JMP32_JSLT_K: imm = -0x80000000 -> never taken",
13398  		.u.insns_int = {
13399  			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13400  			BPF_JMP32_IMM(BPF_JSLT, R1, S32_MIN, 1),
13401  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13402  			BPF_EXIT_INSN(),
13403  		},
13404  		INTERNAL | FLAG_NO_DATA,
13405  		{ },
13406  		{ { 0, 0 } },
13407  	},
13408  	{
13409  		"JMP32_JSLE_K: imm = 0x7fffffff -> always taken",
13410  		.u.insns_int = {
13411  			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13412  			BPF_JMP32_IMM(BPF_JSLE, R1, S32_MAX, 1),
13413  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13414  			BPF_EXIT_INSN(),
13415  		},
13416  		INTERNAL | FLAG_NO_DATA,
13417  		{ },
13418  		{ { 0, 1 } },
13419  	},
13420  	{
13421  		"JMP_JEQ_X: dst = src -> always taken",
13422  		.u.insns_int = {
13423  			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13424  			BPF_JMP_REG(BPF_JEQ, R1, R1, 1),
13425  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13426  			BPF_EXIT_INSN(),
13427  		},
13428  		INTERNAL | FLAG_NO_DATA,
13429  		{ },
13430  		{ { 0, 1 } },
13431  	},
13432  	{
13433  		"JMP_JGE_X: dst = src -> always taken",
13434  		.u.insns_int = {
13435  			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13436  			BPF_JMP_REG(BPF_JGE, R1, R1, 1),
13437  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13438  			BPF_EXIT_INSN(),
13439  		},
13440  		INTERNAL | FLAG_NO_DATA,
13441  		{ },
13442  		{ { 0, 1 } },
13443  	},
13444  	{
13445  		"JMP_JLE_X: dst = src -> always taken",
13446  		.u.insns_int = {
13447  			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13448  			BPF_JMP_REG(BPF_JLE, R1, R1, 1),
13449  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13450  			BPF_EXIT_INSN(),
13451  		},
13452  		INTERNAL | FLAG_NO_DATA,
13453  		{ },
13454  		{ { 0, 1 } },
13455  	},
13456  	{
13457  		"JMP_JSGE_X: dst = src -> always taken",
13458  		.u.insns_int = {
13459  			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13460  			BPF_JMP_REG(BPF_JSGE, R1, R1, 1),
13461  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13462  			BPF_EXIT_INSN(),
13463  		},
13464  		INTERNAL | FLAG_NO_DATA,
13465  		{ },
13466  		{ { 0, 1 } },
13467  	},
13468  	{
13469  		"JMP_JSLE_X: dst = src -> always taken",
13470  		.u.insns_int = {
13471  			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13472  			BPF_JMP_REG(BPF_JSLE, R1, R1, 1),
13473  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13474  			BPF_EXIT_INSN(),
13475  		},
13476  		INTERNAL | FLAG_NO_DATA,
13477  		{ },
13478  		{ { 0, 1 } },
13479  	},
13480  	{
13481  		"JMP_JNE_X: dst = src -> never taken",
13482  		.u.insns_int = {
13483  			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13484  			BPF_JMP_REG(BPF_JNE, R1, R1, 1),
13485  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13486  			BPF_EXIT_INSN(),
13487  		},
13488  		INTERNAL | FLAG_NO_DATA,
13489  		{ },
13490  		{ { 0, 0 } },
13491  	},
13492  	{
13493  		"JMP_JGT_X: dst = src -> never taken",
13494  		.u.insns_int = {
13495  			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13496  			BPF_JMP_REG(BPF_JGT, R1, R1, 1),
13497  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13498  			BPF_EXIT_INSN(),
13499  		},
13500  		INTERNAL | FLAG_NO_DATA,
13501  		{ },
13502  		{ { 0, 0 } },
13503  	},
13504  	{
13505  		"JMP_JLT_X: dst = src -> never taken",
13506  		.u.insns_int = {
13507  			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13508  			BPF_JMP_REG(BPF_JLT, R1, R1, 1),
13509  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13510  			BPF_EXIT_INSN(),
13511  		},
13512  		INTERNAL | FLAG_NO_DATA,
13513  		{ },
13514  		{ { 0, 0 } },
13515  	},
13516  	{
13517  		"JMP_JSGT_X: dst = src -> never taken",
13518  		.u.insns_int = {
13519  			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13520  			BPF_JMP_REG(BPF_JSGT, R1, R1, 1),
13521  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13522  			BPF_EXIT_INSN(),
13523  		},
13524  		INTERNAL | FLAG_NO_DATA,
13525  		{ },
13526  		{ { 0, 0 } },
13527  	},
13528  	{
13529  		"JMP_JSLT_X: dst = src -> never taken",
13530  		.u.insns_int = {
13531  			BPF_ALU64_IMM(BPF_MOV, R0, 1),
13532  			BPF_JMP_REG(BPF_JSLT, R1, R1, 1),
13533  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13534  			BPF_EXIT_INSN(),
13535  		},
13536  		INTERNAL | FLAG_NO_DATA,
13537  		{ },
13538  		{ { 0, 0 } },
13539  	},
13540  	/* Short relative jumps */
13541  	{
13542  		"Short relative jump: offset=0",
13543  		.u.insns_int = {
13544  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13545  			BPF_JMP_IMM(BPF_JEQ, R0, 0, 0),
13546  			BPF_EXIT_INSN(),
13547  			BPF_ALU32_IMM(BPF_MOV, R0, -1),
13548  		},
13549  		INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
13550  		{ },
13551  		{ { 0, 0 } },
13552  	},
13553  	{
13554  		"Short relative jump: offset=1",
13555  		.u.insns_int = {
13556  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13557  			BPF_JMP_IMM(BPF_JEQ, R0, 0, 1),
13558  			BPF_ALU32_IMM(BPF_ADD, R0, 1),
13559  			BPF_EXIT_INSN(),
13560  			BPF_ALU32_IMM(BPF_MOV, R0, -1),
13561  		},
13562  		INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
13563  		{ },
13564  		{ { 0, 0 } },
13565  	},
13566  	{
13567  		"Short relative jump: offset=2",
13568  		.u.insns_int = {
13569  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13570  			BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
13571  			BPF_ALU32_IMM(BPF_ADD, R0, 1),
13572  			BPF_ALU32_IMM(BPF_ADD, R0, 1),
13573  			BPF_EXIT_INSN(),
13574  			BPF_ALU32_IMM(BPF_MOV, R0, -1),
13575  		},
13576  		INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
13577  		{ },
13578  		{ { 0, 0 } },
13579  	},
13580  	{
13581  		"Short relative jump: offset=3",
13582  		.u.insns_int = {
13583  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13584  			BPF_JMP_IMM(BPF_JEQ, R0, 0, 3),
13585  			BPF_ALU32_IMM(BPF_ADD, R0, 1),
13586  			BPF_ALU32_IMM(BPF_ADD, R0, 1),
13587  			BPF_ALU32_IMM(BPF_ADD, R0, 1),
13588  			BPF_EXIT_INSN(),
13589  			BPF_ALU32_IMM(BPF_MOV, R0, -1),
13590  		},
13591  		INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
13592  		{ },
13593  		{ { 0, 0 } },
13594  	},
13595  	{
13596  		"Short relative jump: offset=4",
13597  		.u.insns_int = {
13598  			BPF_ALU64_IMM(BPF_MOV, R0, 0),
13599  			BPF_JMP_IMM(BPF_JEQ, R0, 0, 4),
13600  			BPF_ALU32_IMM(BPF_ADD, R0, 1),
13601  			BPF_ALU32_IMM(BPF_ADD, R0, 1),
13602  			BPF_ALU32_IMM(BPF_ADD, R0, 1),
13603  			BPF_ALU32_IMM(BPF_ADD, R0, 1),
13604  			BPF_EXIT_INSN(),
13605  			BPF_ALU32_IMM(BPF_MOV, R0, -1),
13606  		},
13607  		INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
13608  		{ },
13609  		{ { 0, 0 } },
13610  	},
13611  	/* Conditional branch conversions */
13612  	{
13613  		"Long conditional jump: taken at runtime",
13614  		{ },
13615  		INTERNAL | FLAG_NO_DATA,
13616  		{ },
13617  		{ { 0, 1 } },
13618  		.fill_helper = bpf_fill_max_jmp_taken,
13619  	},
13620  	{
13621  		"Long conditional jump: not taken at runtime",
13622  		{ },
13623  		INTERNAL | FLAG_NO_DATA,
13624  		{ },
13625  		{ { 0, 2 } },
13626  		.fill_helper = bpf_fill_max_jmp_not_taken,
13627  	},
13628  	{
13629  		"Long conditional jump: always taken, known at JIT time",
13630  		{ },
13631  		INTERNAL | FLAG_NO_DATA,
13632  		{ },
13633  		{ { 0, 1 } },
13634  		.fill_helper = bpf_fill_max_jmp_always_taken,
13635  	},
13636  	{
13637  		"Long conditional jump: never taken, known at JIT time",
13638  		{ },
13639  		INTERNAL | FLAG_NO_DATA,
13640  		{ },
13641  		{ { 0, 2 } },
13642  		.fill_helper = bpf_fill_max_jmp_never_taken,
13643  	},
13644  	/* Staggered jump sequences, immediate */
13645  	{
13646  		"Staggered jumps: JMP_JA",
13647  		{ },
13648  		INTERNAL | FLAG_NO_DATA,
13649  		{ },
13650  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13651  		.fill_helper = bpf_fill_staggered_ja,
13652  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13653  	},
13654  	{
13655  		"Staggered jumps: JMP_JEQ_K",
13656  		{ },
13657  		INTERNAL | FLAG_NO_DATA,
13658  		{ },
13659  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13660  		.fill_helper = bpf_fill_staggered_jeq_imm,
13661  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13662  	},
13663  	{
13664  		"Staggered jumps: JMP_JNE_K",
13665  		{ },
13666  		INTERNAL | FLAG_NO_DATA,
13667  		{ },
13668  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13669  		.fill_helper = bpf_fill_staggered_jne_imm,
13670  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13671  	},
13672  	{
13673  		"Staggered jumps: JMP_JSET_K",
13674  		{ },
13675  		INTERNAL | FLAG_NO_DATA,
13676  		{ },
13677  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13678  		.fill_helper = bpf_fill_staggered_jset_imm,
13679  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13680  	},
13681  	{
13682  		"Staggered jumps: JMP_JGT_K",
13683  		{ },
13684  		INTERNAL | FLAG_NO_DATA,
13685  		{ },
13686  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13687  		.fill_helper = bpf_fill_staggered_jgt_imm,
13688  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13689  	},
13690  	{
13691  		"Staggered jumps: JMP_JGE_K",
13692  		{ },
13693  		INTERNAL | FLAG_NO_DATA,
13694  		{ },
13695  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13696  		.fill_helper = bpf_fill_staggered_jge_imm,
13697  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13698  	},
13699  	{
13700  		"Staggered jumps: JMP_JLT_K",
13701  		{ },
13702  		INTERNAL | FLAG_NO_DATA,
13703  		{ },
13704  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13705  		.fill_helper = bpf_fill_staggered_jlt_imm,
13706  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13707  	},
13708  	{
13709  		"Staggered jumps: JMP_JLE_K",
13710  		{ },
13711  		INTERNAL | FLAG_NO_DATA,
13712  		{ },
13713  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13714  		.fill_helper = bpf_fill_staggered_jle_imm,
13715  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13716  	},
13717  	{
13718  		"Staggered jumps: JMP_JSGT_K",
13719  		{ },
13720  		INTERNAL | FLAG_NO_DATA,
13721  		{ },
13722  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13723  		.fill_helper = bpf_fill_staggered_jsgt_imm,
13724  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13725  	},
13726  	{
13727  		"Staggered jumps: JMP_JSGE_K",
13728  		{ },
13729  		INTERNAL | FLAG_NO_DATA,
13730  		{ },
13731  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13732  		.fill_helper = bpf_fill_staggered_jsge_imm,
13733  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13734  	},
13735  	{
13736  		"Staggered jumps: JMP_JSLT_K",
13737  		{ },
13738  		INTERNAL | FLAG_NO_DATA,
13739  		{ },
13740  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13741  		.fill_helper = bpf_fill_staggered_jslt_imm,
13742  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13743  	},
13744  	{
13745  		"Staggered jumps: JMP_JSLE_K",
13746  		{ },
13747  		INTERNAL | FLAG_NO_DATA,
13748  		{ },
13749  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13750  		.fill_helper = bpf_fill_staggered_jsle_imm,
13751  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13752  	},
13753  	/* Staggered jump sequences, register */
13754  	{
13755  		"Staggered jumps: JMP_JEQ_X",
13756  		{ },
13757  		INTERNAL | FLAG_NO_DATA,
13758  		{ },
13759  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13760  		.fill_helper = bpf_fill_staggered_jeq_reg,
13761  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13762  	},
13763  	{
13764  		"Staggered jumps: JMP_JNE_X",
13765  		{ },
13766  		INTERNAL | FLAG_NO_DATA,
13767  		{ },
13768  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13769  		.fill_helper = bpf_fill_staggered_jne_reg,
13770  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13771  	},
13772  	{
13773  		"Staggered jumps: JMP_JSET_X",
13774  		{ },
13775  		INTERNAL | FLAG_NO_DATA,
13776  		{ },
13777  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13778  		.fill_helper = bpf_fill_staggered_jset_reg,
13779  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13780  	},
13781  	{
13782  		"Staggered jumps: JMP_JGT_X",
13783  		{ },
13784  		INTERNAL | FLAG_NO_DATA,
13785  		{ },
13786  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13787  		.fill_helper = bpf_fill_staggered_jgt_reg,
13788  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13789  	},
13790  	{
13791  		"Staggered jumps: JMP_JGE_X",
13792  		{ },
13793  		INTERNAL | FLAG_NO_DATA,
13794  		{ },
13795  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13796  		.fill_helper = bpf_fill_staggered_jge_reg,
13797  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13798  	},
13799  	{
13800  		"Staggered jumps: JMP_JLT_X",
13801  		{ },
13802  		INTERNAL | FLAG_NO_DATA,
13803  		{ },
13804  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13805  		.fill_helper = bpf_fill_staggered_jlt_reg,
13806  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13807  	},
13808  	{
13809  		"Staggered jumps: JMP_JLE_X",
13810  		{ },
13811  		INTERNAL | FLAG_NO_DATA,
13812  		{ },
13813  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13814  		.fill_helper = bpf_fill_staggered_jle_reg,
13815  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13816  	},
13817  	{
13818  		"Staggered jumps: JMP_JSGT_X",
13819  		{ },
13820  		INTERNAL | FLAG_NO_DATA,
13821  		{ },
13822  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13823  		.fill_helper = bpf_fill_staggered_jsgt_reg,
13824  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13825  	},
13826  	{
13827  		"Staggered jumps: JMP_JSGE_X",
13828  		{ },
13829  		INTERNAL | FLAG_NO_DATA,
13830  		{ },
13831  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13832  		.fill_helper = bpf_fill_staggered_jsge_reg,
13833  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13834  	},
13835  	{
13836  		"Staggered jumps: JMP_JSLT_X",
13837  		{ },
13838  		INTERNAL | FLAG_NO_DATA,
13839  		{ },
13840  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13841  		.fill_helper = bpf_fill_staggered_jslt_reg,
13842  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13843  	},
13844  	{
13845  		"Staggered jumps: JMP_JSLE_X",
13846  		{ },
13847  		INTERNAL | FLAG_NO_DATA,
13848  		{ },
13849  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13850  		.fill_helper = bpf_fill_staggered_jsle_reg,
13851  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13852  	},
13853  	/* Staggered jump sequences, JMP32 immediate */
13854  	{
13855  		"Staggered jumps: JMP32_JEQ_K",
13856  		{ },
13857  		INTERNAL | FLAG_NO_DATA,
13858  		{ },
13859  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13860  		.fill_helper = bpf_fill_staggered_jeq32_imm,
13861  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13862  	},
13863  	{
13864  		"Staggered jumps: JMP32_JNE_K",
13865  		{ },
13866  		INTERNAL | FLAG_NO_DATA,
13867  		{ },
13868  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13869  		.fill_helper = bpf_fill_staggered_jne32_imm,
13870  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13871  	},
13872  	{
13873  		"Staggered jumps: JMP32_JSET_K",
13874  		{ },
13875  		INTERNAL | FLAG_NO_DATA,
13876  		{ },
13877  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13878  		.fill_helper = bpf_fill_staggered_jset32_imm,
13879  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13880  	},
13881  	{
13882  		"Staggered jumps: JMP32_JGT_K",
13883  		{ },
13884  		INTERNAL | FLAG_NO_DATA,
13885  		{ },
13886  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13887  		.fill_helper = bpf_fill_staggered_jgt32_imm,
13888  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13889  	},
13890  	{
13891  		"Staggered jumps: JMP32_JGE_K",
13892  		{ },
13893  		INTERNAL | FLAG_NO_DATA,
13894  		{ },
13895  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13896  		.fill_helper = bpf_fill_staggered_jge32_imm,
13897  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13898  	},
13899  	{
13900  		"Staggered jumps: JMP32_JLT_K",
13901  		{ },
13902  		INTERNAL | FLAG_NO_DATA,
13903  		{ },
13904  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13905  		.fill_helper = bpf_fill_staggered_jlt32_imm,
13906  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13907  	},
13908  	{
13909  		"Staggered jumps: JMP32_JLE_K",
13910  		{ },
13911  		INTERNAL | FLAG_NO_DATA,
13912  		{ },
13913  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13914  		.fill_helper = bpf_fill_staggered_jle32_imm,
13915  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13916  	},
13917  	{
13918  		"Staggered jumps: JMP32_JSGT_K",
13919  		{ },
13920  		INTERNAL | FLAG_NO_DATA,
13921  		{ },
13922  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13923  		.fill_helper = bpf_fill_staggered_jsgt32_imm,
13924  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13925  	},
13926  	{
13927  		"Staggered jumps: JMP32_JSGE_K",
13928  		{ },
13929  		INTERNAL | FLAG_NO_DATA,
13930  		{ },
13931  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13932  		.fill_helper = bpf_fill_staggered_jsge32_imm,
13933  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13934  	},
13935  	{
13936  		"Staggered jumps: JMP32_JSLT_K",
13937  		{ },
13938  		INTERNAL | FLAG_NO_DATA,
13939  		{ },
13940  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13941  		.fill_helper = bpf_fill_staggered_jslt32_imm,
13942  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13943  	},
13944  	{
13945  		"Staggered jumps: JMP32_JSLE_K",
13946  		{ },
13947  		INTERNAL | FLAG_NO_DATA,
13948  		{ },
13949  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13950  		.fill_helper = bpf_fill_staggered_jsle32_imm,
13951  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13952  	},
13953  	/* Staggered jump sequences, JMP32 register */
13954  	{
13955  		"Staggered jumps: JMP32_JEQ_X",
13956  		{ },
13957  		INTERNAL | FLAG_NO_DATA,
13958  		{ },
13959  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13960  		.fill_helper = bpf_fill_staggered_jeq32_reg,
13961  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13962  	},
13963  	{
13964  		"Staggered jumps: JMP32_JNE_X",
13965  		{ },
13966  		INTERNAL | FLAG_NO_DATA,
13967  		{ },
13968  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13969  		.fill_helper = bpf_fill_staggered_jne32_reg,
13970  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13971  	},
13972  	{
13973  		"Staggered jumps: JMP32_JSET_X",
13974  		{ },
13975  		INTERNAL | FLAG_NO_DATA,
13976  		{ },
13977  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13978  		.fill_helper = bpf_fill_staggered_jset32_reg,
13979  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13980  	},
13981  	{
13982  		"Staggered jumps: JMP32_JGT_X",
13983  		{ },
13984  		INTERNAL | FLAG_NO_DATA,
13985  		{ },
13986  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13987  		.fill_helper = bpf_fill_staggered_jgt32_reg,
13988  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13989  	},
13990  	{
13991  		"Staggered jumps: JMP32_JGE_X",
13992  		{ },
13993  		INTERNAL | FLAG_NO_DATA,
13994  		{ },
13995  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
13996  		.fill_helper = bpf_fill_staggered_jge32_reg,
13997  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
13998  	},
13999  	{
14000  		"Staggered jumps: JMP32_JLT_X",
14001  		{ },
14002  		INTERNAL | FLAG_NO_DATA,
14003  		{ },
14004  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14005  		.fill_helper = bpf_fill_staggered_jlt32_reg,
14006  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14007  	},
14008  	{
14009  		"Staggered jumps: JMP32_JLE_X",
14010  		{ },
14011  		INTERNAL | FLAG_NO_DATA,
14012  		{ },
14013  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14014  		.fill_helper = bpf_fill_staggered_jle32_reg,
14015  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14016  	},
14017  	{
14018  		"Staggered jumps: JMP32_JSGT_X",
14019  		{ },
14020  		INTERNAL | FLAG_NO_DATA,
14021  		{ },
14022  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14023  		.fill_helper = bpf_fill_staggered_jsgt32_reg,
14024  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14025  	},
14026  	{
14027  		"Staggered jumps: JMP32_JSGE_X",
14028  		{ },
14029  		INTERNAL | FLAG_NO_DATA,
14030  		{ },
14031  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14032  		.fill_helper = bpf_fill_staggered_jsge32_reg,
14033  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14034  	},
14035  	{
14036  		"Staggered jumps: JMP32_JSLT_X",
14037  		{ },
14038  		INTERNAL | FLAG_NO_DATA,
14039  		{ },
14040  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14041  		.fill_helper = bpf_fill_staggered_jslt32_reg,
14042  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14043  	},
14044  	{
14045  		"Staggered jumps: JMP32_JSLE_X",
14046  		{ },
14047  		INTERNAL | FLAG_NO_DATA,
14048  		{ },
14049  		{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14050  		.fill_helper = bpf_fill_staggered_jsle32_reg,
14051  		.nr_testruns = NR_STAGGERED_JMP_RUNS,
14052  	},
14053  };
14054  
14055  static struct net_device dev;
14056  
14057  static struct sk_buff *populate_skb(char *buf, int size)
14058  {
14059  	struct sk_buff *skb;
14060  
14061  	if (size >= MAX_DATA)
14062  		return NULL;
14063  
14064  	skb = alloc_skb(MAX_DATA, GFP_KERNEL);
14065  	if (!skb)
14066  		return NULL;
14067  
14068  	__skb_put_data(skb, buf, size);
14069  
14070  	/* Initialize a fake skb with test pattern. */
14071  	skb_reset_mac_header(skb);
14072  	skb->protocol = htons(ETH_P_IP);
14073  	skb->pkt_type = SKB_TYPE;
14074  	skb->mark = SKB_MARK;
14075  	skb->hash = SKB_HASH;
14076  	skb->queue_mapping = SKB_QUEUE_MAP;
14077  	skb->vlan_tci = SKB_VLAN_TCI;
14078  	skb->vlan_present = SKB_VLAN_PRESENT;
14079  	skb->vlan_proto = htons(ETH_P_IP);
14080  	dev_net_set(&dev, &init_net);
14081  	skb->dev = &dev;
14082  	skb->dev->ifindex = SKB_DEV_IFINDEX;
14083  	skb->dev->type = SKB_DEV_TYPE;
14084  	skb_set_network_header(skb, min(size, ETH_HLEN));
14085  
14086  	return skb;
14087  }
14088  
14089  static void *generate_test_data(struct bpf_test *test, int sub)
14090  {
14091  	struct sk_buff *skb;
14092  	struct page *page;
14093  
14094  	if (test->aux & FLAG_NO_DATA)
14095  		return NULL;
14096  
14097  	/* Test case expects an skb, so populate one. Various
14098  	 * subtests generate skbs of different sizes based on
14099  	 * the same data.
14100  	 */
14101  	skb = populate_skb(test->data, test->test[sub].data_size);
14102  	if (!skb)
14103  		return NULL;
14104  
14105  	if (test->aux & FLAG_SKB_FRAG) {
14106  		/*
14107  		 * when the test requires a fragmented skb, add a
14108  		 * single fragment to the skb, filled with
14109  		 * test->frag_data.
14110  		 */
14111  		void *ptr;
14112  
14113  		page = alloc_page(GFP_KERNEL);
14114  
14115  		if (!page)
14116  			goto err_kfree_skb;
14117  
14118  		ptr = kmap(page);
14119  		if (!ptr)
14120  			goto err_free_page;
14121  		memcpy(ptr, test->frag_data, MAX_DATA);
14122  		kunmap(page);
14123  		skb_add_rx_frag(skb, 0, page, 0, MAX_DATA, MAX_DATA);
14124  	}
14125  
14126  	return skb;
14127  
14128  err_free_page:
14129  	__free_page(page);
14130  err_kfree_skb:
14131  	kfree_skb(skb);
14132  	return NULL;
14133  }
14134  
14135  static void release_test_data(const struct bpf_test *test, void *data)
14136  {
14137  	if (test->aux & FLAG_NO_DATA)
14138  		return;
14139  
14140  	kfree_skb(data);
14141  }
14142  
14143  static int filter_length(int which)
14144  {
14145  	struct sock_filter *fp;
14146  	int len;
14147  
14148  	if (tests[which].fill_helper)
14149  		return tests[which].u.ptr.len;
14150  
14151  	fp = tests[which].u.insns;
14152  	for (len = MAX_INSNS - 1; len > 0; --len)
14153  		if (fp[len].code != 0 || fp[len].k != 0)
14154  			break;
14155  
14156  	return len + 1;
14157  }
14158  
14159  static void *filter_pointer(int which)
14160  {
14161  	if (tests[which].fill_helper)
14162  		return tests[which].u.ptr.insns;
14163  	else
14164  		return tests[which].u.insns;
14165  }
14166  
14167  static struct bpf_prog *generate_filter(int which, int *err)
14168  {
14169  	__u8 test_type = tests[which].aux & TEST_TYPE_MASK;
14170  	unsigned int flen = filter_length(which);
14171  	void *fptr = filter_pointer(which);
14172  	struct sock_fprog_kern fprog;
14173  	struct bpf_prog *fp;
14174  
14175  	switch (test_type) {
14176  	case CLASSIC:
14177  		fprog.filter = fptr;
14178  		fprog.len = flen;
14179  
14180  		*err = bpf_prog_create(&fp, &fprog);
14181  		if (tests[which].aux & FLAG_EXPECTED_FAIL) {
14182  			if (*err == tests[which].expected_errcode) {
14183  				pr_cont("PASS\n");
14184  				/* Verifier rejected filter as expected. */
14185  				*err = 0;
14186  				return NULL;
14187  			} else {
14188  				pr_cont("UNEXPECTED_PASS\n");
14189  				/* Verifier didn't reject the test that's
14190  				 * bad enough, just return!
14191  				 */
14192  				*err = -EINVAL;
14193  				return NULL;
14194  			}
14195  		}
14196  		if (*err) {
14197  			pr_cont("FAIL to prog_create err=%d len=%d\n",
14198  				*err, fprog.len);
14199  			return NULL;
14200  		}
14201  		break;
14202  
14203  	case INTERNAL:
14204  		fp = bpf_prog_alloc(bpf_prog_size(flen), 0);
14205  		if (fp == NULL) {
14206  			pr_cont("UNEXPECTED_FAIL no memory left\n");
14207  			*err = -ENOMEM;
14208  			return NULL;
14209  		}
14210  
14211  		fp->len = flen;
14212  		/* Type doesn't really matter here as long as it's not unspec. */
14213  		fp->type = BPF_PROG_TYPE_SOCKET_FILTER;
14214  		memcpy(fp->insnsi, fptr, fp->len * sizeof(struct bpf_insn));
14215  		fp->aux->stack_depth = tests[which].stack_depth;
14216  		fp->aux->verifier_zext = !!(tests[which].aux &
14217  					    FLAG_VERIFIER_ZEXT);
14218  
14219  		/* We cannot error here as we don't need type compatibility
14220  		 * checks.
14221  		 */
14222  		fp = bpf_prog_select_runtime(fp, err);
14223  		if (*err) {
14224  			pr_cont("FAIL to select_runtime err=%d\n", *err);
14225  			return NULL;
14226  		}
14227  		break;
14228  	}
14229  
14230  	*err = 0;
14231  	return fp;
14232  }
14233  
14234  static void release_filter(struct bpf_prog *fp, int which)
14235  {
14236  	__u8 test_type = tests[which].aux & TEST_TYPE_MASK;
14237  
14238  	switch (test_type) {
14239  	case CLASSIC:
14240  		bpf_prog_destroy(fp);
14241  		break;
14242  	case INTERNAL:
14243  		bpf_prog_free(fp);
14244  		break;
14245  	}
14246  }
14247  
14248  static int __run_one(const struct bpf_prog *fp, const void *data,
14249  		     int runs, u64 *duration)
14250  {
14251  	u64 start, finish;
14252  	int ret = 0, i;
14253  
14254  	migrate_disable();
14255  	start = ktime_get_ns();
14256  
14257  	for (i = 0; i < runs; i++)
14258  		ret = bpf_prog_run(fp, data);
14259  
14260  	finish = ktime_get_ns();
14261  	migrate_enable();
14262  
14263  	*duration = finish - start;
14264  	do_div(*duration, runs);
14265  
14266  	return ret;
14267  }
14268  
14269  static int run_one(const struct bpf_prog *fp, struct bpf_test *test)
14270  {
14271  	int err_cnt = 0, i, runs = MAX_TESTRUNS;
14272  
14273  	if (test->nr_testruns)
14274  		runs = min(test->nr_testruns, MAX_TESTRUNS);
14275  
14276  	for (i = 0; i < MAX_SUBTESTS; i++) {
14277  		void *data;
14278  		u64 duration;
14279  		u32 ret;
14280  
14281  		/*
14282  		 * NOTE: Several sub-tests may be present, in which case
14283  		 * a zero {data_size, result} tuple indicates the end of
14284  		 * the sub-test array. The first test is always run,
14285  		 * even if both data_size and result happen to be zero.
14286  		 */
14287  		if (i > 0 &&
14288  		    test->test[i].data_size == 0 &&
14289  		    test->test[i].result == 0)
14290  			break;
14291  
14292  		data = generate_test_data(test, i);
14293  		if (!data && !(test->aux & FLAG_NO_DATA)) {
14294  			pr_cont("data generation failed ");
14295  			err_cnt++;
14296  			break;
14297  		}
14298  		ret = __run_one(fp, data, runs, &duration);
14299  		release_test_data(test, data);
14300  
14301  		if (ret == test->test[i].result) {
14302  			pr_cont("%lld ", duration);
14303  		} else {
14304  			pr_cont("ret %d != %d ", ret,
14305  				test->test[i].result);
14306  			err_cnt++;
14307  		}
14308  	}
14309  
14310  	return err_cnt;
14311  }
14312  
14313  static char test_name[64];
14314  module_param_string(test_name, test_name, sizeof(test_name), 0);
14315  
14316  static int test_id = -1;
14317  module_param(test_id, int, 0);
14318  
14319  static int test_range[2] = { 0, INT_MAX };
14320  module_param_array(test_range, int, NULL, 0);
14321  
14322  static bool exclude_test(int test_id)
14323  {
14324  	return test_id < test_range[0] || test_id > test_range[1];
14325  }
14326  
14327  static __init struct sk_buff *build_test_skb(void)
14328  {
14329  	u32 headroom = NET_SKB_PAD + NET_IP_ALIGN + ETH_HLEN;
14330  	struct sk_buff *skb[2];
14331  	struct page *page[2];
14332  	int i, data_size = 8;
14333  
14334  	for (i = 0; i < 2; i++) {
14335  		page[i] = alloc_page(GFP_KERNEL);
14336  		if (!page[i]) {
14337  			if (i == 0)
14338  				goto err_page0;
14339  			else
14340  				goto err_page1;
14341  		}
14342  
14343  		/* this will set skb[i]->head_frag */
14344  		skb[i] = dev_alloc_skb(headroom + data_size);
14345  		if (!skb[i]) {
14346  			if (i == 0)
14347  				goto err_skb0;
14348  			else
14349  				goto err_skb1;
14350  		}
14351  
14352  		skb_reserve(skb[i], headroom);
14353  		skb_put(skb[i], data_size);
14354  		skb[i]->protocol = htons(ETH_P_IP);
14355  		skb_reset_network_header(skb[i]);
14356  		skb_set_mac_header(skb[i], -ETH_HLEN);
14357  
14358  		skb_add_rx_frag(skb[i], 0, page[i], 0, 64, 64);
14359  		// skb_headlen(skb[i]): 8, skb[i]->head_frag = 1
14360  	}
14361  
14362  	/* setup shinfo */
14363  	skb_shinfo(skb[0])->gso_size = 1448;
14364  	skb_shinfo(skb[0])->gso_type = SKB_GSO_TCPV4;
14365  	skb_shinfo(skb[0])->gso_type |= SKB_GSO_DODGY;
14366  	skb_shinfo(skb[0])->gso_segs = 0;
14367  	skb_shinfo(skb[0])->frag_list = skb[1];
14368  	skb_shinfo(skb[0])->hwtstamps.hwtstamp = 1000;
14369  
14370  	/* adjust skb[0]'s len */
14371  	skb[0]->len += skb[1]->len;
14372  	skb[0]->data_len += skb[1]->data_len;
14373  	skb[0]->truesize += skb[1]->truesize;
14374  
14375  	return skb[0];
14376  
14377  err_skb1:
14378  	__free_page(page[1]);
14379  err_page1:
14380  	kfree_skb(skb[0]);
14381  err_skb0:
14382  	__free_page(page[0]);
14383  err_page0:
14384  	return NULL;
14385  }
14386  
14387  static __init struct sk_buff *build_test_skb_linear_no_head_frag(void)
14388  {
14389  	unsigned int alloc_size = 2000;
14390  	unsigned int headroom = 102, doffset = 72, data_size = 1308;
14391  	struct sk_buff *skb[2];
14392  	int i;
14393  
14394  	/* skbs linked in a frag_list, both with linear data, with head_frag=0
14395  	 * (data allocated by kmalloc), both have tcp data of 1308 bytes
14396  	 * (total payload is 2616 bytes).
14397  	 * Data offset is 72 bytes (40 ipv6 hdr, 32 tcp hdr). Some headroom.
14398  	 */
14399  	for (i = 0; i < 2; i++) {
14400  		skb[i] = alloc_skb(alloc_size, GFP_KERNEL);
14401  		if (!skb[i]) {
14402  			if (i == 0)
14403  				goto err_skb0;
14404  			else
14405  				goto err_skb1;
14406  		}
14407  
14408  		skb[i]->protocol = htons(ETH_P_IPV6);
14409  		skb_reserve(skb[i], headroom);
14410  		skb_put(skb[i], doffset + data_size);
14411  		skb_reset_network_header(skb[i]);
14412  		if (i == 0)
14413  			skb_reset_mac_header(skb[i]);
14414  		else
14415  			skb_set_mac_header(skb[i], -ETH_HLEN);
14416  		__skb_pull(skb[i], doffset);
14417  	}
14418  
14419  	/* setup shinfo.
14420  	 * mimic bpf_skb_proto_4_to_6, which resets gso_segs and assigns a
14421  	 * reduced gso_size.
14422  	 */
14423  	skb_shinfo(skb[0])->gso_size = 1288;
14424  	skb_shinfo(skb[0])->gso_type = SKB_GSO_TCPV6 | SKB_GSO_DODGY;
14425  	skb_shinfo(skb[0])->gso_segs = 0;
14426  	skb_shinfo(skb[0])->frag_list = skb[1];
14427  
14428  	/* adjust skb[0]'s len */
14429  	skb[0]->len += skb[1]->len;
14430  	skb[0]->data_len += skb[1]->len;
14431  	skb[0]->truesize += skb[1]->truesize;
14432  
14433  	return skb[0];
14434  
14435  err_skb1:
14436  	kfree_skb(skb[0]);
14437  err_skb0:
14438  	return NULL;
14439  }
14440  
14441  struct skb_segment_test {
14442  	const char *descr;
14443  	struct sk_buff *(*build_skb)(void);
14444  	netdev_features_t features;
14445  };
14446  
14447  static struct skb_segment_test skb_segment_tests[] __initconst = {
14448  	{
14449  		.descr = "gso_with_rx_frags",
14450  		.build_skb = build_test_skb,
14451  		.features = NETIF_F_SG | NETIF_F_GSO_PARTIAL | NETIF_F_IP_CSUM |
14452  			    NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM
14453  	},
14454  	{
14455  		.descr = "gso_linear_no_head_frag",
14456  		.build_skb = build_test_skb_linear_no_head_frag,
14457  		.features = NETIF_F_SG | NETIF_F_FRAGLIST |
14458  			    NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_GSO |
14459  			    NETIF_F_LLTX_BIT | NETIF_F_GRO |
14460  			    NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM |
14461  			    NETIF_F_HW_VLAN_STAG_TX_BIT
14462  	}
14463  };
14464  
14465  static __init int test_skb_segment_single(const struct skb_segment_test *test)
14466  {
14467  	struct sk_buff *skb, *segs;
14468  	int ret = -1;
14469  
14470  	skb = test->build_skb();
14471  	if (!skb) {
14472  		pr_info("%s: failed to build_test_skb", __func__);
14473  		goto done;
14474  	}
14475  
14476  	segs = skb_segment(skb, test->features);
14477  	if (!IS_ERR(segs)) {
14478  		kfree_skb_list(segs);
14479  		ret = 0;
14480  	}
14481  	kfree_skb(skb);
14482  done:
14483  	return ret;
14484  }
14485  
14486  static __init int test_skb_segment(void)
14487  {
14488  	int i, err_cnt = 0, pass_cnt = 0;
14489  
14490  	for (i = 0; i < ARRAY_SIZE(skb_segment_tests); i++) {
14491  		const struct skb_segment_test *test = &skb_segment_tests[i];
14492  
14493  		cond_resched();
14494  		if (exclude_test(i))
14495  			continue;
14496  
14497  		pr_info("#%d %s ", i, test->descr);
14498  
14499  		if (test_skb_segment_single(test)) {
14500  			pr_cont("FAIL\n");
14501  			err_cnt++;
14502  		} else {
14503  			pr_cont("PASS\n");
14504  			pass_cnt++;
14505  		}
14506  	}
14507  
14508  	pr_info("%s: Summary: %d PASSED, %d FAILED\n", __func__,
14509  		pass_cnt, err_cnt);
14510  	return err_cnt ? -EINVAL : 0;
14511  }
14512  
14513  static __init int test_bpf(void)
14514  {
14515  	int i, err_cnt = 0, pass_cnt = 0;
14516  	int jit_cnt = 0, run_cnt = 0;
14517  
14518  	for (i = 0; i < ARRAY_SIZE(tests); i++) {
14519  		struct bpf_prog *fp;
14520  		int err;
14521  
14522  		cond_resched();
14523  		if (exclude_test(i))
14524  			continue;
14525  
14526  		pr_info("#%d %s ", i, tests[i].descr);
14527  
14528  		if (tests[i].fill_helper &&
14529  		    tests[i].fill_helper(&tests[i]) < 0) {
14530  			pr_cont("FAIL to prog_fill\n");
14531  			continue;
14532  		}
14533  
14534  		fp = generate_filter(i, &err);
14535  
14536  		if (tests[i].fill_helper) {
14537  			kfree(tests[i].u.ptr.insns);
14538  			tests[i].u.ptr.insns = NULL;
14539  		}
14540  
14541  		if (fp == NULL) {
14542  			if (err == 0) {
14543  				pass_cnt++;
14544  				continue;
14545  			}
14546  			err_cnt++;
14547  			continue;
14548  		}
14549  
14550  		pr_cont("jited:%u ", fp->jited);
14551  
14552  		run_cnt++;
14553  		if (fp->jited)
14554  			jit_cnt++;
14555  
14556  		err = run_one(fp, &tests[i]);
14557  		release_filter(fp, i);
14558  
14559  		if (err) {
14560  			pr_cont("FAIL (%d times)\n", err);
14561  			err_cnt++;
14562  		} else {
14563  			pr_cont("PASS\n");
14564  			pass_cnt++;
14565  		}
14566  	}
14567  
14568  	pr_info("Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n",
14569  		pass_cnt, err_cnt, jit_cnt, run_cnt);
14570  
14571  	return err_cnt ? -EINVAL : 0;
14572  }
14573  
14574  struct tail_call_test {
14575  	const char *descr;
14576  	struct bpf_insn insns[MAX_INSNS];
14577  	int flags;
14578  	int result;
14579  	int stack_depth;
14580  };
14581  
14582  /* Flags that can be passed to tail call test cases */
14583  #define FLAG_NEED_STATE		BIT(0)
14584  #define FLAG_RESULT_IN_STATE	BIT(1)
14585  
14586  /*
14587   * Magic marker used in test snippets for tail calls below.
14588   * BPF_LD/MOV to R2 and R2 with this immediate value is replaced
14589   * with the proper values by the test runner.
14590   */
14591  #define TAIL_CALL_MARKER 0x7a11ca11
14592  
14593  /* Special offset to indicate a NULL call target */
14594  #define TAIL_CALL_NULL 0x7fff
14595  
14596  /* Special offset to indicate an out-of-range index */
14597  #define TAIL_CALL_INVALID 0x7ffe
14598  
14599  #define TAIL_CALL(offset)			       \
14600  	BPF_LD_IMM64(R2, TAIL_CALL_MARKER),	       \
14601  	BPF_RAW_INSN(BPF_ALU | BPF_MOV | BPF_K, R3, 0, \
14602  		     offset, TAIL_CALL_MARKER),	       \
14603  	BPF_JMP_IMM(BPF_TAIL_CALL, 0, 0, 0)
14604  
14605  /*
14606   * A test function to be called from a BPF program, clobbering a lot of
14607   * CPU registers in the process. A JITed BPF program calling this function
14608   * must save and restore any caller-saved registers it uses for internal
14609   * state, for example the current tail call count.
14610   */
14611  BPF_CALL_1(bpf_test_func, u64, arg)
14612  {
14613  	char buf[64];
14614  	long a = 0;
14615  	long b = 1;
14616  	long c = 2;
14617  	long d = 3;
14618  	long e = 4;
14619  	long f = 5;
14620  	long g = 6;
14621  	long h = 7;
14622  
14623  	return snprintf(buf, sizeof(buf),
14624  			"%ld %lu %lx %ld %lu %lx %ld %lu %x",
14625  			a, b, c, d, e, f, g, h, (int)arg);
14626  }
14627  #define BPF_FUNC_test_func __BPF_FUNC_MAX_ID
14628  
14629  /*
14630   * Tail call tests. Each test case may call any other test in the table,
14631   * including itself, specified as a relative index offset from the calling
14632   * test. The index TAIL_CALL_NULL can be used to specify a NULL target
14633   * function to test the JIT error path. Similarly, the index TAIL_CALL_INVALID
14634   * results in a target index that is out of range.
14635   */
14636  static struct tail_call_test tail_call_tests[] = {
14637  	{
14638  		"Tail call leaf",
14639  		.insns = {
14640  			BPF_ALU64_REG(BPF_MOV, R0, R1),
14641  			BPF_ALU64_IMM(BPF_ADD, R0, 1),
14642  			BPF_EXIT_INSN(),
14643  		},
14644  		.result = 1,
14645  	},
14646  	{
14647  		"Tail call 2",
14648  		.insns = {
14649  			BPF_ALU64_IMM(BPF_ADD, R1, 2),
14650  			TAIL_CALL(-1),
14651  			BPF_ALU64_IMM(BPF_MOV, R0, -1),
14652  			BPF_EXIT_INSN(),
14653  		},
14654  		.result = 3,
14655  	},
14656  	{
14657  		"Tail call 3",
14658  		.insns = {
14659  			BPF_ALU64_IMM(BPF_ADD, R1, 3),
14660  			TAIL_CALL(-1),
14661  			BPF_ALU64_IMM(BPF_MOV, R0, -1),
14662  			BPF_EXIT_INSN(),
14663  		},
14664  		.result = 6,
14665  	},
14666  	{
14667  		"Tail call 4",
14668  		.insns = {
14669  			BPF_ALU64_IMM(BPF_ADD, R1, 4),
14670  			TAIL_CALL(-1),
14671  			BPF_ALU64_IMM(BPF_MOV, R0, -1),
14672  			BPF_EXIT_INSN(),
14673  		},
14674  		.result = 10,
14675  	},
14676  	{
14677  		"Tail call error path, max count reached",
14678  		.insns = {
14679  			BPF_LDX_MEM(BPF_W, R2, R1, 0),
14680  			BPF_ALU64_IMM(BPF_ADD, R2, 1),
14681  			BPF_STX_MEM(BPF_W, R1, R2, 0),
14682  			TAIL_CALL(0),
14683  			BPF_EXIT_INSN(),
14684  		},
14685  		.flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE,
14686  		.result = (MAX_TAIL_CALL_CNT + 1) * MAX_TESTRUNS,
14687  	},
14688  	{
14689  		"Tail call count preserved across function calls",
14690  		.insns = {
14691  			BPF_LDX_MEM(BPF_W, R2, R1, 0),
14692  			BPF_ALU64_IMM(BPF_ADD, R2, 1),
14693  			BPF_STX_MEM(BPF_W, R1, R2, 0),
14694  			BPF_STX_MEM(BPF_DW, R10, R1, -8),
14695  			BPF_CALL_REL(BPF_FUNC_get_numa_node_id),
14696  			BPF_CALL_REL(BPF_FUNC_ktime_get_ns),
14697  			BPF_CALL_REL(BPF_FUNC_ktime_get_boot_ns),
14698  			BPF_CALL_REL(BPF_FUNC_ktime_get_coarse_ns),
14699  			BPF_CALL_REL(BPF_FUNC_jiffies64),
14700  			BPF_CALL_REL(BPF_FUNC_test_func),
14701  			BPF_LDX_MEM(BPF_DW, R1, R10, -8),
14702  			BPF_ALU32_REG(BPF_MOV, R0, R1),
14703  			TAIL_CALL(0),
14704  			BPF_EXIT_INSN(),
14705  		},
14706  		.stack_depth = 8,
14707  		.flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE,
14708  		.result = (MAX_TAIL_CALL_CNT + 1) * MAX_TESTRUNS,
14709  	},
14710  	{
14711  		"Tail call error path, NULL target",
14712  		.insns = {
14713  			BPF_LDX_MEM(BPF_W, R2, R1, 0),
14714  			BPF_ALU64_IMM(BPF_ADD, R2, 1),
14715  			BPF_STX_MEM(BPF_W, R1, R2, 0),
14716  			TAIL_CALL(TAIL_CALL_NULL),
14717  			BPF_EXIT_INSN(),
14718  		},
14719  		.flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE,
14720  		.result = MAX_TESTRUNS,
14721  	},
14722  	{
14723  		"Tail call error path, index out of range",
14724  		.insns = {
14725  			BPF_LDX_MEM(BPF_W, R2, R1, 0),
14726  			BPF_ALU64_IMM(BPF_ADD, R2, 1),
14727  			BPF_STX_MEM(BPF_W, R1, R2, 0),
14728  			TAIL_CALL(TAIL_CALL_INVALID),
14729  			BPF_EXIT_INSN(),
14730  		},
14731  		.flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE,
14732  		.result = MAX_TESTRUNS,
14733  	},
14734  };
14735  
14736  static void __init destroy_tail_call_tests(struct bpf_array *progs)
14737  {
14738  	int i;
14739  
14740  	for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++)
14741  		if (progs->ptrs[i])
14742  			bpf_prog_free(progs->ptrs[i]);
14743  	kfree(progs);
14744  }
14745  
14746  static __init int prepare_tail_call_tests(struct bpf_array **pprogs)
14747  {
14748  	int ntests = ARRAY_SIZE(tail_call_tests);
14749  	struct bpf_array *progs;
14750  	int which, err;
14751  
14752  	/* Allocate the table of programs to be used for tall calls */
14753  	progs = kzalloc(sizeof(*progs) + (ntests + 1) * sizeof(progs->ptrs[0]),
14754  			GFP_KERNEL);
14755  	if (!progs)
14756  		goto out_nomem;
14757  
14758  	/* Create all eBPF programs and populate the table */
14759  	for (which = 0; which < ntests; which++) {
14760  		struct tail_call_test *test = &tail_call_tests[which];
14761  		struct bpf_prog *fp;
14762  		int len, i;
14763  
14764  		/* Compute the number of program instructions */
14765  		for (len = 0; len < MAX_INSNS; len++) {
14766  			struct bpf_insn *insn = &test->insns[len];
14767  
14768  			if (len < MAX_INSNS - 1 &&
14769  			    insn->code == (BPF_LD | BPF_DW | BPF_IMM))
14770  				len++;
14771  			if (insn->code == 0)
14772  				break;
14773  		}
14774  
14775  		/* Allocate and initialize the program */
14776  		fp = bpf_prog_alloc(bpf_prog_size(len), 0);
14777  		if (!fp)
14778  			goto out_nomem;
14779  
14780  		fp->len = len;
14781  		fp->type = BPF_PROG_TYPE_SOCKET_FILTER;
14782  		fp->aux->stack_depth = test->stack_depth;
14783  		memcpy(fp->insnsi, test->insns, len * sizeof(struct bpf_insn));
14784  
14785  		/* Relocate runtime tail call offsets and addresses */
14786  		for (i = 0; i < len; i++) {
14787  			struct bpf_insn *insn = &fp->insnsi[i];
14788  			long addr = 0;
14789  
14790  			switch (insn->code) {
14791  			case BPF_LD | BPF_DW | BPF_IMM:
14792  				if (insn->imm != TAIL_CALL_MARKER)
14793  					break;
14794  				insn[0].imm = (u32)(long)progs;
14795  				insn[1].imm = ((u64)(long)progs) >> 32;
14796  				break;
14797  
14798  			case BPF_ALU | BPF_MOV | BPF_K:
14799  				if (insn->imm != TAIL_CALL_MARKER)
14800  					break;
14801  				if (insn->off == TAIL_CALL_NULL)
14802  					insn->imm = ntests;
14803  				else if (insn->off == TAIL_CALL_INVALID)
14804  					insn->imm = ntests + 1;
14805  				else
14806  					insn->imm = which + insn->off;
14807  				insn->off = 0;
14808  				break;
14809  
14810  			case BPF_JMP | BPF_CALL:
14811  				if (insn->src_reg != BPF_PSEUDO_CALL)
14812  					break;
14813  				switch (insn->imm) {
14814  				case BPF_FUNC_get_numa_node_id:
14815  					addr = (long)&numa_node_id;
14816  					break;
14817  				case BPF_FUNC_ktime_get_ns:
14818  					addr = (long)&ktime_get_ns;
14819  					break;
14820  				case BPF_FUNC_ktime_get_boot_ns:
14821  					addr = (long)&ktime_get_boot_fast_ns;
14822  					break;
14823  				case BPF_FUNC_ktime_get_coarse_ns:
14824  					addr = (long)&ktime_get_coarse_ns;
14825  					break;
14826  				case BPF_FUNC_jiffies64:
14827  					addr = (long)&get_jiffies_64;
14828  					break;
14829  				case BPF_FUNC_test_func:
14830  					addr = (long)&bpf_test_func;
14831  					break;
14832  				default:
14833  					err = -EFAULT;
14834  					goto out_err;
14835  				}
14836  				*insn = BPF_EMIT_CALL(addr);
14837  				if ((long)__bpf_call_base + insn->imm != addr)
14838  					*insn = BPF_JMP_A(0); /* Skip: NOP */
14839  				break;
14840  			}
14841  		}
14842  
14843  		fp = bpf_prog_select_runtime(fp, &err);
14844  		if (err)
14845  			goto out_err;
14846  
14847  		progs->ptrs[which] = fp;
14848  	}
14849  
14850  	/* The last entry contains a NULL program pointer */
14851  	progs->map.max_entries = ntests + 1;
14852  	*pprogs = progs;
14853  	return 0;
14854  
14855  out_nomem:
14856  	err = -ENOMEM;
14857  
14858  out_err:
14859  	if (progs)
14860  		destroy_tail_call_tests(progs);
14861  	return err;
14862  }
14863  
14864  static __init int test_tail_calls(struct bpf_array *progs)
14865  {
14866  	int i, err_cnt = 0, pass_cnt = 0;
14867  	int jit_cnt = 0, run_cnt = 0;
14868  
14869  	for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++) {
14870  		struct tail_call_test *test = &tail_call_tests[i];
14871  		struct bpf_prog *fp = progs->ptrs[i];
14872  		int *data = NULL;
14873  		int state = 0;
14874  		u64 duration;
14875  		int ret;
14876  
14877  		cond_resched();
14878  		if (exclude_test(i))
14879  			continue;
14880  
14881  		pr_info("#%d %s ", i, test->descr);
14882  		if (!fp) {
14883  			err_cnt++;
14884  			continue;
14885  		}
14886  		pr_cont("jited:%u ", fp->jited);
14887  
14888  		run_cnt++;
14889  		if (fp->jited)
14890  			jit_cnt++;
14891  
14892  		if (test->flags & FLAG_NEED_STATE)
14893  			data = &state;
14894  		ret = __run_one(fp, data, MAX_TESTRUNS, &duration);
14895  		if (test->flags & FLAG_RESULT_IN_STATE)
14896  			ret = state;
14897  		if (ret == test->result) {
14898  			pr_cont("%lld PASS", duration);
14899  			pass_cnt++;
14900  		} else {
14901  			pr_cont("ret %d != %d FAIL", ret, test->result);
14902  			err_cnt++;
14903  		}
14904  	}
14905  
14906  	pr_info("%s: Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n",
14907  		__func__, pass_cnt, err_cnt, jit_cnt, run_cnt);
14908  
14909  	return err_cnt ? -EINVAL : 0;
14910  }
14911  
14912  static char test_suite[32];
14913  module_param_string(test_suite, test_suite, sizeof(test_suite), 0);
14914  
14915  static __init int find_test_index(const char *test_name)
14916  {
14917  	int i;
14918  
14919  	if (!strcmp(test_suite, "test_bpf")) {
14920  		for (i = 0; i < ARRAY_SIZE(tests); i++) {
14921  			if (!strcmp(tests[i].descr, test_name))
14922  				return i;
14923  		}
14924  	}
14925  
14926  	if (!strcmp(test_suite, "test_tail_calls")) {
14927  		for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++) {
14928  			if (!strcmp(tail_call_tests[i].descr, test_name))
14929  				return i;
14930  		}
14931  	}
14932  
14933  	if (!strcmp(test_suite, "test_skb_segment")) {
14934  		for (i = 0; i < ARRAY_SIZE(skb_segment_tests); i++) {
14935  			if (!strcmp(skb_segment_tests[i].descr, test_name))
14936  				return i;
14937  		}
14938  	}
14939  
14940  	return -1;
14941  }
14942  
14943  static __init int prepare_test_range(void)
14944  {
14945  	int valid_range;
14946  
14947  	if (!strcmp(test_suite, "test_bpf"))
14948  		valid_range = ARRAY_SIZE(tests);
14949  	else if (!strcmp(test_suite, "test_tail_calls"))
14950  		valid_range = ARRAY_SIZE(tail_call_tests);
14951  	else if (!strcmp(test_suite, "test_skb_segment"))
14952  		valid_range = ARRAY_SIZE(skb_segment_tests);
14953  	else
14954  		return 0;
14955  
14956  	if (test_id >= 0) {
14957  		/*
14958  		 * if a test_id was specified, use test_range to
14959  		 * cover only that test.
14960  		 */
14961  		if (test_id >= valid_range) {
14962  			pr_err("test_bpf: invalid test_id specified for '%s' suite.\n",
14963  			       test_suite);
14964  			return -EINVAL;
14965  		}
14966  
14967  		test_range[0] = test_id;
14968  		test_range[1] = test_id;
14969  	} else if (*test_name) {
14970  		/*
14971  		 * if a test_name was specified, find it and setup
14972  		 * test_range to cover only that test.
14973  		 */
14974  		int idx = find_test_index(test_name);
14975  
14976  		if (idx < 0) {
14977  			pr_err("test_bpf: no test named '%s' found for '%s' suite.\n",
14978  			       test_name, test_suite);
14979  			return -EINVAL;
14980  		}
14981  		test_range[0] = idx;
14982  		test_range[1] = idx;
14983  	} else if (test_range[0] != 0 || test_range[1] != INT_MAX) {
14984  		/*
14985  		 * check that the supplied test_range is valid.
14986  		 */
14987  		if (test_range[0] < 0 || test_range[1] >= valid_range) {
14988  			pr_err("test_bpf: test_range is out of bound for '%s' suite.\n",
14989  			       test_suite);
14990  			return -EINVAL;
14991  		}
14992  
14993  		if (test_range[1] < test_range[0]) {
14994  			pr_err("test_bpf: test_range is ending before it starts.\n");
14995  			return -EINVAL;
14996  		}
14997  	}
14998  
14999  	return 0;
15000  }
15001  
15002  static int __init test_bpf_init(void)
15003  {
15004  	struct bpf_array *progs = NULL;
15005  	int ret;
15006  
15007  	if (strlen(test_suite) &&
15008  	    strcmp(test_suite, "test_bpf") &&
15009  	    strcmp(test_suite, "test_tail_calls") &&
15010  	    strcmp(test_suite, "test_skb_segment")) {
15011  		pr_err("test_bpf: invalid test_suite '%s' specified.\n", test_suite);
15012  		return -EINVAL;
15013  	}
15014  
15015  	/*
15016  	 * if test_suite is not specified, but test_id, test_name or test_range
15017  	 * is specified, set 'test_bpf' as the default test suite.
15018  	 */
15019  	if (!strlen(test_suite) &&
15020  	    (test_id != -1 || strlen(test_name) ||
15021  	    (test_range[0] != 0 || test_range[1] != INT_MAX))) {
15022  		pr_info("test_bpf: set 'test_bpf' as the default test_suite.\n");
15023  		strscpy(test_suite, "test_bpf", sizeof(test_suite));
15024  	}
15025  
15026  	ret = prepare_test_range();
15027  	if (ret < 0)
15028  		return ret;
15029  
15030  	if (!strlen(test_suite) || !strcmp(test_suite, "test_bpf")) {
15031  		ret = test_bpf();
15032  		if (ret)
15033  			return ret;
15034  	}
15035  
15036  	if (!strlen(test_suite) || !strcmp(test_suite, "test_tail_calls")) {
15037  		ret = prepare_tail_call_tests(&progs);
15038  		if (ret)
15039  			return ret;
15040  		ret = test_tail_calls(progs);
15041  		destroy_tail_call_tests(progs);
15042  		if (ret)
15043  			return ret;
15044  	}
15045  
15046  	if (!strlen(test_suite) || !strcmp(test_suite, "test_skb_segment"))
15047  		return test_skb_segment();
15048  
15049  	return 0;
15050  }
15051  
15052  static void __exit test_bpf_exit(void)
15053  {
15054  }
15055  
15056  module_init(test_bpf_init);
15057  module_exit(test_bpf_exit);
15058  
15059  MODULE_LICENSE("GPL");
15060