lib/test_bpf.c

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