Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/lib/test_bpf.c

  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         /* BPF_JMP | BPF_JNE | BPF_X */
4660         {
4661                 "JMP_JNE_X: if (3 != 2) return 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_JNE, R1, R2, 1),
4667                         BPF_EXIT_INSN(),
4668                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4669                         BPF_EXIT_INSN(),
4670                 },
4671                 INTERNAL,
4672                 { },
4673                 { { 0, 1 } },
4674         },
4675         /* BPF_JMP | BPF_JEQ | BPF_X */
4676         {
4677                 "JMP_JEQ_X: if (3 == 3) return 1",
4678                 .u.insns_int = {
4679                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
4680                         BPF_LD_IMM64(R1, 3),
4681                         BPF_LD_IMM64(R2, 3),
4682                         BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
4683                         BPF_EXIT_INSN(),
4684                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4685                         BPF_EXIT_INSN(),
4686                 },
4687                 INTERNAL,
4688                 { },
4689                 { { 0, 1 } },
4690         },
4691         /* BPF_JMP | BPF_JSET | BPF_X */
4692         {
4693                 "JMP_JSET_X: if (0x3 & 0x2) return 1",
4694                 .u.insns_int = {
4695                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
4696                         BPF_LD_IMM64(R1, 3),
4697                         BPF_LD_IMM64(R2, 2),
4698                         BPF_JMP_REG(BPF_JSET, R1, R2, 1),
4699                         BPF_EXIT_INSN(),
4700                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4701                         BPF_EXIT_INSN(),
4702                 },
4703                 INTERNAL,
4704                 { },
4705                 { { 0, 1 } },
4706         },
4707         {
4708                 "JMP_JSET_X: if (0x3 & 0xffffffff) return 1",
4709                 .u.insns_int = {
4710                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
4711                         BPF_LD_IMM64(R1, 3),
4712                         BPF_LD_IMM64(R2, 0xffffffff),
4713                         BPF_JMP_REG(BPF_JSET, R1, R2, 1),
4714                         BPF_EXIT_INSN(),
4715                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4716                         BPF_EXIT_INSN(),
4717                 },
4718                 INTERNAL,
4719                 { },
4720                 { { 0, 1 } },
4721         },
4722         {
4723                 "JMP_JA: Jump, gap, jump, ...",
4724                 { },
4725                 CLASSIC | FLAG_NO_DATA,
4726                 { },
4727                 { { 0, 0xababcbac } },
4728                 .fill_helper = bpf_fill_ja,
4729         },
4730         {       /* Mainly checking JIT here. */
4731                 "BPF_MAXINSNS: Maximum possible literals",
4732                 { },
4733                 CLASSIC | FLAG_NO_DATA,
4734                 { },
4735                 { { 0, 0xffffffff } },
4736                 .fill_helper = bpf_fill_maxinsns1,
4737         },
4738         {       /* Mainly checking JIT here. */
4739                 "BPF_MAXINSNS: Single literal",
4740                 { },
4741                 CLASSIC | FLAG_NO_DATA,
4742                 { },
4743                 { { 0, 0xfefefefe } },
4744                 .fill_helper = bpf_fill_maxinsns2,
4745         },
4746         {       /* Mainly checking JIT here. */
4747                 "BPF_MAXINSNS: Run/add until end",
4748                 { },
4749                 CLASSIC | FLAG_NO_DATA,
4750                 { },
4751                 { { 0, 0x947bf368 } },
4752                 .fill_helper = bpf_fill_maxinsns3,
4753         },
4754         {
4755                 "BPF_MAXINSNS: Too many instructions",
4756                 { },
4757                 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4758                 { },
4759                 { },
4760                 .fill_helper = bpf_fill_maxinsns4,
4761         },
4762         {       /* Mainly checking JIT here. */
4763                 "BPF_MAXINSNS: Very long jump",
4764                 { },
4765                 CLASSIC | FLAG_NO_DATA,
4766                 { },
4767                 { { 0, 0xabababab } },
4768                 .fill_helper = bpf_fill_maxinsns5,
4769         },
4770         {       /* Mainly checking JIT here. */
4771                 "BPF_MAXINSNS: Ctx heavy transformations",
4772                 { },
4773                 CLASSIC,
4774                 { },
4775                 {
4776                         {  1, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) },
4777                         { 10, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) }
4778                 },
4779                 .fill_helper = bpf_fill_maxinsns6,
4780         },
4781         {       /* Mainly checking JIT here. */
4782                 "BPF_MAXINSNS: Call heavy transformations",
4783                 { },
4784                 CLASSIC | FLAG_NO_DATA,
4785                 { },
4786                 { { 1, 0 }, { 10, 0 } },
4787                 .fill_helper = bpf_fill_maxinsns7,
4788         },
4789         {       /* Mainly checking JIT here. */
4790                 "BPF_MAXINSNS: Jump heavy test",
4791                 { },
4792                 CLASSIC | FLAG_NO_DATA,
4793                 { },
4794                 { { 0, 0xffffffff } },
4795                 .fill_helper = bpf_fill_maxinsns8,
4796         },
4797         {       /* Mainly checking JIT here. */
4798                 "BPF_MAXINSNS: Very long jump backwards",
4799                 { },
4800                 INTERNAL | FLAG_NO_DATA,
4801                 { },
4802                 { { 0, 0xcbababab } },
4803                 .fill_helper = bpf_fill_maxinsns9,
4804         },
4805         {       /* Mainly checking JIT here. */
4806                 "BPF_MAXINSNS: Edge hopping nuthouse",
4807                 { },
4808                 INTERNAL | FLAG_NO_DATA,
4809                 { },
4810                 { { 0, 0xabababac } },
4811                 .fill_helper = bpf_fill_maxinsns10,
4812         },
4813         {
4814                 "BPF_MAXINSNS: Jump, gap, jump, ...",
4815                 { },
4816                 CLASSIC | FLAG_NO_DATA,
4817                 { },
4818                 { { 0, 0xababcbac } },
4819                 .fill_helper = bpf_fill_maxinsns11,
4820         },
4821         {
4822                 "BPF_MAXINSNS: ld_abs+get_processor_id",
4823                 { },
4824                 CLASSIC,
4825                 { },
4826                 { { 1, 0xbee } },
4827                 .fill_helper = bpf_fill_ld_abs_get_processor_id,
4828         },
4829         {
4830                 "BPF_MAXINSNS: ld_abs+vlan_push/pop",
4831                 { },
4832                 INTERNAL,
4833                 { 0x34 },
4834                 { { ETH_HLEN, 0xbef } },
4835                 .fill_helper = bpf_fill_ld_abs_vlan_push_pop,
4836         },
4837         /*
4838          * LD_IND / LD_ABS on fragmented SKBs
4839          */
4840         {
4841                 "LD_IND byte frag",
4842                 .u.insns = {
4843                         BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
4844                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x0),
4845                         BPF_STMT(BPF_RET | BPF_A, 0x0),
4846                 },
4847                 CLASSIC | FLAG_SKB_FRAG,
4848                 { },
4849                 { {0x40, 0x42} },
4850                 .frag_data = {
4851                         0x42, 0x00, 0x00, 0x00,
4852                         0x43, 0x44, 0x00, 0x00,
4853                         0x21, 0x07, 0x19, 0x83,
4854                 },
4855         },
4856         {
4857                 "LD_IND halfword frag",
4858                 .u.insns = {
4859                         BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
4860                         BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x4),
4861                         BPF_STMT(BPF_RET | BPF_A, 0x0),
4862                 },
4863                 CLASSIC | FLAG_SKB_FRAG,
4864                 { },
4865                 { {0x40, 0x4344} },
4866                 .frag_data = {
4867                         0x42, 0x00, 0x00, 0x00,
4868                         0x43, 0x44, 0x00, 0x00,
4869                         0x21, 0x07, 0x19, 0x83,
4870                 },
4871         },
4872         {
4873                 "LD_IND word frag",
4874                 .u.insns = {
4875                         BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
4876                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x8),
4877                         BPF_STMT(BPF_RET | BPF_A, 0x0),
4878                 },
4879                 CLASSIC | FLAG_SKB_FRAG,
4880                 { },
4881                 { {0x40, 0x21071983} },
4882                 .frag_data = {
4883                         0x42, 0x00, 0x00, 0x00,
4884                         0x43, 0x44, 0x00, 0x00,
4885                         0x21, 0x07, 0x19, 0x83,
4886                 },
4887         },
4888         {
4889                 "LD_IND halfword mixed head/frag",
4890                 .u.insns = {
4891                         BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
4892                         BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
4893                         BPF_STMT(BPF_RET | BPF_A, 0x0),
4894                 },
4895                 CLASSIC | FLAG_SKB_FRAG,
4896                 { [0x3e] = 0x25, [0x3f] = 0x05, },
4897                 { {0x40, 0x0519} },
4898                 .frag_data = { 0x19, 0x82 },
4899         },
4900         {
4901                 "LD_IND word mixed head/frag",
4902                 .u.insns = {
4903                         BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
4904                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
4905                         BPF_STMT(BPF_RET | BPF_A, 0x0),
4906                 },
4907                 CLASSIC | FLAG_SKB_FRAG,
4908                 { [0x3e] = 0x25, [0x3f] = 0x05, },
4909                 { {0x40, 0x25051982} },
4910                 .frag_data = { 0x19, 0x82 },
4911         },
4912         {
4913                 "LD_ABS byte frag",
4914                 .u.insns = {
4915                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x40),
4916                         BPF_STMT(BPF_RET | BPF_A, 0x0),
4917                 },
4918                 CLASSIC | FLAG_SKB_FRAG,
4919                 { },
4920                 { {0x40, 0x42} },
4921                 .frag_data = {
4922                         0x42, 0x00, 0x00, 0x00,
4923                         0x43, 0x44, 0x00, 0x00,
4924                         0x21, 0x07, 0x19, 0x83,
4925                 },
4926         },
4927         {
4928                 "LD_ABS halfword frag",
4929                 .u.insns = {
4930                         BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x44),
4931                         BPF_STMT(BPF_RET | BPF_A, 0x0),
4932                 },
4933                 CLASSIC | FLAG_SKB_FRAG,
4934                 { },
4935                 { {0x40, 0x4344} },
4936                 .frag_data = {
4937                         0x42, 0x00, 0x00, 0x00,
4938                         0x43, 0x44, 0x00, 0x00,
4939                         0x21, 0x07, 0x19, 0x83,
4940                 },
4941         },
4942         {
4943                 "LD_ABS word frag",
4944                 .u.insns = {
4945                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x48),
4946                         BPF_STMT(BPF_RET | BPF_A, 0x0),
4947                 },
4948                 CLASSIC | FLAG_SKB_FRAG,
4949                 { },
4950                 { {0x40, 0x21071983} },
4951                 .frag_data = {
4952                         0x42, 0x00, 0x00, 0x00,
4953                         0x43, 0x44, 0x00, 0x00,
4954                         0x21, 0x07, 0x19, 0x83,
4955                 },
4956         },
4957         {
4958                 "LD_ABS halfword mixed head/frag",
4959                 .u.insns = {
4960                         BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f),
4961                         BPF_STMT(BPF_RET | BPF_A, 0x0),
4962                 },
4963                 CLASSIC | FLAG_SKB_FRAG,
4964                 { [0x3e] = 0x25, [0x3f] = 0x05, },
4965                 { {0x40, 0x0519} },
4966                 .frag_data = { 0x19, 0x82 },
4967         },
4968         {
4969                 "LD_ABS word mixed head/frag",
4970                 .u.insns = {
4971                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3e),
4972                         BPF_STMT(BPF_RET | BPF_A, 0x0),
4973                 },
4974                 CLASSIC | FLAG_SKB_FRAG,
4975                 { [0x3e] = 0x25, [0x3f] = 0x05, },
4976                 { {0x40, 0x25051982} },
4977                 .frag_data = { 0x19, 0x82 },
4978         },
4979         /*
4980          * LD_IND / LD_ABS on non fragmented SKBs
4981          */
4982         {
4983                 /*
4984                  * this tests that the JIT/interpreter correctly resets X
4985                  * before using it in an LD_IND instruction.
4986                  */
4987                 "LD_IND byte default X",
4988                 .u.insns = {
4989                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
4990                         BPF_STMT(BPF_RET | BPF_A, 0x0),
4991                 },
4992                 CLASSIC,
4993                 { [0x1] = 0x42 },
4994                 { {0x40, 0x42 } },
4995         },
4996         {
4997                 "LD_IND byte positive offset",
4998                 .u.insns = {
4999                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
5000                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
5001                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5002                 },
5003                 CLASSIC,
5004                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
5005                 { {0x40, 0x82 } },
5006         },
5007         {
5008                 "LD_IND byte negative offset",
5009                 .u.insns = {
5010                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
5011                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x1),
5012                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5013                 },
5014                 CLASSIC,
5015                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
5016                 { {0x40, 0x05 } },
5017         },
5018         {
5019                 "LD_IND halfword positive offset",
5020                 .u.insns = {
5021                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
5022                         BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x2),
5023                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5024                 },
5025                 CLASSIC,
5026                 {
5027                         [0x1c] = 0xaa, [0x1d] = 0x55,
5028                         [0x1e] = 0xbb, [0x1f] = 0x66,
5029                         [0x20] = 0xcc, [0x21] = 0x77,
5030                         [0x22] = 0xdd, [0x23] = 0x88,
5031                 },
5032                 { {0x40, 0xdd88 } },
5033         },
5034         {
5035                 "LD_IND halfword negative offset",
5036                 .u.insns = {
5037                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
5038                         BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x2),
5039                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5040                 },
5041                 CLASSIC,
5042                 {
5043                         [0x1c] = 0xaa, [0x1d] = 0x55,
5044                         [0x1e] = 0xbb, [0x1f] = 0x66,
5045                         [0x20] = 0xcc, [0x21] = 0x77,
5046                         [0x22] = 0xdd, [0x23] = 0x88,
5047                 },
5048                 { {0x40, 0xbb66 } },
5049         },
5050         {
5051                 "LD_IND halfword unaligned",
5052                 .u.insns = {
5053                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
5054                         BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
5055                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5056                 },
5057                 CLASSIC,
5058                 {
5059                         [0x1c] = 0xaa, [0x1d] = 0x55,
5060                         [0x1e] = 0xbb, [0x1f] = 0x66,
5061                         [0x20] = 0xcc, [0x21] = 0x77,
5062                         [0x22] = 0xdd, [0x23] = 0x88,
5063                 },
5064                 { {0x40, 0x66cc } },
5065         },
5066         {
5067                 "LD_IND word positive offset",
5068                 .u.insns = {
5069                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
5070                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x4),
5071                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5072                 },
5073                 CLASSIC,
5074                 {
5075                         [0x1c] = 0xaa, [0x1d] = 0x55,
5076                         [0x1e] = 0xbb, [0x1f] = 0x66,
5077                         [0x20] = 0xcc, [0x21] = 0x77,
5078                         [0x22] = 0xdd, [0x23] = 0x88,
5079                         [0x24] = 0xee, [0x25] = 0x99,
5080                         [0x26] = 0xff, [0x27] = 0xaa,
5081                 },
5082                 { {0x40, 0xee99ffaa } },
5083         },
5084         {
5085                 "LD_IND word negative offset",
5086                 .u.insns = {
5087                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
5088                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x4),
5089                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5090                 },
5091                 CLASSIC,
5092                 {
5093                         [0x1c] = 0xaa, [0x1d] = 0x55,
5094                         [0x1e] = 0xbb, [0x1f] = 0x66,
5095                         [0x20] = 0xcc, [0x21] = 0x77,
5096                         [0x22] = 0xdd, [0x23] = 0x88,
5097                         [0x24] = 0xee, [0x25] = 0x99,
5098                         [0x26] = 0xff, [0x27] = 0xaa,
5099                 },
5100                 { {0x40, 0xaa55bb66 } },
5101         },
5102         {
5103                 "LD_IND word unaligned (addr & 3 == 2)",
5104                 .u.insns = {
5105                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
5106                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
5107                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5108                 },
5109                 CLASSIC,
5110                 {
5111                         [0x1c] = 0xaa, [0x1d] = 0x55,
5112                         [0x1e] = 0xbb, [0x1f] = 0x66,
5113                         [0x20] = 0xcc, [0x21] = 0x77,
5114                         [0x22] = 0xdd, [0x23] = 0x88,
5115                         [0x24] = 0xee, [0x25] = 0x99,
5116                         [0x26] = 0xff, [0x27] = 0xaa,
5117                 },
5118                 { {0x40, 0xbb66cc77 } },
5119         },
5120         {
5121                 "LD_IND word unaligned (addr & 3 == 1)",
5122                 .u.insns = {
5123                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
5124                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3),
5125                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5126                 },
5127                 CLASSIC,
5128                 {
5129                         [0x1c] = 0xaa, [0x1d] = 0x55,
5130                         [0x1e] = 0xbb, [0x1f] = 0x66,
5131                         [0x20] = 0xcc, [0x21] = 0x77,
5132                         [0x22] = 0xdd, [0x23] = 0x88,
5133                         [0x24] = 0xee, [0x25] = 0x99,
5134                         [0x26] = 0xff, [0x27] = 0xaa,
5135                 },
5136                 { {0x40, 0x55bb66cc } },
5137         },
5138         {
5139                 "LD_IND word unaligned (addr & 3 == 3)",
5140                 .u.insns = {
5141                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
5142                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x1),
5143                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5144                 },
5145                 CLASSIC,
5146                 {
5147                         [0x1c] = 0xaa, [0x1d] = 0x55,
5148                         [0x1e] = 0xbb, [0x1f] = 0x66,
5149                         [0x20] = 0xcc, [0x21] = 0x77,
5150                         [0x22] = 0xdd, [0x23] = 0x88,
5151                         [0x24] = 0xee, [0x25] = 0x99,
5152                         [0x26] = 0xff, [0x27] = 0xaa,
5153                 },
5154                 { {0x40, 0x66cc77dd } },
5155         },
5156         {
5157                 "LD_ABS byte",
5158                 .u.insns = {
5159                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x20),
5160                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5161                 },
5162                 CLASSIC,
5163                 {
5164                         [0x1c] = 0xaa, [0x1d] = 0x55,
5165                         [0x1e] = 0xbb, [0x1f] = 0x66,
5166                         [0x20] = 0xcc, [0x21] = 0x77,
5167                         [0x22] = 0xdd, [0x23] = 0x88,
5168                         [0x24] = 0xee, [0x25] = 0x99,
5169                         [0x26] = 0xff, [0x27] = 0xaa,
5170                 },
5171                 { {0x40, 0xcc } },
5172         },
5173         {
5174                 "LD_ABS halfword",
5175                 .u.insns = {
5176                         BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x22),
5177                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5178                 },
5179                 CLASSIC,
5180                 {
5181                         [0x1c] = 0xaa, [0x1d] = 0x55,
5182                         [0x1e] = 0xbb, [0x1f] = 0x66,
5183                         [0x20] = 0xcc, [0x21] = 0x77,
5184                         [0x22] = 0xdd, [0x23] = 0x88,
5185                         [0x24] = 0xee, [0x25] = 0x99,
5186                         [0x26] = 0xff, [0x27] = 0xaa,
5187                 },
5188                 { {0x40, 0xdd88 } },
5189         },
5190         {
5191                 "LD_ABS halfword unaligned",
5192                 .u.insns = {
5193                         BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x25),
5194                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5195                 },
5196                 CLASSIC,
5197                 {
5198                         [0x1c] = 0xaa, [0x1d] = 0x55,
5199                         [0x1e] = 0xbb, [0x1f] = 0x66,
5200                         [0x20] = 0xcc, [0x21] = 0x77,
5201                         [0x22] = 0xdd, [0x23] = 0x88,
5202                         [0x24] = 0xee, [0x25] = 0x99,
5203                         [0x26] = 0xff, [0x27] = 0xaa,
5204                 },
5205                 { {0x40, 0x99ff } },
5206         },
5207         {
5208                 "LD_ABS word",
5209                 .u.insns = {
5210                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x1c),
5211                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5212                 },
5213                 CLASSIC,
5214                 {
5215                         [0x1c] = 0xaa, [0x1d] = 0x55,
5216                         [0x1e] = 0xbb, [0x1f] = 0x66,
5217                         [0x20] = 0xcc, [0x21] = 0x77,
5218                         [0x22] = 0xdd, [0x23] = 0x88,
5219                         [0x24] = 0xee, [0x25] = 0x99,
5220                         [0x26] = 0xff, [0x27] = 0xaa,
5221                 },
5222                 { {0x40, 0xaa55bb66 } },
5223         },
5224         {
5225                 "LD_ABS word unaligned (addr & 3 == 2)",
5226                 .u.insns = {
5227                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x22),
5228                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5229                 },
5230                 CLASSIC,
5231                 {
5232                         [0x1c] = 0xaa, [0x1d] = 0x55,
5233                         [0x1e] = 0xbb, [0x1f] = 0x66,
5234                         [0x20] = 0xcc, [0x21] = 0x77,
5235                         [0x22] = 0xdd, [0x23] = 0x88,
5236                         [0x24] = 0xee, [0x25] = 0x99,
5237                         [0x26] = 0xff, [0x27] = 0xaa,
5238                 },
5239                 { {0x40, 0xdd88ee99 } },
5240         },
5241         {
5242                 "LD_ABS word unaligned (addr & 3 == 1)",
5243                 .u.insns = {
5244                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x21),
5245                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5246                 },
5247                 CLASSIC,
5248                 {
5249                         [0x1c] = 0xaa, [0x1d] = 0x55,
5250                         [0x1e] = 0xbb, [0x1f] = 0x66,
5251                         [0x20] = 0xcc, [0x21] = 0x77,
5252                         [0x22] = 0xdd, [0x23] = 0x88,
5253                         [0x24] = 0xee, [0x25] = 0x99,
5254                         [0x26] = 0xff, [0x27] = 0xaa,
5255                 },
5256                 { {0x40, 0x77dd88ee } },
5257         },
5258         {
5259                 "LD_ABS word unaligned (addr & 3 == 3)",
5260                 .u.insns = {
5261                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x23),
5262                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5263                 },
5264                 CLASSIC,
5265                 {
5266                         [0x1c] = 0xaa, [0x1d] = 0x55,
5267                         [0x1e] = 0xbb, [0x1f] = 0x66,
5268                         [0x20] = 0xcc, [0x21] = 0x77,
5269                         [0x22] = 0xdd, [0x23] = 0x88,
5270                         [0x24] = 0xee, [0x25] = 0x99,
5271                         [0x26] = 0xff, [0x27] = 0xaa,
5272                 },
5273                 { {0x40, 0x88ee99ff } },
5274         },
5275         /*
5276          * verify that the interpreter or JIT correctly sets A and X
5277          * to 0.
5278          */
5279         {
5280                 "ADD default X",
5281                 .u.insns = {
5282                         /*
5283                          * A = 0x42
5284                          * A = A + X
5285                          * ret A
5286                          */
5287                         BPF_STMT(BPF_LD | BPF_IMM, 0x42),
5288                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
5289                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5290                 },
5291                 CLASSIC | FLAG_NO_DATA,
5292                 {},
5293                 { {0x1, 0x42 } },
5294         },
5295         {
5296                 "ADD default A",
5297                 .u.insns = {
5298                         /*
5299                          * A = A + 0x42
5300                          * ret A
5301                          */
5302                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0x42),
5303                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5304                 },
5305                 CLASSIC | FLAG_NO_DATA,
5306                 {},
5307                 { {0x1, 0x42 } },
5308         },
5309         {
5310                 "SUB default X",
5311                 .u.insns = {
5312                         /*
5313                          * A = 0x66
5314                          * A = A - X
5315                          * ret A
5316                          */
5317                         BPF_STMT(BPF_LD | BPF_IMM, 0x66),
5318                         BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
5319                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5320                 },
5321                 CLASSIC | FLAG_NO_DATA,
5322                 {},
5323                 { {0x1, 0x66 } },
5324         },
5325         {
5326                 "SUB default A",
5327                 .u.insns = {
5328                         /*
5329                          * A = A - -0x66
5330                          * ret A
5331                          */
5332                         BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, -0x66),
5333                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5334                 },
5335                 CLASSIC | FLAG_NO_DATA,
5336                 {},
5337                 { {0x1, 0x66 } },
5338         },
5339         {
5340                 "MUL default X",
5341                 .u.insns = {
5342                         /*
5343                          * A = 0x42
5344                          * A = A * X
5345                          * ret A
5346                          */
5347                         BPF_STMT(BPF_LD | BPF_IMM, 0x42),
5348                         BPF_STMT(BPF_ALU | BPF_MUL | BPF_X, 0),
5349                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5350                 },
5351                 CLASSIC | FLAG_NO_DATA,
5352                 {},
5353                 { {0x1, 0x0 } },
5354         },
5355         {
5356                 "MUL default A",
5357                 .u.insns = {
5358                         /*
5359                          * A = A * 0x66
5360                          * ret A
5361                          */
5362                         BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 0x66),
5363                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5364                 },
5365                 CLASSIC | FLAG_NO_DATA,
5366                 {},
5367                 { {0x1, 0x0 } },
5368         },
5369         {
5370                 "DIV default X",
5371                 .u.insns = {
5372                         /*
5373                          * A = 0x42
5374                          * A = A / X ; this halt the filter execution if X is 0
5375                          * ret 0x42
5376                          */
5377                         BPF_STMT(BPF_LD | BPF_IMM, 0x42),
5378                         BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
5379                         BPF_STMT(BPF_RET | BPF_K, 0x42),
5380                 },
5381                 CLASSIC | FLAG_NO_DATA,
5382                 {},
5383                 { {0x1, 0x0 } },
5384         },
5385         {
5386                 "DIV default A",
5387                 .u.insns = {
5388                         /*
5389                          * A = A / 1
5390                          * ret A
5391                          */
5392                         BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x1),
5393                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5394                 },
5395                 CLASSIC | FLAG_NO_DATA,
5396                 {},
5397                 { {0x1, 0x0 } },
5398         },
5399         {
5400                 "MOD default X",
5401                 .u.insns = {
5402                         /*
5403                          * A = 0x42
5404                          * A = A mod X ; this halt the filter execution if X is 0
5405                          * ret 0x42
5406                          */
5407                         BPF_STMT(BPF_LD | BPF_IMM, 0x42),
5408                         BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
5409                         BPF_STMT(BPF_RET | BPF_K, 0x42),
5410                 },
5411                 CLASSIC | FLAG_NO_DATA,
5412                 {},
5413                 { {0x1, 0x0 } },
5414         },
5415         {
5416                 "MOD default A",
5417                 .u.insns = {
5418                         /*
5419                          * A = A mod 1
5420                          * ret A
5421                          */
5422                         BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x1),
5423                         BPF_STMT(BPF_RET | BPF_A, 0x0),
5424                 },
5425                 CLASSIC | FLAG_NO_DATA,
5426                 {},
5427                 { {0x1, 0x0 } },
5428         },
5429         {
5430                 "JMP EQ default A",
5431                 .u.insns = {
5432                         /*
5433                          * cmp A, 0x0, 0, 1
5434                          * ret 0x42
5435                          * ret 0x66
5436                          */
5437                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0, 0, 1),
5438                         BPF_STMT(BPF_RET | BPF_K, 0x42),
5439                         BPF_STMT(BPF_RET | BPF_K, 0x66),
5440                 },
5441                 CLASSIC | FLAG_NO_DATA,
5442                 {},
5443                 { {0x1, 0x42 } },
5444         },
5445         {
5446                 "JMP EQ default X",
5447                 .u.insns = {
5448                         /*
5449                          * A = 0x0
5450                          * cmp A, X, 0, 1
5451                          * ret 0x42
5452                          * ret 0x66
5453                          */
5454                         BPF_STMT(BPF_LD | BPF_IMM, 0x0),
5455                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0x0, 0, 1),
5456                         BPF_STMT(BPF_RET | BPF_K, 0x42),
5457                         BPF_STMT(BPF_RET | BPF_K, 0x66),
5458                 },
5459                 CLASSIC | FLAG_NO_DATA,
5460                 {},
5461                 { {0x1, 0x42 } },
5462         },
5463 };
5464 
5465 static struct net_device dev;
5466 
5467 static struct sk_buff *populate_skb(char *buf, int size)
5468 {
5469         struct sk_buff *skb;
5470 
5471         if (size >= MAX_DATA)
5472                 return NULL;
5473 
5474         skb = alloc_skb(MAX_DATA, GFP_KERNEL);
5475         if (!skb)
5476                 return NULL;
5477 
5478         memcpy(__skb_put(skb, size), buf, size);
5479 
5480         /* Initialize a fake skb with test pattern. */
5481         skb_reset_mac_header(skb);
5482         skb->protocol = htons(ETH_P_IP);
5483         skb->pkt_type = SKB_TYPE;
5484         skb->mark = SKB_MARK;
5485         skb->hash = SKB_HASH;
5486         skb->queue_mapping = SKB_QUEUE_MAP;
5487         skb->vlan_tci = SKB_VLAN_TCI;
5488         skb->vlan_proto = htons(ETH_P_IP);
5489         skb->dev = &dev;
5490         skb->dev->ifindex = SKB_DEV_IFINDEX;
5491         skb->dev->type = SKB_DEV_TYPE;
5492         skb_set_network_header(skb, min(size, ETH_HLEN));
5493 
5494         return skb;
5495 }
5496 
5497 static void *generate_test_data(struct bpf_test *test, int sub)
5498 {
5499         struct sk_buff *skb;
5500         struct page *page;
5501 
5502         if (test->aux & FLAG_NO_DATA)
5503                 return NULL;
5504 
5505         /* Test case expects an skb, so populate one. Various
5506          * subtests generate skbs of different sizes based on
5507          * the same data.
5508          */
5509         skb = populate_skb(test->data, test->test[sub].data_size);
5510         if (!skb)
5511                 return NULL;
5512 
5513         if (test->aux & FLAG_SKB_FRAG) {
5514                 /*
5515                  * when the test requires a fragmented skb, add a
5516                  * single fragment to the skb, filled with
5517                  * test->frag_data.
5518                  */
5519                 void *ptr;
5520 
5521                 page = alloc_page(GFP_KERNEL);
5522 
5523                 if (!page)
5524                         goto err_kfree_skb;
5525 
5526                 ptr = kmap(page);
5527                 if (!ptr)
5528                         goto err_free_page;
5529                 memcpy(ptr, test->frag_data, MAX_DATA);
5530                 kunmap(page);
5531                 skb_add_rx_frag(skb, 0, page, 0, MAX_DATA, MAX_DATA);
5532         }
5533 
5534         return skb;
5535 
5536 err_free_page:
5537         __free_page(page);
5538 err_kfree_skb:
5539         kfree_skb(skb);
5540         return NULL;
5541 }
5542 
5543 static void release_test_data(const struct bpf_test *test, void *data)
5544 {
5545         if (test->aux & FLAG_NO_DATA)
5546                 return;
5547 
5548         kfree_skb(data);
5549 }
5550 
5551 static int filter_length(int which)
5552 {
5553         struct sock_filter *fp;
5554         int len;
5555 
5556         if (tests[which].fill_helper)
5557                 return tests[which].u.ptr.len;
5558 
5559         fp = tests[which].u.insns;
5560         for (len = MAX_INSNS - 1; len > 0; --len)
5561                 if (fp[len].code != 0 || fp[len].k != 0)
5562                         break;
5563 
5564         return len + 1;
5565 }
5566 
5567 static void *filter_pointer(int which)
5568 {
5569         if (tests[which].fill_helper)
5570                 return tests[which].u.ptr.insns;
5571         else
5572                 return tests[which].u.insns;
5573 }
5574 
5575 static struct bpf_prog *generate_filter(int which, int *err)
5576 {
5577         __u8 test_type = tests[which].aux & TEST_TYPE_MASK;
5578         unsigned int flen = filter_length(which);
5579         void *fptr = filter_pointer(which);
5580         struct sock_fprog_kern fprog;
5581         struct bpf_prog *fp;
5582 
5583         switch (test_type) {
5584         case CLASSIC:
5585                 fprog.filter = fptr;
5586                 fprog.len = flen;
5587 
5588                 *err = bpf_prog_create(&fp, &fprog);
5589                 if (tests[which].aux & FLAG_EXPECTED_FAIL) {
5590                         if (*err == -EINVAL) {
5591                                 pr_cont("PASS\n");
5592                                 /* Verifier rejected filter as expected. */
5593                                 *err = 0;
5594                                 return NULL;
5595                         } else {
5596                                 pr_cont("UNEXPECTED_PASS\n");
5597                                 /* Verifier didn't reject the test that's
5598                                  * bad enough, just return!
5599                                  */
5600                                 *err = -EINVAL;
5601                                 return NULL;
5602                         }
5603                 }
5604                 /* We don't expect to fail. */
5605                 if (*err) {
5606                         pr_cont("FAIL to attach err=%d len=%d\n",
5607                                 *err, fprog.len);
5608                         return NULL;
5609                 }
5610                 break;
5611 
5612         case INTERNAL:
5613                 fp = bpf_prog_alloc(bpf_prog_size(flen), 0);
5614                 if (fp == NULL) {
5615                         pr_cont("UNEXPECTED_FAIL no memory left\n");
5616                         *err = -ENOMEM;
5617                         return NULL;
5618                 }
5619 
5620                 fp->len = flen;
5621                 /* Type doesn't really matter here as long as it's not unspec. */
5622                 fp->type = BPF_PROG_TYPE_SOCKET_FILTER;
5623                 memcpy(fp->insnsi, fptr, fp->len * sizeof(struct bpf_insn));
5624 
5625                 /* We cannot error here as we don't need type compatibility
5626                  * checks.
5627                  */
5628                 fp = bpf_prog_select_runtime(fp, err);
5629                 break;
5630         }
5631 
5632         *err = 0;
5633         return fp;
5634 }
5635 
5636 static void release_filter(struct bpf_prog *fp, int which)
5637 {
5638         __u8 test_type = tests[which].aux & TEST_TYPE_MASK;
5639 
5640         switch (test_type) {
5641         case CLASSIC:
5642                 bpf_prog_destroy(fp);
5643                 break;
5644         case INTERNAL:
5645                 bpf_prog_free(fp);
5646                 break;
5647         }
5648 }
5649 
5650 static int __run_one(const struct bpf_prog *fp, const void *data,
5651                      int runs, u64 *duration)
5652 {
5653         u64 start, finish;
5654         int ret = 0, i;
5655 
5656         start = ktime_get_ns();
5657 
5658         for (i = 0; i < runs; i++)
5659                 ret = BPF_PROG_RUN(fp, data);
5660 
5661         finish = ktime_get_ns();
5662 
5663         *duration = finish - start;
5664         do_div(*duration, runs);
5665 
5666         return ret;
5667 }
5668 
5669 static int run_one(const struct bpf_prog *fp, struct bpf_test *test)
5670 {
5671         int err_cnt = 0, i, runs = MAX_TESTRUNS;
5672 
5673         for (i = 0; i < MAX_SUBTESTS; i++) {
5674                 void *data;
5675                 u64 duration;
5676                 u32 ret;
5677 
5678                 if (test->test[i].data_size == 0 &&
5679                     test->test[i].result == 0)
5680                         break;
5681 
5682                 data = generate_test_data(test, i);
5683                 if (!data && !(test->aux & FLAG_NO_DATA)) {
5684                         pr_cont("data generation failed ");
5685                         err_cnt++;
5686                         break;
5687                 }
5688                 ret = __run_one(fp, data, runs, &duration);
5689                 release_test_data(test, data);
5690 
5691                 if (ret == test->test[i].result) {
5692                         pr_cont("%lld ", duration);
5693                 } else {
5694                         pr_cont("ret %d != %d ", ret,
5695                                 test->test[i].result);
5696                         err_cnt++;
5697                 }
5698         }
5699 
5700         return err_cnt;
5701 }
5702 
5703 static char test_name[64];
5704 module_param_string(test_name, test_name, sizeof(test_name), 0);
5705 
5706 static int test_id = -1;
5707 module_param(test_id, int, 0);
5708 
5709 static int test_range[2] = { 0, ARRAY_SIZE(tests) - 1 };
5710 module_param_array(test_range, int, NULL, 0);
5711 
5712 static __init int find_test_index(const char *test_name)
5713 {
5714         int i;
5715 
5716         for (i = 0; i < ARRAY_SIZE(tests); i++) {
5717                 if (!strcmp(tests[i].descr, test_name))
5718                         return i;
5719         }
5720         return -1;
5721 }
5722 
5723 static __init int prepare_bpf_tests(void)
5724 {
5725         int i;
5726 
5727         if (test_id >= 0) {
5728                 /*
5729                  * if a test_id was specified, use test_range to
5730                  * cover only that test.
5731                  */
5732                 if (test_id >= ARRAY_SIZE(tests)) {
5733                         pr_err("test_bpf: invalid test_id specified.\n");
5734                         return -EINVAL;
5735                 }
5736 
5737                 test_range[0] = test_id;
5738                 test_range[1] = test_id;
5739         } else if (*test_name) {
5740                 /*
5741                  * if a test_name was specified, find it and setup
5742                  * test_range to cover only that test.
5743                  */
5744                 int idx = find_test_index(test_name);
5745 
5746                 if (idx < 0) {
5747                         pr_err("test_bpf: no test named '%s' found.\n",
5748                                test_name);
5749                         return -EINVAL;
5750                 }
5751                 test_range[0] = idx;
5752                 test_range[1] = idx;
5753         } else {
5754                 /*
5755                  * check that the supplied test_range is valid.
5756                  */
5757                 if (test_range[0] >= ARRAY_SIZE(tests) ||
5758                     test_range[1] >= ARRAY_SIZE(tests) ||
5759                     test_range[0] < 0 || test_range[1] < 0) {
5760                         pr_err("test_bpf: test_range is out of bound.\n");
5761                         return -EINVAL;
5762                 }
5763 
5764                 if (test_range[1] < test_range[0]) {
5765                         pr_err("test_bpf: test_range is ending before it starts.\n");
5766                         return -EINVAL;
5767                 }
5768         }
5769 
5770         for (i = 0; i < ARRAY_SIZE(tests); i++) {
5771                 if (tests[i].fill_helper &&
5772                     tests[i].fill_helper(&tests[i]) < 0)
5773                         return -ENOMEM;
5774         }
5775 
5776         return 0;
5777 }
5778 
5779 static __init void destroy_bpf_tests(void)
5780 {
5781         int i;
5782 
5783         for (i = 0; i < ARRAY_SIZE(tests); i++) {
5784                 if (tests[i].fill_helper)
5785                         kfree(tests[i].u.ptr.insns);
5786         }
5787 }
5788 
5789 static bool exclude_test(int test_id)
5790 {
5791         return test_id < test_range[0] || test_id > test_range[1];
5792 }
5793 
5794 static __init int test_bpf(void)
5795 {
5796         int i, err_cnt = 0, pass_cnt = 0;
5797         int jit_cnt = 0, run_cnt = 0;
5798 
5799         for (i = 0; i < ARRAY_SIZE(tests); i++) {
5800                 struct bpf_prog *fp;
5801                 int err;
5802 
5803                 if (exclude_test(i))
5804                         continue;
5805 
5806                 pr_info("#%d %s ", i, tests[i].descr);
5807 
5808                 fp = generate_filter(i, &err);
5809                 if (fp == NULL) {
5810                         if (err == 0) {
5811                                 pass_cnt++;
5812                                 continue;
5813                         }
5814 
5815                         return err;
5816                 }
5817 
5818                 pr_cont("jited:%u ", fp->jited);
5819 
5820                 run_cnt++;
5821                 if (fp->jited)
5822                         jit_cnt++;
5823 
5824                 err = run_one(fp, &tests[i]);
5825                 release_filter(fp, i);
5826 
5827                 if (err) {
5828                         pr_cont("FAIL (%d times)\n", err);
5829                         err_cnt++;
5830                 } else {
5831                         pr_cont("PASS\n");
5832                         pass_cnt++;
5833                 }
5834         }
5835 
5836         pr_info("Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n",
5837                 pass_cnt, err_cnt, jit_cnt, run_cnt);
5838 
5839         return err_cnt ? -EINVAL : 0;
5840 }
5841 
5842 static int __init test_bpf_init(void)
5843 {
5844         int ret;
5845 
5846         ret = prepare_bpf_tests();
5847         if (ret < 0)
5848                 return ret;
5849 
5850         ret = test_bpf();
5851 
5852         destroy_bpf_tests();
5853         return ret;
5854 }
5855 
5856 static void __exit test_bpf_exit(void)
5857 {
5858 }
5859 
5860 module_init(test_bpf_init);
5861 module_exit(test_bpf_exit);
5862 
5863 MODULE_LICENSE("GPL");
5864 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us