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