lib/test_bpf.c

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