Back to home page

LXR

 
 

    


0001 /*
0002  * Testsuite for BPF interpreter and BPF JIT compiler
0003  *
0004  * Copyright (c) 2011-2014 PLUMgrid, http://plumgrid.com
0005  *
0006  * This program is free software; you can redistribute it and/or
0007  * modify it under the terms of version 2 of the GNU General Public
0008  * License as published by the Free Software Foundation.
0009  *
0010  * This program is distributed in the hope that it will be useful, but
0011  * WITHOUT ANY WARRANTY; without even the implied warranty of
0012  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
0013  * General Public License for more details.
0014  */
0015 
0016 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0017 
0018 #include <linux/init.h>
0019 #include <linux/module.h>
0020 #include <linux/filter.h>
0021 #include <linux/bpf.h>
0022 #include <linux/skbuff.h>
0023 #include <linux/netdevice.h>
0024 #include <linux/if_vlan.h>
0025 #include <linux/random.h>
0026 #include <linux/highmem.h>
0027 
0028 /* General test specific settings */
0029 #define MAX_SUBTESTS    3
0030 #define MAX_TESTRUNS    10000
0031 #define MAX_DATA    128
0032 #define MAX_INSNS   512
0033 #define MAX_K       0xffffFFFF
0034 
0035 /* Few constants used to init test 'skb' */
0036 #define SKB_TYPE    3
0037 #define SKB_MARK    0x1234aaaa
0038 #define SKB_HASH    0x1234aaab
0039 #define SKB_QUEUE_MAP   123
0040 #define SKB_VLAN_TCI    0xffff
0041 #define SKB_DEV_IFINDEX 577
0042 #define SKB_DEV_TYPE    588
0043 
0044 /* Redefine REGs to make tests less verbose */
0045 #define R0      BPF_REG_0
0046 #define R1      BPF_REG_1
0047 #define R2      BPF_REG_2
0048 #define R3      BPF_REG_3
0049 #define R4      BPF_REG_4
0050 #define R5      BPF_REG_5
0051 #define R6      BPF_REG_6
0052 #define R7      BPF_REG_7
0053 #define R8      BPF_REG_8
0054 #define R9      BPF_REG_9
0055 #define R10     BPF_REG_10
0056 
0057 /* Flags that can be passed to test cases */
0058 #define FLAG_NO_DATA        BIT(0)
0059 #define FLAG_EXPECTED_FAIL  BIT(1)
0060 #define FLAG_SKB_FRAG       BIT(2)
0061 
0062 enum {
0063     CLASSIC  = BIT(6),  /* Old BPF instructions only. */
0064     INTERNAL = BIT(7),  /* Extended instruction set.  */
0065 };
0066 
0067 #define TEST_TYPE_MASK      (CLASSIC | INTERNAL)
0068 
0069 struct bpf_test {
0070     const char *descr;
0071     union {
0072         struct sock_filter insns[MAX_INSNS];
0073         struct bpf_insn insns_int[MAX_INSNS];
0074         struct {
0075             void *insns;
0076             unsigned int len;
0077         } ptr;
0078     } u;
0079     __u8 aux;
0080     __u8 data[MAX_DATA];
0081     struct {
0082         int data_size;
0083         __u32 result;
0084     } test[MAX_SUBTESTS];
0085     int (*fill_helper)(struct bpf_test *self);
0086     __u8 frag_data[MAX_DATA];
0087 };
0088 
0089 /* Large test cases need separate allocation and fill handler. */
0090 
0091 static int bpf_fill_maxinsns1(struct bpf_test *self)
0092 {
0093     unsigned int len = BPF_MAXINSNS;
0094     struct sock_filter *insn;
0095     __u32 k = ~0;
0096     int i;
0097 
0098     insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
0099     if (!insn)
0100         return -ENOMEM;
0101 
0102     for (i = 0; i < len; i++, k--)
0103         insn[i] = __BPF_STMT(BPF_RET | BPF_K, k);
0104 
0105     self->u.ptr.insns = insn;
0106     self->u.ptr.len = len;
0107 
0108     return 0;
0109 }
0110 
0111 static int bpf_fill_maxinsns2(struct bpf_test *self)
0112 {
0113     unsigned int len = BPF_MAXINSNS;
0114     struct sock_filter *insn;
0115     int i;
0116 
0117     insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
0118     if (!insn)
0119         return -ENOMEM;
0120 
0121     for (i = 0; i < len; i++)
0122         insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
0123 
0124     self->u.ptr.insns = insn;
0125     self->u.ptr.len = len;
0126 
0127     return 0;
0128 }
0129 
0130 static int bpf_fill_maxinsns3(struct bpf_test *self)
0131 {
0132     unsigned int len = BPF_MAXINSNS;
0133     struct sock_filter *insn;
0134     struct rnd_state rnd;
0135     int i;
0136 
0137     insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
0138     if (!insn)
0139         return -ENOMEM;
0140 
0141     prandom_seed_state(&rnd, 3141592653589793238ULL);
0142 
0143     for (i = 0; i < len - 1; i++) {
0144         __u32 k = prandom_u32_state(&rnd);
0145 
0146         insn[i] = __BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, k);
0147     }
0148 
0149     insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
0150 
0151     self->u.ptr.insns = insn;
0152     self->u.ptr.len = len;
0153 
0154     return 0;
0155 }
0156 
0157 static int bpf_fill_maxinsns4(struct bpf_test *self)
0158 {
0159     unsigned int len = BPF_MAXINSNS + 1;
0160     struct sock_filter *insn;
0161     int i;
0162 
0163     insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
0164     if (!insn)
0165         return -ENOMEM;
0166 
0167     for (i = 0; i < len; i++)
0168         insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
0169 
0170     self->u.ptr.insns = insn;
0171     self->u.ptr.len = len;
0172 
0173     return 0;
0174 }
0175 
0176 static int bpf_fill_maxinsns5(struct bpf_test *self)
0177 {
0178     unsigned int len = BPF_MAXINSNS;
0179     struct sock_filter *insn;
0180     int i;
0181 
0182     insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
0183     if (!insn)
0184         return -ENOMEM;
0185 
0186     insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0);
0187 
0188     for (i = 1; i < len - 1; i++)
0189         insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
0190 
0191     insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab);
0192 
0193     self->u.ptr.insns = insn;
0194     self->u.ptr.len = len;
0195 
0196     return 0;
0197 }
0198 
0199 static int bpf_fill_maxinsns6(struct bpf_test *self)
0200 {
0201     unsigned int len = BPF_MAXINSNS;
0202     struct sock_filter *insn;
0203     int i;
0204 
0205     insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
0206     if (!insn)
0207         return -ENOMEM;
0208 
0209     for (i = 0; i < len - 1; i++)
0210         insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
0211                      SKF_AD_VLAN_TAG_PRESENT);
0212 
0213     insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
0214 
0215     self->u.ptr.insns = insn;
0216     self->u.ptr.len = len;
0217 
0218     return 0;
0219 }
0220 
0221 static int bpf_fill_maxinsns7(struct bpf_test *self)
0222 {
0223     unsigned int len = BPF_MAXINSNS;
0224     struct sock_filter *insn;
0225     int i;
0226 
0227     insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
0228     if (!insn)
0229         return -ENOMEM;
0230 
0231     for (i = 0; i < len - 4; i++)
0232         insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
0233                      SKF_AD_CPU);
0234 
0235     insn[len - 4] = __BPF_STMT(BPF_MISC | BPF_TAX, 0);
0236     insn[len - 3] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
0237                    SKF_AD_CPU);
0238     insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0);
0239     insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
0240 
0241     self->u.ptr.insns = insn;
0242     self->u.ptr.len = len;
0243 
0244     return 0;
0245 }
0246 
0247 static int bpf_fill_maxinsns8(struct bpf_test *self)
0248 {
0249     unsigned int len = BPF_MAXINSNS;
0250     struct sock_filter *insn;
0251     int i, jmp_off = len - 3;
0252 
0253     insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
0254     if (!insn)
0255         return -ENOMEM;
0256 
0257     insn[0] = __BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff);
0258 
0259     for (i = 1; i < len - 1; i++)
0260         insn[i] = __BPF_JUMP(BPF_JMP | BPF_JGT, 0xffffffff, jmp_off--, 0);
0261 
0262     insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
0263 
0264     self->u.ptr.insns = insn;
0265     self->u.ptr.len = len;
0266 
0267     return 0;
0268 }
0269 
0270 static int bpf_fill_maxinsns9(struct bpf_test *self)
0271 {
0272     unsigned int len = BPF_MAXINSNS;
0273     struct bpf_insn *insn;
0274     int i;
0275 
0276     insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
0277     if (!insn)
0278         return -ENOMEM;
0279 
0280     insn[0] = BPF_JMP_IMM(BPF_JA, 0, 0, len - 2);
0281     insn[1] = BPF_ALU32_IMM(BPF_MOV, R0, 0xcbababab);
0282     insn[2] = BPF_EXIT_INSN();
0283 
0284     for (i = 3; i < len - 2; i++)
0285         insn[i] = BPF_ALU32_IMM(BPF_MOV, R0, 0xfefefefe);
0286 
0287     insn[len - 2] = BPF_EXIT_INSN();
0288     insn[len - 1] = BPF_JMP_IMM(BPF_JA, 0, 0, -(len - 1));
0289 
0290     self->u.ptr.insns = insn;
0291     self->u.ptr.len = len;
0292 
0293     return 0;
0294 }
0295 
0296 static int bpf_fill_maxinsns10(struct bpf_test *self)
0297 {
0298     unsigned int len = BPF_MAXINSNS, hlen = len - 2;
0299     struct bpf_insn *insn;
0300     int i;
0301 
0302     insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
0303     if (!insn)
0304         return -ENOMEM;
0305 
0306     for (i = 0; i < hlen / 2; i++)
0307         insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 2 - 2 * i);
0308     for (i = hlen - 1; i > hlen / 2; i--)
0309         insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 1 - 2 * i);
0310 
0311     insn[hlen / 2] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen / 2 - 1);
0312     insn[hlen]     = BPF_ALU32_IMM(BPF_MOV, R0, 0xabababac);
0313     insn[hlen + 1] = BPF_EXIT_INSN();
0314 
0315     self->u.ptr.insns = insn;
0316     self->u.ptr.len = len;
0317 
0318     return 0;
0319 }
0320 
0321 static int __bpf_fill_ja(struct bpf_test *self, unsigned int len,
0322              unsigned int plen)
0323 {
0324     struct sock_filter *insn;
0325     unsigned int rlen;
0326     int i, j;
0327 
0328     insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
0329     if (!insn)
0330         return -ENOMEM;
0331 
0332     rlen = (len % plen) - 1;
0333 
0334     for (i = 0; i + plen < len; i += plen)
0335         for (j = 0; j < plen; j++)
0336             insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA,
0337                          plen - 1 - j, 0, 0);
0338     for (j = 0; j < rlen; j++)
0339         insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA, rlen - 1 - j,
0340                      0, 0);
0341 
0342     insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xababcbac);
0343 
0344     self->u.ptr.insns = insn;
0345     self->u.ptr.len = len;
0346 
0347     return 0;
0348 }
0349 
0350 static int bpf_fill_maxinsns11(struct bpf_test *self)
0351 {
0352     /* Hits 70 passes on x86_64, so cannot get JITed there. */
0353     return __bpf_fill_ja(self, BPF_MAXINSNS, 68);
0354 }
0355 
0356 static int bpf_fill_ja(struct bpf_test *self)
0357 {
0358     /* Hits exactly 11 passes on x86_64 JIT. */
0359     return __bpf_fill_ja(self, 12, 9);
0360 }
0361 
0362 static int bpf_fill_ld_abs_get_processor_id(struct bpf_test *self)
0363 {
0364     unsigned int len = BPF_MAXINSNS;
0365     struct sock_filter *insn;
0366     int i;
0367 
0368     insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
0369     if (!insn)
0370         return -ENOMEM;
0371 
0372     for (i = 0; i < len - 1; i += 2) {
0373         insn[i] = __BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 0);
0374         insn[i + 1] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
0375                      SKF_AD_OFF + SKF_AD_CPU);
0376     }
0377 
0378     insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xbee);
0379 
0380     self->u.ptr.insns = insn;
0381     self->u.ptr.len = len;
0382 
0383     return 0;
0384 }
0385 
0386 #define PUSH_CNT 68
0387 /* test: {skb->data[0], vlan_push} x 68 + {skb->data[0], vlan_pop} x 68 */
0388 static int bpf_fill_ld_abs_vlan_push_pop(struct bpf_test *self)
0389 {
0390     unsigned int len = BPF_MAXINSNS;
0391     struct bpf_insn *insn;
0392     int i = 0, j, k = 0;
0393 
0394     insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
0395     if (!insn)
0396         return -ENOMEM;
0397 
0398     insn[i++] = BPF_MOV64_REG(R6, R1);
0399 loop:
0400     for (j = 0; j < PUSH_CNT; j++) {
0401         insn[i++] = BPF_LD_ABS(BPF_B, 0);
0402         insn[i] = BPF_JMP_IMM(BPF_JNE, R0, 0x34, len - i - 2);
0403         i++;
0404         insn[i++] = BPF_MOV64_REG(R1, R6);
0405         insn[i++] = BPF_MOV64_IMM(R2, 1);
0406         insn[i++] = BPF_MOV64_IMM(R3, 2);
0407         insn[i++] = BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
0408                      bpf_skb_vlan_push_proto.func - __bpf_call_base);
0409         insn[i] = BPF_JMP_IMM(BPF_JNE, R0, 0, len - i - 2);
0410         i++;
0411     }
0412 
0413     for (j = 0; j < PUSH_CNT; j++) {
0414         insn[i++] = BPF_LD_ABS(BPF_B, 0);
0415         insn[i] = BPF_JMP_IMM(BPF_JNE, R0, 0x34, len - i - 2);
0416         i++;
0417         insn[i++] = BPF_MOV64_REG(R1, R6);
0418         insn[i++] = BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
0419                      bpf_skb_vlan_pop_proto.func - __bpf_call_base);
0420         insn[i] = BPF_JMP_IMM(BPF_JNE, R0, 0, len - i - 2);
0421         i++;
0422     }
0423     if (++k < 5)
0424         goto loop;
0425 
0426     for (; i < len - 1; i++)
0427         insn[i] = BPF_ALU32_IMM(BPF_MOV, R0, 0xbef);
0428 
0429     insn[len - 1] = BPF_EXIT_INSN();
0430 
0431     self->u.ptr.insns = insn;
0432     self->u.ptr.len = len;
0433 
0434     return 0;
0435 }
0436 
0437 static struct bpf_test tests[] = {
0438     {
0439         "TAX",
0440         .u.insns = {
0441             BPF_STMT(BPF_LD | BPF_IMM, 1),
0442             BPF_STMT(BPF_MISC | BPF_TAX, 0),
0443             BPF_STMT(BPF_LD | BPF_IMM, 2),
0444             BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
0445             BPF_STMT(BPF_ALU | BPF_NEG, 0), /* A == -3 */
0446             BPF_STMT(BPF_MISC | BPF_TAX, 0),
0447             BPF_STMT(BPF_LD | BPF_LEN, 0),
0448             BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
0449             BPF_STMT(BPF_MISC | BPF_TAX, 0), /* X == len - 3 */
0450             BPF_STMT(BPF_LD | BPF_B | BPF_IND, 1),
0451             BPF_STMT(BPF_RET | BPF_A, 0)
0452         },
0453         CLASSIC,
0454         { 10, 20, 30, 40, 50 },
0455         { { 2, 10 }, { 3, 20 }, { 4, 30 } },
0456     },
0457     {
0458         "TXA",
0459         .u.insns = {
0460             BPF_STMT(BPF_LDX | BPF_LEN, 0),
0461             BPF_STMT(BPF_MISC | BPF_TXA, 0),
0462             BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
0463             BPF_STMT(BPF_RET | BPF_A, 0) /* A == len * 2 */
0464         },
0465         CLASSIC,
0466         { 10, 20, 30, 40, 50 },
0467         { { 1, 2 }, { 3, 6 }, { 4, 8 } },
0468     },
0469     {
0470         "ADD_SUB_MUL_K",
0471         .u.insns = {
0472             BPF_STMT(BPF_LD | BPF_IMM, 1),
0473             BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 2),
0474             BPF_STMT(BPF_LDX | BPF_IMM, 3),
0475             BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
0476             BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0xffffffff),
0477             BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 3),
0478             BPF_STMT(BPF_RET | BPF_A, 0)
0479         },
0480         CLASSIC | FLAG_NO_DATA,
0481         { },
0482         { { 0, 0xfffffffd } }
0483     },
0484     {
0485         "DIV_MOD_KX",
0486         .u.insns = {
0487             BPF_STMT(BPF_LD | BPF_IMM, 8),
0488             BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 2),
0489             BPF_STMT(BPF_MISC | BPF_TAX, 0),
0490             BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
0491             BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
0492             BPF_STMT(BPF_MISC | BPF_TAX, 0),
0493             BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
0494             BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x70000000),
0495             BPF_STMT(BPF_MISC | BPF_TAX, 0),
0496             BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
0497             BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
0498             BPF_STMT(BPF_MISC | BPF_TAX, 0),
0499             BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
0500             BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x70000000),
0501             BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
0502             BPF_STMT(BPF_RET | BPF_A, 0)
0503         },
0504         CLASSIC | FLAG_NO_DATA,
0505         { },
0506         { { 0, 0x20000000 } }
0507     },
0508     {
0509         "AND_OR_LSH_K",
0510         .u.insns = {
0511             BPF_STMT(BPF_LD | BPF_IMM, 0xff),
0512             BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
0513             BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 27),
0514             BPF_STMT(BPF_MISC | BPF_TAX, 0),
0515             BPF_STMT(BPF_LD | BPF_IMM, 0xf),
0516             BPF_STMT(BPF_ALU | BPF_OR | BPF_K, 0xf0),
0517             BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
0518             BPF_STMT(BPF_RET | BPF_A, 0)
0519         },
0520         CLASSIC | FLAG_NO_DATA,
0521         { },
0522         { { 0, 0x800000ff }, { 1, 0x800000ff } },
0523     },
0524     {
0525         "LD_IMM_0",
0526         .u.insns = {
0527             BPF_STMT(BPF_LD | BPF_IMM, 0), /* ld #0 */
0528             BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0, 1, 0),
0529             BPF_STMT(BPF_RET | BPF_K, 0),
0530             BPF_STMT(BPF_RET | BPF_K, 1),
0531         },
0532         CLASSIC,
0533         { },
0534         { { 1, 1 } },
0535     },
0536     {
0537         "LD_IND",
0538         .u.insns = {
0539             BPF_STMT(BPF_LDX | BPF_LEN, 0),
0540             BPF_STMT(BPF_LD | BPF_H | BPF_IND, MAX_K),
0541             BPF_STMT(BPF_RET | BPF_K, 1)
0542         },
0543         CLASSIC,
0544         { },
0545         { { 1, 0 }, { 10, 0 }, { 60, 0 } },
0546     },
0547     {
0548         "LD_ABS",
0549         .u.insns = {
0550             BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1000),
0551             BPF_STMT(BPF_RET | BPF_K, 1)
0552         },
0553         CLASSIC,
0554         { },
0555         { { 1, 0 }, { 10, 0 }, { 60, 0 } },
0556     },
0557     {
0558         "LD_ABS_LL",
0559         .u.insns = {
0560             BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF),
0561             BPF_STMT(BPF_MISC | BPF_TAX, 0),
0562             BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF + 1),
0563             BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
0564             BPF_STMT(BPF_RET | BPF_A, 0)
0565         },
0566         CLASSIC,
0567         { 1, 2, 3 },
0568         { { 1, 0 }, { 2, 3 } },
0569     },
0570     {
0571         "LD_IND_LL",
0572         .u.insns = {
0573             BPF_STMT(BPF_LD | BPF_IMM, SKF_LL_OFF - 1),
0574             BPF_STMT(BPF_LDX | BPF_LEN, 0),
0575             BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
0576             BPF_STMT(BPF_MISC | BPF_TAX, 0),
0577             BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
0578             BPF_STMT(BPF_RET | BPF_A, 0)
0579         },
0580         CLASSIC,
0581         { 1, 2, 3, 0xff },
0582         { { 1, 1 }, { 3, 3 }, { 4, 0xff } },
0583     },
0584     {
0585         "LD_ABS_NET",
0586         .u.insns = {
0587             BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF),
0588             BPF_STMT(BPF_MISC | BPF_TAX, 0),
0589             BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF + 1),
0590             BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
0591             BPF_STMT(BPF_RET | BPF_A, 0)
0592         },
0593         CLASSIC,
0594         { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
0595         { { 15, 0 }, { 16, 3 } },
0596     },
0597     {
0598         "LD_IND_NET",
0599         .u.insns = {
0600             BPF_STMT(BPF_LD | BPF_IMM, SKF_NET_OFF - 15),
0601             BPF_STMT(BPF_LDX | BPF_LEN, 0),
0602             BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
0603             BPF_STMT(BPF_MISC | BPF_TAX, 0),
0604             BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
0605             BPF_STMT(BPF_RET | BPF_A, 0)
0606         },
0607         CLASSIC,
0608         { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
0609         { { 14, 0 }, { 15, 1 }, { 17, 3 } },
0610     },
0611     {
0612         "LD_PKTTYPE",
0613         .u.insns = {
0614             BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
0615                  SKF_AD_OFF + SKF_AD_PKTTYPE),
0616             BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
0617             BPF_STMT(BPF_RET | BPF_K, 1),
0618             BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
0619                  SKF_AD_OFF + SKF_AD_PKTTYPE),
0620             BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
0621             BPF_STMT(BPF_RET | BPF_K, 1),
0622             BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
0623                  SKF_AD_OFF + SKF_AD_PKTTYPE),
0624             BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
0625             BPF_STMT(BPF_RET | BPF_K, 1),
0626             BPF_STMT(BPF_RET | BPF_A, 0)
0627         },
0628         CLASSIC,
0629         { },
0630         { { 1, 3 }, { 10, 3 } },
0631     },
0632     {
0633         "LD_MARK",
0634         .u.insns = {
0635             BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
0636                  SKF_AD_OFF + SKF_AD_MARK),
0637             BPF_STMT(BPF_RET | BPF_A, 0)
0638         },
0639         CLASSIC,
0640         { },
0641         { { 1, SKB_MARK}, { 10, SKB_MARK} },
0642     },
0643     {
0644         "LD_RXHASH",
0645         .u.insns = {
0646             BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
0647                  SKF_AD_OFF + SKF_AD_RXHASH),
0648             BPF_STMT(BPF_RET | BPF_A, 0)
0649         },
0650         CLASSIC,
0651         { },
0652         { { 1, SKB_HASH}, { 10, SKB_HASH} },
0653     },
0654     {
0655         "LD_QUEUE",
0656         .u.insns = {
0657             BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
0658                  SKF_AD_OFF + SKF_AD_QUEUE),
0659             BPF_STMT(BPF_RET | BPF_A, 0)
0660         },
0661         CLASSIC,
0662         { },
0663         { { 1, SKB_QUEUE_MAP }, { 10, SKB_QUEUE_MAP } },
0664     },
0665     {
0666         "LD_PROTOCOL",
0667         .u.insns = {
0668             BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 1),
0669             BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 20, 1, 0),
0670             BPF_STMT(BPF_RET | BPF_K, 0),
0671             BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
0672                  SKF_AD_OFF + SKF_AD_PROTOCOL),
0673             BPF_STMT(BPF_MISC | BPF_TAX, 0),
0674             BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
0675             BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 30, 1, 0),
0676             BPF_STMT(BPF_RET | BPF_K, 0),
0677             BPF_STMT(BPF_MISC | BPF_TXA, 0),
0678             BPF_STMT(BPF_RET | BPF_A, 0)
0679         },
0680         CLASSIC,
0681         { 10, 20, 30 },
0682         { { 10, ETH_P_IP }, { 100, ETH_P_IP } },
0683     },
0684     {
0685         "LD_VLAN_TAG",
0686         .u.insns = {
0687             BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
0688                  SKF_AD_OFF + SKF_AD_VLAN_TAG),
0689             BPF_STMT(BPF_RET | BPF_A, 0)
0690         },
0691         CLASSIC,
0692         { },
0693         {
0694             { 1, SKB_VLAN_TCI & ~VLAN_TAG_PRESENT },
0695             { 10, SKB_VLAN_TCI & ~VLAN_TAG_PRESENT }
0696         },
0697     },
0698     {
0699         "LD_VLAN_TAG_PRESENT",
0700         .u.insns = {
0701             BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
0702                  SKF_AD_OFF + SKF_AD_VLAN_TAG_PRESENT),
0703             BPF_STMT(BPF_RET | BPF_A, 0)
0704         },
0705         CLASSIC,
0706         { },
0707         {
0708             { 1, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) },
0709             { 10, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) }
0710         },
0711     },
0712     {
0713         "LD_IFINDEX",
0714         .u.insns = {
0715             BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
0716                  SKF_AD_OFF + SKF_AD_IFINDEX),
0717             BPF_STMT(BPF_RET | BPF_A, 0)
0718         },
0719         CLASSIC,
0720         { },
0721         { { 1, SKB_DEV_IFINDEX }, { 10, SKB_DEV_IFINDEX } },
0722     },
0723     {
0724         "LD_HATYPE",
0725         .u.insns = {
0726             BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
0727                  SKF_AD_OFF + SKF_AD_HATYPE),
0728             BPF_STMT(BPF_RET | BPF_A, 0)
0729         },
0730         CLASSIC,
0731         { },
0732         { { 1, SKB_DEV_TYPE }, { 10, SKB_DEV_TYPE } },
0733     },
0734     {
0735         "LD_CPU",
0736         .u.insns = {
0737             BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
0738                  SKF_AD_OFF + SKF_AD_CPU),
0739             BPF_STMT(BPF_MISC | BPF_TAX, 0),
0740             BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
0741                  SKF_AD_OFF + SKF_AD_CPU),
0742             BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
0743             BPF_STMT(BPF_RET | BPF_A, 0)
0744         },
0745         CLASSIC,
0746         { },
0747         { { 1, 0 }, { 10, 0 } },
0748     },
0749     {
0750         "LD_NLATTR",
0751         .u.insns = {
0752             BPF_STMT(BPF_LDX | BPF_IMM, 2),
0753             BPF_STMT(BPF_MISC | BPF_TXA, 0),
0754             BPF_STMT(BPF_LDX | BPF_IMM, 3),
0755             BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
0756                  SKF_AD_OFF + SKF_AD_NLATTR),
0757             BPF_STMT(BPF_RET | BPF_A, 0)
0758         },
0759         CLASSIC,
0760 #ifdef __BIG_ENDIAN
0761         { 0xff, 0xff, 0, 4, 0, 2, 0, 4, 0, 3 },
0762 #else
0763         { 0xff, 0xff, 4, 0, 2, 0, 4, 0, 3, 0 },
0764 #endif
0765         { { 4, 0 }, { 20, 6 } },
0766     },
0767     {
0768         "LD_NLATTR_NEST",
0769         .u.insns = {
0770             BPF_STMT(BPF_LD | BPF_IMM, 2),
0771             BPF_STMT(BPF_LDX | BPF_IMM, 3),
0772             BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
0773                  SKF_AD_OFF + SKF_AD_NLATTR_NEST),
0774             BPF_STMT(BPF_LD | BPF_IMM, 2),
0775             BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
0776                  SKF_AD_OFF + SKF_AD_NLATTR_NEST),
0777             BPF_STMT(BPF_LD | BPF_IMM, 2),
0778             BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
0779                  SKF_AD_OFF + SKF_AD_NLATTR_NEST),
0780             BPF_STMT(BPF_LD | BPF_IMM, 2),
0781             BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
0782                  SKF_AD_OFF + SKF_AD_NLATTR_NEST),
0783             BPF_STMT(BPF_LD | BPF_IMM, 2),
0784             BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
0785                  SKF_AD_OFF + SKF_AD_NLATTR_NEST),
0786             BPF_STMT(BPF_LD | BPF_IMM, 2),
0787             BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
0788                  SKF_AD_OFF + SKF_AD_NLATTR_NEST),
0789             BPF_STMT(BPF_LD | BPF_IMM, 2),
0790             BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
0791                  SKF_AD_OFF + SKF_AD_NLATTR_NEST),
0792             BPF_STMT(BPF_LD | BPF_IMM, 2),
0793             BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
0794                  SKF_AD_OFF + SKF_AD_NLATTR_NEST),
0795             BPF_STMT(BPF_RET | BPF_A, 0)
0796         },
0797         CLASSIC,
0798 #ifdef __BIG_ENDIAN
0799         { 0xff, 0xff, 0, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3 },
0800 #else
0801         { 0xff, 0xff, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3, 0 },
0802 #endif
0803         { { 4, 0 }, { 20, 10 } },
0804     },
0805     {
0806         "LD_PAYLOAD_OFF",
0807         .u.insns = {
0808             BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
0809                  SKF_AD_OFF + SKF_AD_PAY_OFFSET),
0810             BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
0811                  SKF_AD_OFF + SKF_AD_PAY_OFFSET),
0812             BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
0813                  SKF_AD_OFF + SKF_AD_PAY_OFFSET),
0814             BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
0815                  SKF_AD_OFF + SKF_AD_PAY_OFFSET),
0816             BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
0817                  SKF_AD_OFF + SKF_AD_PAY_OFFSET),
0818             BPF_STMT(BPF_RET | BPF_A, 0)
0819         },
0820         CLASSIC,
0821         /* 00:00:00:00:00:00 > 00:00:00:00:00:00, ethtype IPv4 (0x0800),
0822          * length 98: 127.0.0.1 > 127.0.0.1: ICMP echo request,
0823          * id 9737, seq 1, length 64
0824          */
0825         { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0826           0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0827           0x08, 0x00,
0828           0x45, 0x00, 0x00, 0x54, 0xac, 0x8b, 0x40, 0x00, 0x40,
0829           0x01, 0x90, 0x1b, 0x7f, 0x00, 0x00, 0x01 },
0830         { { 30, 0 }, { 100, 42 } },
0831     },
0832     {
0833         "LD_ANC_XOR",
0834         .u.insns = {
0835             BPF_STMT(BPF_LD | BPF_IMM, 10),
0836             BPF_STMT(BPF_LDX | BPF_IMM, 300),
0837             BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
0838                  SKF_AD_OFF + SKF_AD_ALU_XOR_X),
0839             BPF_STMT(BPF_RET | BPF_A, 0)
0840         },
0841         CLASSIC,
0842         { },
0843         { { 4, 10 ^ 300 }, { 20, 10 ^ 300 } },
0844     },
0845     {
0846         "SPILL_FILL",
0847         .u.insns = {
0848             BPF_STMT(BPF_LDX | BPF_LEN, 0),
0849             BPF_STMT(BPF_LD | BPF_IMM, 2),
0850             BPF_STMT(BPF_ALU | BPF_RSH, 1),
0851             BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
0852             BPF_STMT(BPF_ST, 1), /* M1 = 1 ^ len */
0853             BPF_STMT(BPF_ALU | BPF_XOR | BPF_K, 0x80000000),
0854             BPF_STMT(BPF_ST, 2), /* M2 = 1 ^ len ^ 0x80000000 */
0855             BPF_STMT(BPF_STX, 15), /* M3 = len */
0856             BPF_STMT(BPF_LDX | BPF_MEM, 1),
0857             BPF_STMT(BPF_LD | BPF_MEM, 2),
0858             BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
0859             BPF_STMT(BPF_LDX | BPF_MEM, 15),
0860             BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
0861             BPF_STMT(BPF_RET | BPF_A, 0)
0862         },
0863         CLASSIC,
0864         { },
0865         { { 1, 0x80000001 }, { 2, 0x80000002 }, { 60, 0x80000000 ^ 60 } }
0866     },
0867     {
0868         "JEQ",
0869         .u.insns = {
0870             BPF_STMT(BPF_LDX | BPF_LEN, 0),
0871             BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
0872             BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 0, 1),
0873             BPF_STMT(BPF_RET | BPF_K, 1),
0874             BPF_STMT(BPF_RET | BPF_K, MAX_K)
0875         },
0876         CLASSIC,
0877         { 3, 3, 3, 3, 3 },
0878         { { 1, 0 }, { 3, 1 }, { 4, MAX_K } },
0879     },
0880     {
0881         "JGT",
0882         .u.insns = {
0883             BPF_STMT(BPF_LDX | BPF_LEN, 0),
0884             BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
0885             BPF_JUMP(BPF_JMP | BPF_JGT | BPF_X, 0, 0, 1),
0886             BPF_STMT(BPF_RET | BPF_K, 1),
0887             BPF_STMT(BPF_RET | BPF_K, MAX_K)
0888         },
0889         CLASSIC,
0890         { 4, 4, 4, 3, 3 },
0891         { { 2, 0 }, { 3, 1 }, { 4, MAX_K } },
0892     },
0893     {
0894         "JGE",
0895         .u.insns = {
0896             BPF_STMT(BPF_LDX | BPF_LEN, 0),
0897             BPF_STMT(BPF_LD | BPF_B | BPF_IND, MAX_K),
0898             BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 1, 1, 0),
0899             BPF_STMT(BPF_RET | BPF_K, 10),
0900             BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 2, 1, 0),
0901             BPF_STMT(BPF_RET | BPF_K, 20),
0902             BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 3, 1, 0),
0903             BPF_STMT(BPF_RET | BPF_K, 30),
0904             BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 4, 1, 0),
0905             BPF_STMT(BPF_RET | BPF_K, 40),
0906             BPF_STMT(BPF_RET | BPF_K, MAX_K)
0907         },
0908         CLASSIC,
0909         { 1, 2, 3, 4, 5 },
0910         { { 1, 20 }, { 3, 40 }, { 5, MAX_K } },
0911     },
0912     {
0913         "JSET",
0914         .u.insns = {
0915             BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
0916             BPF_JUMP(BPF_JMP | BPF_JA, 1, 1, 1),
0917             BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
0918             BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
0919             BPF_STMT(BPF_LDX | BPF_LEN, 0),
0920             BPF_STMT(BPF_MISC | BPF_TXA, 0),
0921             BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, 4),
0922             BPF_STMT(BPF_MISC | BPF_TAX, 0),
0923             BPF_STMT(BPF_LD | BPF_W | BPF_IND, 0),
0924             BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 1, 0, 1),
0925             BPF_STMT(BPF_RET | BPF_K, 10),
0926             BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x80000000, 0, 1),
0927             BPF_STMT(BPF_RET | BPF_K, 20),
0928             BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
0929             BPF_STMT(BPF_RET | BPF_K, 30),
0930             BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
0931             BPF_STMT(BPF_RET | BPF_K, 30),
0932             BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
0933             BPF_STMT(BPF_RET | BPF_K, 30),
0934             BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
0935             BPF_STMT(BPF_RET | BPF_K, 30),
0936             BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
0937             BPF_STMT(BPF_RET | BPF_K, 30),
0938             BPF_STMT(BPF_RET | BPF_K, MAX_K)
0939         },
0940         CLASSIC,
0941         { 0, 0xAA, 0x55, 1 },
0942         { { 4, 10 }, { 5, 20 }, { 6, MAX_K } },
0943     },
0944     {
0945         "tcpdump port 22",
0946         .u.insns = {
0947             BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
0948             BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 0, 8), /* IPv6 */
0949             BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 20),
0950             BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
0951             BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
0952             BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 17),
0953             BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 54),
0954             BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 14, 0),
0955             BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 56),
0956             BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 12, 13),
0957             BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0800, 0, 12), /* IPv4 */
0958             BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
0959             BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
0960             BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
0961             BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 8),
0962             BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
0963             BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 6, 0),
0964             BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
0965             BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
0966             BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
0967             BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
0968             BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 1),
0969             BPF_STMT(BPF_RET | BPF_K, 0xffff),
0970             BPF_STMT(BPF_RET | BPF_K, 0),
0971         },
0972         CLASSIC,
0973         /* 3c:07:54:43:e5:76 > 10:bf:48:d6:43:d6, ethertype IPv4(0x0800)
0974          * length 114: 10.1.1.149.49700 > 10.1.2.10.22: Flags [P.],
0975          * seq 1305692979:1305693027, ack 3650467037, win 65535,
0976          * options [nop,nop,TS val 2502645400 ecr 3971138], length 48
0977          */
0978         { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
0979           0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
0980           0x08, 0x00,
0981           0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
0982           0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
0983           0x0a, 0x01, 0x01, 0x95, /* ip src */
0984           0x0a, 0x01, 0x02, 0x0a, /* ip dst */
0985           0xc2, 0x24,
0986           0x00, 0x16 /* dst port */ },
0987         { { 10, 0 }, { 30, 0 }, { 100, 65535 } },
0988     },
0989     {
0990         "tcpdump complex",
0991         .u.insns = {
0992             /* tcpdump -nei eth0 'tcp port 22 and (((ip[2:2] -
0993              * ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0) and
0994              * (len > 115 or len < 30000000000)' -d
0995              */
0996             BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
0997             BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 30, 0),
0998             BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x800, 0, 29),
0999             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");