lib/test_bpf.c

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