lib/test_bpf.c

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