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