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