~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/lib/test_bpf.c

Version: ~ [ linux-5.2-rc5 ] ~ [ linux-5.1.12 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.53 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.128 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.182 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.182 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.68 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Testsuite for BPF interpreter and BPF JIT compiler
  3  *
  4  * Copyright (c) 2011-2014 PLUMgrid, http://plumgrid.com
  5  *
  6  * This program is free software; you can redistribute it and/or
  7  * modify it under the terms of version 2 of the GNU General Public
  8  * License as published by the Free Software Foundation.
  9  *
 10  * This program is distributed in the hope that it will be useful, but
 11  * WITHOUT ANY WARRANTY; without even the implied warranty of
 12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 13  * General Public License for more details.
 14  */
 15 
 16 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 17 
 18 #include <linux/init.h>
 19 #include <linux/module.h>
 20 #include <linux/filter.h>
 21 #include <linux/bpf.h>
 22 #include <linux/skbuff.h>
 23 #include <linux/netdevice.h>
 24 #include <linux/if_vlan.h>
 25 #include <linux/random.h>
 26 #include <linux/highmem.h>
 27 
 28 /* General test specific settings */
 29 #define MAX_SUBTESTS    3
 30 #define MAX_TESTRUNS    10000
 31 #define MAX_DATA        128
 32 #define MAX_INSNS       512
 33 #define MAX_K           0xffffFFFF
 34 
 35 /* Few constants used to init test 'skb' */
 36 #define SKB_TYPE        3
 37 #define SKB_MARK        0x1234aaaa
 38 #define SKB_HASH        0x1234aaab
 39 #define SKB_QUEUE_MAP   123
 40 #define SKB_VLAN_TCI    0xffff
 41 #define SKB_DEV_IFINDEX 577
 42 #define SKB_DEV_TYPE    588
 43 
 44 /* Redefine REGs to make tests less verbose */
 45 #define R0              BPF_REG_0
 46 #define R1              BPF_REG_1
 47 #define R2              BPF_REG_2
 48 #define R3              BPF_REG_3
 49 #define R4              BPF_REG_4
 50 #define R5              BPF_REG_5
 51 #define R6              BPF_REG_6
 52 #define R7              BPF_REG_7
 53 #define R8              BPF_REG_8
 54 #define R9              BPF_REG_9
 55 #define R10             BPF_REG_10
 56 
 57 /* Flags that can be passed to test cases */
 58 #define FLAG_NO_DATA            BIT(0)
 59 #define FLAG_EXPECTED_FAIL      BIT(1)
 60 #define FLAG_SKB_FRAG           BIT(2)
 61 
 62 enum {
 63         CLASSIC  = BIT(6),      /* Old BPF instructions only. */
 64         INTERNAL = BIT(7),      /* Extended instruction set.  */
 65 };
 66 
 67 #define TEST_TYPE_MASK          (CLASSIC | INTERNAL)
 68 
 69 struct bpf_test {
 70         const char *descr;
 71         union {
 72                 struct sock_filter insns[MAX_INSNS];
 73                 struct bpf_insn insns_int[MAX_INSNS];
 74                 struct {
 75                         void *insns;
 76                         unsigned int len;
 77                 } ptr;
 78         } u;
 79         __u8 aux;
 80         __u8 data[MAX_DATA];
 81         struct {
 82                 int data_size;
 83                 __u32 result;
 84         } test[MAX_SUBTESTS];
 85         int (*fill_helper)(struct bpf_test *self);
 86         __u8 frag_data[MAX_DATA];
 87 };
 88 
 89 /* Large test cases need separate allocation and fill handler. */
 90 
 91 static int bpf_fill_maxinsns1(struct bpf_test *self)
 92 {
 93         unsigned int len = BPF_MAXINSNS;
 94         struct sock_filter *insn;
 95         __u32 k = ~0;
 96         int i;
 97 
 98         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
 99         if (!insn)
100                 return -ENOMEM;
101 
102         for (i = 0; i < len; i++, k--)
103                 insn[i] = __BPF_STMT(BPF_RET | BPF_K, k);
104 
105         self->u.ptr.insns = insn;
106         self->u.ptr.len = len;
107 
108         return 0;
109 }
110 
111 static int bpf_fill_maxinsns2(struct bpf_test *self)
112 {
113         unsigned int len = BPF_MAXINSNS;
114         struct sock_filter *insn;
115         int i;
116 
117         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
118         if (!insn)
119                 return -ENOMEM;
120 
121         for (i = 0; i < len; i++)
122                 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
123 
124         self->u.ptr.insns = insn;
125         self->u.ptr.len = len;
126 
127         return 0;
128 }
129 
130 static int bpf_fill_maxinsns3(struct bpf_test *self)
131 {
132         unsigned int len = BPF_MAXINSNS;
133         struct sock_filter *insn;
134         struct rnd_state rnd;
135         int i;
136 
137         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
138         if (!insn)
139                 return -ENOMEM;
140 
141         prandom_seed_state(&rnd, 3141592653589793238ULL);
142 
143         for (i = 0; i < len - 1; i++) {
144                 __u32 k = prandom_u32_state(&rnd);
145 
146                 insn[i] = __BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, k);
147         }
148 
149         insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
150 
151         self->u.ptr.insns = insn;
152         self->u.ptr.len = len;
153 
154         return 0;
155 }
156 
157 static int bpf_fill_maxinsns4(struct bpf_test *self)
158 {
159         unsigned int len = BPF_MAXINSNS + 1;
160         struct sock_filter *insn;
161         int i;
162 
163         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
164         if (!insn)
165                 return -ENOMEM;
166 
167         for (i = 0; i < len; i++)
168                 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
169 
170         self->u.ptr.insns = insn;
171         self->u.ptr.len = len;
172 
173         return 0;
174 }
175 
176 static int bpf_fill_maxinsns5(struct bpf_test *self)
177 {
178         unsigned int len = BPF_MAXINSNS;
179         struct sock_filter *insn;
180         int i;
181 
182         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
183         if (!insn)
184                 return -ENOMEM;
185 
186         insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0);
187 
188         for (i = 1; i < len - 1; i++)
189                 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
190 
191         insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab);
192 
193         self->u.ptr.insns = insn;
194         self->u.ptr.len = len;
195 
196         return 0;
197 }
198 
199 static int bpf_fill_maxinsns6(struct bpf_test *self)
200 {
201         unsigned int len = BPF_MAXINSNS;
202         struct sock_filter *insn;
203         int i;
204 
205         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
206         if (!insn)
207                 return -ENOMEM;
208 
209         for (i = 0; i < len - 1; i++)
210                 insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
211                                      SKF_AD_VLAN_TAG_PRESENT);
212 
213         insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
214 
215         self->u.ptr.insns = insn;
216         self->u.ptr.len = len;
217 
218         return 0;
219 }
220 
221 static int bpf_fill_maxinsns7(struct bpf_test *self)
222 {
223         unsigned int len = BPF_MAXINSNS;
224         struct sock_filter *insn;
225         int i;
226 
227         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
228         if (!insn)
229                 return -ENOMEM;
230 
231         for (i = 0; i < len - 4; i++)
232                 insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
233                                      SKF_AD_CPU);
234 
235         insn[len - 4] = __BPF_STMT(BPF_MISC | BPF_TAX, 0);
236         insn[len - 3] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
237                                    SKF_AD_CPU);
238         insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0);
239         insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
240 
241         self->u.ptr.insns = insn;
242         self->u.ptr.len = len;
243 
244         return 0;
245 }
246 
247 static int bpf_fill_maxinsns8(struct bpf_test *self)
248 {
249         unsigned int len = BPF_MAXINSNS;
250         struct sock_filter *insn;
251         int i, jmp_off = len - 3;
252 
253         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
254         if (!insn)
255                 return -ENOMEM;
256 
257         insn[0] = __BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff);
258 
259         for (i = 1; i < len - 1; i++)
260                 insn[i] = __BPF_JUMP(BPF_JMP | BPF_JGT, 0xffffffff, jmp_off--, 0);
261 
262         insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
263 
264         self->u.ptr.insns = insn;
265         self->u.ptr.len = len;
266 
267         return 0;
268 }
269 
270 static int bpf_fill_maxinsns9(struct bpf_test *self)
271 {
272         unsigned int len = BPF_MAXINSNS;
273         struct bpf_insn *insn;
274         int i;
275 
276         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
277         if (!insn)
278                 return -ENOMEM;
279 
280         insn[0] = BPF_JMP_IMM(BPF_JA, 0, 0, len - 2);
281         insn[1] = BPF_ALU32_IMM(BPF_MOV, R0, 0xcbababab);
282         insn[2] = BPF_EXIT_INSN();
283 
284         for (i = 3; i < len - 2; i++)
285                 insn[i] = BPF_ALU32_IMM(BPF_MOV, R0, 0xfefefefe);
286 
287         insn[len - 2] = BPF_EXIT_INSN();
288         insn[len - 1] = BPF_JMP_IMM(BPF_JA, 0, 0, -(len - 1));
289 
290         self->u.ptr.insns = insn;
291         self->u.ptr.len = len;
292 
293         return 0;
294 }
295 
296 static int bpf_fill_maxinsns10(struct bpf_test *self)
297 {
298         unsigned int len = BPF_MAXINSNS, hlen = len - 2;
299         struct bpf_insn *insn;
300         int i;
301 
302         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
303         if (!insn)
304                 return -ENOMEM;
305 
306         for (i = 0; i < hlen / 2; i++)
307                 insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 2 - 2 * i);
308         for (i = hlen - 1; i > hlen / 2; i--)
309                 insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 1 - 2 * i);
310 
311         insn[hlen / 2] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen / 2 - 1);
312         insn[hlen]     = BPF_ALU32_IMM(BPF_MOV, R0, 0xabababac);
313         insn[hlen + 1] = BPF_EXIT_INSN();
314 
315         self->u.ptr.insns = insn;
316         self->u.ptr.len = len;
317 
318         return 0;
319 }
320 
321 static int __bpf_fill_ja(struct bpf_test *self, unsigned int len,
322                          unsigned int plen)
323 {
324         struct sock_filter *insn;
325         unsigned int rlen;
326         int i, j;
327 
328         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
329         if (!insn)
330                 return -ENOMEM;
331 
332         rlen = (len % plen) - 1;
333 
334         for (i = 0; i + plen < len; i += plen)
335                 for (j = 0; j < plen; j++)
336                         insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA,
337                                                  plen - 1 - j, 0, 0);
338         for (j = 0; j < rlen; j++)
339                 insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA, rlen - 1 - j,
340                                          0, 0);
341 
342         insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xababcbac);
343 
344         self->u.ptr.insns = insn;
345         self->u.ptr.len = len;
346 
347         return 0;
348 }
349 
350 static int bpf_fill_maxinsns11(struct bpf_test *self)
351 {
352         /* Hits 70 passes on x86_64, so cannot get JITed there. */
353         return __bpf_fill_ja(self, BPF_MAXINSNS, 68);
354 }
355 
356 static int bpf_fill_ja(struct bpf_test *self)
357 {
358         /* Hits exactly 11 passes on x86_64 JIT. */
359         return __bpf_fill_ja(self, 12, 9);
360 }
361 
362 static int bpf_fill_ld_abs_get_processor_id(struct bpf_test *self)
363 {
364         unsigned int len = BPF_MAXINSNS;
365         struct sock_filter *insn;
366         int i;
367 
368         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
369         if (!insn)
370                 return -ENOMEM;
371 
372         for (i = 0; i < len - 1; i += 2) {
373                 insn[i] = __BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 0);
374                 insn[i + 1] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
375                                          SKF_AD_OFF + SKF_AD_CPU);
376         }
377 
378         insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xbee);
379 
380         self->u.ptr.insns = insn;
381         self->u.ptr.len = len;
382 
383         return 0;
384 }
385 
386 #define PUSH_CNT 68
387 /* test: {skb->data[0], vlan_push} x 68 + {skb->data[0], vlan_pop} x 68 */
388 static int bpf_fill_ld_abs_vlan_push_pop(struct bpf_test *self)
389 {
390         unsigned int len = BPF_MAXINSNS;
391         struct bpf_insn *insn;
392         int i = 0, j, k = 0;
393 
394         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
395         if (!insn)
396                 return -ENOMEM;
397 
398         insn[i++] = BPF_MOV64_REG(R6, R1);
399 loop:
400         for (j = 0; j < PUSH_CNT; j++) {
401                 insn[i++] = BPF_LD_ABS(BPF_B, 0);
402                 insn[i] = BPF_JMP_IMM(BPF_JNE, R0, 0x34, len - i - 2);
403                 i++;
404                 insn[i++] = BPF_MOV64_REG(R1, R6);
405                 insn[i++] = BPF_MOV64_IMM(R2, 1);
406                 insn[i++] = BPF_MOV64_IMM(R3, 2);
407                 insn[i++] = BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
408                                          bpf_skb_vlan_push_proto.func - __bpf_call_base);
409                 insn[i] = BPF_JMP_IMM(BPF_JNE, R0, 0, len - i - 2);
410                 i++;
411         }
412 
413         for (j = 0; j < PUSH_CNT; j++) {
414                 insn[i++] = BPF_LD_ABS(BPF_B, 0);
415                 insn[i] = BPF_JMP_IMM(BPF_JNE, R0, 0x34, len - i - 2);
416                 i++;
417                 insn[i++] = BPF_MOV64_REG(R1, R6);
418                 insn[i++] = BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
419                                          bpf_skb_vlan_pop_proto.func - __bpf_call_base);
420                 insn[i] = BPF_JMP_IMM(BPF_JNE, R0, 0, len - i - 2);
421                 i++;
422         }
423         if (++k < 5)
424                 goto loop;
425 
426         for (; i < len - 1; i++)
427                 insn[i] = BPF_ALU32_IMM(BPF_MOV, R0, 0xbef);
428 
429         insn[len - 1] = BPF_EXIT_INSN();
430 
431         self->u.ptr.insns = insn;
432         self->u.ptr.len = len;
433 
434         return 0;
435 }
436 
437 static struct bpf_test tests[] = {
438         {
439                 "TAX",
440                 .u.insns = {
441                         BPF_STMT(BPF_LD | BPF_IMM, 1),
442                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
443                         BPF_STMT(BPF_LD | BPF_IMM, 2),
444                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
445                         BPF_STMT(BPF_ALU | BPF_NEG, 0), /* A == -3 */
446                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
447                         BPF_STMT(BPF_LD | BPF_LEN, 0),
448                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
449                         BPF_STMT(BPF_MISC | BPF_TAX, 0), /* X == len - 3 */
450                         BPF_STMT(BPF_LD | BPF_B | BPF_IND, 1),
451                         BPF_STMT(BPF_RET | BPF_A, 0)
452                 },
453                 CLASSIC,
454                 { 10, 20, 30, 40, 50 },
455                 { { 2, 10 }, { 3, 20 }, { 4, 30 } },
456         },
457         {
458                 "TXA",
459                 .u.insns = {
460                         BPF_STMT(BPF_LDX | BPF_LEN, 0),
461                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
462                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
463                         BPF_STMT(BPF_RET | BPF_A, 0) /* A == len * 2 */
464                 },
465                 CLASSIC,
466                 { 10, 20, 30, 40, 50 },
467                 { { 1, 2 }, { 3, 6 }, { 4, 8 } },
468         },
469         {
470                 "ADD_SUB_MUL_K",
471                 .u.insns = {
472                         BPF_STMT(BPF_LD | BPF_IMM, 1),
473                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 2),
474                         BPF_STMT(BPF_LDX | BPF_IMM, 3),
475                         BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
476                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0xffffffff),
477                         BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 3),
478                         BPF_STMT(BPF_RET | BPF_A, 0)
479                 },
480                 CLASSIC | FLAG_NO_DATA,
481                 { },
482                 { { 0, 0xfffffffd } }
483         },
484         {
485                 "DIV_MOD_KX",
486                 .u.insns = {
487                         BPF_STMT(BPF_LD | BPF_IMM, 8),
488                         BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 2),
489                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
490                         BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
491                         BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
492                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
493                         BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
494                         BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x70000000),
495                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
496                         BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
497                         BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
498                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
499                         BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
500                         BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x70000000),
501                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
502                         BPF_STMT(BPF_RET | BPF_A, 0)
503                 },
504                 CLASSIC | FLAG_NO_DATA,
505                 { },
506                 { { 0, 0x20000000 } }
507         },
508         {
509                 "AND_OR_LSH_K",
510                 .u.insns = {
511                         BPF_STMT(BPF_LD | BPF_IMM, 0xff),
512                         BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
513                         BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 27),
514                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
515                         BPF_STMT(BPF_LD | BPF_IMM, 0xf),
516                         BPF_STMT(BPF_ALU | BPF_OR | BPF_K, 0xf0),
517                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
518                         BPF_STMT(BPF_RET | BPF_A, 0)
519                 },
520                 CLASSIC | FLAG_NO_DATA,
521                 { },
522                 { { 0, 0x800000ff }, { 1, 0x800000ff } },
523         },
524         {
525                 "LD_IMM_0",
526                 .u.insns = {
527                         BPF_STMT(BPF_LD | BPF_IMM, 0), /* ld #0 */
528                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0, 1, 0),
529                         BPF_STMT(BPF_RET | BPF_K, 0),
530                         BPF_STMT(BPF_RET | BPF_K, 1),
531                 },
532                 CLASSIC,
533                 { },
534                 { { 1, 1 } },
535         },
536         {
537                 "LD_IND",
538                 .u.insns = {
539                         BPF_STMT(BPF_LDX | BPF_LEN, 0),
540                         BPF_STMT(BPF_LD | BPF_H | BPF_IND, MAX_K),
541                         BPF_STMT(BPF_RET | BPF_K, 1)
542                 },
543                 CLASSIC,
544                 { },
545                 { { 1, 0 }, { 10, 0 }, { 60, 0 } },
546         },
547         {
548                 "LD_ABS",
549                 .u.insns = {
550                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1000),
551                         BPF_STMT(BPF_RET | BPF_K, 1)
552                 },
553                 CLASSIC,
554                 { },
555                 { { 1, 0 }, { 10, 0 }, { 60, 0 } },
556         },
557         {
558                 "LD_ABS_LL",
559                 .u.insns = {
560                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF),
561                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
562                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF + 1),
563                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
564                         BPF_STMT(BPF_RET | BPF_A, 0)
565                 },
566                 CLASSIC,
567                 { 1, 2, 3 },
568                 { { 1, 0 }, { 2, 3 } },
569         },
570         {
571                 "LD_IND_LL",
572                 .u.insns = {
573                         BPF_STMT(BPF_LD | BPF_IMM, SKF_LL_OFF - 1),
574                         BPF_STMT(BPF_LDX | BPF_LEN, 0),
575                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
576                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
577                         BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
578                         BPF_STMT(BPF_RET | BPF_A, 0)
579                 },
580                 CLASSIC,
581                 { 1, 2, 3, 0xff },
582                 { { 1, 1 }, { 3, 3 }, { 4, 0xff } },
583         },
584         {
585                 "LD_ABS_NET",
586                 .u.insns = {
587                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF),
588                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
589                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF + 1),
590                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
591                         BPF_STMT(BPF_RET | BPF_A, 0)
592                 },
593                 CLASSIC,
594                 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
595                 { { 15, 0 }, { 16, 3 } },
596         },
597         {
598                 "LD_IND_NET",
599                 .u.insns = {
600                         BPF_STMT(BPF_LD | BPF_IMM, SKF_NET_OFF - 15),
601                         BPF_STMT(BPF_LDX | BPF_LEN, 0),
602                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
603                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
604                         BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
605                         BPF_STMT(BPF_RET | BPF_A, 0)
606                 },
607                 CLASSIC,
608                 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
609                 { { 14, 0 }, { 15, 1 }, { 17, 3 } },
610         },
611         {
612                 "LD_PKTTYPE",
613                 .u.insns = {
614                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
615                                  SKF_AD_OFF + SKF_AD_PKTTYPE),
616                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
617                         BPF_STMT(BPF_RET | BPF_K, 1),
618                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
619                                  SKF_AD_OFF + SKF_AD_PKTTYPE),
620                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
621                         BPF_STMT(BPF_RET | BPF_K, 1),
622                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
623                                  SKF_AD_OFF + SKF_AD_PKTTYPE),
624                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
625                         BPF_STMT(BPF_RET | BPF_K, 1),
626                         BPF_STMT(BPF_RET | BPF_A, 0)
627                 },
628                 CLASSIC,
629                 { },
630                 { { 1, 3 }, { 10, 3 } },
631         },
632         {
633                 "LD_MARK",
634                 .u.insns = {
635                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
636                                  SKF_AD_OFF + SKF_AD_MARK),
637                         BPF_STMT(BPF_RET | BPF_A, 0)
638                 },
639                 CLASSIC,
640                 { },
641                 { { 1, SKB_MARK}, { 10, SKB_MARK} },
642         },
643         {
644                 "LD_RXHASH",
645                 .u.insns = {
646                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
647                                  SKF_AD_OFF + SKF_AD_RXHASH),
648                         BPF_STMT(BPF_RET | BPF_A, 0)
649                 },
650                 CLASSIC,
651                 { },
652                 { { 1, SKB_HASH}, { 10, SKB_HASH} },
653         },
654         {
655                 "LD_QUEUE",
656                 .u.insns = {
657                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
658                                  SKF_AD_OFF + SKF_AD_QUEUE),
659                         BPF_STMT(BPF_RET | BPF_A, 0)
660                 },
661                 CLASSIC,
662                 { },
663                 { { 1, SKB_QUEUE_MAP }, { 10, SKB_QUEUE_MAP } },
664         },
665         {
666                 "LD_PROTOCOL",
667                 .u.insns = {
668                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 1),
669                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 20, 1, 0),
670                         BPF_STMT(BPF_RET | BPF_K, 0),
671                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
672                                  SKF_AD_OFF + SKF_AD_PROTOCOL),
673                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
674                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
675                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 30, 1, 0),
676                         BPF_STMT(BPF_RET | BPF_K, 0),
677                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
678                         BPF_STMT(BPF_RET | BPF_A, 0)
679                 },
680                 CLASSIC,
681                 { 10, 20, 30 },
682                 { { 10, ETH_P_IP }, { 100, ETH_P_IP } },
683         },
684         {
685                 "LD_VLAN_TAG",
686                 .u.insns = {
687                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
688                                  SKF_AD_OFF + SKF_AD_VLAN_TAG),
689                         BPF_STMT(BPF_RET | BPF_A, 0)
690                 },
691                 CLASSIC,
692                 { },
693                 {
694                         { 1, SKB_VLAN_TCI & ~VLAN_TAG_PRESENT },
695                         { 10, SKB_VLAN_TCI & ~VLAN_TAG_PRESENT }
696                 },
697         },
698         {
699                 "LD_VLAN_TAG_PRESENT",
700                 .u.insns = {
701                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
702                                  SKF_AD_OFF + SKF_AD_VLAN_TAG_PRESENT),
703                         BPF_STMT(BPF_RET | BPF_A, 0)
704                 },
705                 CLASSIC,
706                 { },
707                 {
708                         { 1, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) },
709                         { 10, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) }
710                 },
711         },
712         {
713                 "LD_IFINDEX",
714                 .u.insns = {
715                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
716                                  SKF_AD_OFF + SKF_AD_IFINDEX),
717                         BPF_STMT(BPF_RET | BPF_A, 0)
718                 },
719                 CLASSIC,
720                 { },
721                 { { 1, SKB_DEV_IFINDEX }, { 10, SKB_DEV_IFINDEX } },
722         },
723         {
724                 "LD_HATYPE",
725                 .u.insns = {
726                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
727                                  SKF_AD_OFF + SKF_AD_HATYPE),
728                         BPF_STMT(BPF_RET | BPF_A, 0)
729                 },
730                 CLASSIC,
731                 { },
732                 { { 1, SKB_DEV_TYPE }, { 10, SKB_DEV_TYPE } },
733         },
734         {
735                 "LD_CPU",
736                 .u.insns = {
737                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
738                                  SKF_AD_OFF + SKF_AD_CPU),
739                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
740                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
741                                  SKF_AD_OFF + SKF_AD_CPU),
742                         BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
743                         BPF_STMT(BPF_RET | BPF_A, 0)
744                 },
745                 CLASSIC,
746                 { },
747                 { { 1, 0 }, { 10, 0 } },
748         },
749         {
750                 "LD_NLATTR",
751                 .u.insns = {
752                         BPF_STMT(BPF_LDX | BPF_IMM, 2),
753                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
754                         BPF_STMT(BPF_LDX | BPF_IMM, 3),
755                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
756                                  SKF_AD_OFF + SKF_AD_NLATTR),
757                         BPF_STMT(BPF_RET | BPF_A, 0)
758                 },
759                 CLASSIC,
760 #ifdef __BIG_ENDIAN
761                 { 0xff, 0xff, 0, 4, 0, 2, 0, 4, 0, 3 },
762 #else
763                 { 0xff, 0xff, 4, 0, 2, 0, 4, 0, 3, 0 },
764 #endif
765                 { { 4, 0 }, { 20, 6 } },
766         },
767         {
768                 "LD_NLATTR_NEST",
769                 .u.insns = {
770                         BPF_STMT(BPF_LD | BPF_IMM, 2),
771                         BPF_STMT(BPF_LDX | BPF_IMM, 3),
772                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
773                                  SKF_AD_OFF + SKF_AD_NLATTR_NEST),
774                         BPF_STMT(BPF_LD | BPF_IMM, 2),
775                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
776                                  SKF_AD_OFF + SKF_AD_NLATTR_NEST),
777                         BPF_STMT(BPF_LD | BPF_IMM, 2),
778                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
779                                  SKF_AD_OFF + SKF_AD_NLATTR_NEST),
780                         BPF_STMT(BPF_LD | BPF_IMM, 2),
781                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
782                                  SKF_AD_OFF + SKF_AD_NLATTR_NEST),
783                         BPF_STMT(BPF_LD | BPF_IMM, 2),
784                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
785                                  SKF_AD_OFF + SKF_AD_NLATTR_NEST),
786                         BPF_STMT(BPF_LD | BPF_IMM, 2),
787                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
788                                  SKF_AD_OFF + SKF_AD_NLATTR_NEST),
789                         BPF_STMT(BPF_LD | BPF_IMM, 2),
790                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
791                                  SKF_AD_OFF + SKF_AD_NLATTR_NEST),
792                         BPF_STMT(BPF_LD | BPF_IMM, 2),
793                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
794                                  SKF_AD_OFF + SKF_AD_NLATTR_NEST),
795                         BPF_STMT(BPF_RET | BPF_A, 0)
796                 },
797                 CLASSIC,
798 #ifdef __BIG_ENDIAN
799                 { 0xff, 0xff, 0, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3 },
800 #else
801                 { 0xff, 0xff, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3, 0 },
802 #endif
803                 { { 4, 0 }, { 20, 10 } },
804         },
805         {
806                 "LD_PAYLOAD_OFF",
807                 .u.insns = {
808                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
809                                  SKF_AD_OFF + SKF_AD_PAY_OFFSET),
810                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
811                                  SKF_AD_OFF + SKF_AD_PAY_OFFSET),
812                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
813                                  SKF_AD_OFF + SKF_AD_PAY_OFFSET),
814                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
815                                  SKF_AD_OFF + SKF_AD_PAY_OFFSET),
816                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
817                                  SKF_AD_OFF + SKF_AD_PAY_OFFSET),
818                         BPF_STMT(BPF_RET | BPF_A, 0)
819                 },
820                 CLASSIC,
821                 /* 00:00:00:00:00:00 > 00:00:00:00:00:00, ethtype IPv4 (0x0800),
822                  * length 98: 127.0.0.1 > 127.0.0.1: ICMP echo request,
823                  * id 9737, seq 1, length 64
824                  */
825                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
826                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
827                   0x08, 0x00,
828                   0x45, 0x00, 0x00, 0x54, 0xac, 0x8b, 0x40, 0x00, 0x40,
829                   0x01, 0x90, 0x1b, 0x7f, 0x00, 0x00, 0x01 },
830                 { { 30, 0 }, { 100, 42 } },
831         },
832         {
833                 "LD_ANC_XOR",
834                 .u.insns = {
835                         BPF_STMT(BPF_LD | BPF_IMM, 10),
836                         BPF_STMT(BPF_LDX | BPF_IMM, 300),
837                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
838                                  SKF_AD_OFF + SKF_AD_ALU_XOR_X),
839                         BPF_STMT(BPF_RET | BPF_A, 0)
840                 },
841                 CLASSIC,
842                 { },
843                 { { 4, 10 ^ 300 }, { 20, 10 ^ 300 } },
844         },
845         {
846                 "SPILL_FILL",
847                 .u.insns = {
848                         BPF_STMT(BPF_LDX | BPF_LEN, 0),
849                         BPF_STMT(BPF_LD | BPF_IMM, 2),
850                         BPF_STMT(BPF_ALU | BPF_RSH, 1),
851                         BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
852                         BPF_STMT(BPF_ST, 1), /* M1 = 1 ^ len */
853                         BPF_STMT(BPF_ALU | BPF_XOR | BPF_K, 0x80000000),
854                         BPF_STMT(BPF_ST, 2), /* M2 = 1 ^ len ^ 0x80000000 */
855                         BPF_STMT(BPF_STX, 15), /* M3 = len */
856                         BPF_STMT(BPF_LDX | BPF_MEM, 1),
857                         BPF_STMT(BPF_LD | BPF_MEM, 2),
858                         BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
859                         BPF_STMT(BPF_LDX | BPF_MEM, 15),
860                         BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
861                         BPF_STMT(BPF_RET | BPF_A, 0)
862                 },
863                 CLASSIC,
864                 { },
865                 { { 1, 0x80000001 }, { 2, 0x80000002 }, { 60, 0x80000000 ^ 60 } }
866         },
867         {
868                 "JEQ",
869                 .u.insns = {
870                         BPF_STMT(BPF_LDX | BPF_LEN, 0),
871                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
872                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 0, 1),
873                         BPF_STMT(BPF_RET | BPF_K, 1),
874                         BPF_STMT(BPF_RET | BPF_K, MAX_K)
875                 },
876                 CLASSIC,
877                 { 3, 3, 3, 3, 3 },
878                 { { 1, 0 }, { 3, 1 }, { 4, MAX_K } },
879         },
880         {
881                 "JGT",
882                 .u.insns = {
883                         BPF_STMT(BPF_LDX | BPF_LEN, 0),
884                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
885                         BPF_JUMP(BPF_JMP | BPF_JGT | BPF_X, 0, 0, 1),
886                         BPF_STMT(BPF_RET | BPF_K, 1),
887                         BPF_STMT(BPF_RET | BPF_K, MAX_K)
888                 },
889                 CLASSIC,
890                 { 4, 4, 4, 3, 3 },
891                 { { 2, 0 }, { 3, 1 }, { 4, MAX_K } },
892         },
893         {
894                 "JGE",
895                 .u.insns = {
896                         BPF_STMT(BPF_LDX | BPF_LEN, 0),
897                         BPF_STMT(BPF_LD | BPF_B | BPF_IND, MAX_K),
898                         BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 1, 1, 0),
899                         BPF_STMT(BPF_RET | BPF_K, 10),
900                         BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 2, 1, 0),
901                         BPF_STMT(BPF_RET | BPF_K, 20),
902                         BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 3, 1, 0),
903                         BPF_STMT(BPF_RET | BPF_K, 30),
904                         BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 4, 1, 0),
905                         BPF_STMT(BPF_RET | BPF_K, 40),
906                         BPF_STMT(BPF_RET | BPF_K, MAX_K)
907                 },
908                 CLASSIC,
909                 { 1, 2, 3, 4, 5 },
910                 { { 1, 20 }, { 3, 40 }, { 5, MAX_K } },
911         },
912         {
913                 "JSET",
914                 .u.insns = {
915                         BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
916                         BPF_JUMP(BPF_JMP | BPF_JA, 1, 1, 1),
917                         BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
918                         BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
919                         BPF_STMT(BPF_LDX | BPF_LEN, 0),
920                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
921                         BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, 4),
922                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
923                         BPF_STMT(BPF_LD | BPF_W | BPF_IND, 0),
924                         BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 1, 0, 1),
925                         BPF_STMT(BPF_RET | BPF_K, 10),
926                         BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x80000000, 0, 1),
927                         BPF_STMT(BPF_RET | BPF_K, 20),
928                         BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
929                         BPF_STMT(BPF_RET | BPF_K, 30),
930                         BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
931                         BPF_STMT(BPF_RET | BPF_K, 30),
932                         BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
933                         BPF_STMT(BPF_RET | BPF_K, 30),
934                         BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
935                         BPF_STMT(BPF_RET | BPF_K, 30),
936                         BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
937                         BPF_STMT(BPF_RET | BPF_K, 30),
938                         BPF_STMT(BPF_RET | BPF_K, MAX_K)
939                 },
940                 CLASSIC,
941                 { 0, 0xAA, 0x55, 1 },
942                 { { 4, 10 }, { 5, 20 }, { 6, MAX_K } },
943         },
944         {
945                 "tcpdump port 22",
946                 .u.insns = {
947                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
948                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 0, 8), /* IPv6 */
949                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 20),
950                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
951                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
952                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 17),
953                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 54),
954                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 14, 0),
955                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 56),
956                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 12, 13),
957                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0800, 0, 12), /* IPv4 */
958                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
959                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
960                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
961                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 8),
962                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
963                         BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 6, 0),
964                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
965                         BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
966                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
967                         BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
968                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 1),
969                         BPF_STMT(BPF_RET | BPF_K, 0xffff),
970                         BPF_STMT(BPF_RET | BPF_K, 0),
971                 },
972                 CLASSIC,
973                 /* 3c:07:54:43:e5:76 > 10:bf:48:d6:43:d6, ethertype IPv4(0x0800)
974                  * length 114: 10.1.1.149.49700 > 10.1.2.10.22: Flags [P.],
975                  * seq 1305692979:1305693027, ack 3650467037, win 65535,
976                  * options [nop,nop,TS val 2502645400 ecr 3971138], length 48
977                  */
978                 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
979                   0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
980                   0x08, 0x00,
981                   0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
982                   0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
983                   0x0a, 0x01, 0x01, 0x95, /* ip src */
984                   0x0a, 0x01, 0x02, 0x0a, /* ip dst */
985                   0xc2, 0x24,
986                   0x00, 0x16 /* dst port */ },
987                 { { 10, 0 }, { 30, 0 }, { 100, 65535 } },
988         },
989         {
990                 "tcpdump complex",
991                 .u.insns = {
992                         /* tcpdump -nei eth0 'tcp port 22 and (((ip[2:2] -
993                          * ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0) and
994                          * (len > 115 or len < 30000000000)' -d
995                          */
996                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
997                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 30, 0),
998                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x800, 0, 29),
999                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
1000                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 0, 27),
1001                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
1002                         BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 25, 0),
1003                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
1004                         BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
1005                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
1006                         BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
1007                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 20),
1008                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 16),
1009                         BPF_STMT(BPF_ST, 1),
1010                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 14),
1011                         BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf),
1012                         BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 2),
1013                         BPF_STMT(BPF_MISC | BPF_TAX, 0x5), /* libpcap emits K on TAX */
1014                         BPF_STMT(BPF_LD | BPF_MEM, 1),
1015                         BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
1016                         BPF_STMT(BPF_ST, 5),
1017                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
1018                         BPF_STMT(BPF_LD | BPF_B | BPF_IND, 26),
1019                         BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
1020                         BPF_STMT(BPF_ALU | BPF_RSH | BPF_K, 2),
1021                         BPF_STMT(BPF_MISC | BPF_TAX, 0x9), /* libpcap emits K on TAX */
1022                         BPF_STMT(BPF_LD | BPF_MEM, 5),
1023                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 4, 0),
1024                         BPF_STMT(BPF_LD | BPF_LEN, 0),
1025                         BPF_JUMP(BPF_JMP | BPF_JGT | BPF_K, 0x73, 1, 0),
1026                         BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 0xfc23ac00, 1, 0),
1027                         BPF_STMT(BPF_RET | BPF_K, 0xffff),
1028                         BPF_STMT(BPF_RET | BPF_K, 0),
1029                 },
1030                 CLASSIC,
1031                 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
1032                   0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
1033                   0x08, 0x00,
1034                   0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
1035                   0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
1036                   0x0a, 0x01, 0x01, 0x95, /* ip src */
1037                   0x0a, 0x01, 0x02, 0x0a, /* ip dst */
1038                   0xc2, 0x24,
1039                   0x00, 0x16 /* dst port */ },
1040                 { { 10, 0 }, { 30, 0 }, { 100, 65535 } },
1041         },
1042         {
1043                 "RET_A",
1044                 .u.insns = {
1045                         /* check that unitialized X and A contain zeros */
1046                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
1047                         BPF_STMT(BPF_RET | BPF_A, 0)
1048                 },
1049                 CLASSIC,
1050                 { },
1051                 { {1, 0}, {2, 0} },
1052         },
1053         {
1054                 "INT: ADD trivial",
1055                 .u.insns_int = {
1056                         BPF_ALU64_IMM(BPF_MOV, R1, 1),
1057                         BPF_ALU64_IMM(BPF_ADD, R1, 2),
1058                         BPF_ALU64_IMM(BPF_MOV, R2, 3),
1059                         BPF_ALU64_REG(BPF_SUB, R1, R2),
1060                         BPF_ALU64_IMM(BPF_ADD, R1, -1),
1061                         BPF_ALU64_IMM(BPF_MUL, R1, 3),
1062                         BPF_ALU64_REG(BPF_MOV, R0, R1),
1063                         BPF_EXIT_INSN(),
1064                 },
1065                 INTERNAL,
1066                 { },
1067                 { { 0, 0xfffffffd } }
1068         },
1069         {
1070                 "INT: MUL_X",
1071                 .u.insns_int = {
1072                         BPF_ALU64_IMM(BPF_MOV, R0, -1),
1073                         BPF_ALU64_IMM(BPF_MOV, R1, -1),
1074                         BPF_ALU64_IMM(BPF_MOV, R2, 3),
1075                         BPF_ALU64_REG(BPF_MUL, R1, R2),
1076                         BPF_JMP_IMM(BPF_JEQ, R1, 0xfffffffd, 1),
1077                         BPF_EXIT_INSN(),
1078                         BPF_ALU64_IMM(BPF_MOV, R0, 1),
1079                         BPF_EXIT_INSN(),
1080                 },
1081                 INTERNAL,
1082                 { },
1083                 { { 0, 1 } }
1084         },
1085         {
1086                 "INT: MUL_X2",
1087                 .u.insns_int = {
1088                         BPF_ALU32_IMM(BPF_MOV, R0, -1),
1089                         BPF_ALU32_IMM(BPF_MOV, R1, -1),
1090                         BPF_ALU32_IMM(BPF_MOV, R2, 3),
1091                         BPF_ALU64_REG(BPF_MUL, R1, R2),
1092                         BPF_ALU64_IMM(BPF_RSH, R1, 8),
1093                         BPF_JMP_IMM(BPF_JEQ, R1, 0x2ffffff, 1),
1094                         BPF_EXIT_INSN(),
1095                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
1096                         BPF_EXIT_INSN(),
1097                 },
1098                 INTERNAL,
1099                 { },
1100                 { { 0, 1 } }
1101         },
1102         {
1103                 "INT: MUL32_X",
1104                 .u.insns_int = {
1105                         BPF_ALU32_IMM(BPF_MOV, R0, -1),
1106                         BPF_ALU64_IMM(BPF_MOV, R1, -1),
1107                         BPF_ALU32_IMM(BPF_MOV, R2, 3),
1108                         BPF_ALU32_REG(BPF_MUL, R1, R2),
1109                         BPF_ALU64_IMM(BPF_RSH, R1, 8),
1110                         BPF_JMP_IMM(BPF_JEQ, R1, 0xffffff, 1),
1111                         BPF_EXIT_INSN(),
1112                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
1113                         BPF_EXIT_INSN(),
1114                 },
1115                 INTERNAL,
1116                 { },
1117                 { { 0, 1 } }
1118         },
1119         {
1120                 /* Have to test all register combinations, since
1121                  * JITing of different registers will produce
1122                  * different asm code.
1123                  */
1124                 "INT: ADD 64-bit",
1125                 .u.insns_int = {
1126                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
1127                         BPF_ALU64_IMM(BPF_MOV, R1, 1),
1128                         BPF_ALU64_IMM(BPF_MOV, R2, 2),
1129                         BPF_ALU64_IMM(BPF_MOV, R3, 3),
1130                         BPF_ALU64_IMM(BPF_MOV, R4, 4),
1131                         BPF_ALU64_IMM(BPF_MOV, R5, 5),
1132                         BPF_ALU64_IMM(BPF_MOV, R6, 6),
1133                         BPF_ALU64_IMM(BPF_MOV, R7, 7),
1134                         BPF_ALU64_IMM(BPF_MOV, R8, 8),
1135                         BPF_ALU64_IMM(BPF_MOV, R9, 9),
1136                         BPF_ALU64_IMM(BPF_ADD, R0, 20),
1137                         BPF_ALU64_IMM(BPF_ADD, R1, 20),
1138                         BPF_ALU64_IMM(BPF_ADD, R2, 20),
1139                         BPF_ALU64_IMM(BPF_ADD, R3, 20),
1140                         BPF_ALU64_IMM(BPF_ADD, R4, 20),
1141                         BPF_ALU64_IMM(BPF_ADD, R5, 20),
1142                         BPF_ALU64_IMM(BPF_ADD, R6, 20),
1143                         BPF_ALU64_IMM(BPF_ADD, R7, 20),
1144                         BPF_ALU64_IMM(BPF_ADD, R8, 20),
1145                         BPF_ALU64_IMM(BPF_ADD, R9, 20),
1146                         BPF_ALU64_IMM(BPF_SUB, R0, 10),
1147                         BPF_ALU64_IMM(BPF_SUB, R1, 10),
1148                         BPF_ALU64_IMM(BPF_SUB, R2, 10),
1149                         BPF_ALU64_IMM(BPF_SUB, R3, 10),
1150                         BPF_ALU64_IMM(BPF_SUB, R4, 10),
1151                         BPF_ALU64_IMM(BPF_SUB, R5, 10),
1152                         BPF_ALU64_IMM(BPF_SUB, R6, 10),
1153                         BPF_ALU64_IMM(BPF_SUB, R7, 10),
1154                         BPF_ALU64_IMM(BPF_SUB, R8, 10),
1155                         BPF_ALU64_IMM(BPF_SUB, R9, 10),
1156                         BPF_ALU64_REG(BPF_ADD, R0, R0),
1157                         BPF_ALU64_REG(BPF_ADD, R0, R1),
1158                         BPF_ALU64_REG(BPF_ADD, R0, R2),
1159                         BPF_ALU64_REG(BPF_ADD, R0, R3),
1160                         BPF_ALU64_REG(BPF_ADD, R0, R4),
1161                         BPF_ALU64_REG(BPF_ADD, R0, R5),
1162                         BPF_ALU64_REG(BPF_ADD, R0, R6),
1163                         BPF_ALU64_REG(BPF_ADD, R0, R7),
1164                         BPF_ALU64_REG(BPF_ADD, R0, R8),
1165                         BPF_ALU64_REG(BPF_ADD, R0, R9), /* R0 == 155 */
1166                         BPF_JMP_IMM(BPF_JEQ, R0, 155, 1),
1167                         BPF_EXIT_INSN(),
1168                         BPF_ALU64_REG(BPF_ADD, R1, R0),
1169                         BPF_ALU64_REG(BPF_ADD, R1, R1),
1170                         BPF_ALU64_REG(BPF_ADD, R1, R2),
1171                         BPF_ALU64_REG(BPF_ADD, R1, R3),
1172                         BPF_ALU64_REG(BPF_ADD, R1, R4),
1173                         BPF_ALU64_REG(BPF_ADD, R1, R5),
1174                         BPF_ALU64_REG(BPF_ADD, R1, R6),
1175                         BPF_ALU64_REG(BPF_ADD, R1, R7),
1176                         BPF_ALU64_REG(BPF_ADD, R1, R8),
1177                         BPF_ALU64_REG(BPF_ADD, R1, R9), /* R1 == 456 */
1178                         BPF_JMP_IMM(BPF_JEQ, R1, 456, 1),
1179                         BPF_EXIT_INSN(),
1180                         BPF_ALU64_REG(BPF_ADD, R2, R0),
1181                         BPF_ALU64_REG(BPF_ADD, R2, R1),
1182                         BPF_ALU64_REG(BPF_ADD, R2, R2),
1183                         BPF_ALU64_REG(BPF_ADD, R2, R3),
1184                         BPF_ALU64_REG(BPF_ADD, R2, R4),
1185                         BPF_ALU64_REG(BPF_ADD, R2, R5),
1186                         BPF_ALU64_REG(BPF_ADD, R2, R6),
1187                         BPF_ALU64_REG(BPF_ADD, R2, R7),
1188                         BPF_ALU64_REG(BPF_ADD, R2, R8),
1189                         BPF_ALU64_REG(BPF_ADD, R2, R9), /* R2 == 1358 */
1190                         BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1),
1191                         BPF_EXIT_INSN(),
1192                         BPF_ALU64_REG(BPF_ADD, R3, R0),
1193                         BPF_ALU64_REG(BPF_ADD, R3, R1),
1194                         BPF_ALU64_REG(BPF_ADD, R3, R2),
1195                         BPF_ALU64_REG(BPF_ADD, R3, R3),
1196                         BPF_ALU64_REG(BPF_ADD, R3, R4),
1197                         BPF_ALU64_REG(BPF_ADD, R3, R5),
1198                         BPF_ALU64_REG(BPF_ADD, R3, R6),
1199                         BPF_ALU64_REG(BPF_ADD, R3, R7),
1200                         BPF_ALU64_REG(BPF_ADD, R3, R8),
1201                         BPF_ALU64_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
1202                         BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
1203                         BPF_EXIT_INSN(),
1204                         BPF_ALU64_REG(BPF_ADD, R4, R0),
1205                         BPF_ALU64_REG(BPF_ADD, R4, R1),
1206                         BPF_ALU64_REG(BPF_ADD, R4, R2),
1207                         BPF_ALU64_REG(BPF_ADD, R4, R3),
1208                         BPF_ALU64_REG(BPF_ADD, R4, R4),
1209                         BPF_ALU64_REG(BPF_ADD, R4, R5),
1210                         BPF_ALU64_REG(BPF_ADD, R4, R6),
1211                         BPF_ALU64_REG(BPF_ADD, R4, R7),
1212                         BPF_ALU64_REG(BPF_ADD, R4, R8),
1213                         BPF_ALU64_REG(BPF_ADD, R4, R9), /* R4 == 12177 */
1214                         BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1),
1215                         BPF_EXIT_INSN(),
1216                         BPF_ALU64_REG(BPF_ADD, R5, R0),
1217                         BPF_ALU64_REG(BPF_ADD, R5, R1),
1218                         BPF_ALU64_REG(BPF_ADD, R5, R2),
1219                         BPF_ALU64_REG(BPF_ADD, R5, R3),
1220                         BPF_ALU64_REG(BPF_ADD, R5, R4),
1221                         BPF_ALU64_REG(BPF_ADD, R5, R5),
1222                         BPF_ALU64_REG(BPF_ADD, R5, R6),
1223                         BPF_ALU64_REG(BPF_ADD, R5, R7),
1224                         BPF_ALU64_REG(BPF_ADD, R5, R8),
1225                         BPF_ALU64_REG(BPF_ADD, R5, R9), /* R5 == 36518 */
1226                         BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1),
1227                         BPF_EXIT_INSN(),
1228                         BPF_ALU64_REG(BPF_ADD, R6, R0),
1229                         BPF_ALU64_REG(BPF_ADD, R6, R1),
1230                         BPF_ALU64_REG(BPF_ADD, R6, R2),
1231                         BPF_ALU64_REG(BPF_ADD, R6, R3),
1232                         BPF_ALU64_REG(BPF_ADD, R6, R4),
1233                         BPF_ALU64_REG(BPF_ADD, R6, R5),
1234                         BPF_ALU64_REG(BPF_ADD, R6, R6),
1235                         BPF_ALU64_REG(BPF_ADD, R6, R7),
1236                         BPF_ALU64_REG(BPF_ADD, R6, R8),
1237                         BPF_ALU64_REG(BPF_ADD, R6, R9), /* R6 == 109540 */
1238                         BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1),
1239                         BPF_EXIT_INSN(),
1240                         BPF_ALU64_REG(BPF_ADD, R7, R0),
1241                         BPF_ALU64_REG(BPF_ADD, R7, R1),
1242                         BPF_ALU64_REG(BPF_ADD, R7, R2),
1243                         BPF_ALU64_REG(BPF_ADD, R7, R3),
1244                         BPF_ALU64_REG(BPF_ADD, R7, R4),
1245                         BPF_ALU64_REG(BPF_ADD, R7, R5),
1246                         BPF_ALU64_REG(BPF_ADD, R7, R6),
1247                         BPF_ALU64_REG(BPF_ADD, R7, R7),
1248                         BPF_ALU64_REG(BPF_ADD, R7, R8),
1249                         BPF_ALU64_REG(BPF_ADD, R7, R9), /* R7 == 328605 */
1250                         BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1),
1251                         BPF_EXIT_INSN(),
1252                         BPF_ALU64_REG(BPF_ADD, R8, R0),
1253                         BPF_ALU64_REG(BPF_ADD, R8, R1),
1254                         BPF_ALU64_REG(BPF_ADD, R8, R2),
1255                         BPF_ALU64_REG(BPF_ADD, R8, R3),
1256                         BPF_ALU64_REG(BPF_ADD, R8, R4),
1257                         BPF_ALU64_REG(BPF_ADD, R8, R5),
1258                         BPF_ALU64_REG(BPF_ADD, R8, R6),
1259                         BPF_ALU64_REG(BPF_ADD, R8, R7),
1260                         BPF_ALU64_REG(BPF_ADD, R8, R8),
1261                         BPF_ALU64_REG(BPF_ADD, R8, R9), /* R8 == 985799 */
1262                         BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1),
1263                         BPF_EXIT_INSN(),
1264                         BPF_ALU64_REG(BPF_ADD, R9, R0),
1265                         BPF_ALU64_REG(BPF_ADD, R9, R1),
1266                         BPF_ALU64_REG(BPF_ADD, R9, R2),
1267                         BPF_ALU64_REG(BPF_ADD, R9, R3),
1268                         BPF_ALU64_REG(BPF_ADD, R9, R4),
1269                         BPF_ALU64_REG(BPF_ADD, R9, R5),
1270                         BPF_ALU64_REG(BPF_ADD, R9, R6),
1271                         BPF_ALU64_REG(BPF_ADD, R9, R7),
1272                         BPF_ALU64_REG(BPF_ADD, R9, R8),
1273                         BPF_ALU64_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */
1274                         BPF_ALU64_REG(BPF_MOV, R0, R9),
1275                         BPF_EXIT_INSN(),
1276                 },
1277                 INTERNAL,
1278                 { },
1279                 { { 0, 2957380 } }
1280         },
1281         {
1282                 "INT: ADD 32-bit",
1283                 .u.insns_int = {
1284                         BPF_ALU32_IMM(BPF_MOV, R0, 20),
1285                         BPF_ALU32_IMM(BPF_MOV, R1, 1),
1286                         BPF_ALU32_IMM(BPF_MOV, R2, 2),
1287                         BPF_ALU32_IMM(BPF_MOV, R3, 3),
1288                         BPF_ALU32_IMM(BPF_MOV, R4, 4),
1289                         BPF_ALU32_IMM(BPF_MOV, R5, 5),
1290                         BPF_ALU32_IMM(BPF_MOV, R6, 6),
1291                         BPF_ALU32_IMM(BPF_MOV, R7, 7),
1292                         BPF_ALU32_IMM(BPF_MOV, R8, 8),
1293                         BPF_ALU32_IMM(BPF_MOV, R9, 9),
1294                         BPF_ALU64_IMM(BPF_ADD, R1, 10),
1295                         BPF_ALU64_IMM(BPF_ADD, R2, 10),
1296                         BPF_ALU64_IMM(BPF_ADD, R3, 10),
1297                         BPF_ALU64_IMM(BPF_ADD, R4, 10),
1298                         BPF_ALU64_IMM(BPF_ADD, R5, 10),
1299                         BPF_ALU64_IMM(BPF_ADD, R6, 10),
1300                         BPF_ALU64_IMM(BPF_ADD, R7, 10),
1301                         BPF_ALU64_IMM(BPF_ADD, R8, 10),
1302                         BPF_ALU64_IMM(BPF_ADD, R9, 10),
1303                         BPF_ALU32_REG(BPF_ADD, R0, R1),
1304                         BPF_ALU32_REG(BPF_ADD, R0, R2),
1305                         BPF_ALU32_REG(BPF_ADD, R0, R3),
1306                         BPF_ALU32_REG(BPF_ADD, R0, R4),
1307                         BPF_ALU32_REG(BPF_ADD, R0, R5),
1308                         BPF_ALU32_REG(BPF_ADD, R0, R6),
1309                         BPF_ALU32_REG(BPF_ADD, R0, R7),
1310                         BPF_ALU32_REG(BPF_ADD, R0, R8),
1311                         BPF_ALU32_REG(BPF_ADD, R0, R9), /* R0 == 155 */
1312                         BPF_JMP_IMM(BPF_JEQ, R0, 155, 1),
1313                         BPF_EXIT_INSN(),
1314                         BPF_ALU32_REG(BPF_ADD, R1, R0),
1315                         BPF_ALU32_REG(BPF_ADD, R1, R1),
1316                         BPF_ALU32_REG(BPF_ADD, R1, R2),
1317                         BPF_ALU32_REG(BPF_ADD, R1, R3),
1318                         BPF_ALU32_REG(BPF_ADD, R1, R4),
1319                         BPF_ALU32_REG(BPF_ADD, R1, R5),
1320                         BPF_ALU32_REG(BPF_ADD, R1, R6),
1321                         BPF_ALU32_REG(BPF_ADD, R1, R7),
1322                         BPF_ALU32_REG(BPF_ADD, R1, R8),
1323                         BPF_ALU32_REG(BPF_ADD, R1, R9), /* R1 == 456 */
1324                         BPF_JMP_IMM(BPF_JEQ, R1, 456, 1),
1325                         BPF_EXIT_INSN(),
1326                         BPF_ALU32_REG(BPF_ADD, R2, R0),
1327                         BPF_ALU32_REG(BPF_ADD, R2, R1),
1328                         BPF_ALU32_REG(BPF_ADD, R2, R2),
1329                         BPF_ALU32_REG(BPF_ADD, R2, R3),
1330                         BPF_ALU32_REG(BPF_ADD, R2, R4),
1331                         BPF_ALU32_REG(BPF_ADD, R2, R5),
1332                         BPF_ALU32_REG(BPF_ADD, R2, R6),
1333                         BPF_ALU32_REG(BPF_ADD, R2, R7),
1334                         BPF_ALU32_REG(BPF_ADD, R2, R8),
1335                         BPF_ALU32_REG(BPF_ADD, R2, R9), /* R2 == 1358 */
1336                         BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1),
1337                         BPF_EXIT_INSN(),
1338                         BPF_ALU32_REG(BPF_ADD, R3, R0),
1339                         BPF_ALU32_REG(BPF_ADD, R3, R1),
1340                         BPF_ALU32_REG(BPF_ADD, R3, R2),
1341                         BPF_ALU32_REG(BPF_ADD, R3, R3),
1342                         BPF_ALU32_REG(BPF_ADD, R3, R4),
1343                         BPF_ALU32_REG(BPF_ADD, R3, R5),
1344                         BPF_ALU32_REG(BPF_ADD, R3, R6),
1345                         BPF_ALU32_REG(BPF_ADD, R3, R7),
1346                         BPF_ALU32_REG(BPF_ADD, R3, R8),
1347                         BPF_ALU32_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
1348                         BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
1349                         BPF_EXIT_INSN(),
1350                         BPF_ALU32_REG(BPF_ADD, R4, R0),
1351                         BPF_ALU32_REG(BPF_ADD, R4, R1),
1352                         BPF_ALU32_REG(BPF_ADD, R4, R2),
1353                         BPF_ALU32_REG(BPF_ADD, R4, R3),
1354                         BPF_ALU32_REG(BPF_ADD, R4, R4),
1355                         BPF_ALU32_REG(BPF_ADD, R4, R5),
1356                         BPF_ALU32_REG(BPF_ADD, R4, R6),
1357                         BPF_ALU32_REG(BPF_ADD, R4, R7),
1358                         BPF_ALU32_REG(BPF_ADD, R4, R8),
1359                         BPF_ALU32_REG(BPF_ADD, R4, R9), /* R4 == 12177 */
1360                         BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1),
1361                         BPF_EXIT_INSN(),
1362                         BPF_ALU32_REG(BPF_ADD, R5, R0),
1363                         BPF_ALU32_REG(BPF_ADD, R5, R1),
1364                         BPF_ALU32_REG(BPF_ADD, R5, R2),
1365                         BPF_ALU32_REG(BPF_ADD, R5, R3),
1366                         BPF_ALU32_REG(BPF_ADD, R5, R4),
1367                         BPF_ALU32_REG(BPF_ADD, R5, R5),
1368                         BPF_ALU32_REG(BPF_ADD, R5, R6),
1369                         BPF_ALU32_REG(BPF_ADD, R5, R7),
1370                         BPF_ALU32_REG(BPF_ADD, R5, R8),
1371                         BPF_ALU32_REG(BPF_ADD, R5, R9), /* R5 == 36518 */
1372                         BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1),
1373                         BPF_EXIT_INSN(),
1374                         BPF_ALU32_REG(BPF_ADD, R6, R0),
1375                         BPF_ALU32_REG(BPF_ADD, R6, R1),
1376                         BPF_ALU32_REG(BPF_ADD, R6, R2),
1377                         BPF_ALU32_REG(BPF_ADD, R6, R3),
1378                         BPF_ALU32_REG(BPF_ADD, R6, R4),
1379                         BPF_ALU32_REG(BPF_ADD, R6, R5),
1380                         BPF_ALU32_REG(BPF_ADD, R6, R6),
1381                         BPF_ALU32_REG(BPF_ADD, R6, R7),
1382                         BPF_ALU32_REG(BPF_ADD, R6, R8),
1383                         BPF_ALU32_REG(BPF_ADD, R6, R9), /* R6 == 109540 */
1384                         BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1),
1385                         BPF_EXIT_INSN(),
1386                         BPF_ALU32_REG(BPF_ADD, R7, R0),
1387                         BPF_ALU32_REG(BPF_ADD, R7, R1),
1388                         BPF_ALU32_REG(BPF_ADD, R7, R2),
1389                         BPF_ALU32_REG(BPF_ADD, R7, R3),
1390                         BPF_ALU32_REG(BPF_ADD, R7, R4),
1391                         BPF_ALU32_REG(BPF_ADD, R7, R5),
1392                         BPF_ALU32_REG(BPF_ADD, R7, R6),
1393                         BPF_ALU32_REG(BPF_ADD, R7, R7),
1394                         BPF_ALU32_REG(BPF_ADD, R7, R8),
1395                         BPF_ALU32_REG(BPF_ADD, R7, R9), /* R7 == 328605 */
1396                         BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1),
1397                         BPF_EXIT_INSN(),
1398                         BPF_ALU32_REG(BPF_ADD, R8, R0),
1399                         BPF_ALU32_REG(BPF_ADD, R8, R1),
1400                         BPF_ALU32_REG(BPF_ADD, R8, R2),
1401                         BPF_ALU32_REG(BPF_ADD, R8, R3),
1402                         BPF_ALU32_REG(BPF_ADD, R8, R4),
1403                         BPF_ALU32_REG(BPF_ADD, R8, R5),
1404                         BPF_ALU32_REG(BPF_ADD, R8, R6),
1405                         BPF_ALU32_REG(BPF_ADD, R8, R7),
1406                         BPF_ALU32_REG(BPF_ADD, R8, R8),
1407                         BPF_ALU32_REG(BPF_ADD, R8, R9), /* R8 == 985799 */
1408                         BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1),
1409                         BPF_EXIT_INSN(),
1410                         BPF_ALU32_REG(BPF_ADD, R9, R0),
1411                         BPF_ALU32_REG(BPF_ADD, R9, R1),
1412                         BPF_ALU32_REG(BPF_ADD, R9, R2),
1413                         BPF_ALU32_REG(BPF_ADD, R9, R3),
1414                         BPF_ALU32_REG(BPF_ADD, R9, R4),
1415                         BPF_ALU32_REG(BPF_ADD, R9, R5),
1416                         BPF_ALU32_REG(BPF_ADD, R9, R6),
1417                         BPF_ALU32_REG(BPF_ADD, R9, R7),
1418                         BPF_ALU32_REG(BPF_ADD, R9, R8),
1419                         BPF_ALU32_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */
1420                         BPF_ALU32_REG(BPF_MOV, R0, R9),
1421                         BPF_EXIT_INSN(),
1422                 },
1423                 INTERNAL,
1424                 { },
1425                 { { 0, 2957380 } }
1426         },
1427         {       /* Mainly checking JIT here. */
1428                 "INT: SUB",
1429                 .u.insns_int = {
1430                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
1431                         BPF_ALU64_IMM(BPF_MOV, R1, 1),
1432                         BPF_ALU64_IMM(BPF_MOV, R2, 2),
1433                         BPF_ALU64_IMM(BPF_MOV, R3, 3),
1434                         BPF_ALU64_IMM(BPF_MOV, R4, 4),
1435                         BPF_ALU64_IMM(BPF_MOV, R5, 5),
1436                         BPF_ALU64_IMM(BPF_MOV, R6, 6),
1437                         BPF_ALU64_IMM(BPF_MOV, R7, 7),
1438                         BPF_ALU64_IMM(BPF_MOV, R8, 8),
1439                         BPF_ALU64_IMM(BPF_MOV, R9, 9),
1440                         BPF_ALU64_REG(BPF_SUB, R0, R0),
1441                         BPF_ALU64_REG(BPF_SUB, R0, R1),
1442                         BPF_ALU64_REG(BPF_SUB, R0, R2),
1443                         BPF_ALU64_REG(BPF_SUB, R0, R3),
1444                         BPF_ALU64_REG(BPF_SUB, R0, R4),
1445                         BPF_ALU64_REG(BPF_SUB, R0, R5),
1446                         BPF_ALU64_REG(BPF_SUB, R0, R6),
1447                         BPF_ALU64_REG(BPF_SUB, R0, R7),
1448                         BPF_ALU64_REG(BPF_SUB, R0, R8),
1449                         BPF_ALU64_REG(BPF_SUB, R0, R9),
1450                         BPF_ALU64_IMM(BPF_SUB, R0, 10),
1451                         BPF_JMP_IMM(BPF_JEQ, R0, -55, 1),
1452                         BPF_EXIT_INSN(),
1453                         BPF_ALU64_REG(BPF_SUB, R1, R0),
1454                         BPF_ALU64_REG(BPF_SUB, R1, R2),
1455                         BPF_ALU64_REG(BPF_SUB, R1, R3),
1456                         BPF_ALU64_REG(BPF_SUB, R1, R4),
1457                         BPF_ALU64_REG(BPF_SUB, R1, R5),
1458                         BPF_ALU64_REG(BPF_SUB, R1, R6),
1459                         BPF_ALU64_REG(BPF_SUB, R1, R7),
1460                         BPF_ALU64_REG(BPF_SUB, R1, R8),
1461                         BPF_ALU64_REG(BPF_SUB, R1, R9),
1462                         BPF_ALU64_IMM(BPF_SUB, R1, 10),
1463                         BPF_ALU64_REG(BPF_SUB, R2, R0),
1464                         BPF_ALU64_REG(BPF_SUB, R2, R1),
1465                         BPF_ALU64_REG(BPF_SUB, R2, R3),
1466                         BPF_ALU64_REG(BPF_SUB, R2, R4),
1467                         BPF_ALU64_REG(BPF_SUB, R2, R5),
1468                         BPF_ALU64_REG(BPF_SUB, R2, R6),
1469                         BPF_ALU64_REG(BPF_SUB, R2, R7),
1470                         BPF_ALU64_REG(BPF_SUB, R2, R8),
1471                         BPF_ALU64_REG(BPF_SUB, R2, R9),
1472                         BPF_ALU64_IMM(BPF_SUB, R2, 10),
1473                         BPF_ALU64_REG(BPF_SUB, R3, R0),
1474                         BPF_ALU64_REG(BPF_SUB, R3, R1),
1475                         BPF_ALU64_REG(BPF_SUB, R3, R2),
1476                         BPF_ALU64_REG(BPF_SUB, R3, R4),
1477                         BPF_ALU64_REG(BPF_SUB, R3, R5),
1478                         BPF_ALU64_REG(BPF_SUB, R3, R6),
1479                         BPF_ALU64_REG(BPF_SUB, R3, R7),
1480                         BPF_ALU64_REG(BPF_SUB, R3, R8),
1481                         BPF_ALU64_REG(BPF_SUB, R3, R9),
1482                         BPF_ALU64_IMM(BPF_SUB, R3, 10),
1483                         BPF_ALU64_REG(BPF_SUB, R4, R0),
1484                         BPF_ALU64_REG(BPF_SUB, R4, R1),
1485                         BPF_ALU64_REG(BPF_SUB, R4, R2),
1486                         BPF_ALU64_REG(BPF_SUB, R4, R3),
1487                         BPF_ALU64_REG(BPF_SUB, R4, R5),
1488                         BPF_ALU64_REG(BPF_SUB, R4, R6),
1489                         BPF_ALU64_REG(BPF_SUB, R4, R7),
1490                         BPF_ALU64_REG(BPF_SUB, R4, R8),
1491                         BPF_ALU64_REG(BPF_SUB, R4, R9),
1492                         BPF_ALU64_IMM(BPF_SUB, R4, 10),
1493                         BPF_ALU64_REG(BPF_SUB, R5, R0),
1494                         BPF_ALU64_REG(BPF_SUB, R5, R1),
1495                         BPF_ALU64_REG(BPF_SUB, R5, R2),
1496                         BPF_ALU64_REG(BPF_SUB, R5, R3),
1497                         BPF_ALU64_REG(BPF_SUB, R5, R4),
1498                         BPF_ALU64_REG(BPF_SUB, R5, R6),
1499                         BPF_ALU64_REG(BPF_SUB, R5, R7),
1500                         BPF_ALU64_REG(BPF_SUB, R5, R8),
1501                         BPF_ALU64_REG(BPF_SUB, R5, R9),
1502                         BPF_ALU64_IMM(BPF_SUB, R5, 10),
1503                         BPF_ALU64_REG(BPF_SUB, R6, R0),
1504                         BPF_ALU64_REG(BPF_SUB, R6, R1),
1505                         BPF_ALU64_REG(BPF_SUB, R6, R2),
1506                         BPF_ALU64_REG(BPF_SUB, R6, R3),
1507                         BPF_ALU64_REG(BPF_SUB, R6, R4),
1508                         BPF_ALU64_REG(BPF_SUB, R6, R5),
1509                         BPF_ALU64_REG(BPF_SUB, R6, R7),
1510                         BPF_ALU64_REG(BPF_SUB, R6, R8),
1511                         BPF_ALU64_REG(BPF_SUB, R6, R9),
1512                         BPF_ALU64_IMM(BPF_SUB, R6, 10),
1513                         BPF_ALU64_REG(BPF_SUB, R7, R0),
1514                         BPF_ALU64_REG(BPF_SUB, R7, R1),
1515                         BPF_ALU64_REG(BPF_SUB, R7, R2),
1516                         BPF_ALU64_REG(BPF_SUB, R7, R3),
1517                         BPF_ALU64_REG(BPF_SUB, R7, R4),
1518                         BPF_ALU64_REG(BPF_SUB, R7, R5),
1519                         BPF_ALU64_REG(BPF_SUB, R7, R6),
1520                         BPF_ALU64_REG(BPF_SUB, R7, R8),
1521                         BPF_ALU64_REG(BPF_SUB, R7, R9),
1522                         BPF_ALU64_IMM(BPF_SUB, R7, 10),
1523                         BPF_ALU64_REG(BPF_SUB, R8, R0),
1524                         BPF_ALU64_REG(BPF_SUB, R8, R1),
1525                         BPF_ALU64_REG(BPF_SUB, R8, R2),
1526                         BPF_ALU64_REG(BPF_SUB, R8, R3),
1527                         BPF_ALU64_REG(BPF_SUB, R8, R4),
1528                         BPF_ALU64_REG(BPF_SUB, R8, R5),
1529                         BPF_ALU64_REG(BPF_SUB, R8, R6),
1530                         BPF_ALU64_REG(BPF_SUB, R8, R7),
1531                         BPF_ALU64_REG(BPF_SUB, R8, R9),
1532                         BPF_ALU64_IMM(BPF_SUB, R8, 10),
1533                         BPF_ALU64_REG(BPF_SUB, R9, R0),
1534                         BPF_ALU64_REG(BPF_SUB, R9, R1),
1535                         BPF_ALU64_REG(BPF_SUB, R9, R2),
1536                         BPF_ALU64_REG(BPF_SUB, R9, R3),
1537                         BPF_ALU64_REG(BPF_SUB, R9, R4),
1538                         BPF_ALU64_REG(BPF_SUB, R9, R5),
1539                         BPF_ALU64_REG(BPF_SUB, R9, R6),
1540                         BPF_ALU64_REG(BPF_SUB, R9, R7),
1541                         BPF_ALU64_REG(BPF_SUB, R9, R8),
1542                         BPF_ALU64_IMM(BPF_SUB, R9, 10),
1543                         BPF_ALU64_IMM(BPF_SUB, R0, 10),
1544                         BPF_ALU64_IMM(BPF_NEG, R0, 0),
1545                         BPF_ALU64_REG(BPF_SUB, R0, R1),
1546                         BPF_ALU64_REG(BPF_SUB, R0, R2),
1547                         BPF_ALU64_REG(BPF_SUB, R0, R3),
1548                         BPF_ALU64_REG(BPF_SUB, R0, R4),
1549                         BPF_ALU64_REG(BPF_SUB, R0, R5),
1550                         BPF_ALU64_REG(BPF_SUB, R0, R6),
1551                         BPF_ALU64_REG(BPF_SUB, R0, R7),
1552                         BPF_ALU64_REG(BPF_SUB, R0, R8),
1553                         BPF_ALU64_REG(BPF_SUB, R0, R9),
1554                         BPF_EXIT_INSN(),
1555                 },
1556                 INTERNAL,
1557                 { },
1558                 { { 0, 11 } }
1559         },
1560         {       /* Mainly checking JIT here. */
1561                 "INT: XOR",
1562                 .u.insns_int = {
1563                         BPF_ALU64_REG(BPF_SUB, R0, R0),
1564                         BPF_ALU64_REG(BPF_XOR, R1, R1),
1565                         BPF_JMP_REG(BPF_JEQ, R0, R1, 1),
1566                         BPF_EXIT_INSN(),
1567                         BPF_ALU64_IMM(BPF_MOV, R0, 10),
1568                         BPF_ALU64_IMM(BPF_MOV, R1, -1),
1569                         BPF_ALU64_REG(BPF_SUB, R1, R1),
1570                         BPF_ALU64_REG(BPF_XOR, R2, R2),
1571                         BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
1572                         BPF_EXIT_INSN(),
1573                         BPF_ALU64_REG(BPF_SUB, R2, R2),
1574                         BPF_ALU64_REG(BPF_XOR, R3, R3),
1575                         BPF_ALU64_IMM(BPF_MOV, R0, 10),
1576                         BPF_ALU64_IMM(BPF_MOV, R1, -1),
1577                         BPF_JMP_REG(BPF_JEQ, R2, R3, 1),
1578                         BPF_EXIT_INSN(),
1579                         BPF_ALU64_REG(BPF_SUB, R3, R3),
1580                         BPF_ALU64_REG(BPF_XOR, R4, R4),
1581                         BPF_ALU64_IMM(BPF_MOV, R2, 1),
1582                         BPF_ALU64_IMM(BPF_MOV, R5, -1),
1583                         BPF_JMP_REG(BPF_JEQ, R3, R4, 1),
1584                         BPF_EXIT_INSN(),
1585                         BPF_ALU64_REG(BPF_SUB, R4, R4),
1586                         BPF_ALU64_REG(BPF_XOR, R5, R5),
1587                         BPF_ALU64_IMM(BPF_MOV, R3, 1),
1588                         BPF_ALU64_IMM(BPF_MOV, R7, -1),
1589                         BPF_JMP_REG(BPF_JEQ, R5, R4, 1),
1590                         BPF_EXIT_INSN(),
1591                         BPF_ALU64_IMM(BPF_MOV, R5, 1),
1592                         BPF_ALU64_REG(BPF_SUB, R5, R5),
1593                         BPF_ALU64_REG(BPF_XOR, R6, R6),
1594                         BPF_ALU64_IMM(BPF_MOV, R1, 1),
1595                         BPF_ALU64_IMM(BPF_MOV, R8, -1),
1596                         BPF_JMP_REG(BPF_JEQ, R5, R6, 1),
1597                         BPF_EXIT_INSN(),
1598                         BPF_ALU64_REG(BPF_SUB, R6, R6),
1599                         BPF_ALU64_REG(BPF_XOR, R7, R7),
1600                         BPF_JMP_REG(BPF_JEQ, R7, R6, 1),
1601                         BPF_EXIT_INSN(),
1602                         BPF_ALU64_REG(BPF_SUB, R7, R7),
1603                         BPF_ALU64_REG(BPF_XOR, R8, R8),
1604                         BPF_JMP_REG(BPF_JEQ, R7, R8, 1),
1605                         BPF_EXIT_INSN(),
1606                         BPF_ALU64_REG(BPF_SUB, R8, R8),
1607                         BPF_ALU64_REG(BPF_XOR, R9, R9),
1608                         BPF_JMP_REG(BPF_JEQ, R9, R8, 1),
1609                         BPF_EXIT_INSN(),
1610                         BPF_ALU64_REG(BPF_SUB, R9, R9),
1611                         BPF_ALU64_REG(BPF_XOR, R0, R0),
1612                         BPF_JMP_REG(BPF_JEQ, R9, R0, 1),
1613                         BPF_EXIT_INSN(),
1614                         BPF_ALU64_REG(BPF_SUB, R1, R1),
1615                         BPF_ALU64_REG(BPF_XOR, R0, R0),
1616                         BPF_JMP_REG(BPF_JEQ, R9, R0, 2),
1617                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
1618                         BPF_EXIT_INSN(),
1619                         BPF_ALU64_IMM(BPF_MOV, R0, 1),
1620                         BPF_EXIT_INSN(),
1621                 },
1622                 INTERNAL,
1623                 { },
1624                 { { 0, 1 } }
1625         },
1626         {       /* Mainly checking JIT here. */
1627                 "INT: MUL",
1628                 .u.insns_int = {
1629                         BPF_ALU64_IMM(BPF_MOV, R0, 11),
1630                         BPF_ALU64_IMM(BPF_MOV, R1, 1),
1631                         BPF_ALU64_IMM(BPF_MOV, R2, 2),
1632                         BPF_ALU64_IMM(BPF_MOV, R3, 3),
1633                         BPF_ALU64_IMM(BPF_MOV, R4, 4),
1634                         BPF_ALU64_IMM(BPF_MOV, R5, 5),
1635                         BPF_ALU64_IMM(BPF_MOV, R6, 6),
1636                         BPF_ALU64_IMM(BPF_MOV, R7, 7),
1637                         BPF_ALU64_IMM(BPF_MOV, R8, 8),
1638                         BPF_ALU64_IMM(BPF_MOV, R9, 9),
1639                         BPF_ALU64_REG(BPF_MUL, R0, R0),
1640                         BPF_ALU64_REG(BPF_MUL, R0, R1),
1641                         BPF_ALU64_REG(BPF_MUL, R0, R2),
1642                         BPF_ALU64_REG(BPF_MUL, R0, R3),
1643                         BPF_ALU64_REG(BPF_MUL, R0, R4),
1644                         BPF_ALU64_REG(BPF_MUL, R0, R5),
1645                         BPF_ALU64_REG(BPF_MUL, R0, R6),
1646                         BPF_ALU64_REG(BPF_MUL, R0, R7),
1647                         BPF_ALU64_REG(BPF_MUL, R0, R8),
1648                         BPF_ALU64_REG(BPF_MUL, R0, R9),
1649                         BPF_ALU64_IMM(BPF_MUL, R0, 10),
1650                         BPF_JMP_IMM(BPF_JEQ, R0, 439084800, 1),
1651                         BPF_EXIT_INSN(),
1652                         BPF_ALU64_REG(BPF_MUL, R1, R0),
1653                         BPF_ALU64_REG(BPF_MUL, R1, R2),
1654                         BPF_ALU64_REG(BPF_MUL, R1, R3),
1655                         BPF_ALU64_REG(BPF_MUL, R1, R4),
1656                         BPF_ALU64_REG(BPF_MUL, R1, R5),
1657                         BPF_ALU64_REG(BPF_MUL, R1, R6),
1658                         BPF_ALU64_REG(BPF_MUL, R1, R7),
1659                         BPF_ALU64_REG(BPF_MUL, R1, R8),
1660                         BPF_ALU64_REG(BPF_MUL, R1, R9),
1661                         BPF_ALU64_IMM(BPF_MUL, R1, 10),
1662                         BPF_ALU64_REG(BPF_MOV, R2, R1),
1663                         BPF_ALU64_IMM(BPF_RSH, R2, 32),
1664                         BPF_JMP_IMM(BPF_JEQ, R2, 0x5a924, 1),
1665                         BPF_EXIT_INSN(),
1666                         BPF_ALU64_IMM(BPF_LSH, R1, 32),
1667                         BPF_ALU64_IMM(BPF_ARSH, R1, 32),
1668                         BPF_JMP_IMM(BPF_JEQ, R1, 0xebb90000, 1),
1669                         BPF_EXIT_INSN(),
1670                         BPF_ALU64_REG(BPF_MUL, R2, R0),
1671                         BPF_ALU64_REG(BPF_MUL, R2, R1),
1672                         BPF_ALU64_REG(BPF_MUL, R2, R3),
1673                         BPF_ALU64_REG(BPF_MUL, R2, R4),
1674                         BPF_ALU64_REG(BPF_MUL, R2, R5),
1675                         BPF_ALU64_REG(BPF_MUL, R2, R6),
1676                         BPF_ALU64_REG(BPF_MUL, R2, R7),
1677                         BPF_ALU64_REG(BPF_MUL, R2, R8),
1678                         BPF_ALU64_REG(BPF_MUL, R2, R9),
1679                         BPF_ALU64_IMM(BPF_MUL, R2, 10),
1680                         BPF_ALU64_IMM(BPF_RSH, R2, 32),
1681                         BPF_ALU64_REG(BPF_MOV, R0, R2),
1682                         BPF_EXIT_INSN(),
1683                 },
1684                 INTERNAL,
1685                 { },
1686                 { { 0, 0x35d97ef2 } }
1687         },
1688         {       /* Mainly checking JIT here. */
1689                 "MOV REG64",
1690                 .u.insns_int = {
1691                         BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
1692                         BPF_MOV64_REG(R1, R0),
1693                         BPF_MOV64_REG(R2, R1),
1694                         BPF_MOV64_REG(R3, R2),
1695                         BPF_MOV64_REG(R4, R3),
1696                         BPF_MOV64_REG(R5, R4),
1697                         BPF_MOV64_REG(R6, R5),
1698                         BPF_MOV64_REG(R7, R6),
1699                         BPF_MOV64_REG(R8, R7),
1700                         BPF_MOV64_REG(R9, R8),
1701                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
1702                         BPF_ALU64_IMM(BPF_MOV, R1, 0),
1703                         BPF_ALU64_IMM(BPF_MOV, R2, 0),
1704                         BPF_ALU64_IMM(BPF_MOV, R3, 0),
1705                         BPF_ALU64_IMM(BPF_MOV, R4, 0),
1706                         BPF_ALU64_IMM(BPF_MOV, R5, 0),
1707                         BPF_ALU64_IMM(BPF_MOV, R6, 0),
1708                         BPF_ALU64_IMM(BPF_MOV, R7, 0),
1709                         BPF_ALU64_IMM(BPF_MOV, R8, 0),
1710                         BPF_ALU64_IMM(BPF_MOV, R9, 0),
1711                         BPF_ALU64_REG(BPF_ADD, R0, R0),
1712                         BPF_ALU64_REG(BPF_ADD, R0, R1),
1713                         BPF_ALU64_REG(BPF_ADD, R0, R2),
1714                         BPF_ALU64_REG(BPF_ADD, R0, R3),
1715                         BPF_ALU64_REG(BPF_ADD, R0, R4),
1716                         BPF_ALU64_REG(BPF_ADD, R0, R5),
1717                         BPF_ALU64_REG(BPF_ADD, R0, R6),
1718                         BPF_ALU64_REG(BPF_ADD, R0, R7),
1719                         BPF_ALU64_REG(BPF_ADD, R0, R8),
1720                         BPF_ALU64_REG(BPF_ADD, R0, R9),
1721                         BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
1722                         BPF_EXIT_INSN(),
1723                 },
1724                 INTERNAL,
1725                 { },
1726                 { { 0, 0xfefe } }
1727         },
1728         {       /* Mainly checking JIT here. */
1729                 "MOV REG32",
1730                 .u.insns_int = {
1731                         BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
1732                         BPF_MOV64_REG(R1, R0),
1733                         BPF_MOV64_REG(R2, R1),
1734                         BPF_MOV64_REG(R3, R2),
1735                         BPF_MOV64_REG(R4, R3),
1736                         BPF_MOV64_REG(R5, R4),
1737                         BPF_MOV64_REG(R6, R5),
1738                         BPF_MOV64_REG(R7, R6),
1739                         BPF_MOV64_REG(R8, R7),
1740                         BPF_MOV64_REG(R9, R8),
1741                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
1742                         BPF_ALU32_IMM(BPF_MOV, R1, 0),
1743                         BPF_ALU32_IMM(BPF_MOV, R2, 0),
1744                         BPF_ALU32_IMM(BPF_MOV, R3, 0),
1745                         BPF_ALU32_IMM(BPF_MOV, R4, 0),
1746                         BPF_ALU32_IMM(BPF_MOV, R5, 0),
1747                         BPF_ALU32_IMM(BPF_MOV, R6, 0),
1748                         BPF_ALU32_IMM(BPF_MOV, R7, 0),
1749                         BPF_ALU32_IMM(BPF_MOV, R8, 0),
1750                         BPF_ALU32_IMM(BPF_MOV, R9, 0),
1751                         BPF_ALU64_REG(BPF_ADD, R0, R0),
1752                         BPF_ALU64_REG(BPF_ADD, R0, R1),
1753                         BPF_ALU64_REG(BPF_ADD, R0, R2),
1754                         BPF_ALU64_REG(BPF_ADD, R0, R3),
1755                         BPF_ALU64_REG(BPF_ADD, R0, R4),
1756                         BPF_ALU64_REG(BPF_ADD, R0, R5),
1757                         BPF_ALU64_REG(BPF_ADD, R0, R6),
1758                         BPF_ALU64_REG(BPF_ADD, R0, R7),
1759                         BPF_ALU64_REG(BPF_ADD, R0, R8),
1760                         BPF_ALU64_REG(BPF_ADD, R0, R9),
1761                         BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
1762                         BPF_EXIT_INSN(),
1763                 },
1764                 INTERNAL,
1765                 { },
1766                 { { 0, 0xfefe } }
1767         },
1768         {       /* Mainly checking JIT here. */
1769                 "LD IMM64",
1770                 .u.insns_int = {
1771                         BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
1772                         BPF_MOV64_REG(R1, R0),
1773                         BPF_MOV64_REG(R2, R1),
1774                         BPF_MOV64_REG(R3, R2),
1775                         BPF_MOV64_REG(R4, R3),
1776                         BPF_MOV64_REG(R5, R4),
1777                         BPF_MOV64_REG(R6, R5),
1778                         BPF_MOV64_REG(R7, R6),
1779                         BPF_MOV64_REG(R8, R7),
1780                         BPF_MOV64_REG(R9, R8),
1781                         BPF_LD_IMM64(R0, 0x0LL),
1782                         BPF_LD_IMM64(R1, 0x0LL),
1783                         BPF_LD_IMM64(R2, 0x0LL),
1784                         BPF_LD_IMM64(R3, 0x0LL),
1785                         BPF_LD_IMM64(R4, 0x0LL),
1786                         BPF_LD_IMM64(R5, 0x0LL),
1787                         BPF_LD_IMM64(R6, 0x0LL),
1788                         BPF_LD_IMM64(R7, 0x0LL),
1789                         BPF_LD_IMM64(R8, 0x0LL),
1790                         BPF_LD_IMM64(R9, 0x0LL),
1791                         BPF_ALU64_REG(BPF_ADD, R0, R0),
1792                         BPF_ALU64_REG(BPF_ADD, R0, R1),
1793                         BPF_ALU64_REG(BPF_ADD, R0, R2),
1794                         BPF_ALU64_REG(BPF_ADD, R0, R3),
1795                         BPF_ALU64_REG(BPF_ADD, R0, R4),
1796                         BPF_ALU64_REG(BPF_ADD, R0, R5),
1797                         BPF_ALU64_REG(BPF_ADD, R0, R6),
1798                         BPF_ALU64_REG(BPF_ADD, R0, R7),
1799                         BPF_ALU64_REG(BPF_ADD, R0, R8),
1800                         BPF_ALU64_REG(BPF_ADD, R0, R9),
1801                         BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
1802                         BPF_EXIT_INSN(),
1803                 },
1804                 INTERNAL,
1805                 { },
1806                 { { 0, 0xfefe } }
1807         },
1808         {
1809                 "INT: ALU MIX",
1810                 .u.insns_int = {
1811                         BPF_ALU64_IMM(BPF_MOV, R0, 11),
1812                         BPF_ALU64_IMM(BPF_ADD, R0, -1),
1813                         BPF_ALU64_IMM(BPF_MOV, R2, 2),
1814                         BPF_ALU64_IMM(BPF_XOR, R2, 3),
1815                         BPF_ALU64_REG(BPF_DIV, R0, R2),
1816                         BPF_JMP_IMM(BPF_JEQ, R0, 10, 1),
1817                         BPF_EXIT_INSN(),
1818                         BPF_ALU64_IMM(BPF_MOD, R0, 3),
1819                         BPF_JMP_IMM(BPF_JEQ, R0, 1, 1),
1820                         BPF_EXIT_INSN(),
1821                         BPF_ALU64_IMM(BPF_MOV, R0, -1),
1822                         BPF_EXIT_INSN(),
1823                 },
1824                 INTERNAL,
1825                 { },
1826                 { { 0, -1 } }
1827         },
1828         {
1829                 "INT: shifts by register",
1830                 .u.insns_int = {
1831                         BPF_MOV64_IMM(R0, -1234),
1832                         BPF_MOV64_IMM(R1, 1),
1833                         BPF_ALU32_REG(BPF_RSH, R0, R1),
1834                         BPF_JMP_IMM(BPF_JEQ, R0, 0x7ffffd97, 1),
1835                         BPF_EXIT_INSN(),
1836                         BPF_MOV64_IMM(R2, 1),
1837                         BPF_ALU64_REG(BPF_LSH, R0, R2),
1838                         BPF_MOV32_IMM(R4, -1234),
1839                         BPF_JMP_REG(BPF_JEQ, R0, R4, 1),
1840                         BPF_EXIT_INSN(),
1841                         BPF_ALU64_IMM(BPF_AND, R4, 63),
1842                         BPF_ALU64_REG(BPF_LSH, R0, R4), /* R0 <= 46 */
1843                         BPF_MOV64_IMM(R3, 47),
1844                         BPF_ALU64_REG(BPF_ARSH, R0, R3),
1845                         BPF_JMP_IMM(BPF_JEQ, R0, -617, 1),
1846                         BPF_EXIT_INSN(),
1847                         BPF_MOV64_IMM(R2, 1),
1848                         BPF_ALU64_REG(BPF_LSH, R4, R2), /* R4 = 46 << 1 */
1849                         BPF_JMP_IMM(BPF_JEQ, R4, 92, 1),
1850                         BPF_EXIT_INSN(),
1851                         BPF_MOV64_IMM(R4, 4),
1852                         BPF_ALU64_REG(BPF_LSH, R4, R4), /* R4 = 4 << 4 */
1853                         BPF_JMP_IMM(BPF_JEQ, R4, 64, 1),
1854                         BPF_EXIT_INSN(),
1855                         BPF_MOV64_IMM(R4, 5),
1856                         BPF_ALU32_REG(BPF_LSH, R4, R4), /* R4 = 5 << 5 */
1857                         BPF_JMP_IMM(BPF_JEQ, R4, 160, 1),
1858                         BPF_EXIT_INSN(),
1859                         BPF_MOV64_IMM(R0, -1),
1860                         BPF_EXIT_INSN(),
1861                 },
1862                 INTERNAL,
1863                 { },
1864                 { { 0, -1 } }
1865         },
1866         {
1867                 "INT: DIV + ABS",
1868                 .u.insns_int = {
1869                         BPF_ALU64_REG(BPF_MOV, R6, R1),
1870                         BPF_LD_ABS(BPF_B, 3),
1871                         BPF_ALU64_IMM(BPF_MOV, R2, 2),
1872                         BPF_ALU32_REG(BPF_DIV, R0, R2),
1873                         BPF_ALU64_REG(BPF_MOV, R8, R0),
1874                         BPF_LD_ABS(BPF_B, 4),
1875                         BPF_ALU64_REG(BPF_ADD, R8, R0),
1876                         BPF_LD_IND(BPF_B, R8, -70),
1877                         BPF_EXIT_INSN(),
1878                 },
1879                 INTERNAL,
1880                 { 10, 20, 30, 40, 50 },
1881                 { { 4, 0 }, { 5, 10 } }
1882         },
1883         {
1884                 "INT: DIV by zero",
1885                 .u.insns_int = {
1886                         BPF_ALU64_REG(BPF_MOV, R6, R1),
1887                         BPF_ALU64_IMM(BPF_MOV, R7, 0),
1888                         BPF_LD_ABS(BPF_B, 3),
1889                         BPF_ALU32_REG(BPF_DIV, R0, R7),
1890                         BPF_EXIT_INSN(),
1891                 },
1892                 INTERNAL,
1893                 { 10, 20, 30, 40, 50 },
1894                 { { 3, 0 }, { 4, 0 } }
1895         },
1896         {
1897                 "check: missing ret",
1898                 .u.insns = {
1899                         BPF_STMT(BPF_LD | BPF_IMM, 1),
1900                 },
1901                 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
1902                 { },
1903                 { }
1904         },
1905         {
1906                 "check: div_k_0",
1907                 .u.insns = {
1908                         BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0),
1909                         BPF_STMT(BPF_RET | BPF_K, 0)
1910                 },
1911                 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
1912                 { },
1913                 { }
1914         },
1915         {
1916                 "check: unknown insn",
1917                 .u.insns = {
1918                         /* seccomp insn, rejected in socket filter */
1919                         BPF_STMT(BPF_LDX | BPF_W | BPF_ABS, 0),
1920                         BPF_STMT(BPF_RET | BPF_K, 0)
1921                 },
1922                 CLASSIC | FLAG_EXPECTED_FAIL,
1923                 { },
1924                 { }
1925         },
1926         {
1927                 "check: out of range spill/fill",
1928                 .u.insns = {
1929                         BPF_STMT(BPF_STX, 16),
1930                         BPF_STMT(BPF_RET | BPF_K, 0)
1931                 },
1932                 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
1933                 { },
1934                 { }
1935         },
1936         {
1937                 "JUMPS + HOLES",
1938                 .u.insns = {
1939                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1940                         BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 15),
1941                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1942                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1943                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1944                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1945                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1946                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1947                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1948                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1949                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1950                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1951                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1952                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1953                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1954                         BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 3, 4),
1955                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1956                         BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 1, 2),
1957                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1958                         BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
1959                         BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
1960                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1961                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1962                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1963                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1964                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1965                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1966                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1967                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1968                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1969                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1970                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1971                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1972                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1973                         BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 2, 3),
1974                         BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 1, 2),
1975                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1976                         BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
1977                         BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
1978                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1979                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1980                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1981                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1982                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1983                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1984                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1985                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1986                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1987                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1988                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1989                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1990                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1991                         BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 2, 3),
1992                         BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 1, 2),
1993                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1994                         BPF_STMT(BPF_RET | BPF_A, 0),
1995                         BPF_STMT(BPF_RET | BPF_A, 0),
1996                 },
1997                 CLASSIC,
1998                 { 0x00, 0x1b, 0x21, 0x3c, 0x9d, 0xf8,
1999                   0x90, 0xe2, 0xba, 0x0a, 0x56, 0xb4,
2000                   0x08, 0x00,
2001                   0x45, 0x00, 0x00, 0x28, 0x00, 0x00,
2002                   0x20, 0x00, 0x40, 0x11, 0x00, 0x00, /* IP header */
2003                   0xc0, 0xa8, 0x33, 0x01,
2004                   0xc0, 0xa8, 0x33, 0x02,
2005                   0xbb, 0xb6,
2006                   0xa9, 0xfa,
2007                   0x00, 0x14, 0x00, 0x00,
2008                   0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2009                   0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2010                   0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2011                   0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2012                   0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2013                   0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2014                   0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2015                   0xcc, 0xcc, 0xcc, 0xcc },
2016                 { { 88, 0x001b } }
2017         },
2018         {
2019                 "check: RET X",
2020                 .u.insns = {
2021                         BPF_STMT(BPF_RET | BPF_X, 0),
2022                 },
2023                 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2024                 { },
2025                 { },
2026         },
2027         {
2028                 "check: LDX + RET X",
2029                 .u.insns = {
2030                         BPF_STMT(BPF_LDX | BPF_IMM, 42),
2031                         BPF_STMT(BPF_RET | BPF_X, 0),
2032                 },
2033                 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2034                 { },
2035                 { },
2036         },
2037         {       /* Mainly checking JIT here. */
2038                 "M[]: alt STX + LDX",
2039                 .u.insns = {
2040                         BPF_STMT(BPF_LDX | BPF_IMM, 100),
2041                         BPF_STMT(BPF_STX, 0),
2042                         BPF_STMT(BPF_LDX | BPF_MEM, 0),
2043                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2044                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2045                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2046                         BPF_STMT(BPF_STX, 1),
2047                         BPF_STMT(BPF_LDX | BPF_MEM, 1),
2048                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2049                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2050                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2051                         BPF_STMT(BPF_STX, 2),
2052                         BPF_STMT(BPF_LDX | BPF_MEM, 2),
2053                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2054                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2055                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2056                         BPF_STMT(BPF_STX, 3),
2057                         BPF_STMT(BPF_LDX | BPF_MEM, 3),
2058                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2059                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2060                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2061                         BPF_STMT(BPF_STX, 4),
2062                         BPF_STMT(BPF_LDX | BPF_MEM, 4),
2063                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2064                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2065                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2066                         BPF_STMT(BPF_STX, 5),
2067                         BPF_STMT(BPF_LDX | BPF_MEM, 5),
2068                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2069                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2070                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2071                         BPF_STMT(BPF_STX, 6),
2072                         BPF_STMT(BPF_LDX | BPF_MEM, 6),
2073                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2074                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2075                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2076                         BPF_STMT(BPF_STX, 7),
2077                         BPF_STMT(BPF_LDX | BPF_MEM, 7),
2078                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2079                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2080                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2081                         BPF_STMT(BPF_STX, 8),
2082                         BPF_STMT(BPF_LDX | BPF_MEM, 8),
2083                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2084                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2085                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2086                         BPF_STMT(BPF_STX, 9),
2087                         BPF_STMT(BPF_LDX | BPF_MEM, 9),
2088                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2089                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2090                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2091                         BPF_STMT(BPF_STX, 10),
2092                         BPF_STMT(BPF_LDX | BPF_MEM, 10),
2093                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2094                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2095                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2096                         BPF_STMT(BPF_STX, 11),
2097                         BPF_STMT(BPF_LDX | BPF_MEM, 11),
2098                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2099                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2100                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2101                         BPF_STMT(BPF_STX, 12),
2102                         BPF_STMT(BPF_LDX | BPF_MEM, 12),
2103                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2104                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2105                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2106                         BPF_STMT(BPF_STX, 13),
2107                         BPF_STMT(BPF_LDX | BPF_MEM, 13),
2108                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2109                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2110                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2111                         BPF_STMT(BPF_STX, 14),
2112                         BPF_STMT(BPF_LDX | BPF_MEM, 14),
2113                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2114                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2115                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2116                         BPF_STMT(BPF_STX, 15),
2117                         BPF_STMT(BPF_LDX | BPF_MEM, 15),
2118                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2119                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2120                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2121                         BPF_STMT(BPF_RET | BPF_A, 0),
2122                 },
2123                 CLASSIC | FLAG_NO_DATA,
2124                 { },
2125                 { { 0, 116 } },
2126         },
2127         {       /* Mainly checking JIT here. */
2128                 "M[]: full STX + full LDX",
2129                 .u.insns = {
2130                         BPF_STMT(BPF_LDX | BPF_IMM, 0xbadfeedb),
2131                         BPF_STMT(BPF_STX, 0),
2132                         BPF_STMT(BPF_LDX | BPF_IMM, 0xecabedae),
2133                         BPF_STMT(BPF_STX, 1),
2134                         BPF_STMT(BPF_LDX | BPF_IMM, 0xafccfeaf),
2135                         BPF_STMT(BPF_STX, 2),
2136                         BPF_STMT(BPF_LDX | BPF_IMM, 0xbffdcedc),
2137                         BPF_STMT(BPF_STX, 3),
2138                         BPF_STMT(BPF_LDX | BPF_IMM, 0xfbbbdccb),
2139                         BPF_STMT(BPF_STX, 4),
2140                         BPF_STMT(BPF_LDX | BPF_IMM, 0xfbabcbda),
2141                         BPF_STMT(BPF_STX, 5),
2142                         BPF_STMT(BPF_LDX | BPF_IMM, 0xaedecbdb),
2143                         BPF_STMT(BPF_STX, 6),
2144                         BPF_STMT(BPF_LDX | BPF_IMM, 0xadebbade),
2145                         BPF_STMT(BPF_STX, 7),
2146                         BPF_STMT(BPF_LDX | BPF_IMM, 0xfcfcfaec),
2147                         BPF_STMT(BPF_STX, 8),
2148                         BPF_STMT(BPF_LDX | BPF_IMM, 0xbcdddbdc),
2149                         BPF_STMT(BPF_STX, 9),
2150                         BPF_STMT(BPF_LDX | BPF_IMM, 0xfeefdfac),
2151                         BPF_STMT(BPF_STX, 10),
2152                         BPF_STMT(BPF_LDX | BPF_IMM, 0xcddcdeea),
2153                         BPF_STMT(BPF_STX, 11),
2154                         BPF_STMT(BPF_LDX | BPF_IMM, 0xaccfaebb),
2155                         BPF_STMT(BPF_STX, 12),
2156                         BPF_STMT(BPF_LDX | BPF_IMM, 0xbdcccdcf),
2157                         BPF_STMT(BPF_STX, 13),
2158                         BPF_STMT(BPF_LDX | BPF_IMM, 0xaaedecde),
2159                         BPF_STMT(BPF_STX, 14),
2160                         BPF_STMT(BPF_LDX | BPF_IMM, 0xfaeacdad),
2161                         BPF_STMT(BPF_STX, 15),
2162                         BPF_STMT(BPF_LDX | BPF_MEM, 0),
2163                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2164                         BPF_STMT(BPF_LDX | BPF_MEM, 1),
2165                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2166                         BPF_STMT(BPF_LDX | BPF_MEM, 2),
2167                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2168                         BPF_STMT(BPF_LDX | BPF_MEM, 3),
2169                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2170                         BPF_STMT(BPF_LDX | BPF_MEM, 4),
2171                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2172                         BPF_STMT(BPF_LDX | BPF_MEM, 5),
2173                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2174                         BPF_STMT(BPF_LDX | BPF_MEM, 6),
2175                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2176                         BPF_STMT(BPF_LDX | BPF_MEM, 7),
2177                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2178                         BPF_STMT(BPF_LDX | BPF_MEM, 8),
2179                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2180                         BPF_STMT(BPF_LDX | BPF_MEM, 9),
2181                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2182                         BPF_STMT(BPF_LDX | BPF_MEM, 10),
2183                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2184                         BPF_STMT(BPF_LDX | BPF_MEM, 11),
2185                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2186                         BPF_STMT(BPF_LDX | BPF_MEM, 12),
2187                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2188                         BPF_STMT(BPF_LDX | BPF_MEM, 13),
2189                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2190                         BPF_STMT(BPF_LDX | BPF_MEM, 14),
2191                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2192                         BPF_STMT(BPF_LDX | BPF_MEM, 15),
2193                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2194                         BPF_STMT(BPF_RET | BPF_A, 0),
2195                 },
2196                 CLASSIC | FLAG_NO_DATA,
2197                 { },
2198                 { { 0, 0x2a5a5e5 } },
2199         },
2200         {
2201                 "check: SKF_AD_MAX",
2202                 .u.insns = {
2203                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2204                                  SKF_AD_OFF + SKF_AD_MAX),
2205                         BPF_STMT(BPF_RET | BPF_A, 0),
2206                 },
2207                 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2208                 { },
2209                 { },
2210         },
2211         {       /* Passes checker but fails during runtime. */
2212                 "LD [SKF_AD_OFF-1]",
2213                 .u.insns = {
2214                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2215                                  SKF_AD_OFF - 1),
2216                         BPF_STMT(BPF_RET | BPF_K, 1),
2217                 },
2218                 CLASSIC,
2219                 { },
2220                 { { 1, 0 } },
2221         },
2222         {
2223                 "load 64-bit immediate",
2224                 .u.insns_int = {
2225                         BPF_LD_IMM64(R1, 0x567800001234LL),
2226                         BPF_MOV64_REG(R2, R1),
2227                         BPF_MOV64_REG(R3, R2),
2228                         BPF_ALU64_IMM(BPF_RSH, R2, 32),
2229                         BPF_ALU64_IMM(BPF_LSH, R3, 32),
2230                         BPF_ALU64_IMM(BPF_RSH, R3, 32),
2231                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
2232                         BPF_JMP_IMM(BPF_JEQ, R2, 0x5678, 1),
2233                         BPF_EXIT_INSN(),
2234                         BPF_JMP_IMM(BPF_JEQ, R3, 0x1234, 1),
2235                         BPF_EXIT_INSN(),
2236                         BPF_LD_IMM64(R0, 0x1ffffffffLL),
2237                         BPF_ALU64_IMM(BPF_RSH, R0, 32), /* R0 = 1 */
2238                         BPF_EXIT_INSN(),
2239                 },
2240                 INTERNAL,
2241                 { },
2242                 { { 0, 1 } }
2243         },
2244         {
2245                 "nmap reduced",
2246                 .u.insns_int = {
2247                         BPF_MOV64_REG(R6, R1),
2248                         BPF_LD_ABS(BPF_H, 12),
2249                         BPF_JMP_IMM(BPF_JNE, R0, 0x806, 28),
2250                         BPF_LD_ABS(BPF_H, 12),
2251                         BPF_JMP_IMM(BPF_JNE, R0, 0x806, 26),
2252                         BPF_MOV32_IMM(R0, 18),
2253                         BPF_STX_MEM(BPF_W, R10, R0, -64),
2254                         BPF_LDX_MEM(BPF_W, R7, R10, -64),
2255                         BPF_LD_IND(BPF_W, R7, 14),
2256                         BPF_STX_MEM(BPF_W, R10, R0, -60),
2257                         BPF_MOV32_IMM(R0, 280971478),
2258                         BPF_STX_MEM(BPF_W, R10, R0, -56),
2259                         BPF_LDX_MEM(BPF_W, R7, R10, -56),
2260                         BPF_LDX_MEM(BPF_W, R0, R10, -60),
2261                         BPF_ALU32_REG(BPF_SUB, R0, R7),
2262                         BPF_JMP_IMM(BPF_JNE, R0, 0, 15),
2263                         BPF_LD_ABS(BPF_H, 12),
2264                         BPF_JMP_IMM(BPF_JNE, R0, 0x806, 13),
2265                         BPF_MOV32_IMM(R0, 22),
2266                         BPF_STX_MEM(BPF_W, R10, R0, -56),
2267                         BPF_LDX_MEM(BPF_W, R7, R10, -56),
2268                         BPF_LD_IND(BPF_H, R7, 14),
2269                         BPF_STX_MEM(BPF_W, R10, R0, -52),
2270                         BPF_MOV32_IMM(R0, 17366),
2271                         BPF_STX_MEM(BPF_W, R10, R0, -48),
2272                         BPF_LDX_MEM(BPF_W, R7, R10, -48),
2273                         BPF_LDX_MEM(BPF_W, R0, R10, -52),
2274                         BPF_ALU32_REG(BPF_SUB, R0, R7),
2275                         BPF_JMP_IMM(BPF_JNE, R0, 0, 2),
2276                         BPF_MOV32_IMM(R0, 256),
2277                         BPF_EXIT_INSN(),
2278                         BPF_MOV32_IMM(R0, 0),
2279                         BPF_EXIT_INSN(),
2280                 },
2281                 INTERNAL,
2282                 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x08, 0x06, 0, 0,
2283                   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2284                   0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6},
2285                 { { 38, 256 } }
2286         },
2287         /* BPF_ALU | BPF_MOV | BPF_X */
2288         {
2289                 "ALU_MOV_X: dst = 2",
2290                 .u.insns_int = {
2291                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
2292                         BPF_ALU32_REG(BPF_MOV, R0, R1),
2293                         BPF_EXIT_INSN(),
2294                 },
2295                 INTERNAL,
2296                 { },
2297                 { { 0, 2 } },
2298         },
2299         {
2300                 "ALU_MOV_X: dst = 4294967295",
2301                 .u.insns_int = {
2302                         BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
2303                         BPF_ALU32_REG(BPF_MOV, R0, R1),
2304                         BPF_EXIT_INSN(),
2305                 },
2306                 INTERNAL,
2307                 { },
2308                 { { 0, 4294967295U } },
2309         },
2310         {
2311                 "ALU64_MOV_X: dst = 2",
2312                 .u.insns_int = {
2313                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
2314                         BPF_ALU64_REG(BPF_MOV, R0, R1),
2315                         BPF_EXIT_INSN(),
2316                 },
2317                 INTERNAL,
2318                 { },
2319                 { { 0, 2 } },
2320         },
2321         {
2322                 "ALU64_MOV_X: dst = 4294967295",
2323                 .u.insns_int = {
2324                         BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
2325                         BPF_ALU64_REG(BPF_MOV, R0, R1),
2326                         BPF_EXIT_INSN(),
2327                 },
2328                 INTERNAL,
2329                 { },
2330                 { { 0, 4294967295U } },
2331         },
2332         /* BPF_ALU | BPF_MOV | BPF_K */
2333         {
2334                 "ALU_MOV_K: dst = 2",
2335                 .u.insns_int = {
2336                         BPF_ALU32_IMM(BPF_MOV, R0, 2),
2337                         BPF_EXIT_INSN(),
2338                 },
2339                 INTERNAL,
2340                 { },
2341                 { { 0, 2 } },
2342         },
2343         {
2344                 "ALU_MOV_K: dst = 4294967295",
2345                 .u.insns_int = {
2346                         BPF_ALU32_IMM(BPF_MOV, R0, 4294967295U),
2347                         BPF_EXIT_INSN(),
2348                 },
2349                 INTERNAL,
2350                 { },
2351                 { { 0, 4294967295U } },
2352         },
2353         {
2354                 "ALU_MOV_K: 0x0000ffffffff0000 = 0x00000000ffffffff",
2355                 .u.insns_int = {
2356                         BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
2357                         BPF_LD_IMM64(R3, 0x00000000ffffffffLL),
2358                         BPF_ALU32_IMM(BPF_MOV, R2, 0xffffffff),
2359                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2360                         BPF_MOV32_IMM(R0, 2),
2361                         BPF_EXIT_INSN(),
2362                         BPF_MOV32_IMM(R0, 1),
2363                         BPF_EXIT_INSN(),
2364                 },
2365                 INTERNAL,
2366                 { },
2367                 { { 0, 0x1 } },
2368         },
2369         {
2370                 "ALU64_MOV_K: dst = 2",
2371                 .u.insns_int = {
2372                         BPF_ALU64_IMM(BPF_MOV, R0, 2),
2373                         BPF_EXIT_INSN(),
2374                 },
2375                 INTERNAL,
2376                 { },
2377                 { { 0, 2 } },
2378         },
2379         {
2380                 "ALU64_MOV_K: dst = 2147483647",
2381                 .u.insns_int = {
2382                         BPF_ALU64_IMM(BPF_MOV, R0, 2147483647),
2383                         BPF_EXIT_INSN(),
2384                 },
2385                 INTERNAL,
2386                 { },
2387                 { { 0, 2147483647 } },
2388         },
2389         {
2390                 "ALU64_OR_K: dst = 0x0",
2391                 .u.insns_int = {
2392                         BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
2393                         BPF_LD_IMM64(R3, 0x0),
2394                         BPF_ALU64_IMM(BPF_MOV, R2, 0x0),
2395                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2396                         BPF_MOV32_IMM(R0, 2),
2397                         BPF_EXIT_INSN(),
2398                         BPF_MOV32_IMM(R0, 1),
2399                         BPF_EXIT_INSN(),
2400                 },
2401                 INTERNAL,
2402                 { },
2403                 { { 0, 0x1 } },
2404         },
2405         {
2406                 "ALU64_MOV_K: dst = -1",
2407                 .u.insns_int = {
2408                         BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
2409                         BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
2410                         BPF_ALU64_IMM(BPF_MOV, R2, 0xffffffff),
2411                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2412                         BPF_MOV32_IMM(R0, 2),
2413                         BPF_EXIT_INSN(),
2414                         BPF_MOV32_IMM(R0, 1),
2415                         BPF_EXIT_INSN(),
2416                 },
2417                 INTERNAL,
2418                 { },
2419                 { { 0, 0x1 } },
2420         },
2421         /* BPF_ALU | BPF_ADD | BPF_X */
2422         {
2423                 "ALU_ADD_X: 1 + 2 = 3",
2424                 .u.insns_int = {
2425                         BPF_LD_IMM64(R0, 1),
2426                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
2427                         BPF_ALU32_REG(BPF_ADD, R0, R1),
2428                         BPF_EXIT_INSN(),
2429                 },
2430                 INTERNAL,
2431                 { },
2432                 { { 0, 3 } },
2433         },
2434         {
2435                 "ALU_ADD_X: 1 + 4294967294 = 4294967295",
2436                 .u.insns_int = {
2437                         BPF_LD_IMM64(R0, 1),
2438                         BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
2439                         BPF_ALU32_REG(BPF_ADD, R0, R1),
2440                         BPF_EXIT_INSN(),
2441                 },
2442                 INTERNAL,
2443                 { },
2444                 { { 0, 4294967295U } },
2445         },
2446         {
2447                 "ALU_ADD_X: 2 + 4294967294 = 0",
2448                 .u.insns_int = {
2449                         BPF_LD_IMM64(R0, 2),
2450                         BPF_LD_IMM64(R1, 4294967294U),
2451                         BPF_ALU32_REG(BPF_ADD, R0, R1),
2452                         BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
2453                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
2454                         BPF_EXIT_INSN(),
2455                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
2456                         BPF_EXIT_INSN(),
2457                 },
2458                 INTERNAL,
2459                 { },
2460                 { { 0, 1 } },
2461         },
2462         {
2463                 "ALU64_ADD_X: 1 + 2 = 3",
2464                 .u.insns_int = {
2465                         BPF_LD_IMM64(R0, 1),
2466                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
2467                         BPF_ALU64_REG(BPF_ADD, R0, R1),
2468                         BPF_EXIT_INSN(),
2469                 },
2470                 INTERNAL,
2471                 { },
2472                 { { 0, 3 } },
2473         },
2474         {
2475                 "ALU64_ADD_X: 1 + 4294967294 = 4294967295",
2476                 .u.insns_int = {
2477                         BPF_LD_IMM64(R0, 1),
2478                         BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
2479                         BPF_ALU64_REG(BPF_ADD, R0, R1),
2480                         BPF_EXIT_INSN(),
2481                 },
2482                 INTERNAL,
2483                 { },
2484                 { { 0, 4294967295U } },
2485         },
2486         {
2487                 "ALU64_ADD_X: 2 + 4294967294 = 4294967296",
2488                 .u.insns_int = {
2489                         BPF_LD_IMM64(R0, 2),
2490                         BPF_LD_IMM64(R1, 4294967294U),
2491                         BPF_LD_IMM64(R2, 4294967296ULL),
2492                         BPF_ALU64_REG(BPF_ADD, R0, R1),
2493                         BPF_JMP_REG(BPF_JEQ, R0, R2, 2),
2494                         BPF_MOV32_IMM(R0, 0),
2495                         BPF_EXIT_INSN(),
2496                         BPF_MOV32_IMM(R0, 1),
2497                         BPF_EXIT_INSN(),
2498                 },
2499                 INTERNAL,
2500                 { },
2501                 { { 0, 1 } },
2502         },
2503         /* BPF_ALU | BPF_ADD | BPF_K */
2504         {
2505                 "ALU_ADD_K: 1 + 2 = 3",
2506                 .u.insns_int = {
2507                         BPF_LD_IMM64(R0, 1),
2508                         BPF_ALU32_IMM(BPF_ADD, R0, 2),
2509                         BPF_EXIT_INSN(),
2510                 },
2511                 INTERNAL,
2512                 { },
2513                 { { 0, 3 } },
2514         },
2515         {
2516                 "ALU_ADD_K: 3 + 0 = 3",
2517                 .u.insns_int = {
2518                         BPF_LD_IMM64(R0, 3),
2519                         BPF_ALU32_IMM(BPF_ADD, R0, 0),
2520                         BPF_EXIT_INSN(),
2521                 },
2522                 INTERNAL,
2523                 { },
2524                 { { 0, 3 } },
2525         },
2526         {
2527                 "ALU_ADD_K: 1 + 4294967294 = 4294967295",
2528                 .u.insns_int = {
2529                         BPF_LD_IMM64(R0, 1),
2530                         BPF_ALU32_IMM(BPF_ADD, R0, 4294967294U),
2531                         BPF_EXIT_INSN(),
2532                 },
2533                 INTERNAL,
2534                 { },
2535                 { { 0, 4294967295U } },
2536         },
2537         {
2538                 "ALU_ADD_K: 4294967294 + 2 = 0",
2539                 .u.insns_int = {
2540                         BPF_LD_IMM64(R0, 4294967294U),
2541                         BPF_ALU32_IMM(BPF_ADD, R0, 2),
2542                         BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
2543                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
2544                         BPF_EXIT_INSN(),
2545                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
2546                         BPF_EXIT_INSN(),
2547                 },
2548                 INTERNAL,
2549                 { },
2550                 { { 0, 1 } },
2551         },
2552         {
2553                 "ALU_ADD_K: 0 + (-1) = 0x00000000ffffffff",
2554                 .u.insns_int = {
2555                         BPF_LD_IMM64(R2, 0x0),
2556                         BPF_LD_IMM64(R3, 0x00000000ffffffff),
2557                         BPF_ALU32_IMM(BPF_ADD, R2, 0xffffffff),
2558                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2559                         BPF_MOV32_IMM(R0, 2),
2560                         BPF_EXIT_INSN(),
2561                         BPF_MOV32_IMM(R0, 1),
2562                         BPF_EXIT_INSN(),
2563                 },
2564                 INTERNAL,
2565                 { },
2566                 { { 0, 0x1 } },
2567         },
2568         {
2569                 "ALU_ADD_K: 0 + 0xffff = 0xffff",
2570                 .u.insns_int = {
2571                         BPF_LD_IMM64(R2, 0x0),
2572                         BPF_LD_IMM64(R3, 0xffff),
2573                         BPF_ALU32_IMM(BPF_ADD, R2, 0xffff),
2574                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2575                         BPF_MOV32_IMM(R0, 2),
2576                         BPF_EXIT_INSN(),
2577                         BPF_MOV32_IMM(R0, 1),
2578                         BPF_EXIT_INSN(),
2579                 },
2580                 INTERNAL,
2581                 { },
2582                 { { 0, 0x1 } },
2583         },
2584         {
2585                 "ALU_ADD_K: 0 + 0x7fffffff = 0x7fffffff",
2586                 .u.insns_int = {
2587                         BPF_LD_IMM64(R2, 0x0),
2588                         BPF_LD_IMM64(R3, 0x7fffffff),
2589                         BPF_ALU32_IMM(BPF_ADD, R2, 0x7fffffff),
2590                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2591                         BPF_MOV32_IMM(R0, 2),
2592                         BPF_EXIT_INSN(),
2593                         BPF_MOV32_IMM(R0, 1),
2594                         BPF_EXIT_INSN(),
2595                 },
2596                 INTERNAL,
2597                 { },
2598                 { { 0, 0x1 } },
2599         },
2600         {
2601                 "ALU_ADD_K: 0 + 0x80000000 = 0x80000000",
2602                 .u.insns_int = {
2603                         BPF_LD_IMM64(R2, 0x0),
2604                         BPF_LD_IMM64(R3, 0x80000000),
2605                         BPF_ALU32_IMM(BPF_ADD, R2, 0x80000000),
2606                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2607                         BPF_MOV32_IMM(R0, 2),
2608                         BPF_EXIT_INSN(),
2609                         BPF_MOV32_IMM(R0, 1),
2610                         BPF_EXIT_INSN(),
2611                 },
2612                 INTERNAL,
2613                 { },
2614                 { { 0, 0x1 } },
2615         },
2616         {
2617                 "ALU_ADD_K: 0 + 0x80008000 = 0x80008000",
2618                 .u.insns_int = {
2619                         BPF_LD_IMM64(R2, 0x0),
2620                         BPF_LD_IMM64(R3, 0x80008000),
2621                         BPF_ALU32_IMM(BPF_ADD, R2, 0x80008000),
2622                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2623                         BPF_MOV32_IMM(R0, 2),
2624                         BPF_EXIT_INSN(),
2625                         BPF_MOV32_IMM(R0, 1),
2626                         BPF_EXIT_INSN(),
2627                 },
2628                 INTERNAL,
2629                 { },
2630                 { { 0, 0x1 } },
2631         },
2632         {
2633                 "ALU64_ADD_K: 1 + 2 = 3",
2634                 .u.insns_int = {
2635                         BPF_LD_IMM64(R0, 1),
2636                         BPF_ALU64_IMM(BPF_ADD, R0, 2),
2637                         BPF_EXIT_INSN(),
2638                 },
2639                 INTERNAL,
2640                 { },
2641                 { { 0, 3 } },
2642         },
2643         {
2644                 "ALU64_ADD_K: 3 + 0 = 3",
2645                 .u.insns_int = {
2646                         BPF_LD_IMM64(R0, 3),
2647                         BPF_ALU64_IMM(BPF_ADD, R0, 0),
2648                         BPF_EXIT_INSN(),
2649                 },
2650                 INTERNAL,
2651                 { },
2652                 { { 0, 3 } },
2653         },
2654         {
2655                 "ALU64_ADD_K: 1 + 2147483646 = 2147483647",
2656                 .u.insns_int = {
2657                         BPF_LD_IMM64(R0, 1),
2658                         BPF_ALU64_IMM(BPF_ADD, R0, 2147483646),
2659                         BPF_EXIT_INSN(),
2660                 },
2661                 INTERNAL,
2662                 { },
2663                 { { 0, 2147483647 } },
2664         },
2665         {
2666                 "ALU64_ADD_K: 4294967294 + 2 = 4294967296",
2667                 .u.insns_int = {
2668                         BPF_LD_IMM64(R0, 4294967294U),
2669                         BPF_LD_IMM64(R1, 4294967296ULL),
2670                         BPF_ALU64_IMM(BPF_ADD, R0, 2),
2671                         BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
2672                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
2673                         BPF_EXIT_INSN(),
2674                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
2675                         BPF_EXIT_INSN(),
2676                 },
2677                 INTERNAL,
2678                 { },
2679                 { { 0, 1 } },
2680         },
2681         {
2682                 "ALU64_ADD_K: 2147483646 + -2147483647 = -1",
2683                 .u.insns_int = {
2684                         BPF_LD_IMM64(R0, 2147483646),
2685                         BPF_ALU64_IMM(BPF_ADD, R0, -2147483647),
2686                         BPF_EXIT_INSN(),
2687                 },
2688                 INTERNAL,
2689                 { },
2690                 { { 0, -1 } },
2691         },
2692         {
2693                 "ALU64_ADD_K: 1 + 0 = 1",
2694                 .u.insns_int = {
2695                         BPF_LD_IMM64(R2, 0x1),
2696                         BPF_LD_IMM64(R3, 0x1),
2697                         BPF_ALU64_IMM(BPF_ADD, R2, 0x0),
2698                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2699                         BPF_MOV32_IMM(R0, 2),
2700                         BPF_EXIT_INSN(),
2701                         BPF_MOV32_IMM(R0, 1),
2702                         BPF_EXIT_INSN(),
2703                 },
2704                 INTERNAL,
2705                 { },
2706                 { { 0, 0x1 } },
2707         },
2708         {
2709                 "ALU64_ADD_K: 0 + (-1) = 0xffffffffffffffff",
2710                 .u.insns_int = {
2711                         BPF_LD_IMM64(R2, 0x0),
2712                         BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
2713                         BPF_ALU64_IMM(BPF_ADD, R2, 0xffffffff),
2714                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2715                         BPF_MOV32_IMM(R0, 2),
2716                         BPF_EXIT_INSN(),
2717                         BPF_MOV32_IMM(R0, 1),
2718                         BPF_EXIT_INSN(),
2719                 },
2720                 INTERNAL,
2721                 { },
2722                 { { 0, 0x1 } },
2723         },
2724         {
2725                 "ALU64_ADD_K: 0 + 0xffff = 0xffff",
2726                 .u.insns_int = {
2727                         BPF_LD_IMM64(R2, 0x0),
2728                         BPF_LD_IMM64(R3, 0xffff),
2729                         BPF_ALU64_IMM(BPF_ADD, R2, 0xffff),
2730                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2731                         BPF_MOV32_IMM(R0, 2),
2732                         BPF_EXIT_INSN(),
2733                         BPF_MOV32_IMM(R0, 1),
2734                         BPF_EXIT_INSN(),
2735                 },
2736                 INTERNAL,
2737                 { },
2738                 { { 0, 0x1 } },
2739         },
2740         {
2741                 "ALU64_ADD_K: 0 + 0x7fffffff = 0x7fffffff",
2742                 .u.insns_int = {
2743                         BPF_LD_IMM64(R2, 0x0),
2744                         BPF_LD_IMM64(R3, 0x7fffffff),
2745                         BPF_ALU64_IMM(BPF_ADD, R2, 0x7fffffff),
2746                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2747                         BPF_MOV32_IMM(R0, 2),
2748                         BPF_EXIT_INSN(),
2749                         BPF_MOV32_IMM(R0, 1),
2750                         BPF_EXIT_INSN(),
2751                 },
2752                 INTERNAL,
2753                 { },
2754                 { { 0, 0x1 } },
2755         },
2756         {
2757                 "ALU64_ADD_K: 0 + 0x80000000 = 0xffffffff80000000",
2758                 .u.insns_int = {
2759                         BPF_LD_IMM64(R2, 0x0),
2760                         BPF_LD_IMM64(R3, 0xffffffff80000000LL),
2761                         BPF_ALU64_IMM(BPF_ADD, R2, 0x80000000),
2762                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2763                         BPF_MOV32_IMM(R0, 2),
2764                         BPF_EXIT_INSN(),
2765                         BPF_MOV32_IMM(R0, 1),
2766                         BPF_EXIT_INSN(),
2767                 },
2768                 INTERNAL,
2769                 { },
2770                 { { 0, 0x1 } },
2771         },
2772         {
2773                 "ALU_ADD_K: 0 + 0x80008000 = 0xffffffff80008000",
2774                 .u.insns_int = {
2775                         BPF_LD_IMM64(R2, 0x0),
2776                         BPF_LD_IMM64(R3, 0xffffffff80008000LL),
2777                         BPF_ALU64_IMM(BPF_ADD, R2, 0x80008000),
2778                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2779                         BPF_MOV32_IMM(R0, 2),
2780                         BPF_EXIT_INSN(),
2781                         BPF_MOV32_IMM(R0, 1),
2782                         BPF_EXIT_INSN(),
2783                 },
2784                 INTERNAL,
2785                 { },
2786                 { { 0, 0x1 } },
2787         },
2788         /* BPF_ALU | BPF_SUB | BPF_X */
2789         {
2790                 "ALU_SUB_X: 3 - 1 = 2",
2791                 .u.insns_int = {
2792                         BPF_LD_IMM64(R0, 3),
2793                         BPF_ALU32_IMM(BPF_MOV, R1, 1),
2794                         BPF_ALU32_REG(BPF_SUB, R0, R1),
2795                         BPF_EXIT_INSN(),
2796                 },
2797                 INTERNAL,
2798                 { },
2799                 { { 0, 2 } },
2800         },
2801         {
2802                 "ALU_SUB_X: 4294967295 - 4294967294 = 1",
2803                 .u.insns_int = {
2804                         BPF_LD_IMM64(R0, 4294967295U),
2805                         BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
2806                         BPF_ALU32_REG(BPF_SUB, R0, R1),
2807                         BPF_EXIT_INSN(),
2808                 },
2809                 INTERNAL,
2810                 { },
2811                 { { 0, 1 } },
2812         },
2813         {
2814                 "ALU64_SUB_X: 3 - 1 = 2",
2815                 .u.insns_int = {
2816                         BPF_LD_IMM64(R0, 3),
2817                         BPF_ALU32_IMM(BPF_MOV, R1, 1),
2818                         BPF_ALU64_REG(BPF_SUB, R0, R1),
2819                         BPF_EXIT_INSN(),
2820                 },
2821                 INTERNAL,
2822                 { },
2823                 { { 0, 2 } },
2824         },
2825         {
2826                 "ALU64_SUB_X: 4294967295 - 4294967294 = 1",
2827                 .u.insns_int = {
2828                         BPF_LD_IMM64(R0, 4294967295U),
2829                         BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
2830                         BPF_ALU64_REG(BPF_SUB, R0, R1),
2831                         BPF_EXIT_INSN(),
2832                 },
2833                 INTERNAL,
2834                 { },
2835                 { { 0, 1 } },
2836         },
2837         /* BPF_ALU | BPF_SUB | BPF_K */
2838         {
2839                 "ALU_SUB_K: 3 - 1 = 2",
2840                 .u.insns_int = {
2841                         BPF_LD_IMM64(R0, 3),
2842                         BPF_ALU32_IMM(BPF_SUB, R0, 1),
2843                         BPF_EXIT_INSN(),
2844                 },
2845                 INTERNAL,
2846                 { },
2847                 { { 0, 2 } },
2848         },
2849         {
2850                 "ALU_SUB_K: 3 - 0 = 3",
2851                 .u.insns_int = {
2852                         BPF_LD_IMM64(R0, 3),
2853                         BPF_ALU32_IMM(BPF_SUB, R0, 0),
2854                         BPF_EXIT_INSN(),
2855                 },
2856                 INTERNAL,
2857                 { },
2858                 { { 0, 3 } },
2859         },
2860         {
2861                 "ALU_SUB_K: 4294967295 - 4294967294 = 1",
2862                 .u.insns_int = {
2863                         BPF_LD_IMM64(R0, 4294967295U),
2864                         BPF_ALU32_IMM(BPF_SUB, R0, 4294967294U),
2865                         BPF_EXIT_INSN(),
2866                 },
2867                 INTERNAL,
2868                 { },
2869                 { { 0, 1 } },
2870         },
2871         {
2872                 "ALU64_SUB_K: 3 - 1 = 2",
2873                 .u.insns_int = {
2874                         BPF_LD_IMM64(R0, 3),
2875                         BPF_ALU64_IMM(BPF_SUB, R0, 1),
2876                         BPF_EXIT_INSN(),
2877                 },
2878                 INTERNAL,
2879                 { },
2880                 { { 0, 2 } },
2881         },
2882         {
2883                 "ALU64_SUB_K: 3 - 0 = 3",
2884                 .u.insns_int = {
2885                         BPF_LD_IMM64(R0, 3),
2886                         BPF_ALU64_IMM(BPF_SUB, R0, 0),
2887                         BPF_EXIT_INSN(),
2888                 },
2889                 INTERNAL,
2890                 { },
2891                 { { 0, 3 } },
2892         },
2893         {
2894                 "ALU64_SUB_K: 4294967294 - 4294967295 = -1",
2895                 .u.insns_int = {
2896                         BPF_LD_IMM64(R0, 4294967294U),
2897                         BPF_ALU64_IMM(BPF_SUB, R0, 4294967295U),
2898                         BPF_EXIT_INSN(),
2899                 },
2900                 INTERNAL,
2901                 { },
2902                 { { 0, -1 } },
2903         },
2904         {
2905                 "ALU64_ADD_K: 2147483646 - 2147483647 = -1",
2906                 .u.insns_int = {
2907                         BPF_LD_IMM64(R0, 2147483646),
2908                         BPF_ALU64_IMM(BPF_SUB, R0, 2147483647),
2909                         BPF_EXIT_INSN(),
2910                 },
2911                 INTERNAL,
2912                 { },
2913                 { { 0, -1 } },
2914         },
2915         /* BPF_ALU | BPF_MUL | BPF_X */
2916         {
2917                 "ALU_MUL_X: 2 * 3 = 6",
2918                 .u.insns_int = {
2919                         BPF_LD_IMM64(R0, 2),
2920                         BPF_ALU32_IMM(BPF_MOV, R1, 3),
2921                         BPF_ALU32_REG(BPF_MUL, R0, R1),
2922                         BPF_EXIT_INSN(),
2923                 },
2924                 INTERNAL,
2925                 { },
2926                 { { 0, 6 } },
2927         },
2928         {
2929                 "ALU_MUL_X: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
2930                 .u.insns_int = {
2931                         BPF_LD_IMM64(R0, 2),
2932                         BPF_ALU32_IMM(BPF_MOV, R1, 0x7FFFFFF8),
2933                         BPF_ALU32_REG(BPF_MUL, R0, R1),
2934                         BPF_EXIT_INSN(),
2935                 },
2936                 INTERNAL,
2937                 { },
2938                 { { 0, 0xFFFFFFF0 } },
2939         },
2940         {
2941                 "ALU_MUL_X: -1 * -1 = 1",
2942                 .u.insns_int = {
2943                         BPF_LD_IMM64(R0, -1),
2944                         BPF_ALU32_IMM(BPF_MOV, R1, -1),
2945                         BPF_ALU32_REG(BPF_MUL, R0, R1),
2946                         BPF_EXIT_INSN(),
2947                 },
2948                 INTERNAL,
2949                 { },
2950                 { { 0, 1 } },
2951         },
2952         {
2953                 "ALU64_MUL_X: 2 * 3 = 6",
2954                 .u.insns_int = {
2955                         BPF_LD_IMM64(R0, 2),
2956                         BPF_ALU32_IMM(BPF_MOV, R1, 3),
2957                         BPF_ALU64_REG(BPF_MUL, R0, R1),
2958                         BPF_EXIT_INSN(),
2959                 },
2960                 INTERNAL,
2961                 { },
2962                 { { 0, 6 } },
2963         },
2964         {
2965                 "ALU64_MUL_X: 1 * 2147483647 = 2147483647",
2966                 .u.insns_int = {
2967                         BPF_LD_IMM64(R0, 1),
2968                         BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
2969                         BPF_ALU64_REG(BPF_MUL, R0, R1),
2970                         BPF_EXIT_INSN(),
2971                 },
2972                 INTERNAL,
2973                 { },
2974                 { { 0, 2147483647 } },
2975         },
2976         /* BPF_ALU | BPF_MUL | BPF_K */
2977         {
2978                 "ALU_MUL_K: 2 * 3 = 6",
2979                 .u.insns_int = {
2980                         BPF_LD_IMM64(R0, 2),
2981                         BPF_ALU32_IMM(BPF_MUL, R0, 3),
2982                         BPF_EXIT_INSN(),
2983                 },
2984                 INTERNAL,
2985                 { },
2986                 { { 0, 6 } },
2987         },
2988         {
2989                 "ALU_MUL_K: 3 * 1 = 3",
2990                 .u.insns_int = {
2991                         BPF_LD_IMM64(R0, 3),
2992                         BPF_ALU32_IMM(BPF_MUL, R0, 1),
2993                         BPF_EXIT_INSN(),
2994                 },
2995                 INTERNAL,
2996                 { },
2997                 { { 0, 3 } },
2998         },
2999         {
3000                 "ALU_MUL_K: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
3001                 .u.insns_int = {
3002                         BPF_LD_IMM64(R0, 2),
3003                         BPF_ALU32_IMM(BPF_MUL, R0, 0x7FFFFFF8),
3004                         BPF_EXIT_INSN(),
3005                 },
3006                 INTERNAL,
3007                 { },
3008                 { { 0, 0xFFFFFFF0 } },
3009         },
3010         {
3011                 "ALU_MUL_K: 1 * (-1) = 0x00000000ffffffff",
3012                 .u.insns_int = {
3013                         BPF_LD_IMM64(R2, 0x1),
3014                         BPF_LD_IMM64(R3, 0x00000000ffffffff),
3015                         BPF_ALU32_IMM(BPF_MUL, R2, 0xffffffff),
3016                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3017                         BPF_MOV32_IMM(R0, 2),
3018                         BPF_EXIT_INSN(),
3019                         BPF_MOV32_IMM(R0, 1),
3020                         BPF_EXIT_INSN(),
3021                 },
3022                 INTERNAL,
3023                 { },
3024                 { { 0, 0x1 } },
3025         },
3026         {
3027                 "ALU64_MUL_K: 2 * 3 = 6",
3028                 .u.insns_int = {
3029                         BPF_LD_IMM64(R0, 2),
3030                         BPF_ALU64_IMM(BPF_MUL, R0, 3),
3031                         BPF_EXIT_INSN(),
3032                 },
3033                 INTERNAL,
3034                 { },
3035                 { { 0, 6 } },
3036         },
3037         {
3038                 "ALU64_MUL_K: 3 * 1 = 3",
3039                 .u.insns_int = {
3040                         BPF_LD_IMM64(R0, 3),
3041                         BPF_ALU64_IMM(BPF_MUL, R0, 1),
3042                         BPF_EXIT_INSN(),
3043                 },
3044                 INTERNAL,
3045                 { },
3046                 { { 0, 3 } },
3047         },
3048         {
3049                 "ALU64_MUL_K: 1 * 2147483647 = 2147483647",
3050                 .u.insns_int = {
3051                         BPF_LD_IMM64(R0, 1),
3052                         BPF_ALU64_IMM(BPF_MUL, R0, 2147483647),
3053                         BPF_EXIT_INSN(),
3054                 },
3055                 INTERNAL,
3056                 { },
3057                 { { 0, 2147483647 } },
3058         },
3059         {
3060                 "ALU64_MUL_K: 1 * -2147483647 = -2147483647",
3061                 .u.insns_int = {
3062                         BPF_LD_IMM64(R0, 1),
3063                         BPF_ALU64_IMM(BPF_MUL, R0, -2147483647),
3064                         BPF_EXIT_INSN(),
3065                 },
3066                 INTERNAL,
3067                 { },
3068                 { { 0, -2147483647 } },
3069         },
3070         {
3071                 "ALU64_MUL_K: 1 * (-1) = 0xffffffffffffffff",
3072                 .u.insns_int = {
3073                         BPF_LD_IMM64(R2, 0x1),
3074                         BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
3075                         BPF_ALU64_IMM(BPF_MUL, R2, 0xffffffff),
3076                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3077                         BPF_MOV32_IMM(R0, 2),
3078                         BPF_EXIT_INSN(),
3079                         BPF_MOV32_IMM(R0, 1),
3080                         BPF_EXIT_INSN(),
3081                 },
3082                 INTERNAL,
3083                 { },
3084                 { { 0, 0x1 } },
3085         },
3086         /* BPF_ALU | BPF_DIV | BPF_X */
3087         {
3088                 "ALU_DIV_X: 6 / 2 = 3",
3089                 .u.insns_int = {
3090                         BPF_LD_IMM64(R0, 6),
3091                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
3092                         BPF_ALU32_REG(BPF_DIV, R0, R1),
3093                         BPF_EXIT_INSN(),
3094                 },
3095                 INTERNAL,
3096                 { },
3097                 { { 0, 3 } },
3098         },
3099         {
3100                 "ALU_DIV_X: 4294967295 / 4294967295 = 1",
3101                 .u.insns_int = {
3102                         BPF_LD_IMM64(R0, 4294967295U),
3103                         BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
3104                         BPF_ALU32_REG(BPF_DIV, R0, R1),
3105                         BPF_EXIT_INSN(),
3106                 },
3107                 INTERNAL,
3108                 { },
3109                 { { 0, 1 } },
3110         },
3111         {
3112                 "ALU64_DIV_X: 6 / 2 = 3",
3113                 .u.insns_int = {
3114                         BPF_LD_IMM64(R0, 6),
3115                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
3116                         BPF_ALU64_REG(BPF_DIV, R0, R1),
3117                         BPF_EXIT_INSN(),
3118                 },
3119                 INTERNAL,
3120                 { },
3121                 { { 0, 3 } },
3122         },
3123         {
3124                 "ALU64_DIV_X: 2147483647 / 2147483647 = 1",
3125                 .u.insns_int = {
3126                         BPF_LD_IMM64(R0, 2147483647),
3127                         BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
3128                         BPF_ALU64_REG(BPF_DIV, R0, R1),
3129                         BPF_EXIT_INSN(),
3130                 },
3131                 INTERNAL,
3132                 { },
3133                 { { 0, 1 } },
3134         },
3135         {
3136                 "ALU64_DIV_X: 0xffffffffffffffff / (-1) = 0x0000000000000001",
3137                 .u.insns_int = {
3138                         BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
3139                         BPF_LD_IMM64(R4, 0xffffffffffffffffLL),
3140                         BPF_LD_IMM64(R3, 0x0000000000000001LL),
3141                         BPF_ALU64_REG(BPF_DIV, R2, R4),
3142                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3143                         BPF_MOV32_IMM(R0, 2),
3144                         BPF_EXIT_INSN(),
3145                         BPF_MOV32_IMM(R0, 1),
3146                         BPF_EXIT_INSN(),
3147                 },
3148                 INTERNAL,
3149                 { },
3150                 { { 0, 0x1 } },
3151         },
3152         /* BPF_ALU | BPF_DIV | BPF_K */
3153         {
3154                 "ALU_DIV_K: 6 / 2 = 3",
3155                 .u.insns_int = {
3156                         BPF_LD_IMM64(R0, 6),
3157                         BPF_ALU32_IMM(BPF_DIV, R0, 2),
3158                         BPF_EXIT_INSN(),
3159                 },
3160                 INTERNAL,
3161                 { },
3162                 { { 0, 3 } },
3163         },
3164         {
3165                 "ALU_DIV_K: 3 / 1 = 3",
3166                 .u.insns_int = {
3167                         BPF_LD_IMM64(R0, 3),
3168                         BPF_ALU32_IMM(BPF_DIV, R0, 1),
3169                         BPF_EXIT_INSN(),
3170                 },
3171                 INTERNAL,
3172                 { },
3173                 { { 0, 3 } },
3174         },
3175         {
3176                 "ALU_DIV_K: 4294967295 / 4294967295 = 1",
3177                 .u.insns_int = {
3178                         BPF_LD_IMM64(R0, 4294967295U),
3179                         BPF_ALU32_IMM(BPF_DIV, R0, 4294967295U),
3180                         BPF_EXIT_INSN(),
3181                 },
3182                 INTERNAL,
3183                 { },
3184                 { { 0, 1 } },
3185         },
3186         {
3187                 "ALU_DIV_K: 0xffffffffffffffff / (-1) = 0x1",
3188                 .u.insns_int = {
3189                         BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
3190                         BPF_LD_IMM64(R3, 0x1UL),
3191                         BPF_ALU32_IMM(BPF_DIV, R2, 0xffffffff),
3192                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3193                         BPF_MOV32_IMM(R0, 2),
3194                         BPF_EXIT_INSN(),
3195                         BPF_MOV32_IMM(R0, 1),
3196                         BPF_EXIT_INSN(),
3197                 },
3198                 INTERNAL,
3199                 { },
3200                 { { 0, 0x1 } },
3201         },
3202         {
3203                 "ALU64_DIV_K: 6 / 2 = 3",
3204                 .u.insns_int = {
3205                         BPF_LD_IMM64(R0, 6),
3206                         BPF_ALU64_IMM(BPF_DIV, R0, 2),
3207                         BPF_EXIT_INSN(),
3208                 },
3209                 INTERNAL,
3210                 { },
3211                 { { 0, 3 } },
3212         },
3213         {
3214                 "ALU64_DIV_K: 3 / 1 = 3",
3215                 .u.insns_int = {
3216                         BPF_LD_IMM64(R0, 3),
3217                         BPF_ALU64_IMM(BPF_DIV, R0, 1),
3218                         BPF_EXIT_INSN(),
3219                 },
3220                 INTERNAL,
3221                 { },
3222                 { { 0, 3 } },
3223         },
3224         {
3225                 "ALU64_DIV_K: 2147483647 / 2147483647 = 1",
3226                 .u.insns_int = {
3227                         BPF_LD_IMM64(R0, 2147483647),
3228                         BPF_ALU64_IMM(BPF_DIV, R0, 2147483647),
3229                         BPF_EXIT_INSN(),
3230                 },
3231                 INTERNAL,
3232                 { },
3233                 { { 0, 1 } },
3234         },
3235         {
3236                 "ALU64_DIV_K: 0xffffffffffffffff / (-1) = 0x0000000000000001",
3237                 .u.insns_int = {
3238                         BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
3239                         BPF_LD_IMM64(R3, 0x0000000000000001LL),
3240                         BPF_ALU64_IMM(BPF_DIV, R2, 0xffffffff),
3241                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3242                         BPF_MOV32_IMM(R0, 2),
3243                         BPF_EXIT_INSN(),
3244                         BPF_MOV32_IMM(R0, 1),
3245                         BPF_EXIT_INSN(),
3246                 },
3247                 INTERNAL,
3248                 { },
3249                 { { 0, 0x1 } },
3250         },
3251         /* BPF_ALU | BPF_MOD | BPF_X */
3252         {
3253                 "ALU_MOD_X: 3 % 2 = 1",
3254                 .u.insns_int = {
3255                         BPF_LD_IMM64(R0, 3),
3256                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
3257                         BPF_ALU32_REG(BPF_MOD, R0, R1),
3258                         BPF_EXIT_INSN(),
3259                 },
3260                 INTERNAL,
3261                 { },
3262                 { { 0, 1 } },
3263         },
3264         {
3265                 "ALU_MOD_X: 4294967295 % 4294967293 = 2",
3266                 .u.insns_int = {
3267                         BPF_LD_IMM64(R0, 4294967295U),
3268                         BPF_ALU32_IMM(BPF_MOV, R1, 4294967293U),
3269                         BPF_ALU32_REG(BPF_MOD, R0, R1),
3270                         BPF_EXIT_INSN(),
3271                 },
3272                 INTERNAL,
3273                 { },
3274                 { { 0, 2 } },
3275         },
3276         {
3277                 "ALU64_MOD_X: 3 % 2 = 1",
3278                 .u.insns_int = {
3279                         BPF_LD_IMM64(R0, 3),
3280                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
3281                         BPF_ALU64_REG(BPF_MOD, R0, R1),
3282                         BPF_EXIT_INSN(),
3283                 },
3284                 INTERNAL,
3285                 { },
3286                 { { 0, 1 } },
3287         },
3288         {
3289                 "ALU64_MOD_X: 2147483647 % 2147483645 = 2",
3290                 .u.insns_int = {
3291                         BPF_LD_IMM64(R0, 2147483647),
3292                         BPF_ALU32_IMM(BPF_MOV, R1, 2147483645),
3293                         BPF_ALU64_REG(BPF_MOD, R0, R1),
3294                         BPF_EXIT_INSN(),
3295                 },
3296                 INTERNAL,
3297                 { },
3298                 { { 0, 2 } },
3299         },
3300         /* BPF_ALU | BPF_MOD | BPF_K */
3301         {
3302                 "ALU_MOD_K: 3 % 2 = 1",
3303                 .u.insns_int = {
3304                         BPF_LD_IMM64(R0, 3),
3305                         BPF_ALU32_IMM(BPF_MOD, R0, 2),
3306                         BPF_EXIT_INSN(),
3307                 },
3308                 INTERNAL,
3309                 { },
3310                 { { 0, 1 } },
3311         },
3312         {
3313                 "ALU_MOD_K: 3 % 1 = 0",
3314                 .u.insns_int = {
3315                         BPF_LD_IMM64(R0, 3),
3316                         BPF_ALU32_IMM(BPF_MOD, R0, 1),
3317                         BPF_EXIT_INSN(),
3318                 },
3319                 INTERNAL,
3320                 { },
3321                 { { 0, 0 } },
3322         },
3323         {
3324                 "ALU_MOD_K: 4294967295 % 4294967293 = 2",
3325                 .u.insns_int = {
3326                         BPF_LD_IMM64(R0, 4294967295U),
3327                         BPF_ALU32_IMM(BPF_MOD, R0, 4294967293U),
3328                         BPF_EXIT_INSN(),
3329                 },
3330                 INTERNAL,
3331                 { },
3332                 { { 0, 2 } },
3333         },
3334         {
3335                 "ALU64_MOD_K: 3 % 2 = 1",
3336                 .u.insns_int = {
3337                         BPF_LD_IMM64(R0, 3),
3338                         BPF_ALU64_IMM(BPF_MOD, R0, 2),
3339                         BPF_EXIT_INSN(),
3340                 },
3341                 INTERNAL,
3342                 { },
3343                 { { 0, 1 } },
3344         },
3345         {
3346                 "ALU64_MOD_K: 3 % 1 = 0",
3347                 .u.insns_int = {
3348                         BPF_LD_IMM64(R0, 3),
3349                         BPF_ALU64_IMM(BPF_MOD, R0, 1),
3350                         BPF_EXIT_INSN(),
3351                 },
3352                 INTERNAL,
3353                 { },
3354                 { { 0, 0 } },
3355         },
3356         {
3357                 "ALU64_MOD_K: 2147483647 % 2147483645 = 2",
3358                 .u.insns_int = {
3359                         BPF_LD_IMM64(R0, 2147483647),
3360                         BPF_ALU64_IMM(BPF_MOD, R0, 2147483645),
3361                         BPF_EXIT_INSN(),
3362                 },
3363                 INTERNAL,
3364                 { },
3365                 { { 0, 2 } },
3366         },
3367         /* BPF_ALU | BPF_AND | BPF_X */
3368         {
3369                 "ALU_AND_X: 3 & 2 = 2",
3370                 .u.insns_int = {
3371                         BPF_LD_IMM64(R0, 3),
3372                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
3373                         BPF_ALU32_REG(BPF_AND, R0, R1),
3374                         BPF_EXIT_INSN(),
3375                 },
3376                 INTERNAL,
3377                 { },
3378                 { { 0, 2 } },
3379         },
3380         {
3381                 "ALU_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
3382                 .u.insns_int = {
3383                         BPF_LD_IMM64(R0, 0xffffffff),
3384                         BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3385                         BPF_ALU32_REG(BPF_AND, R0, R1),
3386                         BPF_EXIT_INSN(),
3387                 },
3388                 INTERNAL,
3389                 { },
3390                 { { 0, 0xffffffff } },
3391         },
3392         {
3393                 "ALU64_AND_X: 3 & 2 = 2",
3394                 .u.insns_int = {
3395                         BPF_LD_IMM64(R0, 3),
3396                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
3397                         BPF_ALU64_REG(BPF_AND, R0, R1),
3398                         BPF_EXIT_INSN(),
3399                 },
3400                 INTERNAL,
3401                 { },
3402                 { { 0, 2 } },
3403         },
3404         {
3405                 "ALU64_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
3406                 .u.insns_int = {
3407                         BPF_LD_IMM64(R0, 0xffffffff),
3408                         BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3409                         BPF_ALU64_REG(BPF_AND, R0, R1),
3410                         BPF_EXIT_INSN(),
3411                 },
3412                 INTERNAL,
3413                 { },
3414                 { { 0, 0xffffffff } },
3415         },
3416         /* BPF_ALU | BPF_AND | BPF_K */
3417         {
3418                 "ALU_AND_K: 3 & 2 = 2",
3419                 .u.insns_int = {
3420                         BPF_LD_IMM64(R0, 3),
3421                         BPF_ALU32_IMM(BPF_AND, R0, 2),
3422                         BPF_EXIT_INSN(),
3423                 },
3424                 INTERNAL,
3425                 { },
3426                 { { 0, 2 } },
3427         },
3428         {
3429                 "ALU_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
3430                 .u.insns_int = {
3431                         BPF_LD_IMM64(R0, 0xffffffff),
3432                         BPF_ALU32_IMM(BPF_AND, R0, 0xffffffff),
3433                         BPF_EXIT_INSN(),
3434                 },
3435                 INTERNAL,
3436                 { },
3437                 { { 0, 0xffffffff } },
3438         },
3439         {
3440                 "ALU64_AND_K: 3 & 2 = 2",
3441                 .u.insns_int = {
3442                         BPF_LD_IMM64(R0, 3),
3443                         BPF_ALU64_IMM(BPF_AND, R0, 2),
3444                         BPF_EXIT_INSN(),
3445                 },
3446                 INTERNAL,
3447                 { },
3448                 { { 0, 2 } },
3449         },
3450         {
3451                 "ALU64_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
3452                 .u.insns_int = {
3453                         BPF_LD_IMM64(R0, 0xffffffff),
3454                         BPF_ALU64_IMM(BPF_AND, R0, 0xffffffff),
3455                         BPF_EXIT_INSN(),
3456                 },
3457                 INTERNAL,
3458                 { },
3459                 { { 0, 0xffffffff } },
3460         },
3461         {
3462                 "ALU64_AND_K: 0x0000ffffffff0000 & 0x0 = 0x0000ffff00000000",
3463                 .u.insns_int = {
3464                         BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3465                         BPF_LD_IMM64(R3, 0x0000000000000000LL),
3466                         BPF_ALU64_IMM(BPF_AND, R2, 0x0),
3467                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3468                         BPF_MOV32_IMM(R0, 2),
3469                         BPF_EXIT_INSN(),
3470                         BPF_MOV32_IMM(R0, 1),
3471                         BPF_EXIT_INSN(),
3472                 },
3473                 INTERNAL,
3474                 { },
3475                 { { 0, 0x1 } },
3476         },
3477         {
3478                 "ALU64_AND_K: 0x0000ffffffff0000 & -1 = 0x0000ffffffffffff",
3479                 .u.insns_int = {
3480                         BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3481                         BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
3482                         BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
3483                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3484                         BPF_MOV32_IMM(R0, 2),
3485                         BPF_EXIT_INSN(),
3486                         BPF_MOV32_IMM(R0, 1),
3487                         BPF_EXIT_INSN(),
3488                 },
3489                 INTERNAL,
3490                 { },
3491                 { { 0, 0x1 } },
3492         },
3493         {
3494                 "ALU64_AND_K: 0xffffffffffffffff & -1 = 0xffffffffffffffff",
3495                 .u.insns_int = {
3496                         BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
3497                         BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
3498                         BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
3499                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3500                         BPF_MOV32_IMM(R0, 2),
3501                         BPF_EXIT_INSN(),
3502                         BPF_MOV32_IMM(R0, 1),
3503                         BPF_EXIT_INSN(),
3504                 },
3505                 INTERNAL,
3506                 { },
3507                 { { 0, 0x1 } },
3508         },
3509         /* BPF_ALU | BPF_OR | BPF_X */
3510         {
3511                 "ALU_OR_X: 1 | 2 = 3",
3512                 .u.insns_int = {
3513                         BPF_LD_IMM64(R0, 1),
3514                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
3515                         BPF_ALU32_REG(BPF_OR, R0, R1),
3516                         BPF_EXIT_INSN(),
3517                 },
3518                 INTERNAL,
3519                 { },
3520                 { { 0, 3 } },
3521         },
3522         {
3523                 "ALU_OR_X: 0x0 | 0xffffffff = 0xffffffff",
3524                 .u.insns_int = {
3525                         BPF_LD_IMM64(R0, 0),
3526                         BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3527                         BPF_ALU32_REG(BPF_OR, R0, R1),
3528                         BPF_EXIT_INSN(),
3529                 },
3530                 INTERNAL,
3531                 { },
3532                 { { 0, 0xffffffff } },
3533         },
3534         {
3535                 "ALU64_OR_X: 1 | 2 = 3",
3536                 .u.insns_int = {
3537                         BPF_LD_IMM64(R0, 1),
3538                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
3539                         BPF_ALU64_REG(BPF_OR, R0, R1),
3540                         BPF_EXIT_INSN(),
3541                 },
3542                 INTERNAL,
3543                 { },
3544                 { { 0, 3 } },
3545         },
3546         {
3547                 "ALU64_OR_X: 0 | 0xffffffff = 0xffffffff",
3548                 .u.insns_int = {
3549                         BPF_LD_IMM64(R0, 0),
3550                         BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3551                         BPF_ALU64_REG(BPF_OR, R0, R1),
3552                         BPF_EXIT_INSN(),
3553                 },
3554                 INTERNAL,
3555                 { },
3556                 { { 0, 0xffffffff } },
3557         },
3558         /* BPF_ALU | BPF_OR | BPF_K */
3559         {
3560                 "ALU_OR_K: 1 | 2 = 3",
3561                 .u.insns_int = {
3562                         BPF_LD_IMM64(R0, 1),
3563                         BPF_ALU32_IMM(BPF_OR, R0, 2),
3564                         BPF_EXIT_INSN(),
3565                 },
3566                 INTERNAL,
3567                 { },
3568                 { { 0, 3 } },
3569         },
3570         {
3571                 "ALU_OR_K: 0 & 0xffffffff = 0xffffffff",
3572                 .u.insns_int = {
3573                         BPF_LD_IMM64(R0, 0),
3574                         BPF_ALU32_IMM(BPF_OR, R0, 0xffffffff),
3575                         BPF_EXIT_INSN(),
3576                 },
3577                 INTERNAL,
3578                 { },
3579                 { { 0, 0xffffffff } },
3580         },
3581         {
3582                 "ALU64_OR_K: 1 | 2 = 3",
3583                 .u.insns_int = {
3584                         BPF_LD_IMM64(R0, 1),
3585                         BPF_ALU64_IMM(BPF_OR, R0, 2),
3586                         BPF_EXIT_INSN(),
3587                 },
3588                 INTERNAL,
3589                 { },
3590                 { { 0, 3 } },
3591         },
3592         {
3593                 "ALU64_OR_K: 0 & 0xffffffff = 0xffffffff",
3594                 .u.insns_int = {
3595                         BPF_LD_IMM64(R0, 0),
3596                         BPF_ALU64_IMM(BPF_OR, R0, 0xffffffff),
3597                         BPF_EXIT_INSN(),
3598                 },
3599                 INTERNAL,
3600                 { },
3601                 { { 0, 0xffffffff } },
3602         },
3603         {
3604                 "ALU64_OR_K: 0x0000ffffffff0000 | 0x0 = 0x0000ffff00000000",
3605                 .u.insns_int = {
3606                         BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3607                         BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
3608                         BPF_ALU64_IMM(BPF_OR, R2, 0x0),
3609                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3610                         BPF_MOV32_IMM(R0, 2),
3611                         BPF_EXIT_INSN(),
3612                         BPF_MOV32_IMM(R0, 1),
3613                         BPF_EXIT_INSN(),
3614                 },
3615                 INTERNAL,
3616                 { },
3617                 { { 0, 0x1 } },
3618         },
3619         {
3620                 "ALU64_OR_K: 0x0000ffffffff0000 | -1 = 0xffffffffffffffff",
3621                 .u.insns_int = {
3622                         BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3623                         BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
3624                         BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
3625                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3626                         BPF_MOV32_IMM(R0, 2),
3627                         BPF_EXIT_INSN(),
3628                         BPF_MOV32_IMM(R0, 1),
3629                         BPF_EXIT_INSN(),
3630                 },
3631                 INTERNAL,
3632                 { },
3633                 { { 0, 0x1 } },
3634         },
3635         {
3636                 "ALU64_OR_K: 0x000000000000000 | -1 = 0xffffffffffffffff",
3637                 .u.insns_int = {
3638                         BPF_LD_IMM64(R2, 0x0000000000000000LL),
3639                         BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
3640                         BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
3641                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3642                         BPF_MOV32_IMM(R0, 2),
3643                         BPF_EXIT_INSN(),
3644                         BPF_MOV32_IMM(R0, 1),
3645                         BPF_EXIT_INSN(),
3646                 },
3647                 INTERNAL,
3648                 { },
3649                 { { 0, 0x1 } },
3650         },
3651         /* BPF_ALU | BPF_XOR | BPF_X */
3652         {
3653                 "ALU_XOR_X: 5 ^ 6 = 3",
3654                 .u.insns_int = {
3655                         BPF_LD_IMM64(R0, 5),
3656                         BPF_ALU32_IMM(BPF_MOV, R1, 6),
3657                         BPF_ALU32_REG(BPF_XOR, R0, R1),
3658                         BPF_EXIT_INSN(),
3659                 },
3660                 INTERNAL,
3661                 { },
3662                 { { 0, 3 } },
3663         },
3664         {
3665                 "ALU_XOR_X: 0x1 ^ 0xffffffff = 0xfffffffe",
3666                 .u.insns_int = {
3667                         BPF_LD_IMM64(R0, 1),
3668                         BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3669                         BPF_ALU32_REG(BPF_XOR, R0, R1),
3670                         BPF_EXIT_INSN(),
3671                 },
3672                 INTERNAL,
3673                 { },
3674                 { { 0, 0xfffffffe } },
3675         },
3676         {
3677                 "ALU64_XOR_X: 5 ^ 6 = 3",
3678                 .u.insns_int = {
3679                         BPF_LD_IMM64(R0, 5),
3680                         BPF_ALU32_IMM(BPF_MOV, R1, 6),
3681                         BPF_ALU64_REG(BPF_XOR, R0, R1),
3682                         BPF_EXIT_INSN(),
3683                 },
3684                 INTERNAL,
3685                 { },
3686                 { { 0, 3 } },
3687         },
3688         {
3689                 "ALU64_XOR_X: 1 ^ 0xffffffff = 0xfffffffe",
3690                 .u.insns_int = {
3691                         BPF_LD_IMM64(R0, 1),
3692                         BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3693                         BPF_ALU64_REG(BPF_XOR, R0, R1),
3694                         BPF_EXIT_INSN(),
3695                 },
3696                 INTERNAL,
3697                 { },
3698                 { { 0, 0xfffffffe } },
3699         },
3700         /* BPF_ALU | BPF_XOR | BPF_K */
3701         {
3702                 "ALU_XOR_K: 5 ^ 6 = 3",
3703                 .u.insns_int = {
3704                         BPF_LD_IMM64(R0, 5),
3705                         BPF_ALU32_IMM(BPF_XOR, R0, 6),
3706                         BPF_EXIT_INSN(),
3707                 },
3708                 INTERNAL,
3709                 { },
3710                 { { 0, 3 } },
3711         },
3712         {
3713                 "ALU_XOR_K: 1 ^ 0xffffffff = 0xfffffffe",
3714                 .u.insns_int = {
3715                         BPF_LD_IMM64(R0, 1),
3716                         BPF_ALU32_IMM(BPF_XOR, R0, 0xffffffff),
3717                         BPF_EXIT_INSN(),
3718                 },
3719                 INTERNAL,
3720                 { },
3721                 { { 0, 0xfffffffe } },
3722         },
3723         {
3724                 "ALU64_XOR_K: 5 ^ 6 = 3",
3725                 .u.insns_int = {
3726                         BPF_LD_IMM64(R0, 5),
3727                         BPF_ALU64_IMM(BPF_XOR, R0, 6),
3728                         BPF_EXIT_INSN(),
3729                 },
3730                 INTERNAL,
3731                 { },
3732                 { { 0, 3 } },
3733         },
3734         {
3735                 "ALU64_XOR_K: 1 & 0xffffffff = 0xfffffffe",
3736                 .u.insns_int = {
3737                         BPF_LD_IMM64(R0, 1),
3738                         BPF_ALU64_IMM(BPF_XOR, R0, 0xffffffff),
3739                         BPF_EXIT_INSN(),
3740                 },
3741                 INTERNAL,
3742                 { },
3743                 { { 0, 0xfffffffe } },
3744         },
3745         {
3746                 "ALU64_XOR_K: 0x0000ffffffff0000 ^ 0x0 = 0x0000ffffffff0000",
3747                 .u.insns_int = {
3748                         BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3749                         BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
3750                         BPF_ALU64_IMM(BPF_XOR, R2, 0x0),
3751                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3752                         BPF_MOV32_IMM(R0, 2),
3753                         BPF_EXIT_INSN(),
3754                         BPF_MOV32_IMM(R0, 1),
3755                         BPF_EXIT_INSN(),
3756                 },
3757                 INTERNAL,
3758                 { },
3759                 { { 0, 0x1 } },
3760         },
3761         {
3762                 "ALU64_XOR_K: 0x0000ffffffff0000 ^ -1 = 0xffff00000000ffff",
3763                 .u.insns_int = {
3764                         BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3765                         BPF_LD_IMM64(R3, 0xffff00000000ffffLL),
3766                         BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
3767                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3768                         BPF_MOV32_IMM(R0, 2),
3769                         BPF_EXIT_INSN(),
3770                         BPF_MOV32_IMM(R0, 1),
3771                         BPF_EXIT_INSN(),
3772                 },
3773                 INTERNAL,
3774                 { },
3775                 { { 0, 0x1 } },
3776         },
3777         {
3778                 "ALU64_XOR_K: 0x000000000000000 ^ -1 = 0xffffffffffffffff",
3779                 .u.insns_int = {
3780                         BPF_LD_IMM64(R2, 0x0000000000000000LL),
3781                         BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
3782                         BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
3783                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3784                         BPF_MOV32_IMM(R0, 2),
3785                         BPF_EXIT_INSN(),
3786                         BPF_MOV32_IMM(R0, 1),
3787                         BPF_EXIT_INSN(),
3788                 },
3789                 INTERNAL,
3790                 { },
3791                 { { 0, 0x1 } },
3792         },
3793         /* BPF_ALU | BPF_LSH | BPF_X */
3794         {
3795                 "ALU_LSH_X: 1 << 1 = 2",
3796                 .u.insns_int = {
3797                         BPF_LD_IMM64(R0, 1),
3798                         BPF_ALU32_IMM(BPF_MOV, R1, 1),
3799                         BPF_ALU32_REG(BPF_LSH, R0, R1),
3800                         BPF_EXIT_INSN(),
3801                 },
3802                 INTERNAL,
3803                 { },
3804                 { { 0, 2 } },
3805         },
3806         {
3807                 "ALU_LSH_X: 1 << 31 = 0x80000000",
3808                 .u.insns_int = {
3809                         BPF_LD_IMM64(R0, 1),
3810                         BPF_ALU32_IMM(BPF_MOV, R1, 31),
3811                         BPF_ALU32_REG(BPF_LSH, R0, R1),
3812                         BPF_EXIT_INSN(),
3813                 },
3814                 INTERNAL,
3815                 { },
3816                 { { 0, 0x80000000 } },
3817         },
3818         {
3819                 "ALU64_LSH_X: 1 << 1 = 2",
3820                 .u.insns_int = {
3821                         BPF_LD_IMM64(R0, 1),
3822                         BPF_ALU32_IMM(BPF_MOV, R1, 1),
3823                         BPF_ALU64_REG(BPF_LSH, R0, R1),
3824                         BPF_EXIT_INSN(),
3825                 },
3826                 INTERNAL,
3827                 { },
3828                 { { 0, 2 } },
3829         },
3830         {
3831                 "ALU64_LSH_X: 1 << 31 = 0x80000000",
3832                 .u.insns_int = {
3833                         BPF_LD_IMM64(R0, 1),
3834                         BPF_ALU32_IMM(BPF_MOV, R1, 31),
3835                         BPF_ALU64_REG(BPF_LSH, R0, R1),
3836                         BPF_EXIT_INSN(),
3837                 },
3838                 INTERNAL,
3839                 { },
3840                 { { 0, 0x80000000 } },
3841         },
3842         /* BPF_ALU | BPF_LSH | BPF_K */
3843         {
3844                 "ALU_LSH_K: 1 << 1 = 2",
3845                 .u.insns_int = {
3846                         BPF_LD_IMM64(R0, 1),
3847                         BPF_ALU32_IMM(BPF_LSH, R0, 1),
3848                         BPF_EXIT_INSN(),
3849                 },
3850                 INTERNAL,
3851                 { },
3852                 { { 0, 2 } },
3853         },
3854         {
3855                 "ALU_LSH_K: 1 << 31 = 0x80000000",
3856                 .u.insns_int = {
3857                         BPF_LD_IMM64(R0, 1),
3858                         BPF_ALU32_IMM(BPF_LSH, R0, 31),
3859                         BPF_EXIT_INSN(),
3860                 },
3861                 INTERNAL,
3862                 { },
3863                 { { 0, 0x80000000 } },
3864         },
3865         {
3866                 "ALU64_LSH_K: 1 << 1 = 2",
3867                 .u.insns_int = {
3868                         BPF_LD_IMM64(R0, 1),
3869                         BPF_ALU64_IMM(BPF_LSH, R0, 1),
3870                         BPF_EXIT_INSN(),
3871                 },
3872                 INTERNAL,
3873                 { },
3874                 { { 0, 2 } },
3875         },
3876         {
3877                 "ALU64_LSH_K: 1 << 31 = 0x80000000",
3878                 .u.insns_int = {
3879                         BPF_LD_IMM64(R0, 1),
3880                         BPF_ALU64_IMM(BPF_LSH, R0, 31),
3881                         BPF_EXIT_INSN(),
3882                 },
3883                 INTERNAL,
3884                 { },
3885                 { { 0, 0x80000000 } },
3886         },
3887         /* BPF_ALU | BPF_RSH | BPF_X */
3888         {
3889                 "ALU_RSH_X: 2 >> 1 = 1",
3890                 .u.insns_int = {
3891                         BPF_LD_IMM64(R0, 2),
3892                         BPF_ALU32_IMM(BPF_MOV, R1, 1),
3893                         BPF_ALU32_REG(BPF_RSH, R0, R1),
3894                         BPF_EXIT_INSN(),
3895                 },
3896                 INTERNAL,
3897                 { },
3898                 { { 0, 1 } },
3899         },
3900         {
3901                 "ALU_RSH_X: 0x80000000 >> 31 = 1",
3902                 .u.insns_int = {
3903                         BPF_LD_IMM64(R0, 0x80000000),
3904                         BPF_ALU32_IMM(BPF_MOV, R1, 31),
3905                         BPF_ALU32_REG(BPF_RSH, R0, R1),
3906                         BPF_EXIT_INSN(),
3907                 },
3908                 INTERNAL,
3909                 { },
3910                 { { 0, 1 } },
3911         },
3912         {
3913                 "ALU64_RSH_X: 2 >> 1 = 1",
3914                 .u.insns_int = {
3915                         BPF_LD_IMM64(R0, 2),
3916                         BPF_ALU32_IMM(BPF_MOV, R1, 1),
3917                         BPF_ALU64_REG(BPF_RSH, R0, R1),
3918                         BPF_EXIT_INSN(),
3919                 },
3920                 INTERNAL,
3921                 { },
3922                 { { 0, 1 } },
3923         },
3924         {
3925                 "ALU64_RSH_X: 0x80000000 >> 31 = 1",
3926                 .u.insns_int = {
3927                         BPF_LD_IMM64(R0, 0x80000000),
3928                         BPF_ALU32_IMM(BPF_MOV, R1, 31),
3929                         BPF_ALU64_REG(BPF_RSH, R0, R1),
3930                         BPF_EXIT_INSN(),
3931                 },
3932                 INTERNAL,
3933                 { },
3934                 { { 0, 1 } },
3935         },
3936         /* BPF_ALU | BPF_RSH | BPF_K */
3937         {
3938                 "ALU_RSH_K: 2 >> 1 = 1",
3939                 .u.insns_int = {
3940                         BPF_LD_IMM64(R0, 2),
3941                         BPF_ALU32_IMM(BPF_RSH, R0, 1),
3942                         BPF_EXIT_INSN(),
3943                 },
3944                 INTERNAL,
3945                 { },
3946                 { { 0, 1 } },
3947         },
3948         {
3949                 "ALU_RSH_K: 0x80000000 >> 31 = 1",
3950                 .u.insns_int = {
3951                         BPF_LD_IMM64(R0, 0x80000000),
3952                         BPF_ALU32_IMM(BPF_RSH, R0, 31),
3953                         BPF_EXIT_INSN(),
3954                 },
3955                 INTERNAL,
3956                 { },
3957                 { { 0, 1 } },
3958         },
3959         {
3960                 "ALU64_RSH_K: 2 >> 1 = 1",
3961                 .u.insns_int = {
3962                         BPF_LD_IMM64(R0, 2),
3963                         BPF_ALU64_IMM(BPF_RSH, R0, 1),
3964                         BPF_EXIT_INSN(),
3965                 },
3966                 INTERNAL,
3967                 { },
3968                 { { 0, 1 } },
3969         },
3970         {
3971                 "ALU64_RSH_K: 0x80000000 >> 31 = 1",
3972                 .u.insns_int = {
3973                         BPF_LD_IMM64(R0, 0x80000000),
3974                         BPF_ALU64_IMM(BPF_RSH, R0, 31),
3975                         BPF_EXIT_INSN(),
3976                 },
3977                 INTERNAL,
3978                 { },
3979                 { { 0, 1 } },
3980         },
3981         /* BPF_ALU | BPF_ARSH | BPF_X */
3982         {
3983                 "ALU_ARSH_X: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
3984                 .u.insns_int = {
3985                         BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
3986                         BPF_ALU32_IMM(BPF_MOV, R1, 40),
3987                         BPF_ALU64_REG(BPF_ARSH, R0, R1),
3988                         BPF_EXIT_INSN(),
3989                 },
3990                 INTERNAL,
3991                 { },
3992                 { { 0, 0xffff00ff } },
3993         },
3994         /* BPF_ALU | BPF_ARSH | BPF_K */
3995         {
3996                 "ALU_ARSH_K: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
3997                 .u.insns_int = {
3998                         BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
3999                         BPF_ALU64_IMM(BPF_ARSH, R0, 40),
4000                         BPF_EXIT_INSN(),
4001                 },
4002                 INTERNAL,
4003                 { },
4004                 { { 0, 0xffff00ff } },
4005         },
4006         /* BPF_ALU | BPF_NEG */
4007         {
4008                 "ALU_NEG: -(3) = -3",
4009                 .u.insns_int = {
4010                         BPF_ALU32_IMM(BPF_MOV, R0, 3),
4011                         BPF_ALU32_IMM(BPF_NEG, R0, 0),
4012                         BPF_EXIT_INSN(),
4013                 },
4014                 INTERNAL,
4015                 { },
4016                 { { 0, -3 } },
4017         },
4018         {
4019                 "ALU_NEG: -(-3) = 3",
4020                 .u.insns_int = {
4021                         BPF_ALU32_IMM(BPF_MOV, R0, -3),
4022                         BPF_ALU32_IMM(BPF_NEG, R0, 0),
4023                         BPF_EXIT_INSN(),
4024                 },
4025                 INTERNAL,
4026                 { },
4027                 { { 0, 3 } },
4028         },
4029         {
4030                 "ALU64_NEG: -(3) = -3",
4031                 .u.insns_int = {
4032                         BPF_LD_IMM64(R0, 3),
4033                         BPF_ALU64_IMM(BPF_NEG, R0, 0),
4034                         BPF_EXIT_INSN(),
4035                 },
4036                 INTERNAL,
4037                 { },
4038                 { { 0, -3 } },
4039         },
4040         {
4041                 "ALU64_NEG: -(-3) = 3",
4042                 .u.insns_int = {
4043                         BPF_LD_IMM64(R0, -3),
4044                         BPF_ALU64_IMM(BPF_NEG, R0, 0),
4045                         BPF_EXIT_INSN(),
4046                 },
4047                 INTERNAL,
4048                 { },
4049                 { { 0, 3 } },
4050         },
4051         /* BPF_ALU | BPF_END | BPF_FROM_BE */
4052         {
4053                 "ALU_END_FROM_BE 16: 0x0123456789abcdef -> 0xcdef",
4054                 .u.insns_int = {
4055                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4056                         BPF_ENDIAN(BPF_FROM_BE, R0, 16),
4057                         BPF_EXIT_INSN(),
4058                 },
4059                 INTERNAL,
4060                 { },
4061                 { { 0,  cpu_to_be16(0xcdef) } },
4062         },
4063         {
4064                 "ALU_END_FROM_BE 32: 0x0123456789abcdef -> 0x89abcdef",
4065                 .u.insns_int = {
4066                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4067                         BPF_ENDIAN(BPF_FROM_BE, R0, 32),
4068                         BPF_ALU64_REG(BPF_MOV, R1, R0),
4069                         BPF_ALU64_IMM(BPF_RSH, R1, 32),
4070                         BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
4071                         BPF_EXIT_INSN(),
4072                 },
4073                 INTERNAL,
4074                 { },
4075                 { { 0, cpu_to_be32(0x89abcdef) } },
4076         },
4077         {
4078                 "ALU_END_FROM_BE 64: 0x0123456789abcdef -> 0x89abcdef",
4079                 .u.insns_int = {
4080                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4081                         BPF_ENDIAN(BPF_FROM_BE, R0, 64),
4082                         BPF_EXIT_INSN(),
4083                 },
4084                 INTERNAL,
4085                 { },
4086                 { { 0, (u32) cpu_to_be64(0x0123456789abcdefLL) } },
4087         },
4088         /* BPF_ALU | BPF_END | BPF_FROM_LE */
4089         {
4090                 "ALU_END_FROM_LE 16: 0x0123456789abcdef -> 0xefcd",
4091                 .u.insns_int = {
4092                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4093                         BPF_ENDIAN(BPF_FROM_LE, R0, 16),
4094                         BPF_EXIT_INSN(),
4095                 },
4096                 INTERNAL,
4097                 { },
4098                 { { 0, cpu_to_le16(0xcdef) } },
4099         },
4100         {
4101                 "ALU_END_FROM_LE 32: 0x0123456789abcdef -> 0xefcdab89",
4102                 .u.insns_int = {
4103                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4104                         BPF_ENDIAN(BPF_FROM_LE, R0, 32),
4105                         BPF_ALU64_REG(BPF_MOV, R1, R0),
4106                         BPF_ALU64_IMM(BPF_RSH, R1, 32),
4107                         BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
4108                         BPF_EXIT_INSN(),
4109                 },
4110                 INTERNAL,
4111                 { },
4112                 { { 0, cpu_to_le32(0x89abcdef) } },
4113         },
4114         {
4115                 "ALU_END_FROM_LE 64: 0x0123456789abcdef -> 0x67452301",
4116                 .u.insns_int = {
4117                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4118                         BPF_ENDIAN(BPF_FROM_LE, R0, 64),
4119                         BPF_EXIT_INSN(),
4120                 },
4121                 INTERNAL,
4122                 { },
4123                 { { 0, (u32) cpu_to_le64(0x0123456789abcdefLL) } },
4124         },
4125         /* BPF_ST(X) | BPF_MEM | BPF_B/H/W/DW */
4126         {
4127                 "ST_MEM_B: Store/Load byte: max negative",
4128                 .u.insns_int = {
4129                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4130                         BPF_ST_MEM(BPF_B, R10, -40, 0xff),
4131                         BPF_LDX_MEM(BPF_B, R0, R10, -40),
4132                         BPF_EXIT_INSN(),
4133                 },
4134                 INTERNAL,
4135                 { },
4136                 { { 0, 0xff } },
4137         },
4138         {
4139                 "ST_MEM_B: Store/Load byte: max positive",
4140                 .u.insns_int = {
4141                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4142                         BPF_ST_MEM(BPF_H, R10, -40, 0x7f),
4143                         BPF_LDX_MEM(BPF_H, R0, R10, -40),
4144                         BPF_EXIT_INSN(),
4145                 },
4146                 INTERNAL,
4147                 { },
4148                 { { 0, 0x7f } },
4149         },
4150         {
4151                 "STX_MEM_B: Store/Load byte: max negative",
4152                 .u.insns_int = {
4153                         BPF_LD_IMM64(R0, 0),
4154                         BPF_LD_IMM64(R1, 0xffLL),
4155                         BPF_STX_MEM(BPF_B, R10, R1, -40),
4156                         BPF_LDX_MEM(BPF_B, R0, R10, -40),
4157                         BPF_EXIT_INSN(),
4158                 },
4159                 INTERNAL,
4160                 { },
4161                 { { 0, 0xff } },
4162         },
4163         {
4164                 "ST_MEM_H: Store/Load half word: max negative",
4165                 .u.insns_int = {
4166                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4167                         BPF_ST_MEM(BPF_H, R10, -40, 0xffff),
4168                         BPF_LDX_MEM(BPF_H, R0, R10, -40),
4169                         BPF_EXIT_INSN(),
4170                 },
4171                 INTERNAL,
4172                 { },
4173                 { { 0, 0xffff } },
4174         },
4175         {
4176                 "ST_MEM_H: Store/Load half word: max positive",
4177                 .u.insns_int = {
4178                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4179                         BPF_ST_MEM(BPF_H, R10, -40, 0x7fff),
4180                         BPF_LDX_MEM(BPF_H, R0, R10, -40),
4181                         BPF_EXIT_INSN(),
4182                 },
4183                 INTERNAL,
4184                 { },
4185                 { { 0, 0x7fff } },
4186         },
4187         {
4188                 "STX_MEM_H: Store/Load half word: max negative",
4189                 .u.insns_int = {
4190                         BPF_LD_IMM64(R0, 0),
4191                         BPF_LD_IMM64(R1, 0xffffLL),
4192                         BPF_STX_MEM(BPF_H, R10, R1, -40),
4193                         BPF_LDX_MEM(BPF_H, R0, R10, -40),
4194                         BPF_EXIT_INSN(),
4195                 },
4196                 INTERNAL,
4197                 { },
4198                 { { 0, 0xffff } },
4199         },
4200         {
4201                 "ST_MEM_W: Store/Load word: max negative",
4202                 .u.insns_int = {
4203                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4204                         BPF_ST_MEM(BPF_W, R10, -40, 0xffffffff),
4205                         BPF_LDX_MEM(BPF_W, R0, R10, -40),
4206                         BPF_EXIT_INSN(),
4207                 },
4208                 INTERNAL,
4209                 { },
4210                 { { 0, 0xffffffff } },
4211         },
4212         {
4213                 "ST_MEM_W: Store/Load word: max positive",
4214                 .u.insns_int = {
4215                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4216                         BPF_ST_MEM(BPF_W, R10, -40, 0x7fffffff),
4217                         BPF_LDX_MEM(BPF_W, R0, R10, -40),
4218                         BPF_EXIT_INSN(),
4219                 },
4220                 INTERNAL,
4221                 { },
4222                 { { 0, 0x7fffffff } },
4223         },
4224         {
4225                 "STX_MEM_W: Store/Load word: max negative",
4226                 .u.insns_int = {
4227                         BPF_LD_IMM64(R0, 0),
4228                         BPF_LD_IMM64(R1, 0xffffffffLL),
4229                         BPF_STX_MEM(BPF_W, R10, R1, -40),
4230                         BPF_LDX_MEM(BPF_W, R0, R10, -40),
4231                         BPF_EXIT_INSN(),
4232                 },
4233                 INTERNAL,
4234                 { },
4235                 { { 0, 0xffffffff } },
4236         },
4237         {
4238                 "ST_MEM_DW: Store/Load double word: max negative",
4239                 .u.insns_int = {
4240                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4241                         BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
4242                         BPF_LDX_MEM(BPF_DW, R0, R10, -40),
4243                         BPF_EXIT_INSN(),
4244                 },
4245                 INTERNAL,
4246                 { },
4247                 { { 0, 0xffffffff } },
4248         },
4249         {
4250                 "ST_MEM_DW: Store/Load double word: max negative 2",
4251                 .u.insns_int = {
4252                         BPF_LD_IMM64(R2, 0xffff00000000ffffLL),
4253                         BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
4254                         BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
4255                         BPF_LDX_MEM(BPF_DW, R2, R10, -40),
4256                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4257                         BPF_MOV32_IMM(R0, 2),
4258                         BPF_EXIT_INSN(),
4259                         BPF_MOV32_IMM(R0, 1),
4260                         BPF_EXIT_INSN(),
4261                 },
4262                 INTERNAL,
4263                 { },
4264                 { { 0, 0x1 } },
4265         },
4266         {
4267                 "ST_MEM_DW: Store/Load double word: max positive",
4268                 .u.insns_int = {
4269                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4270                         BPF_ST_MEM(BPF_DW, R10, -40, 0x7fffffff),
4271                         BPF_LDX_MEM(BPF_DW, R0, R10, -40),
4272                         BPF_EXIT_INSN(),
4273                 },
4274                 INTERNAL,
4275                 { },
4276                 { { 0, 0x7fffffff } },
4277         },
4278         {
4279                 "STX_MEM_DW: Store/Load double word: max negative",
4280                 .u.insns_int = {
4281                         BPF_LD_IMM64(R0, 0),
4282                         BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
4283                         BPF_STX_MEM(BPF_W, R10, R1, -40),
4284                         BPF_LDX_MEM(BPF_W, R0, R10, -40),
4285                         BPF_EXIT_INSN(),
4286                 },
4287                 INTERNAL,
4288                 { },
4289                 { { 0, 0xffffffff } },
4290         },
4291         /* BPF_STX | BPF_XADD | BPF_W/DW */
4292         {
4293                 "STX_XADD_W: Test: 0x12 + 0x10 = 0x22",
4294                 .u.insns_int = {
4295                         BPF_ALU32_IMM(BPF_MOV, R0, 0x12),
4296                         BPF_ST_MEM(BPF_W, R10, -40, 0x10),
4297                         BPF_STX_XADD(BPF_W, R10, R0, -40),
4298                         BPF_LDX_MEM(BPF_W, R0, R10, -40),
4299                         BPF_EXIT_INSN(),
4300                 },
4301                 INTERNAL,
4302                 { },
4303                 { { 0, 0x22 } },
4304         },
4305         {
4306                 "STX_XADD_DW: Test: 0x12 + 0x10 = 0x22",
4307                 .u.insns_int = {
4308                         BPF_ALU32_IMM(BPF_MOV, R0, 0x12),
4309                         BPF_ST_MEM(BPF_DW, R10, -40, 0x10),
4310                         BPF_STX_XADD(BPF_DW, R10, R0, -40),
4311                         BPF_LDX_MEM(BPF_DW, R0, R10, -40),
4312                         BPF_EXIT_INSN(),
4313                 },
4314                 INTERNAL,
4315                 { },
4316                 { { 0, 0x22 } },
4317         },
4318         /* BPF_JMP | BPF_EXIT */
4319         {
4320                 "JMP_EXIT",
4321                 .u.insns_int = {
4322                         BPF_ALU32_IMM(BPF_MOV, R0, 0x4711),
4323                         BPF_EXIT_INSN(),
4324                         BPF_ALU32_IMM(BPF_MOV, R0, 0x4712),
4325                 },
4326                 INTERNAL,
4327                 { },
4328                 { { 0, 0x4711 } },
4329         },
4330         /* BPF_JMP | BPF_JA */
4331         {
4332                 "JMP_JA: Unconditional jump: if (true) return 1",
4333                 .u.insns_int = {
4334                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
4335                         BPF_JMP_IMM(BPF_JA, 0, 0, 1),
4336                         BPF_EXIT_INSN(),
4337                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4338                         BPF_EXIT_INSN(),
4339                 },
4340                 INTERNAL,
4341                 { },
4342                 { { 0, 1 } },
4343         },
4344         /* BPF_JMP | BPF_JSGT | BPF_K */
4345         {
4346                 "JMP_JSGT_K: Signed jump: if (-1 > -2) return 1",
4347                 .u.insns_int = {
4348                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
4349                         BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
4350                         BPF_JMP_IMM(BPF_JSGT, R1, -2, 1),
4351                         BPF_EXIT_INSN(),
4352                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4353                         BPF_EXIT_INSN(),
4354                 },
4355                 INTERNAL,
4356                 { },
4357                 { { 0, 1 } },
4358         },
4359         {
4360                 "JMP_JSGT_K: Signed jump: if (-1 > -1) return 0",
4361                 .u.insns_int = {
4362                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4363                         BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
4364                         BPF_JMP_IMM(BPF_JSGT, R1, -1, 1),
4365                         BPF_EXIT_INSN(),
4366                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
4367                         BPF_EXIT_INSN(),
4368                 },
4369                 INTERNAL,
4370                 { },
4371                 { { 0, 1 } },
4372         },
4373         /* BPF_JMP | BPF_JSGE | BPF_K */
4374         {
4375                 "JMP_JSGE_K: Signed jump: if (-1 >= -2) return 1",
4376                 .u.insns_int = {
4377                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
4378                         BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
4379                         BPF_JMP_IMM(BPF_JSGE, R1, -2, 1),
4380                         BPF_EXIT_INSN(),
4381                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4382                         BPF_EXIT_INSN(),
4383                 },
4384                 INTERNAL,
4385                 { },
4386                 { { 0, 1 } },
4387         },
4388         {
4389                 "JMP_JSGE_K: Signed jump: if (-1 >= -1) return 1",
4390                 .u.insns_int = {
4391                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
4392                         BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
4393                         BPF_JMP_IMM(BPF_JSGE, R1, -1, 1),
4394                         BPF_EXIT_INSN(),
4395                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4396                         BPF_EXIT_INSN(),
4397                 },
4398                 INTERNAL,
4399                 { },
4400                 { { 0, 1 } },
4401         },
4402         /* BPF_JMP | BPF_JGT | BPF_K */
4403         {
4404                 "JMP_JGT_K: if (3 > 2) return 1",
4405                 .u.insns_int = {
4406                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
4407                         BPF_LD_IMM64(R1, 3),
4408                         BPF_JMP_IMM(BPF_JGT, R1, 2, 1),
4409                         BPF_EXIT_INSN(),
4410                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4411                         BPF_EXIT_INSN(),
4412                 },
4413                 INTERNAL,
4414                 { },
4415                 { { 0, 1 } },
4416         },
4417         {
4418                 "JMP_JGT_K: Unsigned jump: if (-1 > 1) return 1",
4419                 .u.insns_int = {
4420                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
4421                         BPF_LD_IMM64(R1, -1),
4422                         BPF_JMP_IMM(BPF_JGT, R1, 1, 1),
4423                         BPF_EXIT_INSN(),
4424                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4425                         BPF_EXIT_INSN(),
4426                 },
4427                 INTERNAL,
4428                 { },
4429                 { { 0, 1 } },
4430         },
4431         /* BPF_JMP | BPF_JGE | BPF_K */
4432         {
4433                 "JMP_JGE_K: if (3 >= 2) return 1",
4434                 .u.insns_int = {
4435                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
4436                         BPF_LD_IMM64(R1, 3),
4437                         BPF_JMP_IMM(BPF_JGE, R1, 2, 1),
4438                         BPF_EXIT_INSN(),
4439                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4440                         BPF_EXIT_INSN(),
4441                 },
4442                 INTERNAL,
4443                 { },
4444                 { { 0, 1 } },
4445         },
4446         /* BPF_JMP | BPF_JGT | BPF_K jump backwards */
4447         {
4448                 "JMP_JGT_K: if (3 > 2) return 1 (jump backwards)",
4449                 .u.insns_int = {
4450                         BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
4451                         BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */
4452                         BPF_EXIT_INSN(),
4453                         BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
4454                         BPF_LD_IMM64(R1, 3), /* note: this takes 2 insns */
4455                         BPF_JMP_IMM(BPF_JGT, R1, 2, -6), /* goto out */
4456                         BPF_EXIT_INSN(),
4457                 },
4458                 INTERNAL,
4459                 { },
4460                 { { 0, 1 } },
4461         },
4462         {
4463                 "JMP_JGE_K: if (3 >= 3) return 1",
4464                 .u.insns_int = {
4465                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
4466                         BPF_LD_IMM64(R1, 3),
4467                         BPF_JMP_IMM(BPF_JGE, R1, 3, 1),
4468                         BPF_EXIT_INSN(),
4469                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4470                         BPF_EXIT_INSN(),
4471                 },
4472                 INTERNAL,
4473                 { },
4474                 { { 0, 1 } },
4475         },
4476         /* BPF_JMP | BPF_JNE | BPF_K */
4477         {
4478                 "JMP_JNE_K: if (3 != 2) return 1",
4479                 .u.insns_int = {
4480                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
4481                         BPF_LD_IMM64(R1, 3),
4482                         BPF_JMP_IMM(BPF_JNE, R1, 2, 1),
4483                         BPF_EXIT_INSN(),
4484                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4485                         BPF_EXIT_INSN(),
4486                 },
4487                 INTERNAL,
4488                 { },
4489                 { { 0, 1 } },
4490         },
4491         /* BPF_JMP | BPF_JEQ | BPF_K */
4492         {
4493                 "JMP_JEQ_K: if (3 == 3) return 1",
4494                 .u.insns_int = {
4495                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
4496                         BPF_LD_IMM64(R1, 3),
4497                         BPF_JMP_IMM(BPF_JEQ, R1, 3, 1),
4498                         BPF_EXIT_INSN(),
4499                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4500                         BPF_EXIT_INSN(),
4501                 },
4502                 INTERNAL,
4503                 { },
4504                 { { 0, 1 } },
4505         },
4506         /* BPF_JMP | BPF_JSET | BPF_K */
4507         {
4508                 "JMP_JSET_K: if (0x3 & 0x2) return 1",
4509                 .u.insns_int = {
4510                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
4511                         BPF_LD_IMM64(R1, 3),
4512                         BPF_JMP_IMM(BPF_JSET, R1, 2, 1),
4513                         BPF_EXIT_INSN(),
4514                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4515                         BPF_EXIT_INSN(),
4516                 },
4517                 INTERNAL,
4518                 { },
4519                 { { 0, 1 } },
4520         },
4521         {
4522                 "JMP_JSET_K: if (0x3 & 0xffffffff) return 1",
4523                 .u.insns_int = {
4524                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
4525                         BPF_LD_IMM64(R1, 3),
4526                         BPF_JMP_IMM(BPF_JSET, R1, 0xffffffff, 1),
4527                         BPF_EXIT_INSN(),
4528                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4529                         BPF_EXIT_INSN(),
4530                 },
4531                 INTERNAL,
4532                 { },
4533                 { { 0, 1 } },
4534         },
4535         /* BPF_JMP | BPF_JSGT | BPF_X */
4536         {
4537                 "JMP_JSGT_X: Signed jump: if (-1 > -2) return 1",
4538                 .u.insns_int = {
4539                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
4540                         BPF_LD_IMM64(R1, -1),
4541                         BPF_LD_IMM64(R2, -2),
4542                         BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
4543                         BPF_EXIT_INSN(),
4544                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4545                         BPF_EXIT_INSN(),
4546                 },
4547                 INTERNAL,
4548                 { },
4549                 { { 0, 1 } },
4550         },
4551         {
4552                 "JMP_JSGT_X: Signed jump: if (-1 > -1) return 0",
4553                 .u.insns_int = {
4554                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4555                         BPF_LD_IMM64(R1, -1),
4556                         BPF_LD_IMM64(R2, -1),
4557                         BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
4558                         BPF_EXIT_INSN(),
4559                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
4560                         BPF_EXIT_INSN(),
4561                 },
4562                 INTERNAL,
4563                 { },
4564                 { { 0, 1 } },
4565         },
4566         /* BPF_JMP | BPF_JSGE | BPF_X */
4567         {
4568                 "JMP_JSGE_X: Signed jump: if (-1 >= -2) return 1",
4569                 .u.insns_int = {
4570                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
4571                         BPF_LD_IMM64(R1, -1),
4572                         BPF_LD_IMM64(R2, -2),
4573                         BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
4574                         BPF_EXIT_INSN(),
4575                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4576                         BPF_EXIT_INSN(),
4577                 },
4578                 INTERNAL,
4579                 { },
4580                 { { 0, 1 } },
4581         },
4582         {
4583                 "JMP_JSGE_X: Signed jump: if (-1 >= -1) return 1",
4584                 .u.insns_int = {
4585                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
4586                         BPF_LD_IMM64(R1, -1),
4587                         BPF_LD_IMM64(R2, -1),
4588                         BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
4589                         BPF_EXIT_INSN(),
4590                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4591                         BPF_EXIT_INSN(),
4592                 },
4593                 INTERNAL,
4594                 { },
4595                 { { 0, 1 } },
4596         },
4597         /* BPF_JMP | BPF_JGT | BPF_X */
4598         {
4599                 "JMP_JGT_X: if (3 > 2) return 1",
4600                 .u.insns_int = {
4601                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
4602                         BPF_LD_IMM64(R1, 3),
4603                         BPF_LD_IMM64(R2, 2),
4604                         BPF_JMP_REG(BPF_JGT, R1, R2, 1),
4605                         BPF_EXIT_INSN(),
4606                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4607                         BPF_EXIT_INSN(),
4608                 },
4609                 INTERNAL,
4610                 { },
4611                 { { 0, 1 } },
4612         },
4613         {
4614                 "JMP_JGT_X: Unsigned jump: if (-1 > 1) return 1",
4615                 .u.insns_int = {
4616                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
4617                         BPF_LD_IMM64(R1, -1),
4618                         BPF_LD_IMM64(R2, 1),
4619                         BPF_JMP_REG(BPF_JGT, R1, R2, 1),
4620                         BPF_EXIT_INSN(),
4621                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4622                         BPF_EXIT_INSN(),
4623                 },
4624                 INTERNAL,
4625                 { },
4626                 { { 0, 1 } },
4627         },
4628         /* BPF_JMP | BPF_JGE | BPF_X */
4629         {
4630                 "JMP_JGE_X: if (3 >= 2) return 1",
4631                 .u.insns_int = {
4632                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
4633                         BPF_LD_IMM64(R1, 3),
4634                         BPF_LD_IMM64(R2, 2),
4635                         BPF_JMP_REG(BPF_JGE, R1, R2, 1),
4636                         BPF_EXIT_INSN(),
4637                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4638                         BPF_EXIT_INSN(),
4639                 },
4640                 INTERNAL,
4641                 { },
4642                 { { 0, 1 } },
4643         },
4644         {
4645                 "JMP_JGE_X: if (3 >= 3) return 1",
4646                 .u.insns_int = {
4647                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
4648                         BPF_LD_IMM64(R1, 3),
4649                         BPF_LD_IMM64(R2, 3),
4650                         BPF_JMP_REG(BPF_JGE, R1, R2, 1),
4651                         BPF_EXIT_INSN(),
4652                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4653                         BPF_EXIT_INSN(),
4654                 },
4655                 INTERNAL,
4656                 { },
4657                 { { 0, 1 } },
4658         },
4659         {
4660                 /* Mainly testing JIT + imm64 here. */
4661                 "JMP_JGE_X: ldimm64 test 1",
4662                 .u.insns_int = {
4663                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
4664                         BPF_LD_IMM64(R1, 3),
4665                         BPF_LD_IMM64(R2, 2),
4666                         BPF_JMP_REG(BPF_JGE, R1, R2, 2),
4667                         BPF_LD_IMM64(R0, 0xffffffffffffffffUL),
4668                         BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeUL),
4669                         BPF_EXIT_INSN(),
4670                 },
4671                 INTERNAL,
4672                 { },
4673                 { { 0, 0xeeeeeeeeU } },
4674         },
4675         {
4676                 "JMP_JGE_X: ldimm64 test 2",
4677                 .u.insns_int = {
4678                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
4679                         BPF_LD_IMM64(R1, 3),
4680                         BPF_LD_IMM64(R2, 2),
4681                         BPF_JMP_REG(BPF_JGE, R1, R2, 0),
4682                         BPF_LD_IMM64(R0, 0xffffffffffffffffUL),
4683                         BPF_EXIT_INSN(),
4684                 },
4685                 INTERNAL,
4686                 { },
4687                 { { 0, 0xffffffffU } },
4688         },
4689         {
4690                 "JMP_JGE_X: ldimm64 test 3",
4691                 .u.insns_int = {
4692                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4693                         BPF_LD_IMM64(R1, 3),
4694                         BPF_LD_IMM64(R2, 2),
4695                         BPF_JMP_REG(BPF_JGE, R1, R2, 4),
4696                         BPF_LD_IMM64(R0, 0xffffffffffffffffUL),
4697                         BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeUL),
4698                         BPF_EXIT_INSN(),
4699                 },
4700                 INTERNAL,
4701                 { },
4702                 { { 0, 1 } },
4703         },
4704         /* BPF_JMP | BPF_JNE | BPF_X */
4705         {
4706                 "JMP_JNE_X: if (3 != 2) return 1",
4707                 .u.insns_int = {
4708                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
4709                         BPF_LD_IMM64(R1, 3),
4710                         BPF_LD_IMM64(R2, 2),
4711                         BPF_JMP_REG(BPF_JNE, R1, R2, 1),
4712                         BPF_EXIT_INSN(),
4713                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4714                         BPF_EXIT_INSN(),
4715                 },
4716                 INTERNAL,
4717                 { },
4718                 { { 0, 1 } },
4719         },
4720         /* BPF_JMP | BPF_JEQ | BPF_X */
4721         {
4722                 "JMP_JEQ_X: if (3 == 3) return 1",
4723                 .u.insns_int = {
4724                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
4725                         BPF_LD_IMM64(R1, 3),
4726                         BPF_LD_IMM64(R2, 3),
4727                         BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
4728                         BPF_EXIT_INSN(),
4729                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4730                         BPF_EXIT_INSN(),
4731                 },
4732                 INTERNAL,
4733                 { },
4734                 { { 0, 1 } },
4735         },
4736         /* BPF_JMP | BPF_JSET | BPF_X */
4737         {
4738                 "JMP_JSET_X: if (0x3 & 0x2) return 1",
4739                 .u.insns_int = {
4740                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
4741                         BPF_LD_IMM64(R1, 3),
4742                         BPF_LD_IMM64(R2, 2),
4743                         BPF_JMP_REG(BPF_JSET, R1, R2, 1),
4744                         BPF_EXIT_INSN(),
4745                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4746                         BPF_EXIT_INSN(),
4747                 },
4748                 INTERNAL,
4749                 { },
4750                 { { 0, 1 } },
4751         },
4752         {
4753                 "JMP_JSET_X: if (0x3 & 0xffffffff) return 1",
4754                 .u.insns_int = {
4755                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
4756                         BPF_LD_IMM64(R1, 3),
4757                         BPF_LD_IMM64(R2, 0xffffffff),
4758                         BPF_JMP_REG(BPF_JSET, R1, R2, 1),
4759                         BPF_EXIT_INSN(),
4760                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4761                         BPF_EXIT_INSN(),
4762                 },
4763                 INTERNAL,
4764                 { },
4765                 { { 0, 1 } },
4766         },
4767         {
4768                 "JMP_JA: Jump, gap, jump, ...",
4769                 { },
4770                 CLASSIC | FLAG_NO_DATA,
4771                 { },
4772                 { { 0, 0xababcbac } },
4773                 .fill_helper = bpf_fill_ja,
4774         },
4775         {       /* Mainly checking JIT here. */
4776                 "BPF_MAXINSNS: Maximum possible literals",
4777                 { },
4778                 CLASSIC | FLAG_NO_DATA,
4779                 { },
4780                 { { 0, 0xffffffff } },
4781                 .fill_helper = bpf_fill_maxinsns1,
4782         },
4783         {       /* Mainly checking JIT here. */
4784                 "BPF_MAXINSNS: Single literal",
4785                 { },
4786                 CLASSIC | FLAG_NO_DATA,
4787                 { },
4788                 { { 0, 0xfefefefe } },
4789                 .fill_helper = bpf_fill_maxinsns2,
4790         },
4791         {       /* Mainly checking JIT here. */
4792                 "BPF_MAXINSNS: Run/add until end",
4793                 { },
4794                 CLASSIC | FLAG_NO_DATA,
4795                 { },
4796                 { { 0, 0x947bf368 } },
4797                 .fill_helper = bpf_fill_maxinsns3,
4798         },
4799         {
4800                 "BPF_MAXINSNS: Too many instructions",
4801                 { },
4802                 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4803                 { },
4804                 { },
4805                 .fill_helper = bpf_fill_maxinsns4,
4806         },
4807         {       /* Mainly checking JIT here. */
4808                 "BPF_MAXINSNS: Very long jump",
4809                 { },
4810                 CLASSIC | FLAG_NO_DATA,
4811                 { },
4812                 { { 0, 0xabababab } },
4813                 .fill_helper = bpf_fill_maxinsns5,
4814         },
4815         {       /* Mainly checking JIT here. */
4816                 "BPF_MAXINSNS: Ctx heavy transformations",
4817                 { },
4818                 CLASSIC,
4819                 { },
4820                 {
4821                         {  1, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) },
4822                         { 10, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) }
4823                 },
4824                 .fill_helper = bpf_fill_maxinsns6,
4825         },
4826         {       /* Mainly checking JIT here. */
4827                 "BPF_MAXINSNS: Call heavy transformations",
4828                 { },
4829                 CLASSIC | FLAG_NO_DATA,
4830                 { },
4831                 { { 1, 0 }, { 10, 0 } },
4832                 .fill_helper = bpf_fill_maxinsns7,
4833         },
4834         {       /* Mainly checking JIT here. */
4835                 "BPF_MAXINSNS: Jump heavy test",
4836                 { },
4837                 CLASSIC | FLAG_NO_DATA,
4838                 { },
4839                 { { 0, 0xffffffff } },
4840                 .fill_helper = bpf_fill_maxinsns8,
4841         },
4842         {       /* Mainly checking JIT here. */
4843                 "BPF_MAXINSNS: Very long jump backwards",
4844                 { },
4845                 INTERNAL | FLAG_NO_DATA,
4846                 { },
4847                 { { 0, 0xcbababab } },
4848                 .fill_helper = bpf_fill_maxinsns9,
4849         },
4850         {       /* Mainly checking JIT here. */
4851                 "BPF_MAXINSNS: Edge hopping nuthouse",
4852                 { },
4853                 INTERNAL | FLAG_NO_DATA,
4854                 { },
4855                 { { 0, 0xabababac } },
4856                 .fill_helper = bpf_fill_maxinsns10,
4857         },
4858         {
4859                 "BPF_MAXINSNS: Jump, gap, jump, ...",
4860                 { },
4861                 CLASSIC | FLAG_NO_DATA,
4862                 { },
4863                 { { 0, 0xababcbac } },
4864                 .fill_helper = bpf_fill_maxinsns11,
4865         },
4866         {
4867                 "BPF_MAXINSNS: ld_abs+get_processor_id",
4868                 { },
4869                 CLASSIC,
4870                 { },
4871                 { { 1, 0xbee } },
4872                 .fill_helper = bpf_fill_ld_abs_get_processor_id,
4873         },
4874         {
4875                 "BPF_MAXINSNS: ld_abs+vlan_push/pop",
4876                 { },
4877                 INTERNAL,
4878                 { 0x34 },
4879                 { { ETH_HLEN, 0xbef } },
4880                 .fill_helper = bpf_fill_ld_abs_vlan_push_pop,
4881         },
4882         /*
4883          * LD_IND / LD_ABS on fragmented SKBs
4884          */
4885         {
4886                 "LD_IND byte frag",
4887                 .u.insns = {
4888                         BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
4889                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x0),
4890                         BPF_STMT(BPF_RET | BPF_A, 0x0),
4891                 },
4892                 CLASSIC | FLAG_SKB_FRAG,
4893                 { },
4894                 { {0x40, 0x42} },
4895                 .frag_data = {
4896                         0x42, 0x00, 0x00, 0x00,
4897                         0x43, 0x44, 0x00, 0x00,
4898                         0x21, 0x07, 0x19, 0x83,
4899                 },
4900         },
4901         {
4902                 "LD_IND halfword frag",
4903                 .u.insns = {
4904                         BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
4905                         BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x4),
4906                         BPF_STMT(BPF_RET | BPF_A, 0x0),
4907                 },
4908                 CLASSIC | FLAG_SKB_FRAG,
4909                 { },
4910                 { {0x40, 0x4344} },
4911                 .frag_data = {
4912                         0x42, 0x00, 0x00, 0x00,
4913                         0x43, 0x44, 0x00, 0x00,
4914                         0x21, 0x07, 0x19, 0x83,
4915                 },
4916         },
4917         {
4918                 "LD_IND word frag",
4919                 .u.insns = {
4920                         BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
4921                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x8),
4922                         BPF_STMT(BPF_RET | BPF_A, 0x0),
4923                 },
4924                 CLASSIC | FLAG_SKB_FRAG,
4925                 { },
4926                 { {0x40, 0x21071983} },
4927                 .frag_data = {
4928                         0x42, 0x00, 0x00, 0x00,
4929                         0x43, 0x44, 0x00, 0x00,
4930                         0x21, 0x07, 0x19, 0x83,
4931                 },
4932         },
4933         {
4934                 "LD_IND halfword mixed head/frag",
4935                 .u.insns = {
4936                         BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
4937                         BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
4938                         BPF_STMT(BPF_RET | BPF_A, 0x0),
4939                 },
4940                 CLASSIC | FLAG_SKB_FRAG,
4941                 { [0x3e] = 0x25, [0x3f] = 0x05, },
4942                 { {0x40, 0x0519} },
4943                 .frag_data = { 0x19, 0x82 },
4944         },
4945         {
4946                 "LD_IND word mixed head/frag",
4947                 .u.insns = {
4948                         BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
4949                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
4950                         BPF_STMT(BPF_RET | BPF_A, 0x0),
4951                 },
4952                 CLASSIC | FLAG_SKB_FRAG,
4953                 { [0x3e] = 0x25, [0x3f] = 0x05, },
4954                 { {0x40, 0x25051982} },
4955                 .frag_data = { 0x19, 0x82 },
4956         },
4957         {
4958                 "LD_ABS byte frag",
4959                 .u.insns = {
4960                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x40),
4961                         BPF_STMT(BPF_RET | BPF_A, 0x0),
4962                 },
4963                 CLASSIC | FLAG_SKB_FRAG,
4964                 { },
4965                 { {0x40, 0x42} },
4966                 .frag_data = {
4967                         0x42, 0x00, 0x00, 0x00,
4968                         0x43, 0x44, 0x00, 0x00,
4969                         0x21, 0x07, 0x19, 0x83,
4970                 },
4971         },
4972         {
4973                 "LD_ABS halfword frag",
4974                 .u.insns = {
4975                         BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x44),
4976                         BPF_STMT(BPF_RET | BPF_A, 0x0),
4977                 },
4978                 CLASSIC | FLAG_SKB_FRAG,
4979                 { },
4980                 { {0x40, 0x4344} },
4981                 .frag_data = {
4982                         0x42, 0x00, 0x00, 0x00,
4983                         0x43, 0x44, 0x00, 0x00,
4984                         0x21, 0x07, 0x19, 0x83,
4985                 },
4986         },
4987         {
4988                 "LD_ABS word frag",
4989                 .u.insns = {
4990                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x48),
4991                         BPF_STMT(BPF_RET | BPF_A, 0x0),
4992                 },
4993                 CLASSIC | FLAG_SKB_FRAG,
4994                 { },
4995                 { {0x40, 0x21071983} },
4996                 .frag_data = {
4997                         0x42, 0x00, 0x00, 0x00,
4998                         0x43, 0x44, 0x00, 0x00,
4999                         0x21, 0x07, 0x19, 0x83,
5000                 },
5001         },
5002         {
5003                 "LD_ABS halfword mixed head/frag",
5004                 .u.insns = {
5005                         BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f),
5006                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5007                 },
5008                 CLASSIC | FLAG_SKB_FRAG,
5009                 { [0x3e] = 0x25, [0x3f] = 0x05, },
5010                 { {0x40, 0x0519} },
5011                 .frag_data = { 0x19, 0x82 },
5012         },
5013         {
5014                 "LD_ABS word mixed head/frag",
5015                 .u.insns = {
5016                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3e),
5017                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5018                 },
5019                 CLASSIC | FLAG_SKB_FRAG,
5020                 { [0x3e] = 0x25, [0x3f] = 0x05, },
5021                 { {0x40, 0x25051982} },
5022                 .frag_data = { 0x19, 0x82 },
5023         },
5024         /*
5025          * LD_IND / LD_ABS on non fragmented SKBs
5026          */
5027         {
5028                 /*
5029                  * this tests that the JIT/interpreter correctly resets X
5030                  * before using it in an LD_IND instruction.
5031                  */
5032                 "LD_IND byte default X",
5033                 .u.insns = {
5034                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
5035                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5036                 },
5037                 CLASSIC,
5038                 { [0x1] = 0x42 },
5039                 { {0x40, 0x42 } },
5040         },
5041         {
5042                 "LD_IND byte positive offset",
5043                 .u.insns = {
5044                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
5045                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
5046                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5047                 },
5048                 CLASSIC,
5049                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
5050                 { {0x40, 0x82 } },
5051         },
5052         {
5053                 "LD_IND byte negative offset",
5054                 .u.insns = {
5055                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
5056                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x1),
5057                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5058                 },
5059                 CLASSIC,
5060                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
5061                 { {0x40, 0x05 } },
5062         },
5063         {
5064                 "LD_IND halfword positive offset",
5065                 .u.insns = {
5066                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
5067                         BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x2),
5068                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5069                 },
5070                 CLASSIC,
5071                 {
5072                         [0x1c] = 0xaa, [0x1d] = 0x55,
5073                         [0x1e] = 0xbb, [0x1f] = 0x66,
5074                         [0x20] = 0xcc, [0x21] = 0x77,
5075                         [0x22] = 0xdd, [0x23] = 0x88,
5076                 },
5077                 { {0x40, 0xdd88 } },
5078         },
5079         {
5080                 "LD_IND halfword negative offset",
5081                 .u.insns = {
5082                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
5083                         BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x2),
5084                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5085                 },
5086                 CLASSIC,
5087                 {
5088                         [0x1c] = 0xaa, [0x1d] = 0x55,
5089                         [0x1e] = 0xbb, [0x1f] = 0x66,
5090                         [0x20] = 0xcc, [0x21] = 0x77,
5091                         [0x22] = 0xdd, [0x23] = 0x88,
5092                 },
5093                 { {0x40, 0xbb66 } },
5094         },
5095         {
5096                 "LD_IND halfword unaligned",
5097                 .u.insns = {
5098                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
5099                         BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
5100                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5101                 },
5102                 CLASSIC,
5103                 {
5104                         [0x1c] = 0xaa, [0x1d] = 0x55,
5105                         [0x1e] = 0xbb, [0x1f] = 0x66,
5106                         [0x20] = 0xcc, [0x21] = 0x77,
5107                         [0x22] = 0xdd, [0x23] = 0x88,
5108                 },
5109                 { {0x40, 0x66cc } },
5110         },
5111         {
5112                 "LD_IND word positive offset",
5113                 .u.insns = {
5114                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
5115                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x4),
5116                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5117                 },
5118                 CLASSIC,
5119                 {
5120                         [0x1c] = 0xaa, [0x1d] = 0x55,
5121                         [0x1e] = 0xbb, [0x1f] = 0x66,
5122                         [0x20] = 0xcc, [0x21] = 0x77,
5123                         [0x22] = 0xdd, [0x23] = 0x88,
5124                         [0x24] = 0xee, [0x25] = 0x99,
5125                         [0x26] = 0xff, [0x27] = 0xaa,
5126                 },
5127                 { {0x40, 0xee99ffaa } },
5128         },
5129         {
5130                 "LD_IND word negative offset",
5131                 .u.insns = {
5132                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
5133                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x4),
5134                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5135                 },
5136                 CLASSIC,
5137                 {
5138                         [0x1c] = 0xaa, [0x1d] = 0x55,
5139                         [0x1e] = 0xbb, [0x1f] = 0x66,
5140                         [0x20] = 0xcc, [0x21] = 0x77,
5141                         [0x22] = 0xdd, [0x23] = 0x88,
5142                         [0x24] = 0xee, [0x25] = 0x99,
5143                         [0x26] = 0xff, [0x27] = 0xaa,
5144                 },
5145                 { {0x40, 0xaa55bb66 } },
5146         },
5147         {
5148                 "LD_IND word unaligned (addr & 3 == 2)",
5149                 .u.insns = {
5150                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
5151                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
5152                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5153                 },
5154                 CLASSIC,
5155                 {
5156                         [0x1c] = 0xaa, [0x1d] = 0x55,
5157                         [0x1e] = 0xbb, [0x1f] = 0x66,
5158                         [0x20] = 0xcc, [0x21] = 0x77,
5159                         [0x22] = 0xdd, [0x23] = 0x88,
5160                         [0x24] = 0xee, [0x25] = 0x99,
5161                         [0x26] = 0xff, [0x27] = 0xaa,
5162                 },
5163                 { {0x40, 0xbb66cc77 } },
5164         },
5165         {
5166                 "LD_IND word unaligned (addr & 3 == 1)",
5167                 .u.insns = {
5168                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
5169                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3),
5170                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5171                 },
5172                 CLASSIC,
5173                 {
5174                         [0x1c] = 0xaa, [0x1d] = 0x55,
5175                         [0x1e] = 0xbb, [0x1f] = 0x66,
5176                         [0x20] = 0xcc, [0x21] = 0x77,
5177                         [0x22] = 0xdd, [0x23] = 0x88,
5178                         [0x24] = 0xee, [0x25] = 0x99,
5179                         [0x26] = 0xff, [0x27] = 0xaa,
5180                 },
5181                 { {0x40, 0x55bb66cc } },
5182         },
5183         {
5184                 "LD_IND word unaligned (addr & 3 == 3)",
5185                 .u.insns = {
5186                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
5187                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x1),
5188                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5189                 },
5190                 CLASSIC,
5191                 {
5192                         [0x1c] = 0xaa, [0x1d] = 0x55,
5193                         [0x1e] = 0xbb, [0x1f] = 0x66,
5194                         [0x20] = 0xcc, [0x21] = 0x77,
5195                         [0x22] = 0xdd, [0x23] = 0x88,
5196                         [0x24] = 0xee, [0x25] = 0x99,
5197                         [0x26] = 0xff, [0x27] = 0xaa,
5198                 },
5199                 { {0x40, 0x66cc77dd } },
5200         },
5201         {
5202                 "LD_ABS byte",
5203                 .u.insns = {
5204                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x20),
5205                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5206                 },
5207                 CLASSIC,
5208                 {
5209                         [0x1c] = 0xaa, [0x1d] = 0x55,
5210                         [0x1e] = 0xbb, [0x1f] = 0x66,
5211                         [0x20] = 0xcc, [0x21] = 0x77,
5212                         [0x22] = 0xdd, [0x23] = 0x88,
5213                         [0x24] = 0xee, [0x25] = 0x99,
5214                         [0x26] = 0xff, [0x27] = 0xaa,
5215                 },
5216                 { {0x40, 0xcc } },
5217         },
5218         {
5219                 "LD_ABS halfword",
5220                 .u.insns = {
5221                         BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x22),
5222                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5223                 },
5224                 CLASSIC,
5225                 {
5226                         [0x1c] = 0xaa, [0x1d] = 0x55,
5227                         [0x1e] = 0xbb, [0x1f] = 0x66,
5228                         [0x20] = 0xcc, [0x21] = 0x77,
5229                         [0x22] = 0xdd, [0x23] = 0x88,
5230                         [0x24] = 0xee, [0x25] = 0x99,
5231                         [0x26] = 0xff, [0x27] = 0xaa,
5232                 },
5233                 { {0x40, 0xdd88 } },
5234         },
5235         {
5236                 "LD_ABS halfword unaligned",
5237                 .u.insns = {
5238                         BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x25),
5239                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5240                 },
5241                 CLASSIC,
5242                 {
5243                         [0x1c] = 0xaa, [0x1d] = 0x55,
5244                         [0x1e] = 0xbb, [0x1f] = 0x66,
5245                         [0x20] = 0xcc, [0x21] = 0x77,
5246                         [0x22] = 0xdd, [0x23] = 0x88,
5247                         [0x24] = 0xee, [0x25] = 0x99,
5248                         [0x26] = 0xff, [0x27] = 0xaa,
5249                 },
5250                 { {0x40, 0x99ff } },
5251         },
5252         {
5253                 "LD_ABS word",
5254                 .u.insns = {
5255                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x1c),
5256                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5257                 },
5258                 CLASSIC,
5259                 {
5260                         [0x1c] = 0xaa, [0x1d] = 0x55,
5261                         [0x1e] = 0xbb, [0x1f] = 0x66,
5262                         [0x20] = 0xcc, [0x21] = 0x77,
5263                         [0x22] = 0xdd, [0x23] = 0x88,
5264                         [0x24] = 0xee, [0x25] = 0x99,
5265                         [0x26] = 0xff, [0x27] = 0xaa,
5266                 },
5267                 { {0x40, 0xaa55bb66 } },
5268         },
5269         {
5270                 "LD_ABS word unaligned (addr & 3 == 2)",
5271                 .u.insns = {
5272                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x22),
5273                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5274                 },
5275                 CLASSIC,
5276                 {
5277                         [0x1c] = 0xaa, [0x1d] = 0x55,
5278                         [0x1e] = 0xbb, [0x1f] = 0x66,
5279                         [0x20] = 0xcc, [0x21] = 0x77,
5280                         [0x22] = 0xdd, [0x23] = 0x88,
5281                         [0x24] = 0xee, [0x25] = 0x99,
5282                         [0x26] = 0xff, [0x27] = 0xaa,
5283                 },
5284                 { {0x40, 0xdd88ee99 } },
5285         },
5286         {
5287                 "LD_ABS word unaligned (addr & 3 == 1)",
5288                 .u.insns = {
5289                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x21),
5290                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5291                 },
5292                 CLASSIC,
5293                 {
5294                         [0x1c] = 0xaa, [0x1d] = 0x55,
5295                         [0x1e] = 0xbb, [0x1f] = 0x66,
5296                         [0x20] = 0xcc, [0x21] = 0x77,
5297                         [0x22] = 0xdd, [0x23] = 0x88,
5298                         [0x24] = 0xee, [0x25] = 0x99,
5299                         [0x26] = 0xff, [0x27] = 0xaa,
5300                 },
5301                 { {0x40, 0x77dd88ee } },
5302         },
5303         {
5304                 "LD_ABS word unaligned (addr & 3 == 3)",
5305                 .u.insns = {
5306                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x23),
5307                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5308                 },
5309                 CLASSIC,
5310                 {
5311                         [0x1c] = 0xaa, [0x1d] = 0x55,
5312                         [0x1e] = 0xbb, [0x1f] = 0x66,
5313                         [0x20] = 0xcc, [0x21] = 0x77,
5314                         [0x22] = 0xdd, [0x23] = 0x88,
5315                         [0x24] = 0xee, [0x25] = 0x99,
5316                         [0x26] = 0xff, [0x27] = 0xaa,
5317                 },
5318                 { {0x40, 0x88ee99ff } },
5319         },
5320         /*
5321          * verify that the interpreter or JIT correctly sets A and X
5322          * to 0.
5323          */
5324         {
5325                 "ADD default X",
5326                 .u.insns = {
5327                         /*
5328                          * A = 0x42
5329                          * A = A + X
5330                          * ret A
5331                          */
5332                         BPF_STMT(BPF_LD | BPF_IMM, 0x42),
5333                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
5334                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5335                 },
5336                 CLASSIC | FLAG_NO_DATA,
5337                 {},
5338                 { {0x1, 0x42 } },
5339         },
5340         {
5341                 "ADD default A",
5342                 .u.insns = {
5343                         /*
5344                          * A = A + 0x42
5345                          * ret A
5346                          */
5347                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0x42),
5348                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5349                 },
5350                 CLASSIC | FLAG_NO_DATA,
5351                 {},
5352                 { {0x1, 0x42 } },
5353         },
5354         {
5355                 "SUB default X",
5356                 .u.insns = {
5357                         /*
5358                          * A = 0x66
5359                          * A = A - X
5360                          * ret A
5361                          */
5362                         BPF_STMT(BPF_LD | BPF_IMM, 0x66),
5363                         BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
5364                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5365                 },
5366                 CLASSIC | FLAG_NO_DATA,
5367                 {},
5368                 { {0x1, 0x66 } },
5369         },
5370         {
5371                 "SUB default A",
5372                 .u.insns = {
5373                         /*
5374                          * A = A - -0x66
5375                          * ret A
5376                          */
5377                         BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, -0x66),
5378                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5379                 },
5380                 CLASSIC | FLAG_NO_DATA,
5381                 {},
5382                 { {0x1, 0x66 } },
5383         },
5384         {
5385                 "MUL default X",
5386                 .u.insns = {
5387                         /*
5388                          * A = 0x42
5389                          * A = A * X
5390                          * ret A
5391                          */
5392                         BPF_STMT(BPF_LD | BPF_IMM, 0x42),
5393                         BPF_STMT(BPF_ALU | BPF_MUL | BPF_X, 0),
5394                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5395                 },
5396                 CLASSIC | FLAG_NO_DATA,
5397                 {},
5398                 { {0x1, 0x0 } },
5399         },
5400         {
5401                 "MUL default A",
5402                 .u.insns = {
5403                         /*
5404                          * A = A * 0x66
5405                          * ret A
5406                          */
5407                         BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 0x66),
5408                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5409                 },
5410                 CLASSIC | FLAG_NO_DATA,
5411                 {},
5412                 { {0x1, 0x0 } },
5413         },
5414         {
5415                 "DIV default X",
5416                 .u.insns = {
5417                         /*
5418                          * A = 0x42
5419                          * A = A / X ; this halt the filter execution if X is 0
5420                          * ret 0x42
5421                          */
5422                         BPF_STMT(BPF_LD | BPF_IMM, 0x42),
5423                         BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
5424                         BPF_STMT(BPF_RET | BPF_K, 0x42),
5425                 },
5426                 CLASSIC | FLAG_NO_DATA,
5427                 {},
5428                 { {0x1, 0x0 } },
5429         },
5430         {
5431                 "DIV default A",
5432                 .u.insns = {
5433                         /*
5434                          * A = A / 1
5435                          * ret A
5436                          */
5437                         BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x1),
5438                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5439                 },
5440                 CLASSIC | FLAG_NO_DATA,
5441                 {},
5442                 { {0x1, 0x0 } },
5443         },
5444         {
5445                 "MOD default X",
5446                 .u.insns = {
5447                         /*
5448                          * A = 0x42
5449                          * A = A mod X ; this halt the filter execution if X is 0
5450                          * ret 0x42
5451                          */
5452                         BPF_STMT(BPF_LD | BPF_IMM, 0x42),
5453                         BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
5454                         BPF_STMT(BPF_RET | BPF_K, 0x42),
5455                 },
5456                 CLASSIC | FLAG_NO_DATA,
5457                 {},
5458                 { {0x1, 0x0 } },
5459         },
5460         {
5461                 "MOD default A",
5462                 .u.insns = {
5463                         /*
5464                          * A = A mod 1
5465                          * ret A
5466                          */
5467                         BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x1),
5468                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5469                 },
5470                 CLASSIC | FLAG_NO_DATA,
5471                 {},
5472                 { {0x1, 0x0 } },
5473         },
5474         {
5475                 "JMP EQ default A",
5476                 .u.insns = {
5477                         /*
5478                          * cmp A, 0x0, 0, 1
5479                          * ret 0x42
5480                          * ret 0x66
5481                          */
5482                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0, 0, 1),
5483                         BPF_STMT(BPF_RET | BPF_K, 0x42),
5484                         BPF_STMT(BPF_RET | BPF_K, 0x66),
5485                 },
5486                 CLASSIC | FLAG_NO_DATA,
5487                 {},
5488                 { {0x1, 0x42 } },
5489         },
5490         {
5491                 "JMP EQ default X",
5492                 .u.insns = {
5493                         /*
5494                          * A = 0x0
5495                          * cmp A, X, 0, 1
5496                          * ret 0x42
5497                          * ret 0x66
5498                          */
5499                         BPF_STMT(BPF_LD | BPF_IMM, 0x0),
5500                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0x0, 0, 1),
5501                         BPF_STMT(BPF_RET | BPF_K, 0x42),
5502                         BPF_STMT(BPF_RET | BPF_K, 0x66),
5503                 },
5504                 CLASSIC | FLAG_NO_DATA,
5505                 {},
5506                 { {0x1, 0x42 } },
5507         },
5508 };
5509 
5510 static struct net_device dev;
5511 
5512 static struct sk_buff *populate_skb(char *buf, int size)
5513 {
5514         struct sk_buff *skb;
5515 
5516         if (size >= MAX_DATA)
5517                 return NULL;
5518 
5519         skb = alloc_skb(MAX_DATA, GFP_KERNEL);
5520         if (!skb)
5521                 return NULL;
5522 
5523         memcpy(__skb_put(skb, size), buf, size);
5524 
5525         /* Initialize a fake skb with test pattern. */
5526         skb_reset_mac_header(skb);
5527         skb->protocol = htons(ETH_P_IP);
5528         skb->pkt_type = SKB_TYPE;
5529         skb->mark = SKB_MARK;
5530         skb->hash = SKB_HASH;
5531         skb->queue_mapping = SKB_QUEUE_MAP;
5532         skb->vlan_tci = SKB_VLAN_TCI;
5533         skb->vlan_proto = htons(ETH_P_IP);
5534         skb->dev = &dev;
5535         skb->dev->ifindex = SKB_DEV_IFINDEX;
5536         skb->dev->type = SKB_DEV_TYPE;
5537         skb_set_network_header(skb, min(size, ETH_HLEN));
5538 
5539         return skb;
5540 }
5541 
5542 static void *generate_test_data(struct bpf_test *test, int sub)
5543 {
5544         struct sk_buff *skb;
5545         struct page *page;
5546 
5547         if (test->aux & FLAG_NO_DATA)
5548                 return NULL;
5549 
5550         /* Test case expects an skb, so populate one. Various
5551          * subtests generate skbs of different sizes based on
5552          * the same data.
5553          */
5554         skb = populate_skb(test->data, test->test[sub].data_size);
5555         if (!skb)
5556                 return NULL;
5557 
5558         if (test->aux & FLAG_SKB_FRAG) {
5559                 /*
5560                  * when the test requires a fragmented skb, add a
5561                  * single fragment to the skb, filled with
5562                  * test->frag_data.
5563                  */
5564                 void *ptr;
5565 
5566                 page = alloc_page(GFP_KERNEL);
5567 
5568                 if (!page)
5569                         goto err_kfree_skb;
5570 
5571                 ptr = kmap(page);
5572                 if (!ptr)
5573                         goto err_free_page;
5574                 memcpy(ptr, test->frag_data, MAX_DATA);
5575                 kunmap(page);
5576                 skb_add_rx_frag(skb, 0, page, 0, MAX_DATA, MAX_DATA);
5577         }
5578 
5579         return skb;
5580 
5581 err_free_page:
5582         __free_page(page);
5583 err_kfree_skb:
5584         kfree_skb(skb);
5585         return NULL;
5586 }
5587 
5588 static void release_test_data(const struct bpf_test *test, void *data)
5589 {
5590         if (test->aux & FLAG_NO_DATA)
5591                 return;
5592 
5593         kfree_skb(data);
5594 }
5595 
5596 static int filter_length(int which)
5597 {
5598         struct sock_filter *fp;
5599         int len;
5600 
5601         if (tests[which].fill_helper)
5602                 return tests[which].u.ptr.len;
5603 
5604         fp = tests[which].u.insns;
5605         for (len = MAX_INSNS - 1; len > 0; --len)
5606                 if (fp[len].code != 0 || fp[len].k != 0)
5607                         break;
5608 
5609         return len + 1;
5610 }
5611 
5612 static void *filter_pointer(int which)
5613 {
5614         if (tests[which].fill_helper)
5615                 return tests[which].u.ptr.insns;
5616         else
5617                 return tests[which].u.insns;
5618 }
5619 
5620 static struct bpf_prog *generate_filter(int which, int *err)
5621 {
5622         __u8 test_type = tests[which].aux & TEST_TYPE_MASK;
5623         unsigned int flen = filter_length(which);
5624         void *fptr = filter_pointer(which);
5625         struct sock_fprog_kern fprog;
5626         struct bpf_prog *fp;
5627 
5628         switch (test_type) {
5629         case CLASSIC:
5630                 fprog.filter = fptr;
5631                 fprog.len = flen;
5632 
5633                 *err = bpf_prog_create(&fp, &fprog);
5634                 if (tests[which].aux & FLAG_EXPECTED_FAIL) {
5635                         if (*err == -EINVAL) {
5636                                 pr_cont("PASS\n");
5637                                 /* Verifier rejected filter as expected. */
5638                                 *err = 0;
5639                                 return NULL;
5640                         } else {
5641                                 pr_cont("UNEXPECTED_PASS\n");
5642                                 /* Verifier didn't reject the test that's
5643                                  * bad enough, just return!
5644                                  */
5645                                 *err = -EINVAL;
5646                                 return NULL;
5647                         }
5648                 }
5649                 /* We don't expect to fail. */
5650                 if (*err) {
5651                         pr_cont("FAIL to attach err=%d len=%d\n",
5652                                 *err, fprog.len);
5653                         return NULL;
5654                 }
5655                 break;
5656 
5657         case INTERNAL:
5658                 fp = bpf_prog_alloc(bpf_prog_size(flen), 0);
5659                 if (fp == NULL) {
5660                         pr_cont("UNEXPECTED_FAIL no memory left\n");
5661                         *err = -ENOMEM;
5662                         return NULL;
5663                 }
5664 
5665                 fp->len = flen;
5666                 /* Type doesn't really matter here as long as it's not unspec. */
5667                 fp->type = BPF_PROG_TYPE_SOCKET_FILTER;
5668                 memcpy(fp->insnsi, fptr, fp->len * sizeof(struct bpf_insn));
5669 
5670                 /* We cannot error here as we don't need type compatibility
5671                  * checks.
5672                  */
5673                 fp = bpf_prog_select_runtime(fp, err);
5674                 break;
5675         }
5676 
5677         *err = 0;
5678         return fp;
5679 }
5680 
5681 static void release_filter(struct bpf_prog *fp, int which)
5682 {
5683         __u8 test_type = tests[which].aux & TEST_TYPE_MASK;
5684 
5685         switch (test_type) {
5686         case CLASSIC:
5687                 bpf_prog_destroy(fp);
5688                 break;
5689         case INTERNAL:
5690                 bpf_prog_free(fp);
5691                 break;
5692         }
5693 }
5694 
5695 static int __run_one(const struct bpf_prog *fp, const void *data,
5696                      int runs, u64 *duration)
5697 {
5698         u64 start, finish;
5699         int ret = 0, i;
5700 
5701         start = ktime_get_ns();
5702 
5703         for (i = 0; i < runs; i++)
5704                 ret = BPF_PROG_RUN(fp, data);
5705 
5706         finish = ktime_get_ns();
5707 
5708         *duration = finish - start;
5709         do_div(*duration, runs);
5710 
5711         return ret;
5712 }
5713 
5714 static int run_one(const struct bpf_prog *fp, struct bpf_test *test)
5715 {
5716         int err_cnt = 0, i, runs = MAX_TESTRUNS;
5717 
5718         for (i = 0; i < MAX_SUBTESTS; i++) {
5719                 void *data;
5720                 u64 duration;
5721                 u32 ret;
5722 
5723                 if (test->test[i].data_size == 0 &&
5724                     test->test[i].result == 0)
5725                         break;
5726 
5727                 data = generate_test_data(test, i);
5728                 if (!data && !(test->aux & FLAG_NO_DATA)) {
5729                         pr_cont("data generation failed ");
5730                         err_cnt++;
5731                         break;
5732                 }
5733                 ret = __run_one(fp, data, runs, &duration);
5734                 release_test_data(test, data);
5735 
5736                 if (ret == test->test[i].result) {
5737                         pr_cont("%lld ", duration);
5738                 } else {
5739                         pr_cont("ret %d != %d ", ret,
5740                                 test->test[i].result);
5741                         err_cnt++;
5742                 }
5743         }
5744 
5745         return err_cnt;
5746 }
5747 
5748 static char test_name[64];
5749 module_param_string(test_name, test_name, sizeof(test_name), 0);
5750 
5751 static int test_id = -1;
5752 module_param(test_id, int, 0);
5753 
5754 static int test_range[2] = { 0, ARRAY_SIZE(tests) - 1 };
5755 module_param_array(test_range, int, NULL, 0);
5756 
5757 static __init int find_test_index(const char *test_name)
5758 {
5759         int i;
5760 
5761         for (i = 0; i < ARRAY_SIZE(tests); i++) {
5762                 if (!strcmp(tests[i].descr, test_name))
5763                         return i;
5764         }
5765         return -1;
5766 }
5767 
5768 static __init int prepare_bpf_tests(void)
5769 {
5770         int i;
5771 
5772         if (test_id >= 0) {
5773                 /*
5774                  * if a test_id was specified, use test_range to
5775                  * cover only that test.
5776                  */
5777                 if (test_id >= ARRAY_SIZE(tests)) {
5778                         pr_err("test_bpf: invalid test_id specified.\n");
5779                         return -EINVAL;
5780                 }
5781 
5782                 test_range[0] = test_id;
5783                 test_range[1] = test_id;
5784         } else if (*test_name) {
5785                 /*
5786                  * if a test_name was specified, find it and setup
5787                  * test_range to cover only that test.
5788                  */
5789                 int idx = find_test_index(test_name);
5790 
5791                 if (idx < 0) {
5792                         pr_err("test_bpf: no test named '%s' found.\n",
5793                                test_name);
5794                         return -EINVAL;
5795                 }
5796                 test_range[0] = idx;
5797                 test_range[1] = idx;
5798         } else {
5799                 /*
5800                  * check that the supplied test_range is valid.
5801                  */
5802                 if (test_range[0] >= ARRAY_SIZE(tests) ||
5803                     test_range[1] >= ARRAY_SIZE(tests) ||
5804                     test_range[0] < 0 || test_range[1] < 0) {
5805                         pr_err("test_bpf: test_range is out of bound.\n");
5806                         return -EINVAL;
5807                 }
5808 
5809                 if (test_range[1] < test_range[0]) {
5810                         pr_err("test_bpf: test_range is ending before it starts.\n");
5811                         return -EINVAL;
5812                 }
5813         }
5814 
5815         for (i = 0; i < ARRAY_SIZE(tests); i++) {
5816                 if (tests[i].fill_helper &&
5817                     tests[i].fill_helper(&tests[i]) < 0)
5818                         return -ENOMEM;
5819         }
5820 
5821         return 0;
5822 }
5823 
5824 static __init void destroy_bpf_tests(void)
5825 {
5826         int i;
5827 
5828         for (i = 0; i < ARRAY_SIZE(tests); i++) {
5829                 if (tests[i].fill_helper)
5830                         kfree(tests[i].u.ptr.insns);
5831         }
5832 }
5833 
5834 static bool exclude_test(int test_id)
5835 {
5836         return test_id < test_range[0] || test_id > test_range[1];
5837 }
5838 
5839 static __init int test_bpf(void)
5840 {
5841         int i, err_cnt = 0, pass_cnt = 0;
5842         int jit_cnt = 0, run_cnt = 0;
5843 
5844         for (i = 0; i < ARRAY_SIZE(tests); i++) {
5845                 struct bpf_prog *fp;
5846                 int err;
5847 
5848                 if (exclude_test(i))
5849                         continue;
5850 
5851                 pr_info("#%d %s ", i, tests[i].descr);
5852 
5853                 fp = generate_filter(i, &err);
5854                 if (fp == NULL) {
5855                         if (err == 0) {
5856                                 pass_cnt++;
5857                                 continue;
5858                         }
5859 
5860                         return err;
5861                 }
5862 
5863                 pr_cont("jited:%u ", fp->jited);
5864 
5865                 run_cnt++;
5866                 if (fp->jited)
5867                         jit_cnt++;
5868 
5869                 err = run_one(fp, &tests[i]);
5870                 release_filter(fp, i);
5871 
5872                 if (err) {
5873                         pr_cont("FAIL (%d times)\n", err);
5874                         err_cnt++;
5875                 } else {
5876                         pr_cont("PASS\n");
5877                         pass_cnt++;
5878                 }
5879         }
5880 
5881         pr_info("Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n",
5882                 pass_cnt, err_cnt, jit_cnt, run_cnt);
5883 
5884         return err_cnt ? -EINVAL : 0;
5885 }
5886 
5887 static int __init test_bpf_init(void)
5888 {
5889         int ret;
5890 
5891         ret = prepare_bpf_tests();
5892         if (ret < 0)
5893                 return ret;
5894 
5895         ret = test_bpf();
5896 
5897         destroy_bpf_tests();
5898         return ret;
5899 }
5900 
5901 static void __exit test_bpf_exit(void)
5902 {
5903 }
5904 
5905 module_init(test_bpf_init);
5906 module_exit(test_bpf_exit);
5907 
5908 MODULE_LICENSE("GPL");
5909 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp