lib/test_bpf.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Testsuite for BPF interpreter and BPF JIT compiler
   4  *
   5  * Copyright (c) 2011-2014 PLUMgrid, http://plumgrid.com
   6  */
   7
   8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   9
  10 #include <linux/init.h>
  11 #include <linux/module.h>
  12 #include <linux/filter.h>
  13 #include <linux/bpf.h>
  14 #include <linux/skbuff.h>
  15 #include <linux/netdevice.h>
  16 #include <linux/if_vlan.h>
  17 #include <linux/random.h>
  18 #include <linux/highmem.h>
  19 #include <linux/sched.h>
  20
  21 /* General test specific settings */
  22 #define MAX_SUBTESTS    3
  23 #define MAX_TESTRUNS    1000
  24 #define MAX_DATA        128
  25 #define MAX_INSNS       512
  26 #define MAX_K           0xffffFFFF
  27
  28 /* Few constants used to init test 'skb' */
  29 #define SKB_TYPE        3
  30 #define SKB_MARK        0x1234aaaa
  31 #define SKB_HASH        0x1234aaab
  32 #define SKB_QUEUE_MAP   123
  33 #define SKB_VLAN_TCI    0xffff
  34 #define SKB_VLAN_PRESENT        1
  35 #define SKB_DEV_IFINDEX 577
  36 #define SKB_DEV_TYPE    588
  37
  38 /* Redefine REGs to make tests less verbose */
  39 #define R0              BPF_REG_0
  40 #define R1              BPF_REG_1
  41 #define R2              BPF_REG_2
  42 #define R3              BPF_REG_3
  43 #define R4              BPF_REG_4
  44 #define R5              BPF_REG_5
  45 #define R6              BPF_REG_6
  46 #define R7              BPF_REG_7
  47 #define R8              BPF_REG_8
  48 #define R9              BPF_REG_9
  49 #define R10             BPF_REG_10
  50
  51 /* Flags that can be passed to test cases */
  52 #define FLAG_NO_DATA            BIT(0)
  53 #define FLAG_EXPECTED_FAIL      BIT(1)
  54 #define FLAG_SKB_FRAG           BIT(2)
  55
  56 enum {
  57         CLASSIC  = BIT(6),      /* Old BPF instructions only. */
  58         INTERNAL = BIT(7),      /* Extended instruction set.  */
  59 };
  60
  61 #define TEST_TYPE_MASK          (CLASSIC | INTERNAL)
  62
  63 struct bpf_test {
  64         const char *descr;
  65         union {
  66                 struct sock_filter insns[MAX_INSNS];
  67                 struct bpf_insn insns_int[MAX_INSNS];
  68                 struct {
  69                         void *insns;
  70                         unsigned int len;
  71                 } ptr;
  72         } u;
  73         __u8 aux;
  74         __u8 data[MAX_DATA];
  75         struct {
  76                 int data_size;
  77                 __u32 result;
  78         } test[MAX_SUBTESTS];
  79         int (*fill_helper)(struct bpf_test *self);
  80         int expected_errcode; /* used when FLAG_EXPECTED_FAIL is set in the aux */
  81         __u8 frag_data[MAX_DATA];
  82         int stack_depth; /* for eBPF only, since tests don't call verifier */
  83 };
  84
  85 /* Large test cases need separate allocation and fill handler. */
  86
  87 static int bpf_fill_maxinsns1(struct bpf_test *self)
  88 {
  89         unsigned int len = BPF_MAXINSNS;
  90         struct sock_filter *insn;
  91         __u32 k = ~0;
  92         int i;
  93
  94         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
  95         if (!insn)
  96                 return -ENOMEM;
  97
  98         for (i = 0; i < len; i++, k--)
  99                 insn[i] = __BPF_STMT(BPF_RET | BPF_K, k);
 100
 101         self->u.ptr.insns = insn;
 102         self->u.ptr.len = len;
 103
 104         return 0;
 105 }
 106
 107 static int bpf_fill_maxinsns2(struct bpf_test *self)
 108 {
 109         unsigned int len = BPF_MAXINSNS;
 110         struct sock_filter *insn;
 111         int i;
 112
 113         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
 114         if (!insn)
 115                 return -ENOMEM;
 116
 117         for (i = 0; i < len; i++)
 118                 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
 119
 120         self->u.ptr.insns = insn;
 121         self->u.ptr.len = len;
 122
 123         return 0;
 124 }
 125
 126 static int bpf_fill_maxinsns3(struct bpf_test *self)
 127 {
 128         unsigned int len = BPF_MAXINSNS;
 129         struct sock_filter *insn;
 130         struct rnd_state rnd;
 131         int i;
 132
 133         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
 134         if (!insn)
 135                 return -ENOMEM;
 136
 137         prandom_seed_state(&rnd, 3141592653589793238ULL);
 138
 139         for (i = 0; i < len - 1; i++) {
 140                 __u32 k = prandom_u32_state(&rnd);
 141
 142                 insn[i] = __BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, k);
 143         }
 144
 145         insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
 146
 147         self->u.ptr.insns = insn;
 148         self->u.ptr.len = len;
 149
 150         return 0;
 151 }
 152
 153 static int bpf_fill_maxinsns4(struct bpf_test *self)
 154 {
 155         unsigned int len = BPF_MAXINSNS + 1;
 156         struct sock_filter *insn;
 157         int i;
 158
 159         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
 160         if (!insn)
 161                 return -ENOMEM;
 162
 163         for (i = 0; i < len; i++)
 164                 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
 165
 166         self->u.ptr.insns = insn;
 167         self->u.ptr.len = len;
 168
 169         return 0;
 170 }
 171
 172 static int bpf_fill_maxinsns5(struct bpf_test *self)
 173 {
 174         unsigned int len = BPF_MAXINSNS;
 175         struct sock_filter *insn;
 176         int i;
 177
 178         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
 179         if (!insn)
 180                 return -ENOMEM;
 181
 182         insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0);
 183
 184         for (i = 1; i < len - 1; i++)
 185                 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
 186
 187         insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab);
 188
 189         self->u.ptr.insns = insn;
 190         self->u.ptr.len = len;
 191
 192         return 0;
 193 }
 194
 195 static int bpf_fill_maxinsns6(struct bpf_test *self)
 196 {
 197         unsigned int len = BPF_MAXINSNS;
 198         struct sock_filter *insn;
 199         int i;
 200
 201         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
 202         if (!insn)
 203                 return -ENOMEM;
 204
 205         for (i = 0; i < len - 1; i++)
 206                 insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
 207                                      SKF_AD_VLAN_TAG_PRESENT);
 208
 209         insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
 210
 211         self->u.ptr.insns = insn;
 212         self->u.ptr.len = len;
 213
 214         return 0;
 215 }
 216
 217 static int bpf_fill_maxinsns7(struct bpf_test *self)
 218 {
 219         unsigned int len = BPF_MAXINSNS;
 220         struct sock_filter *insn;
 221         int i;
 222
 223         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
 224         if (!insn)
 225                 return -ENOMEM;
 226
 227         for (i = 0; i < len - 4; i++)
 228                 insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
 229                                      SKF_AD_CPU);
 230
 231         insn[len - 4] = __BPF_STMT(BPF_MISC | BPF_TAX, 0);
 232         insn[len - 3] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
 233                                    SKF_AD_CPU);
 234         insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0);
 235         insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
 236
 237         self->u.ptr.insns = insn;
 238         self->u.ptr.len = len;
 239
 240         return 0;
 241 }
 242
 243 static int bpf_fill_maxinsns8(struct bpf_test *self)
 244 {
 245         unsigned int len = BPF_MAXINSNS;
 246         struct sock_filter *insn;
 247         int i, jmp_off = len - 3;
 248
 249         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
 250         if (!insn)
 251                 return -ENOMEM;
 252
 253         insn[0] = __BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff);
 254
 255         for (i = 1; i < len - 1; i++)
 256                 insn[i] = __BPF_JUMP(BPF_JMP | BPF_JGT, 0xffffffff, jmp_off--, 0);
 257
 258         insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
 259
 260         self->u.ptr.insns = insn;
 261         self->u.ptr.len = len;
 262
 263         return 0;
 264 }
 265
 266 static int bpf_fill_maxinsns9(struct bpf_test *self)
 267 {
 268         unsigned int len = BPF_MAXINSNS;
 269         struct bpf_insn *insn;
 270         int i;
 271
 272         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
 273         if (!insn)
 274                 return -ENOMEM;
 275
 276         insn[0] = BPF_JMP_IMM(BPF_JA, 0, 0, len - 2);
 277         insn[1] = BPF_ALU32_IMM(BPF_MOV, R0, 0xcbababab);
 278         insn[2] = BPF_EXIT_INSN();
 279
 280         for (i = 3; i < len - 2; i++)
 281                 insn[i] = BPF_ALU32_IMM(BPF_MOV, R0, 0xfefefefe);
 282
 283         insn[len - 2] = BPF_EXIT_INSN();
 284         insn[len - 1] = BPF_JMP_IMM(BPF_JA, 0, 0, -(len - 1));
 285
 286         self->u.ptr.insns = insn;
 287         self->u.ptr.len = len;
 288
 289         return 0;
 290 }
 291
 292 static int bpf_fill_maxinsns10(struct bpf_test *self)
 293 {
 294         unsigned int len = BPF_MAXINSNS, hlen = len - 2;
 295         struct bpf_insn *insn;
 296         int i;
 297
 298         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
 299         if (!insn)
 300                 return -ENOMEM;
 301
 302         for (i = 0; i < hlen / 2; i++)
 303                 insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 2 - 2 * i);
 304         for (i = hlen - 1; i > hlen / 2; i--)
 305                 insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 1 - 2 * i);
 306
 307         insn[hlen / 2] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen / 2 - 1);
 308         insn[hlen]     = BPF_ALU32_IMM(BPF_MOV, R0, 0xabababac);
 309         insn[hlen + 1] = BPF_EXIT_INSN();
 310
 311         self->u.ptr.insns = insn;
 312         self->u.ptr.len = len;
 313
 314         return 0;
 315 }
 316
 317 static int __bpf_fill_ja(struct bpf_test *self, unsigned int len,
 318                          unsigned int plen)
 319 {
 320         struct sock_filter *insn;
 321         unsigned int rlen;
 322         int i, j;
 323
 324         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
 325         if (!insn)
 326                 return -ENOMEM;
 327
 328         rlen = (len % plen) - 1;
 329
 330         for (i = 0; i + plen < len; i += plen)
 331                 for (j = 0; j < plen; j++)
 332                         insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA,
 333                                                  plen - 1 - j, 0, 0);
 334         for (j = 0; j < rlen; j++)
 335                 insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA, rlen - 1 - j,
 336                                          0, 0);
 337
 338         insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xababcbac);
 339
 340         self->u.ptr.insns = insn;
 341         self->u.ptr.len = len;
 342
 343         return 0;
 344 }
 345
 346 static int bpf_fill_maxinsns11(struct bpf_test *self)
 347 {
 348         /* Hits 70 passes on x86_64 and triggers NOPs padding. */
 349         return __bpf_fill_ja(self, BPF_MAXINSNS, 68);
 350 }
 351
 352 static int bpf_fill_maxinsns12(struct bpf_test *self)
 353 {
 354         unsigned int len = BPF_MAXINSNS;
 355         struct sock_filter *insn;
 356         int i = 0;
 357
 358         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
 359         if (!insn)
 360                 return -ENOMEM;
 361
 362         insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0);
 363
 364         for (i = 1; i < len - 1; i++)
 365                 insn[i] = __BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0);
 366
 367         insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab);
 368
 369         self->u.ptr.insns = insn;
 370         self->u.ptr.len = len;
 371
 372         return 0;
 373 }
 374
 375 static int bpf_fill_maxinsns13(struct bpf_test *self)
 376 {
 377         unsigned int len = BPF_MAXINSNS;
 378         struct sock_filter *insn;
 379         int i = 0;
 380
 381         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
 382         if (!insn)
 383                 return -ENOMEM;
 384
 385         for (i = 0; i < len - 3; i++)
 386                 insn[i] = __BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0);
 387
 388         insn[len - 3] = __BPF_STMT(BPF_LD | BPF_IMM, 0xabababab);
 389         insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0);
 390         insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
 391
 392         self->u.ptr.insns = insn;
 393         self->u.ptr.len = len;
 394
 395         return 0;
 396 }
 397
 398 static int bpf_fill_ja(struct bpf_test *self)
 399 {
 400         /* Hits exactly 11 passes on x86_64 JIT. */
 401         return __bpf_fill_ja(self, 12, 9);
 402 }
 403
 404 static int bpf_fill_ld_abs_get_processor_id(struct bpf_test *self)
 405 {
 406         unsigned int len = BPF_MAXINSNS;
 407         struct sock_filter *insn;
 408         int i;
 409
 410         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
 411         if (!insn)
 412                 return -ENOMEM;
 413
 414         for (i = 0; i < len - 1; i += 2) {
 415                 insn[i] = __BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 0);
 416                 insn[i + 1] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
 417                                          SKF_AD_OFF + SKF_AD_CPU);
 418         }
 419
 420         insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xbee);
 421
 422         self->u.ptr.insns = insn;
 423         self->u.ptr.len = len;
 424
 425         return 0;
 426 }
 427
 428 static int __bpf_fill_stxdw(struct bpf_test *self, int size)
 429 {
 430         unsigned int len = BPF_MAXINSNS;
 431         struct bpf_insn *insn;
 432         int i;
 433
 434         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
 435         if (!insn)
 436                 return -ENOMEM;
 437
 438         insn[0] = BPF_ALU32_IMM(BPF_MOV, R0, 1);
 439         insn[1] = BPF_ST_MEM(size, R10, -40, 42);
 440
 441         for (i = 2; i < len - 2; i++)
 442                 insn[i] = BPF_STX_XADD(size, R10, R0, -40);
 443
 444         insn[len - 2] = BPF_LDX_MEM(size, R0, R10, -40);
 445         insn[len - 1] = BPF_EXIT_INSN();
 446
 447         self->u.ptr.insns = insn;
 448         self->u.ptr.len = len;
 449         self->stack_depth = 40;
 450
 451         return 0;
 452 }
 453
 454 static int bpf_fill_stxw(struct bpf_test *self)
 455 {
 456         return __bpf_fill_stxdw(self, BPF_W);
 457 }
 458
 459 static int bpf_fill_stxdw(struct bpf_test *self)
 460 {
 461         return __bpf_fill_stxdw(self, BPF_DW);
 462 }
 463
 464 static struct bpf_test tests[] = {
 465         {
 466                 "TAX",
 467                 .u.insns = {
 468                         BPF_STMT(BPF_LD | BPF_IMM, 1),
 469                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
 470                         BPF_STMT(BPF_LD | BPF_IMM, 2),
 471                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
 472                         BPF_STMT(BPF_ALU | BPF_NEG, 0), /* A == -3 */
 473                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
 474                         BPF_STMT(BPF_LD | BPF_LEN, 0),
 475                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
 476                         BPF_STMT(BPF_MISC | BPF_TAX, 0), /* X == len - 3 */
 477                         BPF_STMT(BPF_LD | BPF_B | BPF_IND, 1),
 478                         BPF_STMT(BPF_RET | BPF_A, 0)
 479                 },
 480                 CLASSIC,
 481                 { 10, 20, 30, 40, 50 },
 482                 { { 2, 10 }, { 3, 20 }, { 4, 30 } },
 483         },
 484         {
 485                 "TXA",
 486                 .u.insns = {
 487                         BPF_STMT(BPF_LDX | BPF_LEN, 0),
 488                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
 489                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
 490                         BPF_STMT(BPF_RET | BPF_A, 0) /* A == len * 2 */
 491                 },
 492                 CLASSIC,
 493                 { 10, 20, 30, 40, 50 },
 494                 { { 1, 2 }, { 3, 6 }, { 4, 8 } },
 495         },
 496         {
 497                 "ADD_SUB_MUL_K",
 498                 .u.insns = {
 499                         BPF_STMT(BPF_LD | BPF_IMM, 1),
 500                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 2),
 501                         BPF_STMT(BPF_LDX | BPF_IMM, 3),
 502                         BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
 503                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0xffffffff),
 504                         BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 3),
 505                         BPF_STMT(BPF_RET | BPF_A, 0)
 506                 },
 507                 CLASSIC | FLAG_NO_DATA,
 508                 { },
 509                 { { 0, 0xfffffffd } }
 510         },
 511         {
 512                 "DIV_MOD_KX",
 513                 .u.insns = {
 514                         BPF_STMT(BPF_LD | BPF_IMM, 8),
 515                         BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 2),
 516                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
 517                         BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
 518                         BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
 519                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
 520                         BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
 521                         BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x70000000),
 522                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
 523                         BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
 524                         BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
 525                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
 526                         BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
 527                         BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x70000000),
 528                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
 529                         BPF_STMT(BPF_RET | BPF_A, 0)
 530                 },
 531                 CLASSIC | FLAG_NO_DATA,
 532                 { },
 533                 { { 0, 0x20000000 } }
 534         },
 535         {
 536                 "AND_OR_LSH_K",
 537                 .u.insns = {
 538                         BPF_STMT(BPF_LD | BPF_IMM, 0xff),
 539                         BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
 540                         BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 27),
 541                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
 542                         BPF_STMT(BPF_LD | BPF_IMM, 0xf),
 543                         BPF_STMT(BPF_ALU | BPF_OR | BPF_K, 0xf0),
 544                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
 545                         BPF_STMT(BPF_RET | BPF_A, 0)
 546                 },
 547                 CLASSIC | FLAG_NO_DATA,
 548                 { },
 549                 { { 0, 0x800000ff }, { 1, 0x800000ff } },
 550         },
 551         {
 552                 "LD_IMM_0",
 553                 .u.insns = {
 554                         BPF_STMT(BPF_LD | BPF_IMM, 0), /* ld #0 */
 555                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0, 1, 0),
 556                         BPF_STMT(BPF_RET | BPF_K, 0),
 557                         BPF_STMT(BPF_RET | BPF_K, 1),
 558                 },
 559                 CLASSIC,
 560                 { },
 561                 { { 1, 1 } },
 562         },
 563         {
 564                 "LD_IND",
 565                 .u.insns = {
 566                         BPF_STMT(BPF_LDX | BPF_LEN, 0),
 567                         BPF_STMT(BPF_LD | BPF_H | BPF_IND, MAX_K),
 568                         BPF_STMT(BPF_RET | BPF_K, 1)
 569                 },
 570                 CLASSIC,
 571                 { },
 572                 { { 1, 0 }, { 10, 0 }, { 60, 0 } },
 573         },
 574         {
 575                 "LD_ABS",
 576                 .u.insns = {
 577                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1000),
 578                         BPF_STMT(BPF_RET | BPF_K, 1)
 579                 },
 580                 CLASSIC,
 581                 { },
 582                 { { 1, 0 }, { 10, 0 }, { 60, 0 } },
 583         },
 584         {
 585                 "LD_ABS_LL",
 586                 .u.insns = {
 587                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF),
 588                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
 589                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF + 1),
 590                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
 591                         BPF_STMT(BPF_RET | BPF_A, 0)
 592                 },
 593                 CLASSIC,
 594                 { 1, 2, 3 },
 595                 { { 1, 0 }, { 2, 3 } },
 596         },
 597         {
 598                 "LD_IND_LL",
 599                 .u.insns = {
 600                         BPF_STMT(BPF_LD | BPF_IMM, SKF_LL_OFF - 1),
 601                         BPF_STMT(BPF_LDX | BPF_LEN, 0),
 602                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
 603                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
 604                         BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
 605                         BPF_STMT(BPF_RET | BPF_A, 0)
 606                 },
 607                 CLASSIC,
 608                 { 1, 2, 3, 0xff },
 609                 { { 1, 1 }, { 3, 3 }, { 4, 0xff } },
 610         },
 611         {
 612                 "LD_ABS_NET",
 613                 .u.insns = {
 614                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF),
 615                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
 616                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF + 1),
 617                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
 618                         BPF_STMT(BPF_RET | BPF_A, 0)
 619                 },
 620                 CLASSIC,
 621                 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
 622                 { { 15, 0 }, { 16, 3 } },
 623         },
 624         {
 625                 "LD_IND_NET",
 626                 .u.insns = {
 627                         BPF_STMT(BPF_LD | BPF_IMM, SKF_NET_OFF - 15),
 628                         BPF_STMT(BPF_LDX | BPF_LEN, 0),
 629                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
 630                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
 631                         BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
 632                         BPF_STMT(BPF_RET | BPF_A, 0)
 633                 },
 634                 CLASSIC,
 635                 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
 636                 { { 14, 0 }, { 15, 1 }, { 17, 3 } },
 637         },
 638         {
 639                 "LD_PKTTYPE",
 640                 .u.insns = {
 641                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
 642                                  SKF_AD_OFF + SKF_AD_PKTTYPE),
 643                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
 644                         BPF_STMT(BPF_RET | BPF_K, 1),
 645                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
 646                                  SKF_AD_OFF + SKF_AD_PKTTYPE),
 647                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
 648                         BPF_STMT(BPF_RET | BPF_K, 1),
 649                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
 650                                  SKF_AD_OFF + SKF_AD_PKTTYPE),
 651                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
 652                         BPF_STMT(BPF_RET | BPF_K, 1),
 653                         BPF_STMT(BPF_RET | BPF_A, 0)
 654                 },
 655                 CLASSIC,
 656                 { },
 657                 { { 1, 3 }, { 10, 3 } },
 658         },
 659         {
 660                 "LD_MARK",
 661                 .u.insns = {
 662                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
 663                                  SKF_AD_OFF + SKF_AD_MARK),
 664                         BPF_STMT(BPF_RET | BPF_A, 0)
 665                 },
 666                 CLASSIC,
 667                 { },
 668                 { { 1, SKB_MARK}, { 10, SKB_MARK} },
 669         },
 670         {
 671                 "LD_RXHASH",
 672                 .u.insns = {
 673                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
 674                                  SKF_AD_OFF + SKF_AD_RXHASH),
 675                         BPF_STMT(BPF_RET | BPF_A, 0)
 676                 },
 677                 CLASSIC,
 678                 { },
 679                 { { 1, SKB_HASH}, { 10, SKB_HASH} },
 680         },
 681         {
 682                 "LD_QUEUE",
 683                 .u.insns = {
 684                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
 685                                  SKF_AD_OFF + SKF_AD_QUEUE),
 686                         BPF_STMT(BPF_RET | BPF_A, 0)
 687                 },
 688                 CLASSIC,
 689                 { },
 690                 { { 1, SKB_QUEUE_MAP }, { 10, SKB_QUEUE_MAP } },
 691         },
 692         {
 693                 "LD_PROTOCOL",
 694                 .u.insns = {
 695                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 1),
 696                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 20, 1, 0),
 697                         BPF_STMT(BPF_RET | BPF_K, 0),
 698                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
 699                                  SKF_AD_OFF + SKF_AD_PROTOCOL),
 700                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
 701                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
 702                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 30, 1, 0),
 703                         BPF_STMT(BPF_RET | BPF_K, 0),
 704                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
 705                         BPF_STMT(BPF_RET | BPF_A, 0)
 706                 },
 707                 CLASSIC,
 708                 { 10, 20, 30 },
 709                 { { 10, ETH_P_IP }, { 100, ETH_P_IP } },
 710         },
 711         {
 712                 "LD_VLAN_TAG",
 713                 .u.insns = {
 714                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
 715                                  SKF_AD_OFF + SKF_AD_VLAN_TAG),
 716                         BPF_STMT(BPF_RET | BPF_A, 0)
 717                 },
 718                 CLASSIC,
 719                 { },
 720                 {
 721                         { 1, SKB_VLAN_TCI },
 722                         { 10, SKB_VLAN_TCI }
 723                 },
 724         },
 725         {
 726                 "LD_VLAN_TAG_PRESENT",
 727                 .u.insns = {
 728                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
 729                                  SKF_AD_OFF + SKF_AD_VLAN_TAG_PRESENT),
 730                         BPF_STMT(BPF_RET | BPF_A, 0)
 731                 },
 732                 CLASSIC,
 733                 { },
 734                 {
 735                         { 1, SKB_VLAN_PRESENT },
 736                         { 10, SKB_VLAN_PRESENT }
 737                 },
 738         },
 739         {
 740                 "LD_IFINDEX",
 741                 .u.insns = {
 742                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
 743                                  SKF_AD_OFF + SKF_AD_IFINDEX),
 744                         BPF_STMT(BPF_RET | BPF_A, 0)
 745                 },
 746                 CLASSIC,
 747                 { },
 748                 { { 1, SKB_DEV_IFINDEX }, { 10, SKB_DEV_IFINDEX } },
 749         },
 750         {
 751                 "LD_HATYPE",
 752                 .u.insns = {
 753                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
 754                                  SKF_AD_OFF + SKF_AD_HATYPE),
 755                         BPF_STMT(BPF_RET | BPF_A, 0)
 756                 },
 757                 CLASSIC,
 758                 { },
 759                 { { 1, SKB_DEV_TYPE }, { 10, SKB_DEV_TYPE } },
 760         },
 761         {
 762                 "LD_CPU",
 763                 .u.insns = {
 764                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
 765                                  SKF_AD_OFF + SKF_AD_CPU),
 766                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
 767                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
 768                                  SKF_AD_OFF + SKF_AD_CPU),
 769                         BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
 770                         BPF_STMT(BPF_RET | BPF_A, 0)
 771                 },
 772                 CLASSIC,
 773                 { },
 774                 { { 1, 0 }, { 10, 0 } },
 775         },
 776         {
 777                 "LD_NLATTR",
 778                 .u.insns = {
 779                         BPF_STMT(BPF_LDX | BPF_IMM, 2),
 780                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
 781                         BPF_STMT(BPF_LDX | BPF_IMM, 3),
 782                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
 783                                  SKF_AD_OFF + SKF_AD_NLATTR),
 784                         BPF_STMT(BPF_RET | BPF_A, 0)
 785                 },
 786                 CLASSIC,
 787 #ifdef __BIG_ENDIAN
 788                 { 0xff, 0xff, 0, 4, 0, 2, 0, 4, 0, 3 },
 789 #else
 790                 { 0xff, 0xff, 4, 0, 2, 0, 4, 0, 3, 0 },
 791 #endif
 792                 { { 4, 0 }, { 20, 6 } },
 793         },
 794         {
 795                 "LD_NLATTR_NEST",
 796                 .u.insns = {
 797                         BPF_STMT(BPF_LD | BPF_IMM, 2),
 798                         BPF_STMT(BPF_LDX | BPF_IMM, 3),
 799                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
 800                                  SKF_AD_OFF + SKF_AD_NLATTR_NEST),
 801                         BPF_STMT(BPF_LD | BPF_IMM, 2),
 802                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
 803                                  SKF_AD_OFF + SKF_AD_NLATTR_NEST),
 804                         BPF_STMT(BPF_LD | BPF_IMM, 2),
 805                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
 806                                  SKF_AD_OFF + SKF_AD_NLATTR_NEST),
 807                         BPF_STMT(BPF_LD | BPF_IMM, 2),
 808                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
 809                                  SKF_AD_OFF + SKF_AD_NLATTR_NEST),
 810                         BPF_STMT(BPF_LD | BPF_IMM, 2),
 811                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
 812                                  SKF_AD_OFF + SKF_AD_NLATTR_NEST),
 813                         BPF_STMT(BPF_LD | BPF_IMM, 2),
 814                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
 815                                  SKF_AD_OFF + SKF_AD_NLATTR_NEST),
 816                         BPF_STMT(BPF_LD | BPF_IMM, 2),
 817                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
 818                                  SKF_AD_OFF + SKF_AD_NLATTR_NEST),
 819                         BPF_STMT(BPF_LD | BPF_IMM, 2),
 820                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
 821                                  SKF_AD_OFF + SKF_AD_NLATTR_NEST),
 822                         BPF_STMT(BPF_RET | BPF_A, 0)
 823                 },
 824                 CLASSIC,
 825 #ifdef __BIG_ENDIAN
 826                 { 0xff, 0xff, 0, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3 },
 827 #else
 828                 { 0xff, 0xff, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3, 0 },
 829 #endif
 830                 { { 4, 0 }, { 20, 10 } },
 831         },
 832         {
 833                 "LD_PAYLOAD_OFF",
 834                 .u.insns = {
 835                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
 836                                  SKF_AD_OFF + SKF_AD_PAY_OFFSET),
 837                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
 838                                  SKF_AD_OFF + SKF_AD_PAY_OFFSET),
 839                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
 840                                  SKF_AD_OFF + SKF_AD_PAY_OFFSET),
 841                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
 842                                  SKF_AD_OFF + SKF_AD_PAY_OFFSET),
 843                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
 844                                  SKF_AD_OFF + SKF_AD_PAY_OFFSET),
 845                         BPF_STMT(BPF_RET | BPF_A, 0)
 846                 },
 847                 CLASSIC,
 848                 /* 00:00:00:00:00:00 > 00:00:00:00:00:00, ethtype IPv4 (0x0800),
 849                  * length 98: 127.0.0.1 > 127.0.0.1: ICMP echo request,
 850                  * id 9737, seq 1, length 64
 851                  */
 852                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 853                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 854                   0x08, 0x00,
 855                   0x45, 0x00, 0x00, 0x54, 0xac, 0x8b, 0x40, 0x00, 0x40,
 856                   0x01, 0x90, 0x1b, 0x7f, 0x00, 0x00, 0x01 },
 857                 { { 30, 0 }, { 100, 42 } },
 858         },
 859         {
 860                 "LD_ANC_XOR",
 861                 .u.insns = {
 862                         BPF_STMT(BPF_LD | BPF_IMM, 10),
 863                         BPF_STMT(BPF_LDX | BPF_IMM, 300),
 864                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
 865                                  SKF_AD_OFF + SKF_AD_ALU_XOR_X),
 866                         BPF_STMT(BPF_RET | BPF_A, 0)
 867                 },
 868                 CLASSIC,
 869                 { },
 870                 { { 4, 0xA ^ 300 }, { 20, 0xA ^ 300 } },
 871         },
 872         {
 873                 "SPILL_FILL",
 874                 .u.insns = {
 875                         BPF_STMT(BPF_LDX | BPF_LEN, 0),
 876                         BPF_STMT(BPF_LD | BPF_IMM, 2),
 877                         BPF_STMT(BPF_ALU | BPF_RSH, 1),
 878                         BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
 879                         BPF_STMT(BPF_ST, 1), /* M1 = 1 ^ len */
 880                         BPF_STMT(BPF_ALU | BPF_XOR | BPF_K, 0x80000000),
 881                         BPF_STMT(BPF_ST, 2), /* M2 = 1 ^ len ^ 0x80000000 */
 882                         BPF_STMT(BPF_STX, 15), /* M3 = len */
 883                         BPF_STMT(BPF_LDX | BPF_MEM, 1),
 884                         BPF_STMT(BPF_LD | BPF_MEM, 2),
 885                         BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
 886                         BPF_STMT(BPF_LDX | BPF_MEM, 15),
 887                         BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
 888                         BPF_STMT(BPF_RET | BPF_A, 0)
 889                 },
 890                 CLASSIC,
 891                 { },
 892                 { { 1, 0x80000001 }, { 2, 0x80000002 }, { 60, 0x80000000 ^ 60 } }
 893         },
 894         {
 895                 "JEQ",
 896                 .u.insns = {
 897                         BPF_STMT(BPF_LDX | BPF_LEN, 0),
 898                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
 899                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 0, 1),
 900                         BPF_STMT(BPF_RET | BPF_K, 1),
 901                         BPF_STMT(BPF_RET | BPF_K, MAX_K)
 902                 },
 903                 CLASSIC,
 904                 { 3, 3, 3, 3, 3 },
 905                 { { 1, 0 }, { 3, 1 }, { 4, MAX_K } },
 906         },
 907         {
 908                 "JGT",
 909                 .u.insns = {
 910                         BPF_STMT(BPF_LDX | BPF_LEN, 0),
 911                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
 912                         BPF_JUMP(BPF_JMP | BPF_JGT | BPF_X, 0, 0, 1),
 913                         BPF_STMT(BPF_RET | BPF_K, 1),
 914                         BPF_STMT(BPF_RET | BPF_K, MAX_K)
 915                 },
 916                 CLASSIC,
 917                 { 4, 4, 4, 3, 3 },
 918                 { { 2, 0 }, { 3, 1 }, { 4, MAX_K } },
 919         },
 920         {
 921                 "JGE (jt 0), test 1",
 922                 .u.insns = {
 923                         BPF_STMT(BPF_LDX | BPF_LEN, 0),
 924                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
 925                         BPF_JUMP(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 1),
 926                         BPF_STMT(BPF_RET | BPF_K, 1),
 927                         BPF_STMT(BPF_RET | BPF_K, MAX_K)
 928                 },
 929                 CLASSIC,
 930                 { 4, 4, 4, 3, 3 },
 931                 { { 2, 0 }, { 3, 1 }, { 4, 1 } },
 932         },
 933         {
 934                 "JGE (jt 0), test 2",
 935                 .u.insns = {
 936                         BPF_STMT(BPF_LDX | BPF_LEN, 0),
 937                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
 938                         BPF_JUMP(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 1),
 939                         BPF_STMT(BPF_RET | BPF_K, 1),
 940                         BPF_STMT(BPF_RET | BPF_K, MAX_K)
 941                 },
 942                 CLASSIC,
 943                 { 4, 4, 5, 3, 3 },
 944                 { { 4, 1 }, { 5, 1 }, { 6, MAX_K } },
 945         },
 946         {
 947                 "JGE",
 948                 .u.insns = {
 949                         BPF_STMT(BPF_LDX | BPF_LEN, 0),
 950                         BPF_STMT(BPF_LD | BPF_B | BPF_IND, MAX_K),
 951                         BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 1, 1, 0),
 952                         BPF_STMT(BPF_RET | BPF_K, 10),
 953                         BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 2, 1, 0),
 954                         BPF_STMT(BPF_RET | BPF_K, 20),
 955                         BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 3, 1, 0),
 956                         BPF_STMT(BPF_RET | BPF_K, 30),
 957                         BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 4, 1, 0),
 958                         BPF_STMT(BPF_RET | BPF_K, 40),
 959                         BPF_STMT(BPF_RET | BPF_K, MAX_K)
 960                 },
 961                 CLASSIC,
 962                 { 1, 2, 3, 4, 5 },
 963                 { { 1, 20 }, { 3, 40 }, { 5, MAX_K } },
 964         },
 965         {
 966                 "JSET",
 967                 .u.insns = {
 968                         BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
 969                         BPF_JUMP(BPF_JMP | BPF_JA, 1, 1, 1),
 970                         BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
 971                         BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
 972                         BPF_STMT(BPF_LDX | BPF_LEN, 0),
 973                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
 974                         BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, 4),
 975                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
 976                         BPF_STMT(BPF_LD | BPF_W | BPF_IND, 0),
 977                         BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 1, 0, 1),
 978                         BPF_STMT(BPF_RET | BPF_K, 10),
 979                         BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x80000000, 0, 1),
 980                         BPF_STMT(BPF_RET | BPF_K, 20),
 981                         BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
 982                         BPF_STMT(BPF_RET | BPF_K, 30),
 983                         BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
 984                         BPF_STMT(BPF_RET | BPF_K, 30),
 985                         BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
 986                         BPF_STMT(BPF_RET | BPF_K, 30),
 987                         BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
 988                         BPF_STMT(BPF_RET | BPF_K, 30),
 989                         BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
 990                         BPF_STMT(BPF_RET | BPF_K, 30),
 991                         BPF_STMT(BPF_RET | BPF_K, MAX_K)
 992                 },
 993                 CLASSIC,
 994                 { 0, 0xAA, 0x55, 1 },
 995                 { { 4, 10 }, { 5, 20 }, { 6, MAX_K } },
 996         },
 997         {
 998                 "tcpdump port 22",
 999                 .u.insns = {
1000                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
1001                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 0, 8), /* IPv6 */
1002                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 20),
1003                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
1004                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
1005                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 17),
1006                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 54),
1007                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 14, 0),
1008                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 56),
1009                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 12, 13),
1010                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0800, 0, 12), /* IPv4 */
1011                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
1012                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
1013                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
1014                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 8),
1015                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
1016                         BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 6, 0),
1017                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
1018                         BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
1019                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
1020                         BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
1021                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 1),
1022                         BPF_STMT(BPF_RET | BPF_K, 0xffff),
1023                         BPF_STMT(BPF_RET | BPF_K, 0),
1024                 },
1025                 CLASSIC,
1026                 /* 3c:07:54:43:e5:76 > 10:bf:48:d6:43:d6, ethertype IPv4(0x0800)
1027                  * length 114: 10.1.1.149.49700 > 10.1.2.10.22: Flags [P.],
1028                  * seq 1305692979:1305693027, ack 3650467037, win 65535,
1029                  * options [nop,nop,TS val 2502645400 ecr 3971138], length 48
1030                  */
1031                 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
1032                   0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
1033                   0x08, 0x00,
1034                   0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
1035                   0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
1036                   0x0a, 0x01, 0x01, 0x95, /* ip src */
1037                   0x0a, 0x01, 0x02, 0x0a, /* ip dst */
1038                   0xc2, 0x24,
1039                   0x00, 0x16 /* dst port */ },
1040                 { { 10, 0 }, { 30, 0 }, { 100, 65535 } },
1041         },
1042         {
1043                 "tcpdump complex",
1044                 .u.insns = {
1045                         /* tcpdump -nei eth0 'tcp port 22 and (((ip[2:2] -
1046                          * ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0) and
1047                          * (len > 115 or len < 30000000000)' -d
1048                          */
1049                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
1050                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 30, 0),
1051                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x800, 0, 29),
1052                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
1053                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 0, 27),
1054                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
1055                         BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 25, 0),
1056                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
1057                         BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
1058                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
1059                         BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
1060                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 20),
1061                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 16),
1062                         BPF_STMT(BPF_ST, 1),
1063                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 14),
1064                         BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf),
1065                         BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 2),
1066                         BPF_STMT(BPF_MISC | BPF_TAX, 0x5), /* libpcap emits K on TAX */
1067                         BPF_STMT(BPF_LD | BPF_MEM, 1),
1068                         BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
1069                         BPF_STMT(BPF_ST, 5),
1070                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
1071                         BPF_STMT(BPF_LD | BPF_B | BPF_IND, 26),
1072                         BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
1073                         BPF_STMT(BPF_ALU | BPF_RSH | BPF_K, 2),
1074                         BPF_STMT(BPF_MISC | BPF_TAX, 0x9), /* libpcap emits K on TAX */
1075                         BPF_STMT(BPF_LD | BPF_MEM, 5),
1076                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 4, 0),
1077                         BPF_STMT(BPF_LD | BPF_LEN, 0),
1078                         BPF_JUMP(BPF_JMP | BPF_JGT | BPF_K, 0x73, 1, 0),
1079                         BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 0xfc23ac00, 1, 0),
1080                         BPF_STMT(BPF_RET | BPF_K, 0xffff),
1081                         BPF_STMT(BPF_RET | BPF_K, 0),
1082                 },
1083                 CLASSIC,
1084                 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
1085                   0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
1086                   0x08, 0x00,
1087                   0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
1088                   0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
1089                   0x0a, 0x01, 0x01, 0x95, /* ip src */
1090                   0x0a, 0x01, 0x02, 0x0a, /* ip dst */
1091                   0xc2, 0x24,
1092                   0x00, 0x16 /* dst port */ },
1093                 { { 10, 0 }, { 30, 0 }, { 100, 65535 } },
1094         },
1095         {
1096                 "RET_A",
1097                 .u.insns = {
1098                         /* check that uninitialized X and A contain zeros */
1099                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
1100                         BPF_STMT(BPF_RET | BPF_A, 0)
1101                 },
1102                 CLASSIC,
1103                 { },
1104                 { {1, 0}, {2, 0} },
1105         },
1106         {
1107                 "INT: ADD trivial",
1108                 .u.insns_int = {
1109                         BPF_ALU64_IMM(BPF_MOV, R1, 1),
1110                         BPF_ALU64_IMM(BPF_ADD, R1, 2),
1111                         BPF_ALU64_IMM(BPF_MOV, R2, 3),
1112                         BPF_ALU64_REG(BPF_SUB, R1, R2),
1113                         BPF_ALU64_IMM(BPF_ADD, R1, -1),
1114                         BPF_ALU64_IMM(BPF_MUL, R1, 3),
1115                         BPF_ALU64_REG(BPF_MOV, R0, R1),
1116                         BPF_EXIT_INSN(),
1117                 },
1118                 INTERNAL,
1119                 { },
1120                 { { 0, 0xfffffffd } }
1121         },
1122         {
1123                 "INT: MUL_X",
1124                 .u.insns_int = {
1125                         BPF_ALU64_IMM(BPF_MOV, R0, -1),
1126                         BPF_ALU64_IMM(BPF_MOV, R1, -1),
1127                         BPF_ALU64_IMM(BPF_MOV, R2, 3),
1128                         BPF_ALU64_REG(BPF_MUL, R1, R2),
1129                         BPF_JMP_IMM(BPF_JEQ, R1, 0xfffffffd, 1),
1130                         BPF_EXIT_INSN(),
1131                         BPF_ALU64_IMM(BPF_MOV, R0, 1),
1132                         BPF_EXIT_INSN(),
1133                 },
1134                 INTERNAL,
1135                 { },
1136                 { { 0, 1 } }
1137         },
1138         {
1139                 "INT: MUL_X2",
1140                 .u.insns_int = {
1141                         BPF_ALU32_IMM(BPF_MOV, R0, -1),
1142                         BPF_ALU32_IMM(BPF_MOV, R1, -1),
1143                         BPF_ALU32_IMM(BPF_MOV, R2, 3),
1144                         BPF_ALU64_REG(BPF_MUL, R1, R2),
1145                         BPF_ALU64_IMM(BPF_RSH, R1, 8),
1146                         BPF_JMP_IMM(BPF_JEQ, R1, 0x2ffffff, 1),
1147                         BPF_EXIT_INSN(),
1148                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
1149                         BPF_EXIT_INSN(),
1150                 },
1151                 INTERNAL,
1152                 { },
1153                 { { 0, 1 } }
1154         },
1155         {
1156                 "INT: MUL32_X",
1157                 .u.insns_int = {
1158                         BPF_ALU32_IMM(BPF_MOV, R0, -1),
1159                         BPF_ALU64_IMM(BPF_MOV, R1, -1),
1160                         BPF_ALU32_IMM(BPF_MOV, R2, 3),
1161                         BPF_ALU32_REG(BPF_MUL, R1, R2),
1162                         BPF_ALU64_IMM(BPF_RSH, R1, 8),
1163                         BPF_JMP_IMM(BPF_JEQ, R1, 0xffffff, 1),
1164                         BPF_EXIT_INSN(),
1165                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
1166                         BPF_EXIT_INSN(),
1167                 },
1168                 INTERNAL,
1169                 { },
1170                 { { 0, 1 } }
1171         },
1172         {
1173                 /* Have to test all register combinations, since
1174                  * JITing of different registers will produce
1175                  * different asm code.
1176                  */
1177                 "INT: ADD 64-bit",
1178                 .u.insns_int = {
1179                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
1180                         BPF_ALU64_IMM(BPF_MOV, R1, 1),
1181                         BPF_ALU64_IMM(BPF_MOV, R2, 2),
1182                         BPF_ALU64_IMM(BPF_MOV, R3, 3),
1183                         BPF_ALU64_IMM(BPF_MOV, R4, 4),
1184                         BPF_ALU64_IMM(BPF_MOV, R5, 5),
1185                         BPF_ALU64_IMM(BPF_MOV, R6, 6),
1186                         BPF_ALU64_IMM(BPF_MOV, R7, 7),
1187                         BPF_ALU64_IMM(BPF_MOV, R8, 8),
1188                         BPF_ALU64_IMM(BPF_MOV, R9, 9),
1189                         BPF_ALU64_IMM(BPF_ADD, R0, 20),
1190                         BPF_ALU64_IMM(BPF_ADD, R1, 20),
1191                         BPF_ALU64_IMM(BPF_ADD, R2, 20),
1192                         BPF_ALU64_IMM(BPF_ADD, R3, 20),
1193                         BPF_ALU64_IMM(BPF_ADD, R4, 20),
1194                         BPF_ALU64_IMM(BPF_ADD, R5, 20),
1195                         BPF_ALU64_IMM(BPF_ADD, R6, 20),
1196                         BPF_ALU64_IMM(BPF_ADD, R7, 20),
1197                         BPF_ALU64_IMM(BPF_ADD, R8, 20),
1198                         BPF_ALU64_IMM(BPF_ADD, R9, 20),
1199                         BPF_ALU64_IMM(BPF_SUB, R0, 10),
1200                         BPF_ALU64_IMM(BPF_SUB, R1, 10),
1201                         BPF_ALU64_IMM(BPF_SUB, R2, 10),
1202                         BPF_ALU64_IMM(BPF_SUB, R3, 10),
1203                         BPF_ALU64_IMM(BPF_SUB, R4, 10),
1204                         BPF_ALU64_IMM(BPF_SUB, R5, 10),
1205                         BPF_ALU64_IMM(BPF_SUB, R6, 10),
1206                         BPF_ALU64_IMM(BPF_SUB, R7, 10),
1207                         BPF_ALU64_IMM(BPF_SUB, R8, 10),
1208                         BPF_ALU64_IMM(BPF_SUB, R9, 10),
1209                         BPF_ALU64_REG(BPF_ADD, R0, R0),
1210                         BPF_ALU64_REG(BPF_ADD, R0, R1),
1211                         BPF_ALU64_REG(BPF_ADD, R0, R2),
1212                         BPF_ALU64_REG(BPF_ADD, R0, R3),
1213                         BPF_ALU64_REG(BPF_ADD, R0, R4),
1214                         BPF_ALU64_REG(BPF_ADD, R0, R5),
1215                         BPF_ALU64_REG(BPF_ADD, R0, R6),
1216                         BPF_ALU64_REG(BPF_ADD, R0, R7),
1217                         BPF_ALU64_REG(BPF_ADD, R0, R8),
1218                         BPF_ALU64_REG(BPF_ADD, R0, R9), /* R0 == 155 */
1219                         BPF_JMP_IMM(BPF_JEQ, R0, 155, 1),
1220                         BPF_EXIT_INSN(),
1221                         BPF_ALU64_REG(BPF_ADD, R1, R0),
1222                         BPF_ALU64_REG(BPF_ADD, R1, R1),
1223                         BPF_ALU64_REG(BPF_ADD, R1, R2),
1224                         BPF_ALU64_REG(BPF_ADD, R1, R3),
1225                         BPF_ALU64_REG(BPF_ADD, R1, R4),
1226                         BPF_ALU64_REG(BPF_ADD, R1, R5),
1227                         BPF_ALU64_REG(BPF_ADD, R1, R6),
1228                         BPF_ALU64_REG(BPF_ADD, R1, R7),
1229                         BPF_ALU64_REG(BPF_ADD, R1, R8),
1230                         BPF_ALU64_REG(BPF_ADD, R1, R9), /* R1 == 456 */
1231                         BPF_JMP_IMM(BPF_JEQ, R1, 456, 1),
1232                         BPF_EXIT_INSN(),
1233                         BPF_ALU64_REG(BPF_ADD, R2, R0),
1234                         BPF_ALU64_REG(BPF_ADD, R2, R1),
1235                         BPF_ALU64_REG(BPF_ADD, R2, R2),
1236                         BPF_ALU64_REG(BPF_ADD, R2, R3),
1237                         BPF_ALU64_REG(BPF_ADD, R2, R4),
1238                         BPF_ALU64_REG(BPF_ADD, R2, R5),
1239                         BPF_ALU64_REG(BPF_ADD, R2, R6),
1240                         BPF_ALU64_REG(BPF_ADD, R2, R7),
1241                         BPF_ALU64_REG(BPF_ADD, R2, R8),
1242                         BPF_ALU64_REG(BPF_ADD, R2, R9), /* R2 == 1358 */
1243                         BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1),
1244                         BPF_EXIT_INSN(),
1245                         BPF_ALU64_REG(BPF_ADD, R3, R0),
1246                         BPF_ALU64_REG(BPF_ADD, R3, R1),
1247                         BPF_ALU64_REG(BPF_ADD, R3, R2),
1248                         BPF_ALU64_REG(BPF_ADD, R3, R3),
1249                         BPF_ALU64_REG(BPF_ADD, R3, R4),
1250                         BPF_ALU64_REG(BPF_ADD, R3, R5),
1251                         BPF_ALU64_REG(BPF_ADD, R3, R6),
1252                         BPF_ALU64_REG(BPF_ADD, R3, R7),
1253                         BPF_ALU64_REG(BPF_ADD, R3, R8),
1254                         BPF_ALU64_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
1255                         BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
1256                         BPF_EXIT_INSN(),
1257                         BPF_ALU64_REG(BPF_ADD, R4, R0),
1258                         BPF_ALU64_REG(BPF_ADD, R4, R1),
1259                         BPF_ALU64_REG(BPF_ADD, R4, R2),
1260                         BPF_ALU64_REG(BPF_ADD, R4, R3),
1261                         BPF_ALU64_REG(BPF_ADD, R4, R4),
1262                         BPF_ALU64_REG(BPF_ADD, R4, R5),
1263                         BPF_ALU64_REG(BPF_ADD, R4, R6),
1264                         BPF_ALU64_REG(BPF_ADD, R4, R7),
1265                         BPF_ALU64_REG(BPF_ADD, R4, R8),
1266                         BPF_ALU64_REG(BPF_ADD, R4, R9), /* R4 == 12177 */
1267                         BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1),
1268                         BPF_EXIT_INSN(),
1269                         BPF_ALU64_REG(BPF_ADD, R5, R0),
1270                         BPF_ALU64_REG(BPF_ADD, R5, R1),
1271                         BPF_ALU64_REG(BPF_ADD, R5, R2),
1272                         BPF_ALU64_REG(BPF_ADD, R5, R3),
1273                         BPF_ALU64_REG(BPF_ADD, R5, R4),
1274                         BPF_ALU64_REG(BPF_ADD, R5, R5),
1275                         BPF_ALU64_REG(BPF_ADD, R5, R6),
1276                         BPF_ALU64_REG(BPF_ADD, R5, R7),
1277                         BPF_ALU64_REG(BPF_ADD, R5, R8),
1278                         BPF_ALU64_REG(BPF_ADD, R5, R9), /* R5 == 36518 */
1279                         BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1),
1280                         BPF_EXIT_INSN(),
1281                         BPF_ALU64_REG(BPF_ADD, R6, R0),
1282                         BPF_ALU64_REG(BPF_ADD, R6, R1),
1283                         BPF_ALU64_REG(BPF_ADD, R6, R2),
1284                         BPF_ALU64_REG(BPF_ADD, R6, R3),
1285                         BPF_ALU64_REG(BPF_ADD, R6, R4),
1286                         BPF_ALU64_REG(BPF_ADD, R6, R5),
1287                         BPF_ALU64_REG(BPF_ADD, R6, R6),
1288                         BPF_ALU64_REG(BPF_ADD, R6, R7),
1289                         BPF_ALU64_REG(BPF_ADD, R6, R8),
1290                         BPF_ALU64_REG(BPF_ADD, R6, R9), /* R6 == 109540 */
1291                         BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1),
1292                         BPF_EXIT_INSN(),
1293                         BPF_ALU64_REG(BPF_ADD, R7, R0),
1294                         BPF_ALU64_REG(BPF_ADD, R7, R1),
1295                         BPF_ALU64_REG(BPF_ADD, R7, R2),
1296                         BPF_ALU64_REG(BPF_ADD, R7, R3),
1297                         BPF_ALU64_REG(BPF_ADD, R7, R4),
1298                         BPF_ALU64_REG(BPF_ADD, R7, R5),
1299                         BPF_ALU64_REG(BPF_ADD, R7, R6),
1300                         BPF_ALU64_REG(BPF_ADD, R7, R7),
1301                         BPF_ALU64_REG(BPF_ADD, R7, R8),
1302                         BPF_ALU64_REG(BPF_ADD, R7, R9), /* R7 == 328605 */
1303                         BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1),
1304                         BPF_EXIT_INSN(),
1305                         BPF_ALU64_REG(BPF_ADD, R8, R0),
1306                         BPF_ALU64_REG(BPF_ADD, R8, R1),
1307                         BPF_ALU64_REG(BPF_ADD, R8, R2),
1308                         BPF_ALU64_REG(BPF_ADD, R8, R3),
1309                         BPF_ALU64_REG(BPF_ADD, R8, R4),
1310                         BPF_ALU64_REG(BPF_ADD, R8, R5),
1311                         BPF_ALU64_REG(BPF_ADD, R8, R6),
1312                         BPF_ALU64_REG(BPF_ADD, R8, R7),
1313                         BPF_ALU64_REG(BPF_ADD, R8, R8),
1314                         BPF_ALU64_REG(BPF_ADD, R8, R9), /* R8 == 985799 */
1315                         BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1),
1316                         BPF_EXIT_INSN(),
1317                         BPF_ALU64_REG(BPF_ADD, R9, R0),
1318                         BPF_ALU64_REG(BPF_ADD, R9, R1),
1319                         BPF_ALU64_REG(BPF_ADD, R9, R2),
1320                         BPF_ALU64_REG(BPF_ADD, R9, R3),
1321                         BPF_ALU64_REG(BPF_ADD, R9, R4),
1322                         BPF_ALU64_REG(BPF_ADD, R9, R5),
1323                         BPF_ALU64_REG(BPF_ADD, R9, R6),
1324                         BPF_ALU64_REG(BPF_ADD, R9, R7),
1325                         BPF_ALU64_REG(BPF_ADD, R9, R8),
1326                         BPF_ALU64_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */
1327                         BPF_ALU64_REG(BPF_MOV, R0, R9),
1328                         BPF_EXIT_INSN(),
1329                 },
1330                 INTERNAL,
1331                 { },
1332                 { { 0, 2957380 } }
1333         },
1334         {
1335                 "INT: ADD 32-bit",
1336                 .u.insns_int = {
1337                         BPF_ALU32_IMM(BPF_MOV, R0, 20),
1338                         BPF_ALU32_IMM(BPF_MOV, R1, 1),
1339                         BPF_ALU32_IMM(BPF_MOV, R2, 2),
1340                         BPF_ALU32_IMM(BPF_MOV, R3, 3),
1341                         BPF_ALU32_IMM(BPF_MOV, R4, 4),
1342                         BPF_ALU32_IMM(BPF_MOV, R5, 5),
1343                         BPF_ALU32_IMM(BPF_MOV, R6, 6),
1344                         BPF_ALU32_IMM(BPF_MOV, R7, 7),
1345                         BPF_ALU32_IMM(BPF_MOV, R8, 8),
1346                         BPF_ALU32_IMM(BPF_MOV, R9, 9),
1347                         BPF_ALU64_IMM(BPF_ADD, R1, 10),
1348                         BPF_ALU64_IMM(BPF_ADD, R2, 10),
1349                         BPF_ALU64_IMM(BPF_ADD, R3, 10),
1350                         BPF_ALU64_IMM(BPF_ADD, R4, 10),
1351                         BPF_ALU64_IMM(BPF_ADD, R5, 10),
1352                         BPF_ALU64_IMM(BPF_ADD, R6, 10),
1353                         BPF_ALU64_IMM(BPF_ADD, R7, 10),
1354                         BPF_ALU64_IMM(BPF_ADD, R8, 10),
1355                         BPF_ALU64_IMM(BPF_ADD, R9, 10),
1356                         BPF_ALU32_REG(BPF_ADD, R0, R1),
1357                         BPF_ALU32_REG(BPF_ADD, R0, R2),
1358                         BPF_ALU32_REG(BPF_ADD, R0, R3),
1359                         BPF_ALU32_REG(BPF_ADD, R0, R4),
1360                         BPF_ALU32_REG(BPF_ADD, R0, R5),
1361                         BPF_ALU32_REG(BPF_ADD, R0, R6),
1362                         BPF_ALU32_REG(BPF_ADD, R0, R7),
1363                         BPF_ALU32_REG(BPF_ADD, R0, R8),
1364                         BPF_ALU32_REG(BPF_ADD, R0, R9), /* R0 == 155 */
1365                         BPF_JMP_IMM(BPF_JEQ, R0, 155, 1),
1366                         BPF_EXIT_INSN(),
1367                         BPF_ALU32_REG(BPF_ADD, R1, R0),
1368                         BPF_ALU32_REG(BPF_ADD, R1, R1),
1369                         BPF_ALU32_REG(BPF_ADD, R1, R2),
1370                         BPF_ALU32_REG(BPF_ADD, R1, R3),
1371                         BPF_ALU32_REG(BPF_ADD, R1, R4),
1372                         BPF_ALU32_REG(BPF_ADD, R1, R5),
1373                         BPF_ALU32_REG(BPF_ADD, R1, R6),
1374                         BPF_ALU32_REG(BPF_ADD, R1, R7),
1375                         BPF_ALU32_REG(BPF_ADD, R1, R8),
1376                         BPF_ALU32_REG(BPF_ADD, R1, R9), /* R1 == 456 */
1377                         BPF_JMP_IMM(BPF_JEQ, R1, 456, 1),
1378                         BPF_EXIT_INSN(),
1379                         BPF_ALU32_REG(BPF_ADD, R2, R0),
1380                         BPF_ALU32_REG(BPF_ADD, R2, R1),
1381                         BPF_ALU32_REG(BPF_ADD, R2, R2),
1382                         BPF_ALU32_REG(BPF_ADD, R2, R3),
1383                         BPF_ALU32_REG(BPF_ADD, R2, R4),
1384                         BPF_ALU32_REG(BPF_ADD, R2, R5),
1385                         BPF_ALU32_REG(BPF_ADD, R2, R6),
1386                         BPF_ALU32_REG(BPF_ADD, R2, R7),
1387                         BPF_ALU32_REG(BPF_ADD, R2, R8),
1388                         BPF_ALU32_REG(BPF_ADD, R2, R9), /* R2 == 1358 */
1389                         BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1),
1390                         BPF_EXIT_INSN(),
1391                         BPF_ALU32_REG(BPF_ADD, R3, R0),
1392                         BPF_ALU32_REG(BPF_ADD, R3, R1),
1393                         BPF_ALU32_REG(BPF_ADD, R3, R2),
1394                         BPF_ALU32_REG(BPF_ADD, R3, R3),
1395                         BPF_ALU32_REG(BPF_ADD, R3, R4),
1396                         BPF_ALU32_REG(BPF_ADD, R3, R5),
1397                         BPF_ALU32_REG(BPF_ADD, R3, R6),
1398                         BPF_ALU32_REG(BPF_ADD, R3, R7),
1399                         BPF_ALU32_REG(BPF_ADD, R3, R8),
1400                         BPF_ALU32_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
1401                         BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
1402                         BPF_EXIT_INSN(),
1403                         BPF_ALU32_REG(BPF_ADD, R4, R0),
1404                         BPF_ALU32_REG(BPF_ADD, R4, R1),
1405                         BPF_ALU32_REG(BPF_ADD, R4, R2),
1406                         BPF_ALU32_REG(BPF_ADD, R4, R3),
1407                         BPF_ALU32_REG(BPF_ADD, R4, R4),
1408                         BPF_ALU32_REG(BPF_ADD, R4, R5),
1409                         BPF_ALU32_REG(BPF_ADD, R4, R6),
1410                         BPF_ALU32_REG(BPF_ADD, R4, R7),
1411                         BPF_ALU32_REG(BPF_ADD, R4, R8),
1412                         BPF_ALU32_REG(BPF_ADD, R4, R9), /* R4 == 12177 */
1413                         BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1),
1414                         BPF_EXIT_INSN(),
1415                         BPF_ALU32_REG(BPF_ADD, R5, R0),
1416                         BPF_ALU32_REG(BPF_ADD, R5, R1),
1417                         BPF_ALU32_REG(BPF_ADD, R5, R2),
1418                         BPF_ALU32_REG(BPF_ADD, R5, R3),
1419                         BPF_ALU32_REG(BPF_ADD, R5, R4),
1420                         BPF_ALU32_REG(BPF_ADD, R5, R5),
1421                         BPF_ALU32_REG(BPF_ADD, R5, R6),
1422                         BPF_ALU32_REG(BPF_ADD, R5, R7),
1423                         BPF_ALU32_REG(BPF_ADD, R5, R8),
1424                         BPF_ALU32_REG(BPF_ADD, R5, R9), /* R5 == 36518 */
1425                         BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1),
1426                         BPF_EXIT_INSN(),
1427                         BPF_ALU32_REG(BPF_ADD, R6, R0),
1428                         BPF_ALU32_REG(BPF_ADD, R6, R1),
1429                         BPF_ALU32_REG(BPF_ADD, R6, R2),
1430                         BPF_ALU32_REG(BPF_ADD, R6, R3),
1431                         BPF_ALU32_REG(BPF_ADD, R6, R4),
1432                         BPF_ALU32_REG(BPF_ADD, R6, R5),
1433                         BPF_ALU32_REG(BPF_ADD, R6, R6),
1434                         BPF_ALU32_REG(BPF_ADD, R6, R7),
1435                         BPF_ALU32_REG(BPF_ADD, R6, R8),
1436                         BPF_ALU32_REG(BPF_ADD, R6, R9), /* R6 == 109540 */
1437                         BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1),
1438                         BPF_EXIT_INSN(),
1439                         BPF_ALU32_REG(BPF_ADD, R7, R0),
1440                         BPF_ALU32_REG(BPF_ADD, R7, R1),
1441                         BPF_ALU32_REG(BPF_ADD, R7, R2),
1442                         BPF_ALU32_REG(BPF_ADD, R7, R3),
1443                         BPF_ALU32_REG(BPF_ADD, R7, R4),
1444                         BPF_ALU32_REG(BPF_ADD, R7, R5),
1445                         BPF_ALU32_REG(BPF_ADD, R7, R6),
1446                         BPF_ALU32_REG(BPF_ADD, R7, R7),
1447                         BPF_ALU32_REG(BPF_ADD, R7, R8),
1448                         BPF_ALU32_REG(BPF_ADD, R7, R9), /* R7 == 328605 */
1449                         BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1),
1450                         BPF_EXIT_INSN(),
1451                         BPF_ALU32_REG(BPF_ADD, R8, R0),
1452                         BPF_ALU32_REG(BPF_ADD, R8, R1),
1453                         BPF_ALU32_REG(BPF_ADD, R8, R2),
1454                         BPF_ALU32_REG(BPF_ADD, R8, R3),
1455                         BPF_ALU32_REG(BPF_ADD, R8, R4),
1456                         BPF_ALU32_REG(BPF_ADD, R8, R5),
1457                         BPF_ALU32_REG(BPF_ADD, R8, R6),
1458                         BPF_ALU32_REG(BPF_ADD, R8, R7),
1459                         BPF_ALU32_REG(BPF_ADD, R8, R8),
1460                         BPF_ALU32_REG(BPF_ADD, R8, R9), /* R8 == 985799 */
1461                         BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1),
1462                         BPF_EXIT_INSN(),
1463                         BPF_ALU32_REG(BPF_ADD, R9, R0),
1464                         BPF_ALU32_REG(BPF_ADD, R9, R1),
1465                         BPF_ALU32_REG(BPF_ADD, R9, R2),
1466                         BPF_ALU32_REG(BPF_ADD, R9, R3),
1467                         BPF_ALU32_REG(BPF_ADD, R9, R4),
1468                         BPF_ALU32_REG(BPF_ADD, R9, R5),
1469                         BPF_ALU32_REG(BPF_ADD, R9, R6),
1470                         BPF_ALU32_REG(BPF_ADD, R9, R7),
1471                         BPF_ALU32_REG(BPF_ADD, R9, R8),
1472                         BPF_ALU32_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */
1473                         BPF_ALU32_REG(BPF_MOV, R0, R9),
1474                         BPF_EXIT_INSN(),
1475                 },
1476                 INTERNAL,
1477                 { },
1478                 { { 0, 2957380 } }
1479         },
1480         {       /* Mainly checking JIT here. */
1481                 "INT: SUB",
1482                 .u.insns_int = {
1483                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
1484                         BPF_ALU64_IMM(BPF_MOV, R1, 1),
1485                         BPF_ALU64_IMM(BPF_MOV, R2, 2),
1486                         BPF_ALU64_IMM(BPF_MOV, R3, 3),
1487                         BPF_ALU64_IMM(BPF_MOV, R4, 4),
1488                         BPF_ALU64_IMM(BPF_MOV, R5, 5),
1489                         BPF_ALU64_IMM(BPF_MOV, R6, 6),
1490                         BPF_ALU64_IMM(BPF_MOV, R7, 7),
1491                         BPF_ALU64_IMM(BPF_MOV, R8, 8),
1492                         BPF_ALU64_IMM(BPF_MOV, R9, 9),
1493                         BPF_ALU64_REG(BPF_SUB, R0, R0),
1494                         BPF_ALU64_REG(BPF_SUB, R0, R1),
1495                         BPF_ALU64_REG(BPF_SUB, R0, R2),
1496                         BPF_ALU64_REG(BPF_SUB, R0, R3),
1497                         BPF_ALU64_REG(BPF_SUB, R0, R4),
1498                         BPF_ALU64_REG(BPF_SUB, R0, R5),
1499                         BPF_ALU64_REG(BPF_SUB, R0, R6),
1500                         BPF_ALU64_REG(BPF_SUB, R0, R7),
1501                         BPF_ALU64_REG(BPF_SUB, R0, R8),
1502                         BPF_ALU64_REG(BPF_SUB, R0, R9),
1503                         BPF_ALU64_IMM(BPF_SUB, R0, 10),
1504                         BPF_JMP_IMM(BPF_JEQ, R0, -55, 1),
1505                         BPF_EXIT_INSN(),
1506                         BPF_ALU64_REG(BPF_SUB, R1, R0),
1507                         BPF_ALU64_REG(BPF_SUB, R1, R2),
1508                         BPF_ALU64_REG(BPF_SUB, R1, R3),
1509                         BPF_ALU64_REG(BPF_SUB, R1, R4),
1510                         BPF_ALU64_REG(BPF_SUB, R1, R5),
1511                         BPF_ALU64_REG(BPF_SUB, R1, R6),
1512                         BPF_ALU64_REG(BPF_SUB, R1, R7),
1513                         BPF_ALU64_REG(BPF_SUB, R1, R8),
1514                         BPF_ALU64_REG(BPF_SUB, R1, R9),
1515                         BPF_ALU64_IMM(BPF_SUB, R1, 10),
1516                         BPF_ALU64_REG(BPF_SUB, R2, R0),
1517                         BPF_ALU64_REG(BPF_SUB, R2, R1),
1518                         BPF_ALU64_REG(BPF_SUB, R2, R3),
1519                         BPF_ALU64_REG(BPF_SUB, R2, R4),
1520                         BPF_ALU64_REG(BPF_SUB, R2, R5),
1521                         BPF_ALU64_REG(BPF_SUB, R2, R6),
1522                         BPF_ALU64_REG(BPF_SUB, R2, R7),
1523                         BPF_ALU64_REG(BPF_SUB, R2, R8),
1524                         BPF_ALU64_REG(BPF_SUB, R2, R9),
1525                         BPF_ALU64_IMM(BPF_SUB, R2, 10),
1526                         BPF_ALU64_REG(BPF_SUB, R3, R0),
1527                         BPF_ALU64_REG(BPF_SUB, R3, R1),
1528                         BPF_ALU64_REG(BPF_SUB, R3, R2),
1529                         BPF_ALU64_REG(BPF_SUB, R3, R4),
1530                         BPF_ALU64_REG(BPF_SUB, R3, R5),
1531                         BPF_ALU64_REG(BPF_SUB, R3, R6),
1532                         BPF_ALU64_REG(BPF_SUB, R3, R7),
1533                         BPF_ALU64_REG(BPF_SUB, R3, R8),
1534                         BPF_ALU64_REG(BPF_SUB, R3, R9),
1535                         BPF_ALU64_IMM(BPF_SUB, R3, 10),
1536                         BPF_ALU64_REG(BPF_SUB, R4, R0),
1537                         BPF_ALU64_REG(BPF_SUB, R4, R1),
1538                         BPF_ALU64_REG(BPF_SUB, R4, R2),
1539                         BPF_ALU64_REG(BPF_SUB, R4, R3),
1540                         BPF_ALU64_REG(BPF_SUB, R4, R5),
1541                         BPF_ALU64_REG(BPF_SUB, R4, R6),
1542                         BPF_ALU64_REG(BPF_SUB, R4, R7),
1543                         BPF_ALU64_REG(BPF_SUB, R4, R8),
1544                         BPF_ALU64_REG(BPF_SUB, R4, R9),
1545                         BPF_ALU64_IMM(BPF_SUB, R4, 10),
1546                         BPF_ALU64_REG(BPF_SUB, R5, R0),
1547                         BPF_ALU64_REG(BPF_SUB, R5, R1),
1548                         BPF_ALU64_REG(BPF_SUB, R5, R2),
1549                         BPF_ALU64_REG(BPF_SUB, R5, R3),
1550                         BPF_ALU64_REG(BPF_SUB, R5, R4),
1551                         BPF_ALU64_REG(BPF_SUB, R5, R6),
1552                         BPF_ALU64_REG(BPF_SUB, R5, R7),
1553                         BPF_ALU64_REG(BPF_SUB, R5, R8),
1554                         BPF_ALU64_REG(BPF_SUB, R5, R9),
1555                         BPF_ALU64_IMM(BPF_SUB, R5, 10),
1556                         BPF_ALU64_REG(BPF_SUB, R6, R0),
1557                         BPF_ALU64_REG(BPF_SUB, R6, R1),
1558                         BPF_ALU64_REG(BPF_SUB, R6, R2),
1559                         BPF_ALU64_REG(BPF_SUB, R6, R3),
1560                         BPF_ALU64_REG(BPF_SUB, R6, R4),
1561                         BPF_ALU64_REG(BPF_SUB, R6, R5),
1562                         BPF_ALU64_REG(BPF_SUB, R6, R7),
1563                         BPF_ALU64_REG(BPF_SUB, R6, R8),
1564                         BPF_ALU64_REG(BPF_SUB, R6, R9),
1565                         BPF_ALU64_IMM(BPF_SUB, R6, 10),
1566                         BPF_ALU64_REG(BPF_SUB, R7, R0),
1567                         BPF_ALU64_REG(BPF_SUB, R7, R1),
1568                         BPF_ALU64_REG(BPF_SUB, R7, R2),
1569                         BPF_ALU64_REG(BPF_SUB, R7, R3),
1570                         BPF_ALU64_REG(BPF_SUB, R7, R4),
1571                         BPF_ALU64_REG(BPF_SUB, R7, R5),
1572                         BPF_ALU64_REG(BPF_SUB, R7, R6),
1573                         BPF_ALU64_REG(BPF_SUB, R7, R8),
1574                         BPF_ALU64_REG(BPF_SUB, R7, R9),
1575                         BPF_ALU64_IMM(BPF_SUB, R7, 10),
1576                         BPF_ALU64_REG(BPF_SUB, R8, R0),
1577                         BPF_ALU64_REG(BPF_SUB, R8, R1),
1578                         BPF_ALU64_REG(BPF_SUB, R8, R2),
1579                         BPF_ALU64_REG(BPF_SUB, R8, R3),
1580                         BPF_ALU64_REG(BPF_SUB, R8, R4),
1581                         BPF_ALU64_REG(BPF_SUB, R8, R5),
1582                         BPF_ALU64_REG(BPF_SUB, R8, R6),
1583                         BPF_ALU64_REG(BPF_SUB, R8, R7),
1584                         BPF_ALU64_REG(BPF_SUB, R8, R9),
1585                         BPF_ALU64_IMM(BPF_SUB, R8, 10),
1586                         BPF_ALU64_REG(BPF_SUB, R9, R0),
1587                         BPF_ALU64_REG(BPF_SUB, R9, R1),
1588                         BPF_ALU64_REG(BPF_SUB, R9, R2),
1589                         BPF_ALU64_REG(BPF_SUB, R9, R3),
1590                         BPF_ALU64_REG(BPF_SUB, R9, R4),
1591                         BPF_ALU64_REG(BPF_SUB, R9, R5),
1592                         BPF_ALU64_REG(BPF_SUB, R9, R6),
1593                         BPF_ALU64_REG(BPF_SUB, R9, R7),
1594                         BPF_ALU64_REG(BPF_SUB, R9, R8),
1595                         BPF_ALU64_IMM(BPF_SUB, R9, 10),
1596                         BPF_ALU64_IMM(BPF_SUB, R0, 10),
1597                         BPF_ALU64_IMM(BPF_NEG, R0, 0),
1598                         BPF_ALU64_REG(BPF_SUB, R0, R1),
1599                         BPF_ALU64_REG(BPF_SUB, R0, R2),
1600                         BPF_ALU64_REG(BPF_SUB, R0, R3),
1601                         BPF_ALU64_REG(BPF_SUB, R0, R4),
1602                         BPF_ALU64_REG(BPF_SUB, R0, R5),
1603                         BPF_ALU64_REG(BPF_SUB, R0, R6),
1604                         BPF_ALU64_REG(BPF_SUB, R0, R7),
1605                         BPF_ALU64_REG(BPF_SUB, R0, R8),
1606                         BPF_ALU64_REG(BPF_SUB, R0, R9),
1607                         BPF_EXIT_INSN(),
1608                 },
1609                 INTERNAL,
1610                 { },
1611                 { { 0, 11 } }
1612         },
1613         {       /* Mainly checking JIT here. */
1614                 "INT: XOR",
1615                 .u.insns_int = {
1616                         BPF_ALU64_REG(BPF_SUB, R0, R0),
1617                         BPF_ALU64_REG(BPF_XOR, R1, R1),
1618                         BPF_JMP_REG(BPF_JEQ, R0, R1, 1),
1619                         BPF_EXIT_INSN(),
1620                         BPF_ALU64_IMM(BPF_MOV, R0, 10),
1621                         BPF_ALU64_IMM(BPF_MOV, R1, -1),
1622                         BPF_ALU64_REG(BPF_SUB, R1, R1),
1623                         BPF_ALU64_REG(BPF_XOR, R2, R2),
1624                         BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
1625                         BPF_EXIT_INSN(),
1626                         BPF_ALU64_REG(BPF_SUB, R2, R2),
1627                         BPF_ALU64_REG(BPF_XOR, R3, R3),
1628                         BPF_ALU64_IMM(BPF_MOV, R0, 10),
1629                         BPF_ALU64_IMM(BPF_MOV, R1, -1),
1630                         BPF_JMP_REG(BPF_JEQ, R2, R3, 1),
1631                         BPF_EXIT_INSN(),
1632                         BPF_ALU64_REG(BPF_SUB, R3, R3),
1633                         BPF_ALU64_REG(BPF_XOR, R4, R4),
1634                         BPF_ALU64_IMM(BPF_MOV, R2, 1),
1635                         BPF_ALU64_IMM(BPF_MOV, R5, -1),
1636                         BPF_JMP_REG(BPF_JEQ, R3, R4, 1),
1637                         BPF_EXIT_INSN(),
1638                         BPF_ALU64_REG(BPF_SUB, R4, R4),
1639                         BPF_ALU64_REG(BPF_XOR, R5, R5),
1640                         BPF_ALU64_IMM(BPF_MOV, R3, 1),
1641                         BPF_ALU64_IMM(BPF_MOV, R7, -1),
1642                         BPF_JMP_REG(BPF_JEQ, R5, R4, 1),
1643                         BPF_EXIT_INSN(),
1644                         BPF_ALU64_IMM(BPF_MOV, R5, 1),
1645                         BPF_ALU64_REG(BPF_SUB, R5, R5),
1646                         BPF_ALU64_REG(BPF_XOR, R6, R6),
1647                         BPF_ALU64_IMM(BPF_MOV, R1, 1),
1648                         BPF_ALU64_IMM(BPF_MOV, R8, -1),
1649                         BPF_JMP_REG(BPF_JEQ, R5, R6, 1),
1650                         BPF_EXIT_INSN(),
1651                         BPF_ALU64_REG(BPF_SUB, R6, R6),
1652                         BPF_ALU64_REG(BPF_XOR, R7, R7),
1653                         BPF_JMP_REG(BPF_JEQ, R7, R6, 1),
1654                         BPF_EXIT_INSN(),
1655                         BPF_ALU64_REG(BPF_SUB, R7, R7),
1656                         BPF_ALU64_REG(BPF_XOR, R8, R8),
1657                         BPF_JMP_REG(BPF_JEQ, R7, R8, 1),
1658                         BPF_EXIT_INSN(),
1659                         BPF_ALU64_REG(BPF_SUB, R8, R8),
1660                         BPF_ALU64_REG(BPF_XOR, R9, R9),
1661                         BPF_JMP_REG(BPF_JEQ, R9, R8, 1),
1662                         BPF_EXIT_INSN(),
1663                         BPF_ALU64_REG(BPF_SUB, R9, R9),
1664                         BPF_ALU64_REG(BPF_XOR, R0, R0),
1665                         BPF_JMP_REG(BPF_JEQ, R9, R0, 1),
1666                         BPF_EXIT_INSN(),
1667                         BPF_ALU64_REG(BPF_SUB, R1, R1),
1668                         BPF_ALU64_REG(BPF_XOR, R0, R0),
1669                         BPF_JMP_REG(BPF_JEQ, R9, R0, 2),
1670                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
1671                         BPF_EXIT_INSN(),
1672                         BPF_ALU64_IMM(BPF_MOV, R0, 1),
1673                         BPF_EXIT_INSN(),
1674                 },
1675                 INTERNAL,
1676                 { },
1677                 { { 0, 1 } }
1678         },
1679         {       /* Mainly checking JIT here. */
1680                 "INT: MUL",
1681                 .u.insns_int = {
1682                         BPF_ALU64_IMM(BPF_MOV, R0, 11),
1683                         BPF_ALU64_IMM(BPF_MOV, R1, 1),
1684                         BPF_ALU64_IMM(BPF_MOV, R2, 2),
1685                         BPF_ALU64_IMM(BPF_MOV, R3, 3),
1686                         BPF_ALU64_IMM(BPF_MOV, R4, 4),
1687                         BPF_ALU64_IMM(BPF_MOV, R5, 5),
1688                         BPF_ALU64_IMM(BPF_MOV, R6, 6),
1689                         BPF_ALU64_IMM(BPF_MOV, R7, 7),
1690                         BPF_ALU64_IMM(BPF_MOV, R8, 8),
1691                         BPF_ALU64_IMM(BPF_MOV, R9, 9),
1692                         BPF_ALU64_REG(BPF_MUL, R0, R0),
1693                         BPF_ALU64_REG(BPF_MUL, R0, R1),
1694                         BPF_ALU64_REG(BPF_MUL, R0, R2),
1695                         BPF_ALU64_REG(BPF_MUL, R0, R3),
1696                         BPF_ALU64_REG(BPF_MUL, R0, R4),
1697                         BPF_ALU64_REG(BPF_MUL, R0, R5),
1698                         BPF_ALU64_REG(BPF_MUL, R0, R6),
1699                         BPF_ALU64_REG(BPF_MUL, R0, R7),
1700                         BPF_ALU64_REG(BPF_MUL, R0, R8),
1701                         BPF_ALU64_REG(BPF_MUL, R0, R9),
1702                         BPF_ALU64_IMM(BPF_MUL, R0, 10),
1703                         BPF_JMP_IMM(BPF_JEQ, R0, 439084800, 1),
1704                         BPF_EXIT_INSN(),
1705                         BPF_ALU64_REG(BPF_MUL, R1, R0),
1706                         BPF_ALU64_REG(BPF_MUL, R1, R2),
1707                         BPF_ALU64_REG(BPF_MUL, R1, R3),
1708                         BPF_ALU64_REG(BPF_MUL, R1, R4),
1709                         BPF_ALU64_REG(BPF_MUL, R1, R5),
1710                         BPF_ALU64_REG(BPF_MUL, R1, R6),
1711                         BPF_ALU64_REG(BPF_MUL, R1, R7),
1712                         BPF_ALU64_REG(BPF_MUL, R1, R8),
1713                         BPF_ALU64_REG(BPF_MUL, R1, R9),
1714                         BPF_ALU64_IMM(BPF_MUL, R1, 10),
1715                         BPF_ALU64_REG(BPF_MOV, R2, R1),
1716                         BPF_ALU64_IMM(BPF_RSH, R2, 32),
1717                         BPF_JMP_IMM(BPF_JEQ, R2, 0x5a924, 1),
1718                         BPF_EXIT_INSN(),
1719                         BPF_ALU64_IMM(BPF_LSH, R1, 32),
1720                         BPF_ALU64_IMM(BPF_ARSH, R1, 32),
1721                         BPF_JMP_IMM(BPF_JEQ, R1, 0xebb90000, 1),
1722                         BPF_EXIT_INSN(),
1723                         BPF_ALU64_REG(BPF_MUL, R2, R0),
1724                         BPF_ALU64_REG(BPF_MUL, R2, R1),
1725                         BPF_ALU64_REG(BPF_MUL, R2, R3),
1726                         BPF_ALU64_REG(BPF_MUL, R2, R4),
1727                         BPF_ALU64_REG(BPF_MUL, R2, R5),
1728                         BPF_ALU64_REG(BPF_MUL, R2, R6),
1729                         BPF_ALU64_REG(BPF_MUL, R2, R7),
1730                         BPF_ALU64_REG(BPF_MUL, R2, R8),
1731                         BPF_ALU64_REG(BPF_MUL, R2, R9),
1732                         BPF_ALU64_IMM(BPF_MUL, R2, 10),
1733                         BPF_ALU64_IMM(BPF_RSH, R2, 32),
1734                         BPF_ALU64_REG(BPF_MOV, R0, R2),
1735                         BPF_EXIT_INSN(),
1736                 },
1737                 INTERNAL,
1738                 { },
1739                 { { 0, 0x35d97ef2 } }
1740         },
1741         {       /* Mainly checking JIT here. */
1742                 "MOV REG64",
1743                 .u.insns_int = {
1744                         BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
1745                         BPF_MOV64_REG(R1, R0),
1746                         BPF_MOV64_REG(R2, R1),
1747                         BPF_MOV64_REG(R3, R2),
1748                         BPF_MOV64_REG(R4, R3),
1749                         BPF_MOV64_REG(R5, R4),
1750                         BPF_MOV64_REG(R6, R5),
1751                         BPF_MOV64_REG(R7, R6),
1752                         BPF_MOV64_REG(R8, R7),
1753                         BPF_MOV64_REG(R9, R8),
1754                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
1755                         BPF_ALU64_IMM(BPF_MOV, R1, 0),
1756                         BPF_ALU64_IMM(BPF_MOV, R2, 0),
1757                         BPF_ALU64_IMM(BPF_MOV, R3, 0),
1758                         BPF_ALU64_IMM(BPF_MOV, R4, 0),
1759                         BPF_ALU64_IMM(BPF_MOV, R5, 0),
1760                         BPF_ALU64_IMM(BPF_MOV, R6, 0),
1761                         BPF_ALU64_IMM(BPF_MOV, R7, 0),
1762                         BPF_ALU64_IMM(BPF_MOV, R8, 0),
1763                         BPF_ALU64_IMM(BPF_MOV, R9, 0),
1764                         BPF_ALU64_REG(BPF_ADD, R0, R0),
1765                         BPF_ALU64_REG(BPF_ADD, R0, R1),
1766                         BPF_ALU64_REG(BPF_ADD, R0, R2),
1767                         BPF_ALU64_REG(BPF_ADD, R0, R3),
1768                         BPF_ALU64_REG(BPF_ADD, R0, R4),
1769                         BPF_ALU64_REG(BPF_ADD, R0, R5),
1770                         BPF_ALU64_REG(BPF_ADD, R0, R6),
1771                         BPF_ALU64_REG(BPF_ADD, R0, R7),
1772                         BPF_ALU64_REG(BPF_ADD, R0, R8),
1773                         BPF_ALU64_REG(BPF_ADD, R0, R9),
1774                         BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
1775                         BPF_EXIT_INSN(),
1776                 },
1777                 INTERNAL,
1778                 { },
1779                 { { 0, 0xfefe } }
1780         },
1781         {       /* Mainly checking JIT here. */
1782                 "MOV REG32",
1783                 .u.insns_int = {
1784                         BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
1785                         BPF_MOV64_REG(R1, R0),
1786                         BPF_MOV64_REG(R2, R1),
1787                         BPF_MOV64_REG(R3, R2),
1788                         BPF_MOV64_REG(R4, R3),
1789                         BPF_MOV64_REG(R5, R4),
1790                         BPF_MOV64_REG(R6, R5),
1791                         BPF_MOV64_REG(R7, R6),
1792                         BPF_MOV64_REG(R8, R7),
1793                         BPF_MOV64_REG(R9, R8),
1794                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
1795                         BPF_ALU32_IMM(BPF_MOV, R1, 0),
1796                         BPF_ALU32_IMM(BPF_MOV, R2, 0),
1797                         BPF_ALU32_IMM(BPF_MOV, R3, 0),
1798                         BPF_ALU32_IMM(BPF_MOV, R4, 0),
1799                         BPF_ALU32_IMM(BPF_MOV, R5, 0),
1800                         BPF_ALU32_IMM(BPF_MOV, R6, 0),
1801                         BPF_ALU32_IMM(BPF_MOV, R7, 0),
1802                         BPF_ALU32_IMM(BPF_MOV, R8, 0),
1803                         BPF_ALU32_IMM(BPF_MOV, R9, 0),
1804                         BPF_ALU64_REG(BPF_ADD, R0, R0),
1805                         BPF_ALU64_REG(BPF_ADD, R0, R1),
1806                         BPF_ALU64_REG(BPF_ADD, R0, R2),
1807                         BPF_ALU64_REG(BPF_ADD, R0, R3),
1808                         BPF_ALU64_REG(BPF_ADD, R0, R4),
1809                         BPF_ALU64_REG(BPF_ADD, R0, R5),
1810                         BPF_ALU64_REG(BPF_ADD, R0, R6),
1811                         BPF_ALU64_REG(BPF_ADD, R0, R7),
1812                         BPF_ALU64_REG(BPF_ADD, R0, R8),
1813                         BPF_ALU64_REG(BPF_ADD, R0, R9),
1814                         BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
1815                         BPF_EXIT_INSN(),
1816                 },
1817                 INTERNAL,
1818                 { },
1819                 { { 0, 0xfefe } }
1820         },
1821         {       /* Mainly checking JIT here. */
1822                 "LD IMM64",
1823                 .u.insns_int = {
1824                         BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
1825                         BPF_MOV64_REG(R1, R0),
1826                         BPF_MOV64_REG(R2, R1),
1827                         BPF_MOV64_REG(R3, R2),
1828                         BPF_MOV64_REG(R4, R3),
1829                         BPF_MOV64_REG(R5, R4),
1830                         BPF_MOV64_REG(R6, R5),
1831                         BPF_MOV64_REG(R7, R6),
1832                         BPF_MOV64_REG(R8, R7),
1833                         BPF_MOV64_REG(R9, R8),
1834                         BPF_LD_IMM64(R0, 0x0LL),
1835                         BPF_LD_IMM64(R1, 0x0LL),
1836                         BPF_LD_IMM64(R2, 0x0LL),
1837                         BPF_LD_IMM64(R3, 0x0LL),
1838                         BPF_LD_IMM64(R4, 0x0LL),
1839                         BPF_LD_IMM64(R5, 0x0LL),
1840                         BPF_LD_IMM64(R6, 0x0LL),
1841                         BPF_LD_IMM64(R7, 0x0LL),
1842                         BPF_LD_IMM64(R8, 0x0LL),
1843                         BPF_LD_IMM64(R9, 0x0LL),
1844                         BPF_ALU64_REG(BPF_ADD, R0, R0),
1845                         BPF_ALU64_REG(BPF_ADD, R0, R1),
1846                         BPF_ALU64_REG(BPF_ADD, R0, R2),
1847                         BPF_ALU64_REG(BPF_ADD, R0, R3),
1848                         BPF_ALU64_REG(BPF_ADD, R0, R4),
1849                         BPF_ALU64_REG(BPF_ADD, R0, R5),
1850                         BPF_ALU64_REG(BPF_ADD, R0, R6),
1851                         BPF_ALU64_REG(BPF_ADD, R0, R7),
1852                         BPF_ALU64_REG(BPF_ADD, R0, R8),
1853                         BPF_ALU64_REG(BPF_ADD, R0, R9),
1854                         BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
1855                         BPF_EXIT_INSN(),
1856                 },
1857                 INTERNAL,
1858                 { },
1859                 { { 0, 0xfefe } }
1860         },
1861         {
1862                 "INT: ALU MIX",
1863                 .u.insns_int = {
1864                         BPF_ALU64_IMM(BPF_MOV, R0, 11),
1865                         BPF_ALU64_IMM(BPF_ADD, R0, -1),
1866                         BPF_ALU64_IMM(BPF_MOV, R2, 2),
1867                         BPF_ALU64_IMM(BPF_XOR, R2, 3),
1868                         BPF_ALU64_REG(BPF_DIV, R0, R2),
1869                         BPF_JMP_IMM(BPF_JEQ, R0, 10, 1),
1870                         BPF_EXIT_INSN(),
1871                         BPF_ALU64_IMM(BPF_MOD, R0, 3),
1872                         BPF_JMP_IMM(BPF_JEQ, R0, 1, 1),
1873                         BPF_EXIT_INSN(),
1874                         BPF_ALU64_IMM(BPF_MOV, R0, -1),
1875                         BPF_EXIT_INSN(),
1876                 },
1877                 INTERNAL,
1878                 { },
1879                 { { 0, -1 } }
1880         },
1881         {
1882                 "INT: shifts by register",
1883                 .u.insns_int = {
1884                         BPF_MOV64_IMM(R0, -1234),
1885                         BPF_MOV64_IMM(R1, 1),
1886                         BPF_ALU32_REG(BPF_RSH, R0, R1),
1887                         BPF_JMP_IMM(BPF_JEQ, R0, 0x7ffffd97, 1),
1888                         BPF_EXIT_INSN(),
1889                         BPF_MOV64_IMM(R2, 1),
1890                         BPF_ALU64_REG(BPF_LSH, R0, R2),
1891                         BPF_MOV32_IMM(R4, -1234),
1892                         BPF_JMP_REG(BPF_JEQ, R0, R4, 1),
1893                         BPF_EXIT_INSN(),
1894                         BPF_ALU64_IMM(BPF_AND, R4, 63),
1895                         BPF_ALU64_REG(BPF_LSH, R0, R4), /* R0 <= 46 */
1896                         BPF_MOV64_IMM(R3, 47),
1897                         BPF_ALU64_REG(BPF_ARSH, R0, R3),
1898                         BPF_JMP_IMM(BPF_JEQ, R0, -617, 1),
1899                         BPF_EXIT_INSN(),
1900                         BPF_MOV64_IMM(R2, 1),
1901                         BPF_ALU64_REG(BPF_LSH, R4, R2), /* R4 = 46 << 1 */
1902                         BPF_JMP_IMM(BPF_JEQ, R4, 92, 1),
1903                         BPF_EXIT_INSN(),
1904                         BPF_MOV64_IMM(R4, 4),
1905                         BPF_ALU64_REG(BPF_LSH, R4, R4), /* R4 = 4 << 4 */
1906                         BPF_JMP_IMM(BPF_JEQ, R4, 64, 1),
1907                         BPF_EXIT_INSN(),
1908                         BPF_MOV64_IMM(R4, 5),
1909                         BPF_ALU32_REG(BPF_LSH, R4, R4), /* R4 = 5 << 5 */
1910                         BPF_JMP_IMM(BPF_JEQ, R4, 160, 1),
1911                         BPF_EXIT_INSN(),
1912                         BPF_MOV64_IMM(R0, -1),
1913                         BPF_EXIT_INSN(),
1914                 },
1915                 INTERNAL,
1916                 { },
1917                 { { 0, -1 } }
1918         },
1919         {
1920                 "check: missing ret",
1921                 .u.insns = {
1922                         BPF_STMT(BPF_LD | BPF_IMM, 1),
1923                 },
1924                 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
1925                 { },
1926                 { },
1927                 .fill_helper = NULL,
1928                 .expected_errcode = -EINVAL,
1929         },
1930         {
1931                 "check: div_k_0",
1932                 .u.insns = {
1933                         BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0),
1934                         BPF_STMT(BPF_RET | BPF_K, 0)
1935                 },
1936                 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
1937                 { },
1938                 { },
1939                 .fill_helper = NULL,
1940                 .expected_errcode = -EINVAL,
1941         },
1942         {
1943                 "check: unknown insn",
1944                 .u.insns = {
1945                         /* seccomp insn, rejected in socket filter */
1946                         BPF_STMT(BPF_LDX | BPF_W | BPF_ABS, 0),
1947                         BPF_STMT(BPF_RET | BPF_K, 0)
1948                 },
1949                 CLASSIC | FLAG_EXPECTED_FAIL,
1950                 { },
1951                 { },
1952                 .fill_helper = NULL,
1953                 .expected_errcode = -EINVAL,
1954         },
1955         {
1956                 "check: out of range spill/fill",
1957                 .u.insns = {
1958                         BPF_STMT(BPF_STX, 16),
1959                         BPF_STMT(BPF_RET | BPF_K, 0)
1960                 },
1961                 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
1962                 { },
1963                 { },
1964                 .fill_helper = NULL,
1965                 .expected_errcode = -EINVAL,
1966         },
1967         {
1968                 "JUMPS + HOLES",
1969                 .u.insns = {
1970                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1971                         BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 15),
1972                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1973                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1974                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1975                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1976                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1977                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1978                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1979                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1980                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1981                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1982                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1983                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1984                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1985                         BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 3, 4),
1986                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1987                         BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 1, 2),
1988                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1989                         BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
1990                         BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
1991                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1992                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1993                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1994                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1995                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1996                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1997                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1998                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1999                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2000                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2001                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2002                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2003                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2004                         BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 2, 3),
2005                         BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 1, 2),
2006                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2007                         BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
2008                         BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
2009                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2010                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2011                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2012                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2013                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2014                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2015                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2016                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2017                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2018                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2019                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2020                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2021                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2022                         BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 2, 3),
2023                         BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 1, 2),
2024                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2025                         BPF_STMT(BPF_RET | BPF_A, 0),
2026                         BPF_STMT(BPF_RET | BPF_A, 0),
2027                 },
2028                 CLASSIC,
2029                 { 0x00, 0x1b, 0x21, 0x3c, 0x9d, 0xf8,
2030                   0x90, 0xe2, 0xba, 0x0a, 0x56, 0xb4,
2031                   0x08, 0x00,
2032                   0x45, 0x00, 0x00, 0x28, 0x00, 0x00,
2033                   0x20, 0x00, 0x40, 0x11, 0x00, 0x00, /* IP header */
2034                   0xc0, 0xa8, 0x33, 0x01,
2035                   0xc0, 0xa8, 0x33, 0x02,
2036                   0xbb, 0xb6,
2037                   0xa9, 0xfa,
2038                   0x00, 0x14, 0x00, 0x00,
2039                   0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2040                   0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2041                   0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2042                   0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2043                   0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2044                   0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2045                   0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2046                   0xcc, 0xcc, 0xcc, 0xcc },
2047                 { { 88, 0x001b } }
2048         },
2049         {
2050                 "check: RET X",
2051                 .u.insns = {
2052                         BPF_STMT(BPF_RET | BPF_X, 0),
2053                 },
2054                 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2055                 { },
2056                 { },
2057                 .fill_helper = NULL,
2058                 .expected_errcode = -EINVAL,
2059         },
2060         {
2061                 "check: LDX + RET X",
2062                 .u.insns = {
2063                         BPF_STMT(BPF_LDX | BPF_IMM, 42),
2064                         BPF_STMT(BPF_RET | BPF_X, 0),
2065                 },
2066                 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2067                 { },
2068                 { },
2069                 .fill_helper = NULL,
2070                 .expected_errcode = -EINVAL,
2071         },
2072         {       /* Mainly checking JIT here. */
2073                 "M[]: alt STX + LDX",
2074                 .u.insns = {
2075                         BPF_STMT(BPF_LDX | BPF_IMM, 100),
2076                         BPF_STMT(BPF_STX, 0),
2077                         BPF_STMT(BPF_LDX | BPF_MEM, 0),
2078                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2079                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2080                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2081                         BPF_STMT(BPF_STX, 1),
2082                         BPF_STMT(BPF_LDX | BPF_MEM, 1),
2083                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2084                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2085                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2086                         BPF_STMT(BPF_STX, 2),
2087                         BPF_STMT(BPF_LDX | BPF_MEM, 2),
2088                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2089                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2090                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2091                         BPF_STMT(BPF_STX, 3),
2092                         BPF_STMT(BPF_LDX | BPF_MEM, 3),
2093                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2094                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2095                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2096                         BPF_STMT(BPF_STX, 4),
2097                         BPF_STMT(BPF_LDX | BPF_MEM, 4),
2098                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2099                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2100                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2101                         BPF_STMT(BPF_STX, 5),
2102                         BPF_STMT(BPF_LDX | BPF_MEM, 5),
2103                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2104                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2105                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2106                         BPF_STMT(BPF_STX, 6),
2107                         BPF_STMT(BPF_LDX | BPF_MEM, 6),
2108                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2109                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2110                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2111                         BPF_STMT(BPF_STX, 7),
2112                         BPF_STMT(BPF_LDX | BPF_MEM, 7),
2113                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2114                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2115                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2116                         BPF_STMT(BPF_STX, 8),
2117                         BPF_STMT(BPF_LDX | BPF_MEM, 8),
2118                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2119                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2120                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2121                         BPF_STMT(BPF_STX, 9),
2122                         BPF_STMT(BPF_LDX | BPF_MEM, 9),
2123                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2124                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2125                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2126                         BPF_STMT(BPF_STX, 10),
2127                         BPF_STMT(BPF_LDX | BPF_MEM, 10),
2128                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2129                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2130                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2131                         BPF_STMT(BPF_STX, 11),
2132                         BPF_STMT(BPF_LDX | BPF_MEM, 11),
2133                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2134                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2135                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2136                         BPF_STMT(BPF_STX, 12),
2137                         BPF_STMT(BPF_LDX | BPF_MEM, 12),
2138                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2139                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2140                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2141                         BPF_STMT(BPF_STX, 13),
2142                         BPF_STMT(BPF_LDX | BPF_MEM, 13),
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, 14),
2147                         BPF_STMT(BPF_LDX | BPF_MEM, 14),
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, 15),
2152                         BPF_STMT(BPF_LDX | BPF_MEM, 15),
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_RET | BPF_A, 0),
2157                 },
2158                 CLASSIC | FLAG_NO_DATA,
2159                 { },
2160                 { { 0, 116 } },
2161         },
2162         {       /* Mainly checking JIT here. */
2163                 "M[]: full STX + full LDX",
2164                 .u.insns = {
2165                         BPF_STMT(BPF_LDX | BPF_IMM, 0xbadfeedb),
2166                         BPF_STMT(BPF_STX, 0),
2167                         BPF_STMT(BPF_LDX | BPF_IMM, 0xecabedae),
2168                         BPF_STMT(BPF_STX, 1),
2169                         BPF_STMT(BPF_LDX | BPF_IMM, 0xafccfeaf),
2170                         BPF_STMT(BPF_STX, 2),
2171                         BPF_STMT(BPF_LDX | BPF_IMM, 0xbffdcedc),
2172                         BPF_STMT(BPF_STX, 3),
2173                         BPF_STMT(BPF_LDX | BPF_IMM, 0xfbbbdccb),
2174                         BPF_STMT(BPF_STX, 4),
2175                         BPF_STMT(BPF_LDX | BPF_IMM, 0xfbabcbda),
2176                         BPF_STMT(BPF_STX, 5),
2177                         BPF_STMT(BPF_LDX | BPF_IMM, 0xaedecbdb),
2178                         BPF_STMT(BPF_STX, 6),
2179                         BPF_STMT(BPF_LDX | BPF_IMM, 0xadebbade),
2180                         BPF_STMT(BPF_STX, 7),
2181                         BPF_STMT(BPF_LDX | BPF_IMM, 0xfcfcfaec),
2182                         BPF_STMT(BPF_STX, 8),
2183                         BPF_STMT(BPF_LDX | BPF_IMM, 0xbcdddbdc),
2184                         BPF_STMT(BPF_STX, 9),
2185                         BPF_STMT(BPF_LDX | BPF_IMM, 0xfeefdfac),
2186                         BPF_STMT(BPF_STX, 10),
2187                         BPF_STMT(BPF_LDX | BPF_IMM, 0xcddcdeea),
2188                         BPF_STMT(BPF_STX, 11),
2189                         BPF_STMT(BPF_LDX | BPF_IMM, 0xaccfaebb),
2190                         BPF_STMT(BPF_STX, 12),
2191                         BPF_STMT(BPF_LDX | BPF_IMM, 0xbdcccdcf),
2192                         BPF_STMT(BPF_STX, 13),
2193                         BPF_STMT(BPF_LDX | BPF_IMM, 0xaaedecde),
2194                         BPF_STMT(BPF_STX, 14),
2195                         BPF_STMT(BPF_LDX | BPF_IMM, 0xfaeacdad),
2196                         BPF_STMT(BPF_STX, 15),
2197                         BPF_STMT(BPF_LDX | BPF_MEM, 0),
2198                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2199                         BPF_STMT(BPF_LDX | BPF_MEM, 1),
2200                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2201                         BPF_STMT(BPF_LDX | BPF_MEM, 2),
2202                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2203                         BPF_STMT(BPF_LDX | BPF_MEM, 3),
2204                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2205                         BPF_STMT(BPF_LDX | BPF_MEM, 4),
2206                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2207                         BPF_STMT(BPF_LDX | BPF_MEM, 5),
2208                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2209                         BPF_STMT(BPF_LDX | BPF_MEM, 6),
2210                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2211                         BPF_STMT(BPF_LDX | BPF_MEM, 7),
2212                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2213                         BPF_STMT(BPF_LDX | BPF_MEM, 8),
2214                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2215                         BPF_STMT(BPF_LDX | BPF_MEM, 9),
2216                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2217                         BPF_STMT(BPF_LDX | BPF_MEM, 10),
2218                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2219                         BPF_STMT(BPF_LDX | BPF_MEM, 11),
2220                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2221                         BPF_STMT(BPF_LDX | BPF_MEM, 12),
2222                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2223                         BPF_STMT(BPF_LDX | BPF_MEM, 13),
2224                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2225                         BPF_STMT(BPF_LDX | BPF_MEM, 14),
2226                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2227                         BPF_STMT(BPF_LDX | BPF_MEM, 15),
2228                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2229                         BPF_STMT(BPF_RET | BPF_A, 0),
2230                 },
2231                 CLASSIC | FLAG_NO_DATA,
2232                 { },
2233                 { { 0, 0x2a5a5e5 } },
2234         },
2235         {
2236                 "check: SKF_AD_MAX",
2237                 .u.insns = {
2238                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2239                                  SKF_AD_OFF + SKF_AD_MAX),
2240                         BPF_STMT(BPF_RET | BPF_A, 0),
2241                 },
2242                 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2243                 { },
2244                 { },
2245                 .fill_helper = NULL,
2246                 .expected_errcode = -EINVAL,
2247         },
2248         {       /* Passes checker but fails during runtime. */
2249                 "LD [SKF_AD_OFF-1]",
2250                 .u.insns = {
2251                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2252                                  SKF_AD_OFF - 1),
2253                         BPF_STMT(BPF_RET | BPF_K, 1),
2254                 },
2255                 CLASSIC,
2256                 { },
2257                 { { 1, 0 } },
2258         },
2259         {
2260                 "load 64-bit immediate",
2261                 .u.insns_int = {
2262                         BPF_LD_IMM64(R1, 0x567800001234LL),
2263                         BPF_MOV64_REG(R2, R1),
2264                         BPF_MOV64_REG(R3, R2),
2265                         BPF_ALU64_IMM(BPF_RSH, R2, 32),
2266                         BPF_ALU64_IMM(BPF_LSH, R3, 32),
2267                         BPF_ALU64_IMM(BPF_RSH, R3, 32),
2268                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
2269                         BPF_JMP_IMM(BPF_JEQ, R2, 0x5678, 1),
2270                         BPF_EXIT_INSN(),
2271                         BPF_JMP_IMM(BPF_JEQ, R3, 0x1234, 1),
2272                         BPF_EXIT_INSN(),
2273                         BPF_LD_IMM64(R0, 0x1ffffffffLL),
2274                         BPF_ALU64_IMM(BPF_RSH, R0, 32), /* R0 = 1 */
2275                         BPF_EXIT_INSN(),
2276                 },
2277                 INTERNAL,
2278                 { },
2279                 { { 0, 1 } }
2280         },
2281         /* BPF_ALU | BPF_MOV | BPF_X */
2282         {
2283                 "ALU_MOV_X: dst = 2",
2284                 .u.insns_int = {
2285                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
2286                         BPF_ALU32_REG(BPF_MOV, R0, R1),
2287                         BPF_EXIT_INSN(),
2288                 },
2289                 INTERNAL,
2290                 { },
2291                 { { 0, 2 } },
2292         },
2293         {
2294                 "ALU_MOV_X: dst = 4294967295",
2295                 .u.insns_int = {
2296                         BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
2297                         BPF_ALU32_REG(BPF_MOV, R0, R1),
2298                         BPF_EXIT_INSN(),
2299                 },
2300                 INTERNAL,
2301                 { },
2302                 { { 0, 4294967295U } },
2303         },
2304         {
2305                 "ALU64_MOV_X: dst = 2",
2306                 .u.insns_int = {
2307                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
2308                         BPF_ALU64_REG(BPF_MOV, R0, R1),
2309                         BPF_EXIT_INSN(),
2310                 },
2311                 INTERNAL,
2312                 { },
2313                 { { 0, 2 } },
2314         },
2315         {
2316                 "ALU64_MOV_X: dst = 4294967295",
2317                 .u.insns_int = {
2318                         BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
2319                         BPF_ALU64_REG(BPF_MOV, R0, R1),
2320                         BPF_EXIT_INSN(),
2321                 },
2322                 INTERNAL,
2323                 { },
2324                 { { 0, 4294967295U } },
2325         },
2326         /* BPF_ALU | BPF_MOV | BPF_K */
2327         {
2328                 "ALU_MOV_K: dst = 2",
2329                 .u.insns_int = {
2330                         BPF_ALU32_IMM(BPF_MOV, R0, 2),
2331                         BPF_EXIT_INSN(),
2332                 },
2333                 INTERNAL,
2334                 { },
2335                 { { 0, 2 } },
2336         },
2337         {
2338                 "ALU_MOV_K: dst = 4294967295",
2339                 .u.insns_int = {
2340                         BPF_ALU32_IMM(BPF_MOV, R0, 4294967295U),
2341                         BPF_EXIT_INSN(),
2342                 },
2343                 INTERNAL,
2344                 { },
2345                 { { 0, 4294967295U } },
2346         },
2347         {
2348                 "ALU_MOV_K: 0x0000ffffffff0000 = 0x00000000ffffffff",
2349                 .u.insns_int = {
2350                         BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
2351                         BPF_LD_IMM64(R3, 0x00000000ffffffffLL),
2352                         BPF_ALU32_IMM(BPF_MOV, R2, 0xffffffff),
2353                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2354                         BPF_MOV32_IMM(R0, 2),
2355                         BPF_EXIT_INSN(),
2356                         BPF_MOV32_IMM(R0, 1),
2357                         BPF_EXIT_INSN(),
2358                 },
2359                 INTERNAL,
2360                 { },
2361                 { { 0, 0x1 } },
2362         },
2363         {
2364                 "ALU_MOV_K: small negative",
2365                 .u.insns_int = {
2366                         BPF_ALU32_IMM(BPF_MOV, R0, -123),
2367                         BPF_EXIT_INSN(),
2368                 },
2369                 INTERNAL,
2370                 { },
2371                 { { 0, -123 } }
2372         },
2373         {
2374                 "ALU_MOV_K: small negative zero extension",
2375                 .u.insns_int = {
2376                         BPF_ALU32_IMM(BPF_MOV, R0, -123),
2377                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
2378                         BPF_EXIT_INSN(),
2379                 },
2380                 INTERNAL,
2381                 { },
2382                 { { 0, 0 } }
2383         },
2384         {
2385                 "ALU_MOV_K: large negative",
2386                 .u.insns_int = {
2387                         BPF_ALU32_IMM(BPF_MOV, R0, -123456789),
2388                         BPF_EXIT_INSN(),
2389                 },
2390                 INTERNAL,
2391                 { },
2392                 { { 0, -123456789 } }
2393         },
2394         {
2395                 "ALU_MOV_K: large negative zero extension",
2396                 .u.insns_int = {
2397                         BPF_ALU32_IMM(BPF_MOV, R0, -123456789),
2398                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
2399                         BPF_EXIT_INSN(),
2400                 },
2401                 INTERNAL,
2402                 { },
2403                 { { 0, 0 } }
2404         },
2405         {
2406                 "ALU64_MOV_K: dst = 2",
2407                 .u.insns_int = {
2408                         BPF_ALU64_IMM(BPF_MOV, R0, 2),
2409                         BPF_EXIT_INSN(),
2410                 },
2411                 INTERNAL,
2412                 { },
2413                 { { 0, 2 } },
2414         },
2415         {
2416                 "ALU64_MOV_K: dst = 2147483647",
2417                 .u.insns_int = {
2418                         BPF_ALU64_IMM(BPF_MOV, R0, 2147483647),
2419                         BPF_EXIT_INSN(),
2420                 },
2421                 INTERNAL,
2422                 { },
2423                 { { 0, 2147483647 } },
2424         },
2425         {
2426                 "ALU64_OR_K: dst = 0x0",
2427                 .u.insns_int = {
2428                         BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
2429                         BPF_LD_IMM64(R3, 0x0),
2430                         BPF_ALU64_IMM(BPF_MOV, R2, 0x0),
2431                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2432                         BPF_MOV32_IMM(R0, 2),
2433                         BPF_EXIT_INSN(),
2434                         BPF_MOV32_IMM(R0, 1),
2435                         BPF_EXIT_INSN(),
2436                 },
2437                 INTERNAL,
2438                 { },
2439                 { { 0, 0x1 } },
2440         },
2441         {
2442                 "ALU64_MOV_K: dst = -1",
2443                 .u.insns_int = {
2444                         BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
2445                         BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
2446                         BPF_ALU64_IMM(BPF_MOV, R2, 0xffffffff),
2447                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2448                         BPF_MOV32_IMM(R0, 2),
2449                         BPF_EXIT_INSN(),
2450                         BPF_MOV32_IMM(R0, 1),
2451                         BPF_EXIT_INSN(),
2452                 },
2453                 INTERNAL,
2454                 { },
2455                 { { 0, 0x1 } },
2456         },
2457         {
2458                 "ALU64_MOV_K: small negative",
2459                 .u.insns_int = {
2460                         BPF_ALU64_IMM(BPF_MOV, R0, -123),
2461                         BPF_EXIT_INSN(),
2462                 },
2463                 INTERNAL,
2464                 { },
2465                 { { 0, -123 } }
2466         },
2467         {
2468                 "ALU64_MOV_K: small negative sign extension",
2469                 .u.insns_int = {
2470                         BPF_ALU64_IMM(BPF_MOV, R0, -123),
2471                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
2472                         BPF_EXIT_INSN(),
2473                 },
2474                 INTERNAL,
2475                 { },
2476                 { { 0, 0xffffffff } }
2477         },
2478         {
2479                 "ALU64_MOV_K: large negative",
2480                 .u.insns_int = {
2481                         BPF_ALU64_IMM(BPF_MOV, R0, -123456789),
2482                         BPF_EXIT_INSN(),
2483                 },
2484                 INTERNAL,
2485                 { },
2486                 { { 0, -123456789 } }
2487         },
2488         {
2489                 "ALU64_MOV_K: large negative sign extension",
2490                 .u.insns_int = {
2491                         BPF_ALU64_IMM(BPF_MOV, R0, -123456789),
2492                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
2493                         BPF_EXIT_INSN(),
2494                 },
2495                 INTERNAL,
2496                 { },
2497                 { { 0, 0xffffffff } }
2498         },
2499         /* BPF_ALU | BPF_ADD | BPF_X */
2500         {
2501                 "ALU_ADD_X: 1 + 2 = 3",
2502                 .u.insns_int = {
2503                         BPF_LD_IMM64(R0, 1),
2504                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
2505                         BPF_ALU32_REG(BPF_ADD, R0, R1),
2506                         BPF_EXIT_INSN(),
2507                 },
2508                 INTERNAL,
2509                 { },
2510                 { { 0, 3 } },
2511         },
2512         {
2513                 "ALU_ADD_X: 1 + 4294967294 = 4294967295",
2514                 .u.insns_int = {
2515                         BPF_LD_IMM64(R0, 1),
2516                         BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
2517                         BPF_ALU32_REG(BPF_ADD, R0, R1),
2518                         BPF_EXIT_INSN(),
2519                 },
2520                 INTERNAL,
2521                 { },
2522                 { { 0, 4294967295U } },
2523         },
2524         {
2525                 "ALU_ADD_X: 2 + 4294967294 = 0",
2526                 .u.insns_int = {
2527                         BPF_LD_IMM64(R0, 2),
2528                         BPF_LD_IMM64(R1, 4294967294U),
2529                         BPF_ALU32_REG(BPF_ADD, R0, R1),
2530                         BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
2531                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
2532                         BPF_EXIT_INSN(),
2533                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
2534                         BPF_EXIT_INSN(),
2535                 },
2536                 INTERNAL,
2537                 { },
2538                 { { 0, 1 } },
2539         },
2540         {
2541                 "ALU64_ADD_X: 1 + 2 = 3",
2542                 .u.insns_int = {
2543                         BPF_LD_IMM64(R0, 1),
2544                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
2545                         BPF_ALU64_REG(BPF_ADD, R0, R1),
2546                         BPF_EXIT_INSN(),
2547                 },
2548                 INTERNAL,
2549                 { },
2550                 { { 0, 3 } },
2551         },
2552         {
2553                 "ALU64_ADD_X: 1 + 4294967294 = 4294967295",
2554                 .u.insns_int = {
2555                         BPF_LD_IMM64(R0, 1),
2556                         BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
2557                         BPF_ALU64_REG(BPF_ADD, R0, R1),
2558                         BPF_EXIT_INSN(),
2559                 },
2560                 INTERNAL,
2561                 { },
2562                 { { 0, 4294967295U } },
2563         },
2564         {
2565                 "ALU64_ADD_X: 2 + 4294967294 = 4294967296",
2566                 .u.insns_int = {
2567                         BPF_LD_IMM64(R0, 2),
2568                         BPF_LD_IMM64(R1, 4294967294U),
2569                         BPF_LD_IMM64(R2, 4294967296ULL),
2570                         BPF_ALU64_REG(BPF_ADD, R0, R1),
2571                         BPF_JMP_REG(BPF_JEQ, R0, R2, 2),
2572                         BPF_MOV32_IMM(R0, 0),
2573                         BPF_EXIT_INSN(),
2574                         BPF_MOV32_IMM(R0, 1),
2575                         BPF_EXIT_INSN(),
2576                 },
2577                 INTERNAL,
2578                 { },
2579                 { { 0, 1 } },
2580         },
2581         /* BPF_ALU | BPF_ADD | BPF_K */
2582         {
2583                 "ALU_ADD_K: 1 + 2 = 3",
2584                 .u.insns_int = {
2585                         BPF_LD_IMM64(R0, 1),
2586                         BPF_ALU32_IMM(BPF_ADD, R0, 2),
2587                         BPF_EXIT_INSN(),
2588                 },
2589                 INTERNAL,
2590                 { },
2591                 { { 0, 3 } },
2592         },
2593         {
2594                 "ALU_ADD_K: 3 + 0 = 3",
2595                 .u.insns_int = {
2596                         BPF_LD_IMM64(R0, 3),
2597                         BPF_ALU32_IMM(BPF_ADD, R0, 0),
2598                         BPF_EXIT_INSN(),
2599                 },
2600                 INTERNAL,
2601                 { },
2602                 { { 0, 3 } },
2603         },
2604         {
2605                 "ALU_ADD_K: 1 + 4294967294 = 4294967295",
2606                 .u.insns_int = {
2607                         BPF_LD_IMM64(R0, 1),
2608                         BPF_ALU32_IMM(BPF_ADD, R0, 4294967294U),
2609                         BPF_EXIT_INSN(),
2610                 },
2611                 INTERNAL,
2612                 { },
2613                 { { 0, 4294967295U } },
2614         },
2615         {
2616                 "ALU_ADD_K: 4294967294 + 2 = 0",
2617                 .u.insns_int = {
2618                         BPF_LD_IMM64(R0, 4294967294U),
2619                         BPF_ALU32_IMM(BPF_ADD, R0, 2),
2620                         BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
2621                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
2622                         BPF_EXIT_INSN(),
2623                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
2624                         BPF_EXIT_INSN(),
2625                 },
2626                 INTERNAL,
2627                 { },
2628                 { { 0, 1 } },
2629         },
2630         {
2631                 "ALU_ADD_K: 0 + (-1) = 0x00000000ffffffff",
2632                 .u.insns_int = {
2633                         BPF_LD_IMM64(R2, 0x0),
2634                         BPF_LD_IMM64(R3, 0x00000000ffffffff),
2635                         BPF_ALU32_IMM(BPF_ADD, R2, 0xffffffff),
2636                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2637                         BPF_MOV32_IMM(R0, 2),
2638                         BPF_EXIT_INSN(),
2639                         BPF_MOV32_IMM(R0, 1),
2640                         BPF_EXIT_INSN(),
2641                 },
2642                 INTERNAL,
2643                 { },
2644                 { { 0, 0x1 } },
2645         },
2646         {
2647                 "ALU_ADD_K: 0 + 0xffff = 0xffff",
2648                 .u.insns_int = {
2649                         BPF_LD_IMM64(R2, 0x0),
2650                         BPF_LD_IMM64(R3, 0xffff),
2651                         BPF_ALU32_IMM(BPF_ADD, R2, 0xffff),
2652                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2653                         BPF_MOV32_IMM(R0, 2),
2654                         BPF_EXIT_INSN(),
2655                         BPF_MOV32_IMM(R0, 1),
2656                         BPF_EXIT_INSN(),
2657                 },
2658                 INTERNAL,
2659                 { },
2660                 { { 0, 0x1 } },
2661         },
2662         {
2663                 "ALU_ADD_K: 0 + 0x7fffffff = 0x7fffffff",
2664                 .u.insns_int = {
2665                         BPF_LD_IMM64(R2, 0x0),
2666                         BPF_LD_IMM64(R3, 0x7fffffff),
2667                         BPF_ALU32_IMM(BPF_ADD, R2, 0x7fffffff),
2668                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2669                         BPF_MOV32_IMM(R0, 2),
2670                         BPF_EXIT_INSN(),
2671                         BPF_MOV32_IMM(R0, 1),
2672                         BPF_EXIT_INSN(),
2673                 },
2674                 INTERNAL,
2675                 { },
2676                 { { 0, 0x1 } },
2677         },
2678         {
2679                 "ALU_ADD_K: 0 + 0x80000000 = 0x80000000",
2680                 .u.insns_int = {
2681                         BPF_LD_IMM64(R2, 0x0),
2682                         BPF_LD_IMM64(R3, 0x80000000),
2683                         BPF_ALU32_IMM(BPF_ADD, R2, 0x80000000),
2684                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2685                         BPF_MOV32_IMM(R0, 2),
2686                         BPF_EXIT_INSN(),
2687                         BPF_MOV32_IMM(R0, 1),
2688                         BPF_EXIT_INSN(),
2689                 },
2690                 INTERNAL,
2691                 { },
2692                 { { 0, 0x1 } },
2693         },
2694         {
2695                 "ALU_ADD_K: 0 + 0x80008000 = 0x80008000",
2696                 .u.insns_int = {
2697                         BPF_LD_IMM64(R2, 0x0),
2698                         BPF_LD_IMM64(R3, 0x80008000),
2699                         BPF_ALU32_IMM(BPF_ADD, R2, 0x80008000),
2700                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2701                         BPF_MOV32_IMM(R0, 2),
2702                         BPF_EXIT_INSN(),
2703                         BPF_MOV32_IMM(R0, 1),
2704                         BPF_EXIT_INSN(),
2705                 },
2706                 INTERNAL,
2707                 { },
2708                 { { 0, 0x1 } },
2709         },
2710         {
2711                 "ALU64_ADD_K: 1 + 2 = 3",
2712                 .u.insns_int = {
2713                         BPF_LD_IMM64(R0, 1),
2714                         BPF_ALU64_IMM(BPF_ADD, R0, 2),
2715                         BPF_EXIT_INSN(),
2716                 },
2717                 INTERNAL,
2718                 { },
2719                 { { 0, 3 } },
2720         },
2721         {
2722                 "ALU64_ADD_K: 3 + 0 = 3",
2723                 .u.insns_int = {
2724                         BPF_LD_IMM64(R0, 3),
2725                         BPF_ALU64_IMM(BPF_ADD, R0, 0),
2726                         BPF_EXIT_INSN(),
2727                 },
2728                 INTERNAL,
2729                 { },
2730                 { { 0, 3 } },
2731         },
2732         {
2733                 "ALU64_ADD_K: 1 + 2147483646 = 2147483647",
2734                 .u.insns_int = {
2735                         BPF_LD_IMM64(R0, 1),
2736                         BPF_ALU64_IMM(BPF_ADD, R0, 2147483646),
2737                         BPF_EXIT_INSN(),
2738                 },
2739                 INTERNAL,
2740                 { },
2741                 { { 0, 2147483647 } },
2742         },
2743         {
2744                 "ALU64_ADD_K: 4294967294 + 2 = 4294967296",
2745                 .u.insns_int = {
2746                         BPF_LD_IMM64(R0, 4294967294U),
2747                         BPF_LD_IMM64(R1, 4294967296ULL),
2748                         BPF_ALU64_IMM(BPF_ADD, R0, 2),
2749                         BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
2750                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
2751                         BPF_EXIT_INSN(),
2752                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
2753                         BPF_EXIT_INSN(),
2754                 },
2755                 INTERNAL,
2756                 { },
2757                 { { 0, 1 } },
2758         },
2759         {
2760                 "ALU64_ADD_K: 2147483646 + -2147483647 = -1",
2761                 .u.insns_int = {
2762                         BPF_LD_IMM64(R0, 2147483646),
2763                         BPF_ALU64_IMM(BPF_ADD, R0, -2147483647),
2764                         BPF_EXIT_INSN(),
2765                 },
2766                 INTERNAL,
2767                 { },
2768                 { { 0, -1 } },
2769         },
2770         {
2771                 "ALU64_ADD_K: 1 + 0 = 1",
2772                 .u.insns_int = {
2773                         BPF_LD_IMM64(R2, 0x1),
2774                         BPF_LD_IMM64(R3, 0x1),
2775                         BPF_ALU64_IMM(BPF_ADD, R2, 0x0),
2776                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2777                         BPF_MOV32_IMM(R0, 2),
2778                         BPF_EXIT_INSN(),
2779                         BPF_MOV32_IMM(R0, 1),
2780                         BPF_EXIT_INSN(),
2781                 },
2782                 INTERNAL,
2783                 { },
2784                 { { 0, 0x1 } },
2785         },
2786         {
2787                 "ALU64_ADD_K: 0 + (-1) = 0xffffffffffffffff",
2788                 .u.insns_int = {
2789                         BPF_LD_IMM64(R2, 0x0),
2790                         BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
2791                         BPF_ALU64_IMM(BPF_ADD, R2, 0xffffffff),
2792                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2793                         BPF_MOV32_IMM(R0, 2),
2794                         BPF_EXIT_INSN(),
2795                         BPF_MOV32_IMM(R0, 1),
2796                         BPF_EXIT_INSN(),
2797                 },
2798                 INTERNAL,
2799                 { },
2800                 { { 0, 0x1 } },
2801         },
2802         {
2803                 "ALU64_ADD_K: 0 + 0xffff = 0xffff",
2804                 .u.insns_int = {
2805                         BPF_LD_IMM64(R2, 0x0),
2806                         BPF_LD_IMM64(R3, 0xffff),
2807                         BPF_ALU64_IMM(BPF_ADD, R2, 0xffff),
2808                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2809                         BPF_MOV32_IMM(R0, 2),
2810                         BPF_EXIT_INSN(),
2811                         BPF_MOV32_IMM(R0, 1),
2812                         BPF_EXIT_INSN(),
2813                 },
2814                 INTERNAL,
2815                 { },
2816                 { { 0, 0x1 } },
2817         },
2818         {
2819                 "ALU64_ADD_K: 0 + 0x7fffffff = 0x7fffffff",
2820                 .u.insns_int = {
2821                         BPF_LD_IMM64(R2, 0x0),
2822                         BPF_LD_IMM64(R3, 0x7fffffff),
2823                         BPF_ALU64_IMM(BPF_ADD, R2, 0x7fffffff),
2824                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2825                         BPF_MOV32_IMM(R0, 2),
2826                         BPF_EXIT_INSN(),
2827                         BPF_MOV32_IMM(R0, 1),
2828                         BPF_EXIT_INSN(),
2829                 },
2830                 INTERNAL,
2831                 { },
2832                 { { 0, 0x1 } },
2833         },
2834         {
2835                 "ALU64_ADD_K: 0 + 0x80000000 = 0xffffffff80000000",
2836                 .u.insns_int = {
2837                         BPF_LD_IMM64(R2, 0x0),
2838                         BPF_LD_IMM64(R3, 0xffffffff80000000LL),
2839                         BPF_ALU64_IMM(BPF_ADD, R2, 0x80000000),
2840                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2841                         BPF_MOV32_IMM(R0, 2),
2842                         BPF_EXIT_INSN(),
2843                         BPF_MOV32_IMM(R0, 1),
2844                         BPF_EXIT_INSN(),
2845                 },
2846                 INTERNAL,
2847                 { },
2848                 { { 0, 0x1 } },
2849         },
2850         {
2851                 "ALU_ADD_K: 0 + 0x80008000 = 0xffffffff80008000",
2852                 .u.insns_int = {
2853                         BPF_LD_IMM64(R2, 0x0),
2854                         BPF_LD_IMM64(R3, 0xffffffff80008000LL),
2855                         BPF_ALU64_IMM(BPF_ADD, R2, 0x80008000),
2856                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2857                         BPF_MOV32_IMM(R0, 2),
2858                         BPF_EXIT_INSN(),
2859                         BPF_MOV32_IMM(R0, 1),
2860                         BPF_EXIT_INSN(),
2861                 },
2862                 INTERNAL,
2863                 { },
2864                 { { 0, 0x1 } },
2865         },
2866         /* BPF_ALU | BPF_SUB | BPF_X */
2867         {
2868                 "ALU_SUB_X: 3 - 1 = 2",
2869                 .u.insns_int = {
2870                         BPF_LD_IMM64(R0, 3),
2871                         BPF_ALU32_IMM(BPF_MOV, R1, 1),
2872                         BPF_ALU32_REG(BPF_SUB, R0, R1),
2873                         BPF_EXIT_INSN(),
2874                 },
2875                 INTERNAL,
2876                 { },
2877                 { { 0, 2 } },
2878         },
2879         {
2880                 "ALU_SUB_X: 4294967295 - 4294967294 = 1",
2881                 .u.insns_int = {
2882                         BPF_LD_IMM64(R0, 4294967295U),
2883                         BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
2884                         BPF_ALU32_REG(BPF_SUB, R0, R1),
2885                         BPF_EXIT_INSN(),
2886                 },
2887                 INTERNAL,
2888                 { },
2889                 { { 0, 1 } },
2890         },
2891         {
2892                 "ALU64_SUB_X: 3 - 1 = 2",
2893                 .u.insns_int = {
2894                         BPF_LD_IMM64(R0, 3),
2895                         BPF_ALU32_IMM(BPF_MOV, R1, 1),
2896                         BPF_ALU64_REG(BPF_SUB, R0, R1),
2897                         BPF_EXIT_INSN(),
2898                 },
2899                 INTERNAL,
2900                 { },
2901                 { { 0, 2 } },
2902         },
2903         {
2904                 "ALU64_SUB_X: 4294967295 - 4294967294 = 1",
2905                 .u.insns_int = {
2906                         BPF_LD_IMM64(R0, 4294967295U),
2907                         BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
2908                         BPF_ALU64_REG(BPF_SUB, R0, R1),
2909                         BPF_EXIT_INSN(),
2910                 },
2911                 INTERNAL,
2912                 { },
2913                 { { 0, 1 } },
2914         },
2915         /* BPF_ALU | BPF_SUB | BPF_K */
2916         {
2917                 "ALU_SUB_K: 3 - 1 = 2",
2918                 .u.insns_int = {
2919                         BPF_LD_IMM64(R0, 3),
2920                         BPF_ALU32_IMM(BPF_SUB, R0, 1),
2921                         BPF_EXIT_INSN(),
2922                 },
2923                 INTERNAL,
2924                 { },
2925                 { { 0, 2 } },
2926         },
2927         {
2928                 "ALU_SUB_K: 3 - 0 = 3",
2929                 .u.insns_int = {
2930                         BPF_LD_IMM64(R0, 3),
2931                         BPF_ALU32_IMM(BPF_SUB, R0, 0),
2932                         BPF_EXIT_INSN(),
2933                 },
2934                 INTERNAL,
2935                 { },
2936                 { { 0, 3 } },
2937         },
2938         {
2939                 "ALU_SUB_K: 4294967295 - 4294967294 = 1",
2940                 .u.insns_int = {
2941                         BPF_LD_IMM64(R0, 4294967295U),
2942                         BPF_ALU32_IMM(BPF_SUB, R0, 4294967294U),
2943                         BPF_EXIT_INSN(),
2944                 },
2945                 INTERNAL,
2946                 { },
2947                 { { 0, 1 } },
2948         },
2949         {
2950                 "ALU64_SUB_K: 3 - 1 = 2",
2951                 .u.insns_int = {
2952                         BPF_LD_IMM64(R0, 3),
2953                         BPF_ALU64_IMM(BPF_SUB, R0, 1),
2954                         BPF_EXIT_INSN(),
2955                 },
2956                 INTERNAL,
2957                 { },
2958                 { { 0, 2 } },
2959         },
2960         {
2961                 "ALU64_SUB_K: 3 - 0 = 3",
2962                 .u.insns_int = {
2963                         BPF_LD_IMM64(R0, 3),
2964                         BPF_ALU64_IMM(BPF_SUB, R0, 0),
2965                         BPF_EXIT_INSN(),
2966                 },
2967                 INTERNAL,
2968                 { },
2969                 { { 0, 3 } },
2970         },
2971         {
2972                 "ALU64_SUB_K: 4294967294 - 4294967295 = -1",
2973                 .u.insns_int = {
2974                         BPF_LD_IMM64(R0, 4294967294U),
2975                         BPF_ALU64_IMM(BPF_SUB, R0, 4294967295U),
2976                         BPF_EXIT_INSN(),
2977                 },
2978                 INTERNAL,
2979                 { },
2980                 { { 0, -1 } },
2981         },
2982         {
2983                 "ALU64_ADD_K: 2147483646 - 2147483647 = -1",
2984                 .u.insns_int = {
2985                         BPF_LD_IMM64(R0, 2147483646),
2986                         BPF_ALU64_IMM(BPF_SUB, R0, 2147483647),
2987                         BPF_EXIT_INSN(),
2988                 },
2989                 INTERNAL,
2990                 { },
2991                 { { 0, -1 } },
2992         },
2993         /* BPF_ALU | BPF_MUL | BPF_X */
2994         {
2995                 "ALU_MUL_X: 2 * 3 = 6",
2996                 .u.insns_int = {
2997                         BPF_LD_IMM64(R0, 2),
2998                         BPF_ALU32_IMM(BPF_MOV, R1, 3),
2999                         BPF_ALU32_REG(BPF_MUL, R0, R1),
3000                         BPF_EXIT_INSN(),
3001                 },
3002                 INTERNAL,
3003                 { },
3004                 { { 0, 6 } },
3005         },
3006         {
3007                 "ALU_MUL_X: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
3008                 .u.insns_int = {
3009                         BPF_LD_IMM64(R0, 2),
3010                         BPF_ALU32_IMM(BPF_MOV, R1, 0x7FFFFFF8),
3011                         BPF_ALU32_REG(BPF_MUL, R0, R1),
3012                         BPF_EXIT_INSN(),
3013                 },
3014                 INTERNAL,
3015                 { },
3016                 { { 0, 0xFFFFFFF0 } },
3017         },
3018         {
3019                 "ALU_MUL_X: -1 * -1 = 1",
3020                 .u.insns_int = {
3021                         BPF_LD_IMM64(R0, -1),
3022                         BPF_ALU32_IMM(BPF_MOV, R1, -1),
3023                         BPF_ALU32_REG(BPF_MUL, R0, R1),
3024                         BPF_EXIT_INSN(),
3025                 },
3026                 INTERNAL,
3027                 { },
3028                 { { 0, 1 } },
3029         },
3030         {
3031                 "ALU64_MUL_X: 2 * 3 = 6",
3032                 .u.insns_int = {
3033                         BPF_LD_IMM64(R0, 2),
3034                         BPF_ALU32_IMM(BPF_MOV, R1, 3),
3035                         BPF_ALU64_REG(BPF_MUL, R0, R1),
3036                         BPF_EXIT_INSN(),
3037                 },
3038                 INTERNAL,
3039                 { },
3040                 { { 0, 6 } },
3041         },
3042         {
3043                 "ALU64_MUL_X: 1 * 2147483647 = 2147483647",
3044                 .u.insns_int = {
3045                         BPF_LD_IMM64(R0, 1),
3046                         BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
3047                         BPF_ALU64_REG(BPF_MUL, R0, R1),
3048                         BPF_EXIT_INSN(),
3049                 },
3050                 INTERNAL,
3051                 { },
3052                 { { 0, 2147483647 } },
3053         },
3054         /* BPF_ALU | BPF_MUL | BPF_K */
3055         {
3056                 "ALU_MUL_K: 2 * 3 = 6",
3057                 .u.insns_int = {
3058                         BPF_LD_IMM64(R0, 2),
3059                         BPF_ALU32_IMM(BPF_MUL, R0, 3),
3060                         BPF_EXIT_INSN(),
3061                 },
3062                 INTERNAL,
3063                 { },
3064                 { { 0, 6 } },
3065         },
3066         {
3067                 "ALU_MUL_K: 3 * 1 = 3",
3068                 .u.insns_int = {
3069                         BPF_LD_IMM64(R0, 3),
3070                         BPF_ALU32_IMM(BPF_MUL, R0, 1),
3071                         BPF_EXIT_INSN(),
3072                 },
3073                 INTERNAL,
3074                 { },
3075                 { { 0, 3 } },
3076         },
3077         {
3078                 "ALU_MUL_K: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
3079                 .u.insns_int = {
3080                         BPF_LD_IMM64(R0, 2),
3081                         BPF_ALU32_IMM(BPF_MUL, R0, 0x7FFFFFF8),
3082                         BPF_EXIT_INSN(),
3083                 },
3084                 INTERNAL,
3085                 { },
3086                 { { 0, 0xFFFFFFF0 } },
3087         },
3088         {
3089                 "ALU_MUL_K: 1 * (-1) = 0x00000000ffffffff",
3090                 .u.insns_int = {
3091                         BPF_LD_IMM64(R2, 0x1),
3092                         BPF_LD_IMM64(R3, 0x00000000ffffffff),
3093                         BPF_ALU32_IMM(BPF_MUL, R2, 0xffffffff),
3094                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3095                         BPF_MOV32_IMM(R0, 2),
3096                         BPF_EXIT_INSN(),
3097                         BPF_MOV32_IMM(R0, 1),
3098                         BPF_EXIT_INSN(),
3099                 },
3100                 INTERNAL,
3101                 { },
3102                 { { 0, 0x1 } },
3103         },
3104         {
3105                 "ALU64_MUL_K: 2 * 3 = 6",
3106                 .u.insns_int = {
3107                         BPF_LD_IMM64(R0, 2),
3108                         BPF_ALU64_IMM(BPF_MUL, R0, 3),
3109                         BPF_EXIT_INSN(),
3110                 },
3111                 INTERNAL,
3112                 { },
3113                 { { 0, 6 } },
3114         },
3115         {
3116                 "ALU64_MUL_K: 3 * 1 = 3",
3117                 .u.insns_int = {
3118                         BPF_LD_IMM64(R0, 3),
3119                         BPF_ALU64_IMM(BPF_MUL, R0, 1),
3120                         BPF_EXIT_INSN(),
3121                 },
3122                 INTERNAL,
3123                 { },
3124                 { { 0, 3 } },
3125         },
3126         {
3127                 "ALU64_MUL_K: 1 * 2147483647 = 2147483647",
3128                 .u.insns_int = {
3129                         BPF_LD_IMM64(R0, 1),
3130                         BPF_ALU64_IMM(BPF_MUL, R0, 2147483647),
3131                         BPF_EXIT_INSN(),
3132                 },
3133                 INTERNAL,
3134                 { },
3135                 { { 0, 2147483647 } },
3136         },
3137         {
3138                 "ALU64_MUL_K: 1 * -2147483647 = -2147483647",
3139                 .u.insns_int = {
3140                         BPF_LD_IMM64(R0, 1),
3141                         BPF_ALU64_IMM(BPF_MUL, R0, -2147483647),
3142                         BPF_EXIT_INSN(),
3143                 },
3144                 INTERNAL,
3145                 { },
3146                 { { 0, -2147483647 } },
3147         },
3148         {
3149                 "ALU64_MUL_K: 1 * (-1) = 0xffffffffffffffff",
3150                 .u.insns_int = {
3151                         BPF_LD_IMM64(R2, 0x1),
3152                         BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
3153                         BPF_ALU64_IMM(BPF_MUL, R2, 0xffffffff),
3154                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3155                         BPF_MOV32_IMM(R0, 2),
3156                         BPF_EXIT_INSN(),
3157                         BPF_MOV32_IMM(R0, 1),
3158                         BPF_EXIT_INSN(),
3159                 },
3160                 INTERNAL,
3161                 { },
3162                 { { 0, 0x1 } },
3163         },
3164         /* BPF_ALU | BPF_DIV | BPF_X */
3165         {
3166                 "ALU_DIV_X: 6 / 2 = 3",
3167                 .u.insns_int = {
3168                         BPF_LD_IMM64(R0, 6),
3169                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
3170                         BPF_ALU32_REG(BPF_DIV, R0, R1),
3171                         BPF_EXIT_INSN(),
3172                 },
3173                 INTERNAL,
3174                 { },
3175                 { { 0, 3 } },
3176         },
3177         {
3178                 "ALU_DIV_X: 4294967295 / 4294967295 = 1",
3179                 .u.insns_int = {
3180                         BPF_LD_IMM64(R0, 4294967295U),
3181                         BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
3182                         BPF_ALU32_REG(BPF_DIV, R0, R1),
3183                         BPF_EXIT_INSN(),
3184                 },
3185                 INTERNAL,
3186                 { },
3187                 { { 0, 1 } },
3188         },
3189         {
3190                 "ALU64_DIV_X: 6 / 2 = 3",
3191                 .u.insns_int = {
3192                         BPF_LD_IMM64(R0, 6),
3193                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
3194                         BPF_ALU64_REG(BPF_DIV, R0, R1),
3195                         BPF_EXIT_INSN(),
3196                 },
3197                 INTERNAL,
3198                 { },
3199                 { { 0, 3 } },
3200         },
3201         {
3202                 "ALU64_DIV_X: 2147483647 / 2147483647 = 1",
3203                 .u.insns_int = {
3204                         BPF_LD_IMM64(R0, 2147483647),
3205                         BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
3206                         BPF_ALU64_REG(BPF_DIV, R0, R1),
3207                         BPF_EXIT_INSN(),
3208                 },
3209                 INTERNAL,
3210                 { },
3211                 { { 0, 1 } },
3212         },
3213         {
3214                 "ALU64_DIV_X: 0xffffffffffffffff / (-1) = 0x0000000000000001",
3215                 .u.insns_int = {
3216                         BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
3217                         BPF_LD_IMM64(R4, 0xffffffffffffffffLL),
3218                         BPF_LD_IMM64(R3, 0x0000000000000001LL),
3219                         BPF_ALU64_REG(BPF_DIV, R2, R4),
3220                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3221                         BPF_MOV32_IMM(R0, 2),
3222                         BPF_EXIT_INSN(),
3223                         BPF_MOV32_IMM(R0, 1),
3224                         BPF_EXIT_INSN(),
3225                 },
3226                 INTERNAL,
3227                 { },
3228                 { { 0, 0x1 } },
3229         },
3230         /* BPF_ALU | BPF_DIV | BPF_K */
3231         {
3232                 "ALU_DIV_K: 6 / 2 = 3",
3233                 .u.insns_int = {
3234                         BPF_LD_IMM64(R0, 6),
3235                         BPF_ALU32_IMM(BPF_DIV, R0, 2),
3236                         BPF_EXIT_INSN(),
3237                 },
3238                 INTERNAL,
3239                 { },
3240                 { { 0, 3 } },
3241         },
3242         {
3243                 "ALU_DIV_K: 3 / 1 = 3",
3244                 .u.insns_int = {
3245                         BPF_LD_IMM64(R0, 3),
3246                         BPF_ALU32_IMM(BPF_DIV, R0, 1),
3247                         BPF_EXIT_INSN(),
3248                 },
3249                 INTERNAL,
3250                 { },
3251                 { { 0, 3 } },
3252         },
3253         {
3254                 "ALU_DIV_K: 4294967295 / 4294967295 = 1",
3255                 .u.insns_int = {
3256                         BPF_LD_IMM64(R0, 4294967295U),
3257                         BPF_ALU32_IMM(BPF_DIV, R0, 4294967295U),
3258                         BPF_EXIT_INSN(),
3259                 },
3260                 INTERNAL,
3261                 { },
3262                 { { 0, 1 } },
3263         },
3264         {
3265                 "ALU_DIV_K: 0xffffffffffffffff / (-1) = 0x1",
3266                 .u.insns_int = {
3267                         BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
3268                         BPF_LD_IMM64(R3, 0x1UL),
3269                         BPF_ALU32_IMM(BPF_DIV, R2, 0xffffffff),
3270                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3271                         BPF_MOV32_IMM(R0, 2),
3272                         BPF_EXIT_INSN(),
3273                         BPF_MOV32_IMM(R0, 1),
3274                         BPF_EXIT_INSN(),
3275                 },
3276                 INTERNAL,
3277                 { },
3278                 { { 0, 0x1 } },
3279         },
3280         {
3281                 "ALU64_DIV_K: 6 / 2 = 3",
3282                 .u.insns_int = {
3283                         BPF_LD_IMM64(R0, 6),
3284                         BPF_ALU64_IMM(BPF_DIV, R0, 2),
3285                         BPF_EXIT_INSN(),
3286                 },
3287                 INTERNAL,
3288                 { },
3289                 { { 0, 3 } },
3290         },
3291         {
3292                 "ALU64_DIV_K: 3 / 1 = 3",
3293                 .u.insns_int = {
3294                         BPF_LD_IMM64(R0, 3),
3295                         BPF_ALU64_IMM(BPF_DIV, R0, 1),
3296                         BPF_EXIT_INSN(),
3297                 },
3298                 INTERNAL,
3299                 { },
3300                 { { 0, 3 } },
3301         },
3302         {
3303                 "ALU64_DIV_K: 2147483647 / 2147483647 = 1",
3304                 .u.insns_int = {
3305                         BPF_LD_IMM64(R0, 2147483647),
3306                         BPF_ALU64_IMM(BPF_DIV, R0, 2147483647),
3307                         BPF_EXIT_INSN(),
3308                 },
3309                 INTERNAL,
3310                 { },
3311                 { { 0, 1 } },
3312         },
3313         {
3314                 "ALU64_DIV_K: 0xffffffffffffffff / (-1) = 0x0000000000000001",
3315                 .u.insns_int = {
3316                         BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
3317                         BPF_LD_IMM64(R3, 0x0000000000000001LL),
3318                         BPF_ALU64_IMM(BPF_DIV, R2, 0xffffffff),
3319                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3320                         BPF_MOV32_IMM(R0, 2),
3321                         BPF_EXIT_INSN(),
3322                         BPF_MOV32_IMM(R0, 1),
3323                         BPF_EXIT_INSN(),
3324                 },
3325                 INTERNAL,
3326                 { },
3327                 { { 0, 0x1 } },
3328         },
3329         /* BPF_ALU | BPF_MOD | BPF_X */
3330         {
3331                 "ALU_MOD_X: 3 % 2 = 1",
3332                 .u.insns_int = {
3333                         BPF_LD_IMM64(R0, 3),
3334                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
3335                         BPF_ALU32_REG(BPF_MOD, R0, R1),
3336                         BPF_EXIT_INSN(),
3337                 },
3338                 INTERNAL,
3339                 { },
3340                 { { 0, 1 } },
3341         },
3342         {
3343                 "ALU_MOD_X: 4294967295 % 4294967293 = 2",
3344                 .u.insns_int = {
3345                         BPF_LD_IMM64(R0, 4294967295U),
3346                         BPF_ALU32_IMM(BPF_MOV, R1, 4294967293U),
3347                         BPF_ALU32_REG(BPF_MOD, R0, R1),
3348                         BPF_EXIT_INSN(),
3349                 },
3350                 INTERNAL,
3351                 { },
3352                 { { 0, 2 } },
3353         },
3354         {
3355                 "ALU64_MOD_X: 3 % 2 = 1",
3356                 .u.insns_int = {
3357                         BPF_LD_IMM64(R0, 3),
3358                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
3359                         BPF_ALU64_REG(BPF_MOD, R0, R1),
3360                         BPF_EXIT_INSN(),
3361                 },
3362                 INTERNAL,
3363                 { },
3364                 { { 0, 1 } },
3365         },
3366         {
3367                 "ALU64_MOD_X: 2147483647 % 2147483645 = 2",
3368                 .u.insns_int = {
3369                         BPF_LD_IMM64(R0, 2147483647),
3370                         BPF_ALU32_IMM(BPF_MOV, R1, 2147483645),
3371                         BPF_ALU64_REG(BPF_MOD, R0, R1),
3372                         BPF_EXIT_INSN(),
3373                 },
3374                 INTERNAL,
3375                 { },
3376                 { { 0, 2 } },
3377         },
3378         /* BPF_ALU | BPF_MOD | BPF_K */
3379         {
3380                 "ALU_MOD_K: 3 % 2 = 1",
3381                 .u.insns_int = {
3382                         BPF_LD_IMM64(R0, 3),
3383                         BPF_ALU32_IMM(BPF_MOD, R0, 2),
3384                         BPF_EXIT_INSN(),
3385                 },
3386                 INTERNAL,
3387                 { },
3388                 { { 0, 1 } },
3389         },
3390         {
3391                 "ALU_MOD_K: 3 % 1 = 0",
3392                 .u.insns_int = {
3393                         BPF_LD_IMM64(R0, 3),
3394                         BPF_ALU32_IMM(BPF_MOD, R0, 1),
3395                         BPF_EXIT_INSN(),
3396                 },
3397                 INTERNAL,
3398                 { },
3399                 { { 0, 0 } },
3400         },
3401         {
3402                 "ALU_MOD_K: 4294967295 % 4294967293 = 2",
3403                 .u.insns_int = {
3404                         BPF_LD_IMM64(R0, 4294967295U),
3405                         BPF_ALU32_IMM(BPF_MOD, R0, 4294967293U),
3406                         BPF_EXIT_INSN(),
3407                 },
3408                 INTERNAL,
3409                 { },
3410                 { { 0, 2 } },
3411         },
3412         {
3413                 "ALU64_MOD_K: 3 % 2 = 1",
3414                 .u.insns_int = {
3415                         BPF_LD_IMM64(R0, 3),
3416                         BPF_ALU64_IMM(BPF_MOD, R0, 2),
3417                         BPF_EXIT_INSN(),
3418                 },
3419                 INTERNAL,
3420                 { },
3421                 { { 0, 1 } },
3422         },
3423         {
3424                 "ALU64_MOD_K: 3 % 1 = 0",
3425                 .u.insns_int = {
3426                         BPF_LD_IMM64(R0, 3),
3427                         BPF_ALU64_IMM(BPF_MOD, R0, 1),
3428                         BPF_EXIT_INSN(),
3429                 },
3430                 INTERNAL,
3431                 { },
3432                 { { 0, 0 } },
3433         },
3434         {
3435                 "ALU64_MOD_K: 2147483647 % 2147483645 = 2",
3436                 .u.insns_int = {
3437                         BPF_LD_IMM64(R0, 2147483647),
3438                         BPF_ALU64_IMM(BPF_MOD, R0, 2147483645),
3439                         BPF_EXIT_INSN(),
3440                 },
3441                 INTERNAL,
3442                 { },
3443                 { { 0, 2 } },
3444         },
3445         /* BPF_ALU | BPF_AND | BPF_X */
3446         {
3447                 "ALU_AND_X: 3 & 2 = 2",
3448                 .u.insns_int = {
3449                         BPF_LD_IMM64(R0, 3),
3450                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
3451                         BPF_ALU32_REG(BPF_AND, R0, R1),
3452                         BPF_EXIT_INSN(),
3453                 },
3454                 INTERNAL,
3455                 { },
3456                 { { 0, 2 } },
3457         },
3458         {
3459                 "ALU_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
3460                 .u.insns_int = {
3461                         BPF_LD_IMM64(R0, 0xffffffff),
3462                         BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3463                         BPF_ALU32_REG(BPF_AND, R0, R1),
3464                         BPF_EXIT_INSN(),
3465                 },
3466                 INTERNAL,
3467                 { },
3468                 { { 0, 0xffffffff } },
3469         },
3470         {
3471                 "ALU64_AND_X: 3 & 2 = 2",
3472                 .u.insns_int = {
3473                         BPF_LD_IMM64(R0, 3),
3474                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
3475                         BPF_ALU64_REG(BPF_AND, R0, R1),
3476                         BPF_EXIT_INSN(),
3477                 },
3478                 INTERNAL,
3479                 { },
3480                 { { 0, 2 } },
3481         },
3482         {
3483                 "ALU64_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
3484                 .u.insns_int = {
3485                         BPF_LD_IMM64(R0, 0xffffffff),
3486                         BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3487                         BPF_ALU64_REG(BPF_AND, R0, R1),
3488                         BPF_EXIT_INSN(),
3489                 },
3490                 INTERNAL,
3491                 { },
3492                 { { 0, 0xffffffff } },
3493         },
3494         /* BPF_ALU | BPF_AND | BPF_K */
3495         {
3496                 "ALU_AND_K: 3 & 2 = 2",
3497                 .u.insns_int = {
3498                         BPF_LD_IMM64(R0, 3),
3499                         BPF_ALU32_IMM(BPF_AND, R0, 2),
3500                         BPF_EXIT_INSN(),
3501                 },
3502                 INTERNAL,
3503                 { },
3504                 { { 0, 2 } },
3505         },
3506         {
3507                 "ALU_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
3508                 .u.insns_int = {
3509                         BPF_LD_IMM64(R0, 0xffffffff),
3510                         BPF_ALU32_IMM(BPF_AND, R0, 0xffffffff),
3511                         BPF_EXIT_INSN(),
3512                 },
3513                 INTERNAL,
3514                 { },
3515                 { { 0, 0xffffffff } },
3516         },
3517         {
3518                 "ALU_AND_K: Small immediate",
3519                 .u.insns_int = {
3520                         BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
3521                         BPF_ALU32_IMM(BPF_AND, R0, 15),
3522                         BPF_EXIT_INSN(),
3523                 },
3524                 INTERNAL,
3525                 { },
3526                 { { 0, 4 } }
3527         },
3528         {
3529                 "ALU_AND_K: Large immediate",
3530                 .u.insns_int = {
3531                         BPF_ALU32_IMM(BPF_MOV, R0, 0xf1f2f3f4),
3532                         BPF_ALU32_IMM(BPF_AND, R0, 0xafbfcfdf),
3533                         BPF_EXIT_INSN(),
3534                 },
3535                 INTERNAL,
3536                 { },
3537                 { { 0, 0xa1b2c3d4 } }
3538         },
3539         {
3540                 "ALU_AND_K: Zero extension",
3541                 .u.insns_int = {
3542                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
3543                         BPF_LD_IMM64(R1, 0x0000000080a0c0e0LL),
3544                         BPF_ALU32_IMM(BPF_AND, R0, 0xf0f0f0f0),
3545                         BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
3546                         BPF_MOV32_IMM(R0, 2),
3547                         BPF_EXIT_INSN(),
3548                         BPF_MOV32_IMM(R0, 1),
3549                         BPF_EXIT_INSN(),
3550                 },
3551                 INTERNAL,
3552                 { },
3553                 { { 0, 1 } }
3554         },
3555         {
3556                 "ALU64_AND_K: 3 & 2 = 2",
3557                 .u.insns_int = {
3558                         BPF_LD_IMM64(R0, 3),
3559                         BPF_ALU64_IMM(BPF_AND, R0, 2),
3560                         BPF_EXIT_INSN(),
3561                 },
3562                 INTERNAL,
3563                 { },
3564                 { { 0, 2 } },
3565         },
3566         {
3567                 "ALU64_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
3568                 .u.insns_int = {
3569                         BPF_LD_IMM64(R0, 0xffffffff),
3570                         BPF_ALU64_IMM(BPF_AND, R0, 0xffffffff),
3571                         BPF_EXIT_INSN(),
3572                 },
3573                 INTERNAL,
3574                 { },
3575                 { { 0, 0xffffffff } },
3576         },
3577         {
3578                 "ALU64_AND_K: 0x0000ffffffff0000 & 0x0 = 0x0000000000000000",
3579                 .u.insns_int = {
3580                         BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3581                         BPF_LD_IMM64(R3, 0x0000000000000000LL),
3582                         BPF_ALU64_IMM(BPF_AND, R2, 0x0),
3583                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3584                         BPF_MOV32_IMM(R0, 2),
3585                         BPF_EXIT_INSN(),
3586                         BPF_MOV32_IMM(R0, 1),
3587                         BPF_EXIT_INSN(),
3588                 },
3589                 INTERNAL,
3590                 { },
3591                 { { 0, 0x1 } },
3592         },
3593         {
3594                 "ALU64_AND_K: 0x0000ffffffff0000 & -1 = 0x0000ffffffff0000",
3595                 .u.insns_int = {
3596                         BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3597                         BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
3598                         BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
3599                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3600                         BPF_MOV32_IMM(R0, 2),
3601                         BPF_EXIT_INSN(),
3602                         BPF_MOV32_IMM(R0, 1),
3603                         BPF_EXIT_INSN(),
3604                 },
3605                 INTERNAL,
3606                 { },
3607                 { { 0, 0x1 } },
3608         },
3609         {
3610                 "ALU64_AND_K: 0xffffffffffffffff & -1 = 0xffffffffffffffff",
3611                 .u.insns_int = {
3612                         BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
3613                         BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
3614                         BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
3615                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3616                         BPF_MOV32_IMM(R0, 2),
3617                         BPF_EXIT_INSN(),
3618                         BPF_MOV32_IMM(R0, 1),
3619                         BPF_EXIT_INSN(),
3620                 },
3621                 INTERNAL,
3622                 { },
3623                 { { 0, 0x1 } },
3624         },
3625         {
3626                 "ALU64_AND_K: Sign extension 1",
3627                 .u.insns_int = {
3628                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
3629                         BPF_LD_IMM64(R1, 0x00000000090b0d0fLL),
3630                         BPF_ALU64_IMM(BPF_AND, R0, 0x0f0f0f0f),
3631                         BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
3632                         BPF_MOV32_IMM(R0, 2),
3633                         BPF_EXIT_INSN(),
3634                         BPF_MOV32_IMM(R0, 1),
3635                         BPF_EXIT_INSN(),
3636                 },
3637                 INTERNAL,
3638                 { },
3639                 { { 0, 1 } }
3640         },
3641         {
3642                 "ALU64_AND_K: Sign extension 2",
3643                 .u.insns_int = {
3644                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
3645                         BPF_LD_IMM64(R1, 0x0123456780a0c0e0LL),
3646                         BPF_ALU64_IMM(BPF_AND, R0, 0xf0f0f0f0),
3647                         BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
3648                         BPF_MOV32_IMM(R0, 2),
3649                         BPF_EXIT_INSN(),
3650                         BPF_MOV32_IMM(R0, 1),
3651                         BPF_EXIT_INSN(),
3652                 },
3653                 INTERNAL,
3654                 { },
3655                 { { 0, 1 } }
3656         },
3657         /* BPF_ALU | BPF_OR | BPF_X */
3658         {
3659                 "ALU_OR_X: 1 | 2 = 3",
3660                 .u.insns_int = {
3661                         BPF_LD_IMM64(R0, 1),
3662                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
3663                         BPF_ALU32_REG(BPF_OR, R0, R1),
3664                         BPF_EXIT_INSN(),
3665                 },
3666                 INTERNAL,
3667                 { },
3668                 { { 0, 3 } },
3669         },
3670         {
3671                 "ALU_OR_X: 0x0 | 0xffffffff = 0xffffffff",
3672                 .u.insns_int = {
3673                         BPF_LD_IMM64(R0, 0),
3674                         BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3675                         BPF_ALU32_REG(BPF_OR, R0, R1),
3676                         BPF_EXIT_INSN(),
3677                 },
3678                 INTERNAL,
3679                 { },
3680                 { { 0, 0xffffffff } },
3681         },
3682         {
3683                 "ALU64_OR_X: 1 | 2 = 3",
3684                 .u.insns_int = {
3685                         BPF_LD_IMM64(R0, 1),
3686                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
3687                         BPF_ALU64_REG(BPF_OR, R0, R1),
3688                         BPF_EXIT_INSN(),
3689                 },
3690                 INTERNAL,
3691                 { },
3692                 { { 0, 3 } },
3693         },
3694         {
3695                 "ALU64_OR_X: 0 | 0xffffffff = 0xffffffff",
3696                 .u.insns_int = {
3697                         BPF_LD_IMM64(R0, 0),
3698                         BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3699                         BPF_ALU64_REG(BPF_OR, R0, R1),
3700                         BPF_EXIT_INSN(),
3701                 },
3702                 INTERNAL,
3703                 { },
3704                 { { 0, 0xffffffff } },
3705         },
3706         /* BPF_ALU | BPF_OR | BPF_K */
3707         {
3708                 "ALU_OR_K: 1 | 2 = 3",
3709                 .u.insns_int = {
3710                         BPF_LD_IMM64(R0, 1),
3711                         BPF_ALU32_IMM(BPF_OR, R0, 2),
3712                         BPF_EXIT_INSN(),
3713                 },
3714                 INTERNAL,
3715                 { },
3716                 { { 0, 3 } },
3717         },
3718         {
3719                 "ALU_OR_K: 0 & 0xffffffff = 0xffffffff",
3720                 .u.insns_int = {
3721                         BPF_LD_IMM64(R0, 0),
3722                         BPF_ALU32_IMM(BPF_OR, R0, 0xffffffff),
3723                         BPF_EXIT_INSN(),
3724                 },
3725                 INTERNAL,
3726                 { },
3727                 { { 0, 0xffffffff } },
3728         },
3729         {
3730                 "ALU_OR_K: Small immediate",
3731                 .u.insns_int = {
3732                         BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
3733                         BPF_ALU32_IMM(BPF_OR, R0, 1),
3734                         BPF_EXIT_INSN(),
3735                 },
3736                 INTERNAL,
3737                 { },
3738                 { { 0, 0x01020305 } }
3739         },
3740         {
3741                 "ALU_OR_K: Large immediate",
3742                 .u.insns_int = {
3743                         BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
3744                         BPF_ALU32_IMM(BPF_OR, R0, 0xa0b0c0d0),
3745                         BPF_EXIT_INSN(),
3746                 },
3747                 INTERNAL,
3748                 { },
3749                 { { 0, 0xa1b2c3d4 } }
3750         },
3751         {
3752                 "ALU_OR_K: Zero extension",
3753                 .u.insns_int = {
3754                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
3755                         BPF_LD_IMM64(R1, 0x00000000f9fbfdffLL),
3756                         BPF_ALU32_IMM(BPF_OR, R0, 0xf0f0f0f0),
3757                         BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
3758                         BPF_MOV32_IMM(R0, 2),
3759                         BPF_EXIT_INSN(),
3760                         BPF_MOV32_IMM(R0, 1),
3761                         BPF_EXIT_INSN(),
3762                 },
3763                 INTERNAL,
3764                 { },
3765                 { { 0, 1 } }
3766         },
3767         {
3768                 "ALU64_OR_K: 1 | 2 = 3",
3769                 .u.insns_int = {
3770                         BPF_LD_IMM64(R0, 1),
3771                         BPF_ALU64_IMM(BPF_OR, R0, 2),
3772                         BPF_EXIT_INSN(),
3773                 },
3774                 INTERNAL,
3775                 { },
3776                 { { 0, 3 } },
3777         },
3778         {
3779                 "ALU64_OR_K: 0 & 0xffffffff = 0xffffffff",
3780                 .u.insns_int = {
3781                         BPF_LD_IMM64(R0, 0),
3782                         BPF_ALU64_IMM(BPF_OR, R0, 0xffffffff),
3783                         BPF_EXIT_INSN(),
3784                 },
3785                 INTERNAL,
3786                 { },
3787                 { { 0, 0xffffffff } },
3788         },
3789         {
3790                 "ALU64_OR_K: 0x0000ffffffff0000 | 0x0 = 0x0000ffffffff0000",
3791                 .u.insns_int = {
3792                         BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3793                         BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
3794                         BPF_ALU64_IMM(BPF_OR, R2, 0x0),
3795                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3796                         BPF_MOV32_IMM(R0, 2),
3797                         BPF_EXIT_INSN(),
3798                         BPF_MOV32_IMM(R0, 1),
3799                         BPF_EXIT_INSN(),
3800                 },
3801                 INTERNAL,
3802                 { },
3803                 { { 0, 0x1 } },
3804         },
3805         {
3806                 "ALU64_OR_K: 0x0000ffffffff0000 | -1 = 0xffffffffffffffff",
3807                 .u.insns_int = {
3808                         BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3809                         BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
3810                         BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
3811                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3812                         BPF_MOV32_IMM(R0, 2),
3813                         BPF_EXIT_INSN(),
3814                         BPF_MOV32_IMM(R0, 1),
3815                         BPF_EXIT_INSN(),
3816                 },
3817                 INTERNAL,
3818                 { },
3819                 { { 0, 0x1 } },
3820         },
3821         {
3822                 "ALU64_OR_K: 0x000000000000000 | -1 = 0xffffffffffffffff",
3823                 .u.insns_int = {
3824                         BPF_LD_IMM64(R2, 0x0000000000000000LL),
3825                         BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
3826                         BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
3827                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3828                         BPF_MOV32_IMM(R0, 2),
3829                         BPF_EXIT_INSN(),
3830                         BPF_MOV32_IMM(R0, 1),
3831                         BPF_EXIT_INSN(),
3832                 },
3833                 INTERNAL,
3834                 { },
3835                 { { 0, 0x1 } },
3836         },
3837         {
3838                 "ALU64_OR_K: Sign extension 1",
3839                 .u.insns_int = {
3840                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
3841                         BPF_LD_IMM64(R1, 0x012345678fafcfefLL),
3842                         BPF_ALU64_IMM(BPF_OR, R0, 0x0f0f0f0f),
3843                         BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
3844                         BPF_MOV32_IMM(R0, 2),
3845                         BPF_EXIT_INSN(),
3846                         BPF_MOV32_IMM(R0, 1),
3847                         BPF_EXIT_INSN(),
3848                 },
3849                 INTERNAL,
3850                 { },
3851                 { { 0, 1 } }
3852         },
3853         {
3854                 "ALU64_OR_K: Sign extension 2",
3855                 .u.insns_int = {
3856                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
3857                         BPF_LD_IMM64(R1, 0xfffffffff9fbfdffLL),
3858                         BPF_ALU64_IMM(BPF_OR, R0, 0xf0f0f0f0),
3859                         BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
3860                         BPF_MOV32_IMM(R0, 2),
3861                         BPF_EXIT_INSN(),
3862                         BPF_MOV32_IMM(R0, 1),
3863                         BPF_EXIT_INSN(),
3864                 },
3865                 INTERNAL,
3866                 { },
3867                 { { 0, 1 } }
3868         },
3869         /* BPF_ALU | BPF_XOR | BPF_X */
3870         {
3871                 "ALU_XOR_X: 5 ^ 6 = 3",
3872                 .u.insns_int = {
3873                         BPF_LD_IMM64(R0, 5),
3874                         BPF_ALU32_IMM(BPF_MOV, R1, 6),
3875                         BPF_ALU32_REG(BPF_XOR, R0, R1),
3876                         BPF_EXIT_INSN(),
3877                 },
3878                 INTERNAL,
3879                 { },
3880                 { { 0, 3 } },
3881         },
3882         {
3883                 "ALU_XOR_X: 0x1 ^ 0xffffffff = 0xfffffffe",
3884                 .u.insns_int = {
3885                         BPF_LD_IMM64(R0, 1),
3886                         BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3887                         BPF_ALU32_REG(BPF_XOR, R0, R1),
3888                         BPF_EXIT_INSN(),
3889                 },
3890                 INTERNAL,
3891                 { },
3892                 { { 0, 0xfffffffe } },
3893         },
3894         {
3895                 "ALU64_XOR_X: 5 ^ 6 = 3",
3896                 .u.insns_int = {
3897                         BPF_LD_IMM64(R0, 5),
3898                         BPF_ALU32_IMM(BPF_MOV, R1, 6),
3899                         BPF_ALU64_REG(BPF_XOR, R0, R1),
3900                         BPF_EXIT_INSN(),
3901                 },
3902                 INTERNAL,
3903                 { },
3904                 { { 0, 3 } },
3905         },
3906         {
3907                 "ALU64_XOR_X: 1 ^ 0xffffffff = 0xfffffffe",
3908                 .u.insns_int = {
3909                         BPF_LD_IMM64(R0, 1),
3910                         BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3911                         BPF_ALU64_REG(BPF_XOR, R0, R1),
3912                         BPF_EXIT_INSN(),
3913                 },
3914                 INTERNAL,
3915                 { },
3916                 { { 0, 0xfffffffe } },
3917         },
3918         /* BPF_ALU | BPF_XOR | BPF_K */
3919         {
3920                 "ALU_XOR_K: 5 ^ 6 = 3",
3921                 .u.insns_int = {
3922                         BPF_LD_IMM64(R0, 5),
3923                         BPF_ALU32_IMM(BPF_XOR, R0, 6),
3924                         BPF_EXIT_INSN(),
3925                 },
3926                 INTERNAL,
3927                 { },
3928                 { { 0, 3 } },
3929         },
3930         {
3931                 "ALU_XOR_K: 1 ^ 0xffffffff = 0xfffffffe",
3932                 .u.insns_int = {
3933                         BPF_LD_IMM64(R0, 1),
3934                         BPF_ALU32_IMM(BPF_XOR, R0, 0xffffffff),
3935                         BPF_EXIT_INSN(),
3936                 },
3937                 INTERNAL,
3938                 { },
3939                 { { 0, 0xfffffffe } },
3940         },
3941         {
3942                 "ALU_XOR_K: Small immediate",
3943                 .u.insns_int = {
3944                         BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
3945                         BPF_ALU32_IMM(BPF_XOR, R0, 15),
3946                         BPF_EXIT_INSN(),
3947                 },
3948                 INTERNAL,
3949                 { },
3950                 { { 0, 0x0102030b } }
3951         },
3952         {
3953                 "ALU_XOR_K: Large immediate",
3954                 .u.insns_int = {
3955                         BPF_ALU32_IMM(BPF_MOV, R0, 0xf1f2f3f4),
3956                         BPF_ALU32_IMM(BPF_XOR, R0, 0xafbfcfdf),
3957                         BPF_EXIT_INSN(),
3958                 },
3959                 INTERNAL,
3960                 { },
3961                 { { 0, 0x5e4d3c2b } }
3962         },
3963         {
3964                 "ALU_XOR_K: Zero extension",
3965                 .u.insns_int = {
3966                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
3967                         BPF_LD_IMM64(R1, 0x00000000795b3d1fLL),
3968                         BPF_ALU32_IMM(BPF_XOR, R0, 0xf0f0f0f0),
3969                         BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
3970                         BPF_MOV32_IMM(R0, 2),
3971                         BPF_EXIT_INSN(),
3972                         BPF_MOV32_IMM(R0, 1),
3973                         BPF_EXIT_INSN(),
3974                 },
3975                 INTERNAL,
3976                 { },
3977                 { { 0, 1 } }
3978         },
3979         {
3980                 "ALU64_XOR_K: 5 ^ 6 = 3",
3981                 .u.insns_int = {
3982                         BPF_LD_IMM64(R0, 5),
3983                         BPF_ALU64_IMM(BPF_XOR, R0, 6),
3984                         BPF_EXIT_INSN(),
3985                 },
3986                 INTERNAL,
3987                 { },
3988                 { { 0, 3 } },
3989         },
3990         {
3991                 "ALU64_XOR_K: 1 ^ 0xffffffff = 0xfffffffe",
3992                 .u.insns_int = {
3993                         BPF_LD_IMM64(R0, 1),
3994                         BPF_ALU64_IMM(BPF_XOR, R0, 0xffffffff),
3995                         BPF_EXIT_INSN(),
3996                 },
3997                 INTERNAL,
3998                 { },
3999                 { { 0, 0xfffffffe } },
4000         },
4001         {
4002                 "ALU64_XOR_K: 0x0000ffffffff0000 ^ 0x0 = 0x0000ffffffff0000",
4003                 .u.insns_int = {
4004                         BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
4005                         BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
4006                         BPF_ALU64_IMM(BPF_XOR, R2, 0x0),
4007                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4008                         BPF_MOV32_IMM(R0, 2),
4009                         BPF_EXIT_INSN(),
4010                         BPF_MOV32_IMM(R0, 1),
4011                         BPF_EXIT_INSN(),
4012                 },
4013                 INTERNAL,
4014                 { },
4015                 { { 0, 0x1 } },
4016         },
4017         {
4018                 "ALU64_XOR_K: 0x0000ffffffff0000 ^ -1 = 0xffff00000000ffff",
4019                 .u.insns_int = {
4020                         BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
4021                         BPF_LD_IMM64(R3, 0xffff00000000ffffLL),
4022                         BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
4023                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4024                         BPF_MOV32_IMM(R0, 2),
4025                         BPF_EXIT_INSN(),
4026                         BPF_MOV32_IMM(R0, 1),
4027                         BPF_EXIT_INSN(),
4028                 },
4029                 INTERNAL,
4030                 { },
4031                 { { 0, 0x1 } },
4032         },
4033         {
4034                 "ALU64_XOR_K: 0x000000000000000 ^ -1 = 0xffffffffffffffff",
4035                 .u.insns_int = {
4036                         BPF_LD_IMM64(R2, 0x0000000000000000LL),
4037                         BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
4038                         BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
4039                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4040                         BPF_MOV32_IMM(R0, 2),
4041                         BPF_EXIT_INSN(),
4042                         BPF_MOV32_IMM(R0, 1),
4043                         BPF_EXIT_INSN(),
4044                 },
4045                 INTERNAL,
4046                 { },
4047                 { { 0, 0x1 } },
4048         },
4049         {
4050                 "ALU64_XOR_K: Sign extension 1",
4051                 .u.insns_int = {
4052                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4053                         BPF_LD_IMM64(R1, 0x0123456786a4c2e0LL),
4054                         BPF_ALU64_IMM(BPF_XOR, R0, 0x0f0f0f0f),
4055                         BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
4056                         BPF_MOV32_IMM(R0, 2),
4057                         BPF_EXIT_INSN(),
4058                         BPF_MOV32_IMM(R0, 1),
4059                         BPF_EXIT_INSN(),
4060                 },
4061                 INTERNAL,
4062                 { },
4063                 { { 0, 1 } }
4064         },
4065         {
4066                 "ALU64_XOR_K: Sign extension 2",
4067                 .u.insns_int = {
4068                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4069                         BPF_LD_IMM64(R1, 0xfedcba98795b3d1fLL),
4070                         BPF_ALU64_IMM(BPF_XOR, R0, 0xf0f0f0f0),
4071                         BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
4072                         BPF_MOV32_IMM(R0, 2),
4073                         BPF_EXIT_INSN(),
4074                         BPF_MOV32_IMM(R0, 1),
4075                         BPF_EXIT_INSN(),
4076                 },
4077                 INTERNAL,
4078                 { },
4079                 { { 0, 1 } }
4080         },
4081         /* BPF_ALU | BPF_LSH | BPF_X */
4082         {
4083                 "ALU_LSH_X: 1 << 1 = 2",
4084                 .u.insns_int = {
4085                         BPF_LD_IMM64(R0, 1),
4086                         BPF_ALU32_IMM(BPF_MOV, R1, 1),
4087                         BPF_ALU32_REG(BPF_LSH, R0, R1),
4088                         BPF_EXIT_INSN(),
4089                 },
4090                 INTERNAL,
4091                 { },
4092                 { { 0, 2 } },
4093         },
4094         {
4095                 "ALU_LSH_X: 1 << 31 = 0x80000000",
4096                 .u.insns_int = {
4097                         BPF_LD_IMM64(R0, 1),
4098                         BPF_ALU32_IMM(BPF_MOV, R1, 31),
4099                         BPF_ALU32_REG(BPF_LSH, R0, R1),
4100                         BPF_EXIT_INSN(),
4101                 },
4102                 INTERNAL,
4103                 { },
4104                 { { 0, 0x80000000 } },
4105         },
4106         {
4107                 "ALU_LSH_X: 0x12345678 << 12 = 0x45678000",
4108                 .u.insns_int = {
4109                         BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
4110                         BPF_ALU32_IMM(BPF_MOV, R1, 12),
4111                         BPF_ALU32_REG(BPF_LSH, R0, R1),
4112                         BPF_EXIT_INSN(),
4113                 },
4114                 INTERNAL,
4115                 { },
4116                 { { 0, 0x45678000 } }
4117         },
4118         {
4119                 "ALU64_LSH_X: 1 << 1 = 2",
4120                 .u.insns_int = {
4121                         BPF_LD_IMM64(R0, 1),
4122                         BPF_ALU32_IMM(BPF_MOV, R1, 1),
4123                         BPF_ALU64_REG(BPF_LSH, R0, R1),
4124                         BPF_EXIT_INSN(),
4125                 },
4126                 INTERNAL,
4127                 { },
4128                 { { 0, 2 } },
4129         },
4130         {
4131                 "ALU64_LSH_X: 1 << 31 = 0x80000000",
4132                 .u.insns_int = {
4133                         BPF_LD_IMM64(R0, 1),
4134                         BPF_ALU32_IMM(BPF_MOV, R1, 31),
4135                         BPF_ALU64_REG(BPF_LSH, R0, R1),
4136                         BPF_EXIT_INSN(),
4137                 },
4138                 INTERNAL,
4139                 { },
4140                 { { 0, 0x80000000 } },
4141         },
4142         {
4143                 "ALU64_LSH_X: Shift < 32, low word",
4144                 .u.insns_int = {
4145                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4146                         BPF_ALU32_IMM(BPF_MOV, R1, 12),
4147                         BPF_ALU64_REG(BPF_LSH, R0, R1),
4148                         BPF_EXIT_INSN(),
4149                 },
4150                 INTERNAL,
4151                 { },
4152                 { { 0, 0xbcdef000 } }
4153         },
4154         {
4155                 "ALU64_LSH_X: Shift < 32, high word",
4156                 .u.insns_int = {
4157                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4158                         BPF_ALU32_IMM(BPF_MOV, R1, 12),
4159                         BPF_ALU64_REG(BPF_LSH, R0, R1),
4160                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4161                         BPF_EXIT_INSN(),
4162                 },
4163                 INTERNAL,
4164                 { },
4165                 { { 0, 0x3456789a } }
4166         },
4167         {
4168                 "ALU64_LSH_X: Shift > 32, low word",
4169                 .u.insns_int = {
4170                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4171                         BPF_ALU32_IMM(BPF_MOV, R1, 36),
4172                         BPF_ALU64_REG(BPF_LSH, R0, R1),
4173                         BPF_EXIT_INSN(),
4174                 },
4175                 INTERNAL,
4176                 { },
4177                 { { 0, 0 } }
4178         },
4179         {
4180                 "ALU64_LSH_X: Shift > 32, high word",
4181                 .u.insns_int = {
4182                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4183                         BPF_ALU32_IMM(BPF_MOV, R1, 36),
4184                         BPF_ALU64_REG(BPF_LSH, R0, R1),
4185                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4186                         BPF_EXIT_INSN(),
4187                 },
4188                 INTERNAL,
4189                 { },
4190                 { { 0, 0x9abcdef0 } }
4191         },
4192         {
4193                 "ALU64_LSH_X: Shift == 32, low word",
4194                 .u.insns_int = {
4195                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4196                         BPF_ALU32_IMM(BPF_MOV, R1, 32),
4197                         BPF_ALU64_REG(BPF_LSH, R0, R1),
4198                         BPF_EXIT_INSN(),
4199                 },
4200                 INTERNAL,
4201                 { },
4202                 { { 0, 0 } }
4203         },
4204         {
4205                 "ALU64_LSH_X: Shift == 32, high word",
4206                 .u.insns_int = {
4207                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4208                         BPF_ALU32_IMM(BPF_MOV, R1, 32),
4209                         BPF_ALU64_REG(BPF_LSH, R0, R1),
4210                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4211                         BPF_EXIT_INSN(),
4212                 },
4213                 INTERNAL,
4214                 { },
4215                 { { 0, 0x89abcdef } }
4216         },
4217         {
4218                 "ALU64_LSH_X: Zero shift, low word",
4219                 .u.insns_int = {
4220                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4221                         BPF_ALU32_IMM(BPF_MOV, R1, 0),
4222                         BPF_ALU64_REG(BPF_LSH, R0, R1),
4223                         BPF_EXIT_INSN(),
4224                 },
4225                 INTERNAL,
4226                 { },
4227                 { { 0, 0x89abcdef } }
4228         },
4229         {
4230                 "ALU64_LSH_X: Zero shift, high word",
4231                 .u.insns_int = {
4232                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4233                         BPF_ALU32_IMM(BPF_MOV, R1, 0),
4234                         BPF_ALU64_REG(BPF_LSH, R0, R1),
4235                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4236                         BPF_EXIT_INSN(),
4237                 },
4238                 INTERNAL,
4239                 { },
4240                 { { 0, 0x01234567 } }
4241         },
4242         /* BPF_ALU | BPF_LSH | BPF_K */
4243         {
4244                 "ALU_LSH_K: 1 << 1 = 2",
4245                 .u.insns_int = {
4246                         BPF_LD_IMM64(R0, 1),
4247                         BPF_ALU32_IMM(BPF_LSH, R0, 1),
4248                         BPF_EXIT_INSN(),
4249                 },
4250                 INTERNAL,
4251                 { },
4252                 { { 0, 2 } },
4253         },
4254         {
4255                 "ALU_LSH_K: 1 << 31 = 0x80000000",
4256                 .u.insns_int = {
4257                         BPF_LD_IMM64(R0, 1),
4258                         BPF_ALU32_IMM(BPF_LSH, R0, 31),
4259                         BPF_EXIT_INSN(),
4260                 },
4261                 INTERNAL,
4262                 { },
4263                 { { 0, 0x80000000 } },
4264         },
4265         {
4266                 "ALU_LSH_K: 0x12345678 << 12 = 0x45678000",
4267                 .u.insns_int = {
4268                         BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
4269                         BPF_ALU32_IMM(BPF_LSH, R0, 12),
4270                         BPF_EXIT_INSN(),
4271                 },
4272                 INTERNAL,
4273                 { },
4274                 { { 0, 0x45678000 } }
4275         },
4276         {
4277                 "ALU_LSH_K: 0x12345678 << 0 = 0x12345678",
4278                 .u.insns_int = {
4279                         BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
4280                         BPF_ALU32_IMM(BPF_LSH, R0, 0),
4281                         BPF_EXIT_INSN(),
4282                 },
4283                 INTERNAL,
4284                 { },
4285                 { { 0, 0x12345678 } }
4286         },
4287         {
4288                 "ALU64_LSH_K: 1 << 1 = 2",
4289                 .u.insns_int = {
4290                         BPF_LD_IMM64(R0, 1),
4291                         BPF_ALU64_IMM(BPF_LSH, R0, 1),
4292                         BPF_EXIT_INSN(),
4293                 },
4294                 INTERNAL,
4295                 { },
4296                 { { 0, 2 } },
4297         },
4298         {
4299                 "ALU64_LSH_K: 1 << 31 = 0x80000000",
4300                 .u.insns_int = {
4301                         BPF_LD_IMM64(R0, 1),
4302                         BPF_ALU64_IMM(BPF_LSH, R0, 31),
4303                         BPF_EXIT_INSN(),
4304                 },
4305                 INTERNAL,
4306                 { },
4307                 { { 0, 0x80000000 } },
4308         },
4309         {
4310                 "ALU64_LSH_K: Shift < 32, low word",
4311                 .u.insns_int = {
4312                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4313                         BPF_ALU64_IMM(BPF_LSH, R0, 12),
4314                         BPF_EXIT_INSN(),
4315                 },
4316                 INTERNAL,
4317                 { },
4318                 { { 0, 0xbcdef000 } }
4319         },
4320         {
4321                 "ALU64_LSH_K: Shift < 32, high word",
4322                 .u.insns_int = {
4323                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4324                         BPF_ALU64_IMM(BPF_LSH, R0, 12),
4325                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4326                         BPF_EXIT_INSN(),
4327                 },
4328                 INTERNAL,
4329                 { },
4330                 { { 0, 0x3456789a } }
4331         },
4332         {
4333                 "ALU64_LSH_K: Shift > 32, low word",
4334                 .u.insns_int = {
4335                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4336                         BPF_ALU64_IMM(BPF_LSH, R0, 36),
4337                         BPF_EXIT_INSN(),
4338                 },
4339                 INTERNAL,
4340                 { },
4341                 { { 0, 0 } }
4342         },
4343         {
4344                 "ALU64_LSH_K: Shift > 32, high word",
4345                 .u.insns_int = {
4346                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4347                         BPF_ALU64_IMM(BPF_LSH, R0, 36),
4348                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4349                         BPF_EXIT_INSN(),
4350                 },
4351                 INTERNAL,
4352                 { },
4353                 { { 0, 0x9abcdef0 } }
4354         },
4355         {
4356                 "ALU64_LSH_K: Shift == 32, low word",
4357                 .u.insns_int = {
4358                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4359                         BPF_ALU64_IMM(BPF_LSH, R0, 32),
4360                         BPF_EXIT_INSN(),
4361                 },
4362                 INTERNAL,
4363                 { },
4364                 { { 0, 0 } }
4365         },
4366         {
4367                 "ALU64_LSH_K: Shift == 32, high word",
4368                 .u.insns_int = {
4369                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4370                         BPF_ALU64_IMM(BPF_LSH, R0, 32),
4371                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4372                         BPF_EXIT_INSN(),
4373                 },
4374                 INTERNAL,
4375                 { },
4376                 { { 0, 0x89abcdef } }
4377         },
4378         {
4379                 "ALU64_LSH_K: Zero shift",
4380                 .u.insns_int = {
4381                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4382                         BPF_ALU64_IMM(BPF_LSH, R0, 0),
4383                         BPF_EXIT_INSN(),
4384                 },
4385                 INTERNAL,
4386                 { },
4387                 { { 0, 0x89abcdef } }
4388         },
4389         /* BPF_ALU | BPF_RSH | BPF_X */
4390         {
4391                 "ALU_RSH_X: 2 >> 1 = 1",
4392                 .u.insns_int = {
4393                         BPF_LD_IMM64(R0, 2),
4394                         BPF_ALU32_IMM(BPF_MOV, R1, 1),
4395                         BPF_ALU32_REG(BPF_RSH, R0, R1),
4396                         BPF_EXIT_INSN(),
4397                 },
4398                 INTERNAL,
4399                 { },
4400                 { { 0, 1 } },
4401         },
4402         {
4403                 "ALU_RSH_X: 0x80000000 >> 31 = 1",
4404                 .u.insns_int = {
4405                         BPF_LD_IMM64(R0, 0x80000000),
4406                         BPF_ALU32_IMM(BPF_MOV, R1, 31),
4407                         BPF_ALU32_REG(BPF_RSH, R0, R1),
4408                         BPF_EXIT_INSN(),
4409                 },
4410                 INTERNAL,
4411                 { },
4412                 { { 0, 1 } },
4413         },
4414         {
4415                 "ALU_RSH_X: 0x12345678 >> 20 = 0x123",
4416                 .u.insns_int = {
4417                         BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
4418                         BPF_ALU32_IMM(BPF_MOV, R1, 20),
4419                         BPF_ALU32_REG(BPF_RSH, R0, R1),
4420                         BPF_EXIT_INSN(),
4421                 },
4422                 INTERNAL,
4423                 { },
4424                 { { 0, 0x123 } }
4425         },
4426         {
4427                 "ALU64_RSH_X: 2 >> 1 = 1",
4428                 .u.insns_int = {
4429                         BPF_LD_IMM64(R0, 2),
4430                         BPF_ALU32_IMM(BPF_MOV, R1, 1),
4431                         BPF_ALU64_REG(BPF_RSH, R0, R1),
4432                         BPF_EXIT_INSN(),
4433                 },
4434                 INTERNAL,
4435                 { },
4436                 { { 0, 1 } },
4437         },
4438         {
4439                 "ALU64_RSH_X: 0x80000000 >> 31 = 1",
4440                 .u.insns_int = {
4441                         BPF_LD_IMM64(R0, 0x80000000),
4442                         BPF_ALU32_IMM(BPF_MOV, R1, 31),
4443                         BPF_ALU64_REG(BPF_RSH, R0, R1),
4444                         BPF_EXIT_INSN(),
4445                 },
4446                 INTERNAL,
4447                 { },
4448                 { { 0, 1 } },
4449         },
4450         {
4451                 "ALU64_RSH_X: Shift < 32, low word",
4452                 .u.insns_int = {
4453                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4454                         BPF_ALU32_IMM(BPF_MOV, R1, 12),
4455                         BPF_ALU64_REG(BPF_RSH, R0, R1),
4456                         BPF_EXIT_INSN(),
4457                 },
4458                 INTERNAL,
4459                 { },
4460                 { { 0, 0x56789abc } }
4461         },
4462         {
4463                 "ALU64_RSH_X: Shift < 32, high word",
4464                 .u.insns_int = {
4465                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4466                         BPF_ALU32_IMM(BPF_MOV, R1, 12),
4467                         BPF_ALU64_REG(BPF_RSH, R0, R1),
4468                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4469                         BPF_EXIT_INSN(),
4470                 },
4471                 INTERNAL,
4472                 { },
4473                 { { 0, 0x00081234 } }
4474         },
4475         {
4476                 "ALU64_RSH_X: Shift > 32, low word",
4477                 .u.insns_int = {
4478                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4479                         BPF_ALU32_IMM(BPF_MOV, R1, 36),
4480                         BPF_ALU64_REG(BPF_RSH, R0, R1),
4481                         BPF_EXIT_INSN(),
4482                 },
4483                 INTERNAL,
4484                 { },
4485                 { { 0, 0x08123456 } }
4486         },
4487         {
4488                 "ALU64_RSH_X: Shift > 32, high word",
4489                 .u.insns_int = {
4490                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4491                         BPF_ALU32_IMM(BPF_MOV, R1, 36),
4492                         BPF_ALU64_REG(BPF_RSH, R0, R1),
4493                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4494                         BPF_EXIT_INSN(),
4495                 },
4496                 INTERNAL,
4497                 { },
4498                 { { 0, 0 } }
4499         },
4500         {
4501                 "ALU64_RSH_X: Shift == 32, low word",
4502                 .u.insns_int = {
4503                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4504                         BPF_ALU32_IMM(BPF_MOV, R1, 32),
4505                         BPF_ALU64_REG(BPF_RSH, R0, R1),
4506                         BPF_EXIT_INSN(),
4507                 },
4508                 INTERNAL,
4509                 { },
4510                 { { 0, 0x81234567 } }
4511         },
4512         {
4513                 "ALU64_RSH_X: Shift == 32, high word",
4514                 .u.insns_int = {
4515                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4516                         BPF_ALU32_IMM(BPF_MOV, R1, 32),
4517                         BPF_ALU64_REG(BPF_RSH, R0, R1),
4518                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4519                         BPF_EXIT_INSN(),
4520                 },
4521                 INTERNAL,
4522                 { },
4523                 { { 0, 0 } }
4524         },
4525         {
4526                 "ALU64_RSH_X: Zero shift, low word",
4527                 .u.insns_int = {
4528                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4529                         BPF_ALU32_IMM(BPF_MOV, R1, 0),
4530                         BPF_ALU64_REG(BPF_RSH, R0, R1),
4531                         BPF_EXIT_INSN(),
4532                 },
4533                 INTERNAL,
4534                 { },
4535                 { { 0, 0x89abcdef } }
4536         },
4537         {
4538                 "ALU64_RSH_X: Zero shift, high word",
4539                 .u.insns_int = {
4540                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4541                         BPF_ALU32_IMM(BPF_MOV, R1, 0),
4542                         BPF_ALU64_REG(BPF_RSH, R0, R1),
4543                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4544                         BPF_EXIT_INSN(),
4545                 },
4546                 INTERNAL,
4547                 { },
4548                 { { 0, 0x81234567 } }
4549         },
4550         /* BPF_ALU | BPF_RSH | BPF_K */
4551         {
4552                 "ALU_RSH_K: 2 >> 1 = 1",
4553                 .u.insns_int = {
4554                         BPF_LD_IMM64(R0, 2),
4555                         BPF_ALU32_IMM(BPF_RSH, R0, 1),
4556                         BPF_EXIT_INSN(),
4557                 },
4558                 INTERNAL,
4559                 { },
4560                 { { 0, 1 } },
4561         },
4562         {
4563                 "ALU_RSH_K: 0x80000000 >> 31 = 1",
4564                 .u.insns_int = {
4565                         BPF_LD_IMM64(R0, 0x80000000),
4566                         BPF_ALU32_IMM(BPF_RSH, R0, 31),
4567                         BPF_EXIT_INSN(),
4568                 },
4569                 INTERNAL,
4570                 { },
4571                 { { 0, 1 } },
4572         },
4573         {
4574                 "ALU_RSH_K: 0x12345678 >> 20 = 0x123",
4575                 .u.insns_int = {
4576                         BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
4577                         BPF_ALU32_IMM(BPF_RSH, R0, 20),
4578                         BPF_EXIT_INSN(),
4579                 },
4580                 INTERNAL,
4581                 { },
4582                 { { 0, 0x123 } }
4583         },
4584         {
4585                 "ALU_RSH_K: 0x12345678 >> 0 = 0x12345678",
4586                 .u.insns_int = {
4587                         BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
4588                         BPF_ALU32_IMM(BPF_RSH, R0, 0),
4589                         BPF_EXIT_INSN(),
4590                 },
4591                 INTERNAL,
4592                 { },
4593                 { { 0, 0x12345678 } }
4594         },
4595         {
4596                 "ALU64_RSH_K: 2 >> 1 = 1",
4597                 .u.insns_int = {
4598                         BPF_LD_IMM64(R0, 2),
4599                         BPF_ALU64_IMM(BPF_RSH, R0, 1),
4600                         BPF_EXIT_INSN(),
4601                 },
4602                 INTERNAL,
4603                 { },
4604                 { { 0, 1 } },
4605         },
4606         {
4607                 "ALU64_RSH_K: 0x80000000 >> 31 = 1",
4608                 .u.insns_int = {
4609                         BPF_LD_IMM64(R0, 0x80000000),
4610                         BPF_ALU64_IMM(BPF_RSH, R0, 31),
4611                         BPF_EXIT_INSN(),
4612                 },
4613                 INTERNAL,
4614                 { },
4615                 { { 0, 1 } },
4616         },
4617         {
4618                 "ALU64_RSH_K: Shift < 32, low word",
4619                 .u.insns_int = {
4620                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4621                         BPF_ALU64_IMM(BPF_RSH, R0, 12),
4622                         BPF_EXIT_INSN(),
4623                 },
4624                 INTERNAL,
4625                 { },
4626                 { { 0, 0x56789abc } }
4627         },
4628         {
4629                 "ALU64_RSH_K: Shift < 32, high word",
4630                 .u.insns_int = {
4631                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4632                         BPF_ALU64_IMM(BPF_RSH, R0, 12),
4633                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4634                         BPF_EXIT_INSN(),
4635                 },
4636                 INTERNAL,
4637                 { },
4638                 { { 0, 0x00081234 } }
4639         },
4640         {
4641                 "ALU64_RSH_K: Shift > 32, low word",
4642                 .u.insns_int = {
4643                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4644                         BPF_ALU64_IMM(BPF_RSH, R0, 36),
4645                         BPF_EXIT_INSN(),
4646                 },
4647                 INTERNAL,
4648                 { },
4649                 { { 0, 0x08123456 } }
4650         },
4651         {
4652                 "ALU64_RSH_K: Shift > 32, high word",
4653                 .u.insns_int = {
4654                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4655                         BPF_ALU64_IMM(BPF_RSH, R0, 36),
4656                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4657                         BPF_EXIT_INSN(),
4658                 },
4659                 INTERNAL,
4660                 { },
4661                 { { 0, 0 } }
4662         },
4663         {
4664                 "ALU64_RSH_K: Shift == 32, low word",
4665                 .u.insns_int = {
4666                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4667                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4668                         BPF_EXIT_INSN(),
4669                 },
4670                 INTERNAL,
4671                 { },
4672                 { { 0, 0x81234567 } }
4673         },
4674         {
4675                 "ALU64_RSH_K: Shift == 32, high word",
4676                 .u.insns_int = {
4677                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4678                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4679                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4680                         BPF_EXIT_INSN(),
4681                 },
4682                 INTERNAL,
4683                 { },
4684                 { { 0, 0 } }
4685         },
4686         {
4687                 "ALU64_RSH_K: Zero shift",
4688                 .u.insns_int = {
4689                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4690                         BPF_ALU64_IMM(BPF_RSH, R0, 0),
4691                         BPF_EXIT_INSN(),
4692                 },
4693                 INTERNAL,
4694                 { },
4695                 { { 0, 0x89abcdef } }
4696         },
4697         /* BPF_ALU | BPF_ARSH | BPF_X */
4698         {
4699                 "ALU32_ARSH_X: -1234 >> 7 = -10",
4700                 .u.insns_int = {
4701                         BPF_ALU32_IMM(BPF_MOV, R0, -1234),
4702                         BPF_ALU32_IMM(BPF_MOV, R1, 7),
4703                         BPF_ALU32_REG(BPF_ARSH, R0, R1),
4704                         BPF_EXIT_INSN(),
4705                 },
4706                 INTERNAL,
4707                 { },
4708                 { { 0, -10 } }
4709         },
4710         {
4711                 "ALU64_ARSH_X: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
4712                 .u.insns_int = {
4713                         BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
4714                         BPF_ALU32_IMM(BPF_MOV, R1, 40),
4715                         BPF_ALU64_REG(BPF_ARSH, R0, R1),
4716                         BPF_EXIT_INSN(),
4717                 },
4718                 INTERNAL,
4719                 { },
4720                 { { 0, 0xffff00ff } },
4721         },
4722         {
4723                 "ALU64_ARSH_X: Shift < 32, low word",
4724                 .u.insns_int = {
4725                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4726                         BPF_ALU32_IMM(BPF_MOV, R1, 12),
4727                         BPF_ALU64_REG(BPF_ARSH, R0, R1),
4728                         BPF_EXIT_INSN(),
4729                 },
4730                 INTERNAL,
4731                 { },
4732                 { { 0, 0x56789abc } }
4733         },
4734         {
4735                 "ALU64_ARSH_X: Shift < 32, high word",
4736                 .u.insns_int = {
4737                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4738                         BPF_ALU32_IMM(BPF_MOV, R1, 12),
4739                         BPF_ALU64_REG(BPF_ARSH, R0, R1),
4740                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4741                         BPF_EXIT_INSN(),
4742                 },
4743                 INTERNAL,
4744                 { },
4745                 { { 0, 0xfff81234 } }
4746         },
4747         {
4748                 "ALU64_ARSH_X: Shift > 32, low word",
4749                 .u.insns_int = {
4750                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4751                         BPF_ALU32_IMM(BPF_MOV, R1, 36),
4752                         BPF_ALU64_REG(BPF_ARSH, R0, R1),
4753                         BPF_EXIT_INSN(),
4754                 },
4755                 INTERNAL,
4756                 { },
4757                 { { 0, 0xf8123456 } }
4758         },
4759         {
4760                 "ALU64_ARSH_X: Shift > 32, high word",
4761                 .u.insns_int = {
4762                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4763                         BPF_ALU32_IMM(BPF_MOV, R1, 36),
4764                         BPF_ALU64_REG(BPF_ARSH, R0, R1),
4765                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4766                         BPF_EXIT_INSN(),
4767                 },
4768                 INTERNAL,
4769                 { },
4770                 { { 0, -1 } }
4771         },
4772         {
4773                 "ALU64_ARSH_X: Shift == 32, low word",
4774                 .u.insns_int = {
4775                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4776                         BPF_ALU32_IMM(BPF_MOV, R1, 32),
4777                         BPF_ALU64_REG(BPF_ARSH, R0, R1),
4778                         BPF_EXIT_INSN(),
4779                 },
4780                 INTERNAL,
4781                 { },
4782                 { { 0, 0x81234567 } }
4783         },
4784         {
4785                 "ALU64_ARSH_X: Shift == 32, high word",
4786                 .u.insns_int = {
4787                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4788                         BPF_ALU32_IMM(BPF_MOV, R1, 32),
4789                         BPF_ALU64_REG(BPF_ARSH, R0, R1),
4790                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4791                         BPF_EXIT_INSN(),
4792                 },
4793                 INTERNAL,
4794                 { },
4795                 { { 0, -1 } }
4796         },
4797         {
4798                 "ALU64_ARSH_X: Zero shift, low word",
4799                 .u.insns_int = {
4800                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4801                         BPF_ALU32_IMM(BPF_MOV, R1, 0),
4802                         BPF_ALU64_REG(BPF_ARSH, R0, R1),
4803                         BPF_EXIT_INSN(),
4804                 },
4805                 INTERNAL,
4806                 { },
4807                 { { 0, 0x89abcdef } }
4808         },
4809         {
4810                 "ALU64_ARSH_X: Zero shift, high word",
4811                 .u.insns_int = {
4812                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4813                         BPF_ALU32_IMM(BPF_MOV, R1, 0),
4814                         BPF_ALU64_REG(BPF_ARSH, R0, R1),
4815                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4816                         BPF_EXIT_INSN(),
4817                 },
4818                 INTERNAL,
4819                 { },
4820                 { { 0, 0x81234567 } }
4821         },
4822         /* BPF_ALU | BPF_ARSH | BPF_K */
4823         {
4824                 "ALU32_ARSH_K: -1234 >> 7 = -10",
4825                 .u.insns_int = {
4826                         BPF_ALU32_IMM(BPF_MOV, R0, -1234),
4827                         BPF_ALU32_IMM(BPF_ARSH, R0, 7),
4828                         BPF_EXIT_INSN(),
4829                 },
4830                 INTERNAL,
4831                 { },
4832                 { { 0, -10 } }
4833         },
4834         {
4835                 "ALU32_ARSH_K: -1234 >> 0 = -1234",
4836                 .u.insns_int = {
4837                         BPF_ALU32_IMM(BPF_MOV, R0, -1234),
4838                         BPF_ALU32_IMM(BPF_ARSH, R0, 0),
4839                         BPF_EXIT_INSN(),
4840                 },
4841                 INTERNAL,
4842                 { },
4843                 { { 0, -1234 } }
4844         },
4845         {
4846                 "ALU64_ARSH_K: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
4847                 .u.insns_int = {
4848                         BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
4849                         BPF_ALU64_IMM(BPF_ARSH, R0, 40),
4850                         BPF_EXIT_INSN(),
4851                 },
4852                 INTERNAL,
4853                 { },
4854                 { { 0, 0xffff00ff } },
4855         },
4856         {
4857                 "ALU64_ARSH_K: Shift < 32, low word",
4858                 .u.insns_int = {
4859                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4860                         BPF_ALU64_IMM(BPF_RSH, R0, 12),
4861                         BPF_EXIT_INSN(),
4862                 },
4863                 INTERNAL,
4864                 { },
4865                 { { 0, 0x56789abc } }
4866         },
4867         {
4868                 "ALU64_ARSH_K: Shift < 32, high word",
4869                 .u.insns_int = {
4870                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4871                         BPF_ALU64_IMM(BPF_ARSH, R0, 12),
4872                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4873                         BPF_EXIT_INSN(),
4874                 },
4875                 INTERNAL,
4876                 { },
4877                 { { 0, 0xfff81234 } }
4878         },
4879         {
4880                 "ALU64_ARSH_K: Shift > 32, low word",
4881                 .u.insns_int = {
4882                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4883                         BPF_ALU64_IMM(BPF_ARSH, R0, 36),
4884                         BPF_EXIT_INSN(),
4885                 },
4886                 INTERNAL,
4887                 { },
4888                 { { 0, 0xf8123456 } }
4889         },
4890         {
4891                 "ALU64_ARSH_K: Shift > 32, high word",
4892                 .u.insns_int = {
4893                         BPF_LD_IMM64(R0, 0xf123456789abcdefLL),
4894                         BPF_ALU64_IMM(BPF_ARSH, R0, 36),
4895                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4896                         BPF_EXIT_INSN(),
4897                 },
4898                 INTERNAL,
4899                 { },
4900                 { { 0, -1 } }
4901         },
4902         {
4903                 "ALU64_ARSH_K: Shift == 32, low word",
4904                 .u.insns_int = {
4905                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4906                         BPF_ALU64_IMM(BPF_ARSH, R0, 32),
4907                         BPF_EXIT_INSN(),
4908                 },
4909                 INTERNAL,
4910                 { },
4911                 { { 0, 0x81234567 } }
4912         },
4913         {
4914                 "ALU64_ARSH_K: Shift == 32, high word",
4915                 .u.insns_int = {
4916                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4917                         BPF_ALU64_IMM(BPF_ARSH, R0, 32),
4918                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4919                         BPF_EXIT_INSN(),
4920                 },
4921                 INTERNAL,
4922                 { },
4923                 { { 0, -1 } }
4924         },
4925         {
4926                 "ALU64_ARSH_K: Zero shoft",
4927                 .u.insns_int = {
4928                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4929                         BPF_ALU64_IMM(BPF_ARSH, R0, 0),
4930                         BPF_EXIT_INSN(),
4931                 },
4932                 INTERNAL,
4933                 { },
4934                 { { 0, 0x89abcdef } }
4935         },
4936         /* BPF_ALU | BPF_NEG */
4937         {
4938                 "ALU_NEG: -(3) = -3",
4939                 .u.insns_int = {
4940                         BPF_ALU32_IMM(BPF_MOV, R0, 3),
4941                         BPF_ALU32_IMM(BPF_NEG, R0, 0),
4942                         BPF_EXIT_INSN(),
4943                 },
4944                 INTERNAL,
4945                 { },
4946                 { { 0, -3 } },
4947         },
4948         {
4949                 "ALU_NEG: -(-3) = 3",
4950                 .u.insns_int = {
4951                         BPF_ALU32_IMM(BPF_MOV, R0, -3),
4952                         BPF_ALU32_IMM(BPF_NEG, R0, 0),
4953                         BPF_EXIT_INSN(),
4954                 },
4955                 INTERNAL,
4956                 { },
4957                 { { 0, 3 } },
4958         },
4959         {
4960                 "ALU64_NEG: -(3) = -3",
4961                 .u.insns_int = {
4962                         BPF_LD_IMM64(R0, 3),
4963                         BPF_ALU64_IMM(BPF_NEG, R0, 0),
4964                         BPF_EXIT_INSN(),
4965                 },
4966                 INTERNAL,
4967                 { },
4968                 { { 0, -3 } },
4969         },
4970         {
4971                 "ALU64_NEG: -(-3) = 3",
4972                 .u.insns_int = {
4973                         BPF_LD_IMM64(R0, -3),
4974                         BPF_ALU64_IMM(BPF_NEG, R0, 0),
4975                         BPF_EXIT_INSN(),
4976                 },
4977                 INTERNAL,
4978                 { },
4979                 { { 0, 3 } },
4980         },
4981         /* BPF_ALU | BPF_END | BPF_FROM_BE */
4982         {
4983                 "ALU_END_FROM_BE 16: 0x0123456789abcdef -> 0xcdef",
4984                 .u.insns_int = {
4985                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4986                         BPF_ENDIAN(BPF_FROM_BE, R0, 16),
4987                         BPF_EXIT_INSN(),
4988                 },
4989                 INTERNAL,
4990                 { },
4991                 { { 0,  cpu_to_be16(0xcdef) } },
4992         },
4993         {
4994                 "ALU_END_FROM_BE 32: 0x0123456789abcdef -> 0x89abcdef",
4995                 .u.insns_int = {
4996                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4997                         BPF_ENDIAN(BPF_FROM_BE, R0, 32),
4998                         BPF_ALU64_REG(BPF_MOV, R1, R0),
4999                         BPF_ALU64_IMM(BPF_RSH, R1, 32),
5000                         BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
5001                         BPF_EXIT_INSN(),
5002                 },
5003                 INTERNAL,
5004                 { },
5005                 { { 0, cpu_to_be32(0x89abcdef) } },
5006         },
5007         {
5008                 "ALU_END_FROM_BE 64: 0x0123456789abcdef -> 0x89abcdef",
5009                 .u.insns_int = {
5010                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5011                         BPF_ENDIAN(BPF_FROM_BE, R0, 64),
5012                         BPF_EXIT_INSN(),
5013                 },
5014                 INTERNAL,
5015                 { },
5016                 { { 0, (u32) cpu_to_be64(0x0123456789abcdefLL) } },
5017         },
5018         /* BPF_ALU | BPF_END | BPF_FROM_LE */
5019         {
5020                 "ALU_END_FROM_LE 16: 0x0123456789abcdef -> 0xefcd",
5021                 .u.insns_int = {
5022                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5023                         BPF_ENDIAN(BPF_FROM_LE, R0, 16),
5024                         BPF_EXIT_INSN(),
5025                 },
5026                 INTERNAL,
5027                 { },
5028                 { { 0, cpu_to_le16(0xcdef) } },
5029         },
5030         {
5031                 "ALU_END_FROM_LE 32: 0x0123456789abcdef -> 0xefcdab89",
5032                 .u.insns_int = {
5033                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5034                         BPF_ENDIAN(BPF_FROM_LE, R0, 32),
5035                         BPF_ALU64_REG(BPF_MOV, R1, R0),
5036                         BPF_ALU64_IMM(BPF_RSH, R1, 32),
5037                         BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
5038                         BPF_EXIT_INSN(),
5039                 },
5040                 INTERNAL,
5041                 { },
5042                 { { 0, cpu_to_le32(0x89abcdef) } },
5043         },
5044         {
5045                 "ALU_END_FROM_LE 64: 0x0123456789abcdef -> 0x67452301",
5046                 .u.insns_int = {
5047                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5048                         BPF_ENDIAN(BPF_FROM_LE, R0, 64),
5049                         BPF_EXIT_INSN(),
5050                 },
5051                 INTERNAL,
5052                 { },
5053                 { { 0, (u32) cpu_to_le64(0x0123456789abcdefLL) } },
5054         },
5055         /* BPF_ST(X) | BPF_MEM | BPF_B/H/W/DW */
5056         {
5057                 "ST_MEM_B: Store/Load byte: max negative",
5058                 .u.insns_int = {
5059                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
5060                         BPF_ST_MEM(BPF_B, R10, -40, 0xff),
5061                         BPF_LDX_MEM(BPF_B, R0, R10, -40),
5062                         BPF_EXIT_INSN(),
5063                 },
5064                 INTERNAL,
5065                 { },
5066                 { { 0, 0xff } },
5067                 .stack_depth = 40,
5068         },
5069         {
5070                 "ST_MEM_B: Store/Load byte: max positive",
5071                 .u.insns_int = {
5072                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
5073                         BPF_ST_MEM(BPF_H, R10, -40, 0x7f),
5074                         BPF_LDX_MEM(BPF_H, R0, R10, -40),
5075                         BPF_EXIT_INSN(),
5076                 },
5077                 INTERNAL,
5078                 { },
5079                 { { 0, 0x7f } },
5080                 .stack_depth = 40,
5081         },
5082         {
5083                 "STX_MEM_B: Store/Load byte: max negative",
5084                 .u.insns_int = {
5085                         BPF_LD_IMM64(R0, 0),
5086                         BPF_LD_IMM64(R1, 0xffLL),
5087                         BPF_STX_MEM(BPF_B, R10, R1, -40),
5088                         BPF_LDX_MEM(BPF_B, R0, R10, -40),
5089                         BPF_EXIT_INSN(),
5090                 },
5091                 INTERNAL,
5092                 { },
5093                 { { 0, 0xff } },
5094                 .stack_depth = 40,
5095         },
5096         {
5097                 "ST_MEM_H: Store/Load half word: max negative",
5098                 .u.insns_int = {
5099                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
5100                         BPF_ST_MEM(BPF_H, R10, -40, 0xffff),
5101                         BPF_LDX_MEM(BPF_H, R0, R10, -40),
5102                         BPF_EXIT_INSN(),
5103                 },
5104                 INTERNAL,
5105                 { },
5106                 { { 0, 0xffff } },
5107                 .stack_depth = 40,
5108         },
5109         {
5110                 "ST_MEM_H: Store/Load half word: max positive",
5111                 .u.insns_int = {
5112                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
5113                         BPF_ST_MEM(BPF_H, R10, -40, 0x7fff),
5114                         BPF_LDX_MEM(BPF_H, R0, R10, -40),
5115                         BPF_EXIT_INSN(),
5116                 },
5117                 INTERNAL,
5118                 { },
5119                 { { 0, 0x7fff } },
5120                 .stack_depth = 40,
5121         },
5122         {
5123                 "STX_MEM_H: Store/Load half word: max negative",
5124                 .u.insns_int = {
5125                         BPF_LD_IMM64(R0, 0),
5126                         BPF_LD_IMM64(R1, 0xffffLL),
5127                         BPF_STX_MEM(BPF_H, R10, R1, -40),
5128                         BPF_LDX_MEM(BPF_H, R0, R10, -40),
5129                         BPF_EXIT_INSN(),
5130                 },
5131                 INTERNAL,
5132                 { },
5133                 { { 0, 0xffff } },
5134                 .stack_depth = 40,
5135         },
5136         {
5137                 "ST_MEM_W: Store/Load word: max negative",
5138                 .u.insns_int = {
5139                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
5140                         BPF_ST_MEM(BPF_W, R10, -40, 0xffffffff),
5141                         BPF_LDX_MEM(BPF_W, R0, R10, -40),
5142                         BPF_EXIT_INSN(),
5143                 },
5144                 INTERNAL,
5145                 { },
5146                 { { 0, 0xffffffff } },
5147                 .stack_depth = 40,
5148         },
5149         {
5150                 "ST_MEM_W: Store/Load word: max positive",
5151                 .u.insns_int = {
5152                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
5153                         BPF_ST_MEM(BPF_W, R10, -40, 0x7fffffff),
5154                         BPF_LDX_MEM(BPF_W, R0, R10, -40),
5155                         BPF_EXIT_INSN(),
5156                 },
5157                 INTERNAL,
5158                 { },
5159                 { { 0, 0x7fffffff } },
5160                 .stack_depth = 40,
5161         },
5162         {
5163                 "STX_MEM_W: Store/Load word: max negative",
5164                 .u.insns_int = {
5165                         BPF_LD_IMM64(R0, 0),
5166                         BPF_LD_IMM64(R1, 0xffffffffLL),
5167                         BPF_STX_MEM(BPF_W, R10, R1, -40),
5168                         BPF_LDX_MEM(BPF_W, R0, R10, -40),
5169                         BPF_EXIT_INSN(),
5170                 },
5171                 INTERNAL,
5172                 { },
5173                 { { 0, 0xffffffff } },
5174                 .stack_depth = 40,
5175         },
5176         {
5177                 "ST_MEM_DW: Store/Load double word: max negative",
5178                 .u.insns_int = {
5179                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
5180                         BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
5181                         BPF_LDX_MEM(BPF_DW, R0, R10, -40),
5182                         BPF_EXIT_INSN(),
5183                 },
5184                 INTERNAL,
5185                 { },
5186                 { { 0, 0xffffffff } },
5187                 .stack_depth = 40,
5188         },
5189         {
5190                 "ST_MEM_DW: Store/Load double word: max negative 2",
5191                 .u.insns_int = {
5192                         BPF_LD_IMM64(R2, 0xffff00000000ffffLL),
5193                         BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
5194                         BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
5195                         BPF_LDX_MEM(BPF_DW, R2, R10, -40),
5196                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5197                         BPF_MOV32_IMM(R0, 2),
5198                         BPF_EXIT_INSN(),
5199                         BPF_MOV32_IMM(R0, 1),
5200                         BPF_EXIT_INSN(),
5201                 },
5202                 INTERNAL,
5203                 { },
5204                 { { 0, 0x1 } },
5205                 .stack_depth = 40,
5206         },
5207         {
5208                 "ST_MEM_DW: Store/Load double word: max positive",
5209                 .u.insns_int = {
5210                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
5211                         BPF_ST_MEM(BPF_DW, R10, -40, 0x7fffffff),
5212                         BPF_LDX_MEM(BPF_DW, R0, R10, -40),
5213                         BPF_EXIT_INSN(),
5214                 },
5215                 INTERNAL,
5216                 { },
5217                 { { 0, 0x7fffffff } },
5218                 .stack_depth = 40,
5219         },
5220         {
5221                 "STX_MEM_DW: Store/Load double word: max negative",
5222                 .u.insns_int = {
5223                         BPF_LD_IMM64(R0, 0),
5224                         BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
5225                         BPF_STX_MEM(BPF_DW, R10, R1, -40),
5226                         BPF_LDX_MEM(BPF_DW, R0, R10, -40),
5227                         BPF_EXIT_INSN(),
5228                 },
5229                 INTERNAL,
5230                 { },
5231                 { { 0, 0xffffffff } },
5232                 .stack_depth = 40,
5233         },
5234         /* BPF_STX | BPF_ATOMIC | BPF_W/DW */
5235         {
5236                 "STX_XADD_W: Test: 0x12 + 0x10 = 0x22",
5237                 .u.insns_int = {
5238                         BPF_ALU32_IMM(BPF_MOV, R0, 0x12),
5239                         BPF_ST_MEM(BPF_W, R10, -40, 0x10),
5240                         BPF_ATOMIC_OP(BPF_W, BPF_ADD, R10, R0, -40),
5241                         BPF_LDX_MEM(BPF_W, R0, R10, -40),
5242                         BPF_EXIT_INSN(),
5243                 },
5244                 INTERNAL,
5245                 { },
5246                 { { 0, 0x22 } },
5247                 .stack_depth = 40,
5248         },
5249         {
5250                 "STX_XADD_W: Test side-effects, r10: 0x12 + 0x10 = 0x22",
5251                 .u.insns_int = {
5252                         BPF_ALU64_REG(BPF_MOV, R1, R10),
5253                         BPF_ALU32_IMM(BPF_MOV, R0, 0x12),
5254                         BPF_ST_MEM(BPF_W, R10, -40, 0x10),
5255                         BPF_ATOMIC_OP(BPF_W, BPF_ADD, R10, R0, -40),
5256                         BPF_ALU64_REG(BPF_MOV, R0, R10),
5257                         BPF_ALU64_REG(BPF_SUB, R0, R1),
5258                         BPF_EXIT_INSN(),
5259                 },
5260                 INTERNAL,
5261                 { },
5262                 { { 0, 0 } },
5263                 .stack_depth = 40,
5264         },
5265         {
5266                 "STX_XADD_W: Test side-effects, r0: 0x12 + 0x10 = 0x22",
5267                 .u.insns_int = {
5268                         BPF_ALU32_IMM(BPF_MOV, R0, 0x12),
5269                         BPF_ST_MEM(BPF_W, R10, -40, 0x10),
5270                         BPF_ATOMIC_OP(BPF_W, BPF_ADD, R10, R0, -40),
5271                         BPF_EXIT_INSN(),
5272                 },
5273                 INTERNAL,
5274                 { },
5275                 { { 0, 0x12 } },
5276                 .stack_depth = 40,
5277         },
5278         {
5279                 "STX_XADD_W: X + 1 + 1 + 1 + ...",
5280                 { },
5281                 INTERNAL,
5282                 { },
5283                 { { 0, 4134 } },
5284                 .fill_helper = bpf_fill_stxw,
5285         },
5286         {
5287                 "STX_XADD_DW: Test: 0x12 + 0x10 = 0x22",
5288                 .u.insns_int = {
5289                         BPF_ALU32_IMM(BPF_MOV, R0, 0x12),
5290                         BPF_ST_MEM(BPF_DW, R10, -40, 0x10),
5291                         BPF_ATOMIC_OP(BPF_DW, BPF_ADD, R10, R0, -40),
5292                         BPF_LDX_MEM(BPF_DW, R0, R10, -40),
5293                         BPF_EXIT_INSN(),
5294                 },
5295                 INTERNAL,
5296                 { },
5297                 { { 0, 0x22 } },
5298                 .stack_depth = 40,
5299         },
5300         {
5301                 "STX_XADD_DW: Test side-effects, r10: 0x12 + 0x10 = 0x22",
5302                 .u.insns_int = {
5303                         BPF_ALU64_REG(BPF_MOV, R1, R10),
5304                         BPF_ALU32_IMM(BPF_MOV, R0, 0x12),
5305                         BPF_ST_MEM(BPF_DW, R10, -40, 0x10),
5306                         BPF_ATOMIC_OP(BPF_DW, BPF_ADD, R10, R0, -40),
5307                         BPF_ALU64_REG(BPF_MOV, R0, R10),
5308                         BPF_ALU64_REG(BPF_SUB, R0, R1),
5309                         BPF_EXIT_INSN(),
5310                 },
5311                 INTERNAL,
5312                 { },
5313                 { { 0, 0 } },
5314                 .stack_depth = 40,
5315         },
5316         {
5317                 "STX_XADD_DW: Test side-effects, r0: 0x12 + 0x10 = 0x22",
5318                 .u.insns_int = {
5319                         BPF_ALU32_IMM(BPF_MOV, R0, 0x12),
5320                         BPF_ST_MEM(BPF_DW, R10, -40, 0x10),
5321                         BPF_ATOMIC_OP(BPF_DW, BPF_ADD, R10, R0, -40),
5322                         BPF_EXIT_INSN(),
5323                 },
5324                 INTERNAL,
5325                 { },
5326                 { { 0, 0x12 } },
5327                 .stack_depth = 40,
5328         },
5329         {
5330                 "STX_XADD_DW: X + 1 + 1 + 1 + ...",
5331                 { },
5332                 INTERNAL,
5333                 { },
5334                 { { 0, 4134 } },
5335                 .fill_helper = bpf_fill_stxdw,
5336         },
5337         /* BPF_JMP32 | BPF_JEQ | BPF_K */
5338         {
5339                 "JMP32_JEQ_K: Small immediate",
5340                 .u.insns_int = {
5341                         BPF_ALU32_IMM(BPF_MOV, R0, 123),
5342                         BPF_JMP32_IMM(BPF_JEQ, R0, 321, 1),
5343                         BPF_JMP32_IMM(BPF_JEQ, R0, 123, 1),
5344                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5345                         BPF_EXIT_INSN(),
5346                 },
5347                 INTERNAL,
5348                 { },
5349                 { { 0, 123 } }
5350         },
5351         {
5352                 "JMP32_JEQ_K: Large immediate",
5353                 .u.insns_int = {
5354                         BPF_ALU32_IMM(BPF_MOV, R0, 12345678),
5355                         BPF_JMP32_IMM(BPF_JEQ, R0, 12345678 & 0xffff, 1),
5356                         BPF_JMP32_IMM(BPF_JEQ, R0, 12345678, 1),
5357                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5358                         BPF_EXIT_INSN(),
5359                 },
5360                 INTERNAL,
5361                 { },
5362                 { { 0, 12345678 } }
5363         },
5364         {
5365                 "JMP32_JEQ_K: negative immediate",
5366                 .u.insns_int = {
5367                         BPF_ALU32_IMM(BPF_MOV, R0, -123),
5368                         BPF_JMP32_IMM(BPF_JEQ, R0,  123, 1),
5369                         BPF_JMP32_IMM(BPF_JEQ, R0, -123, 1),
5370                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5371                         BPF_EXIT_INSN(),
5372                 },
5373                 INTERNAL,
5374                 { },
5375                 { { 0, -123 } }
5376         },
5377         /* BPF_JMP32 | BPF_JEQ | BPF_X */
5378         {
5379                 "JMP32_JEQ_X",
5380                 .u.insns_int = {
5381                         BPF_ALU32_IMM(BPF_MOV, R0, 1234),
5382                         BPF_ALU32_IMM(BPF_MOV, R1, 4321),
5383                         BPF_JMP32_REG(BPF_JEQ, R0, R1, 2),
5384                         BPF_ALU32_IMM(BPF_MOV, R1, 1234),
5385                         BPF_JMP32_REG(BPF_JEQ, R0, R1, 1),
5386                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5387                         BPF_EXIT_INSN(),
5388                 },
5389                 INTERNAL,
5390                 { },
5391                 { { 0, 1234 } }
5392         },
5393         /* BPF_JMP32 | BPF_JNE | BPF_K */
5394         {
5395                 "JMP32_JNE_K: Small immediate",
5396                 .u.insns_int = {
5397                         BPF_ALU32_IMM(BPF_MOV, R0, 123),
5398                         BPF_JMP32_IMM(BPF_JNE, R0, 123, 1),
5399                         BPF_JMP32_IMM(BPF_JNE, R0, 321, 1),
5400                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5401                         BPF_EXIT_INSN(),
5402                 },
5403                 INTERNAL,
5404                 { },
5405                 { { 0, 123 } }
5406         },
5407         {
5408                 "JMP32_JNE_K: Large immediate",
5409                 .u.insns_int = {
5410                         BPF_ALU32_IMM(BPF_MOV, R0, 12345678),
5411                         BPF_JMP32_IMM(BPF_JNE, R0, 12345678, 1),
5412                         BPF_JMP32_IMM(BPF_JNE, R0, 12345678 & 0xffff, 1),
5413                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5414                         BPF_EXIT_INSN(),
5415                 },
5416                 INTERNAL,
5417                 { },
5418                 { { 0, 12345678 } }
5419         },
5420         {
5421                 "JMP32_JNE_K: negative immediate",
5422                 .u.insns_int = {
5423                         BPF_ALU32_IMM(BPF_MOV, R0, -123),
5424                         BPF_JMP32_IMM(BPF_JNE, R0, -123, 1),
5425                         BPF_JMP32_IMM(BPF_JNE, R0,  123, 1),
5426                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5427                         BPF_EXIT_INSN(),
5428                 },
5429                 INTERNAL,
5430                 { },
5431                 { { 0, -123 } }
5432         },
5433         /* BPF_JMP32 | BPF_JNE | BPF_X */
5434         {
5435                 "JMP32_JNE_X",
5436                 .u.insns_int = {
5437                         BPF_ALU32_IMM(BPF_MOV, R0, 1234),
5438                         BPF_ALU32_IMM(BPF_MOV, R1, 1234),
5439                         BPF_JMP32_REG(BPF_JNE, R0, R1, 2),
5440                         BPF_ALU32_IMM(BPF_MOV, R1, 4321),
5441                         BPF_JMP32_REG(BPF_JNE, R0, R1, 1),
5442                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5443                         BPF_EXIT_INSN(),
5444                 },
5445                 INTERNAL,
5446                 { },
5447                 { { 0, 1234 } }
5448         },
5449         /* BPF_JMP32 | BPF_JSET | BPF_K */
5450         {
5451                 "JMP32_JSET_K: Small immediate",
5452                 .u.insns_int = {
5453                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
5454                         BPF_JMP32_IMM(BPF_JSET, R0, 2, 1),
5455                         BPF_JMP32_IMM(BPF_JSET, R0, 3, 1),
5456                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5457                         BPF_EXIT_INSN(),
5458                 },
5459                 INTERNAL,
5460                 { },
5461                 { { 0, 1 } }
5462         },
5463         {
5464                 "JMP32_JSET_K: Large immediate",
5465                 .u.insns_int = {
5466                         BPF_ALU32_IMM(BPF_MOV, R0, 0x40000000),
5467                         BPF_JMP32_IMM(BPF_JSET, R0, 0x3fffffff, 1),
5468                         BPF_JMP32_IMM(BPF_JSET, R0, 0x60000000, 1),
5469                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5470                         BPF_EXIT_INSN(),
5471                 },
5472                 INTERNAL,
5473                 { },
5474                 { { 0, 0x40000000 } }
5475         },
5476         {
5477                 "JMP32_JSET_K: negative immediate",
5478                 .u.insns_int = {
5479                         BPF_ALU32_IMM(BPF_MOV, R0, -123),
5480                         BPF_JMP32_IMM(BPF_JSET, R0, -1, 1),
5481                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5482                         BPF_EXIT_INSN(),
5483                 },
5484                 INTERNAL,
5485                 { },
5486                 { { 0, -123 } }
5487         },
5488         /* BPF_JMP32 | BPF_JSET | BPF_X */
5489         {
5490                 "JMP32_JSET_X",
5491                 .u.insns_int = {
5492                         BPF_ALU32_IMM(BPF_MOV, R0, 8),
5493                         BPF_ALU32_IMM(BPF_MOV, R1, 7),
5494                         BPF_JMP32_REG(BPF_JSET, R0, R1, 2),
5495                         BPF_ALU32_IMM(BPF_MOV, R1, 8 | 2),
5496                         BPF_JMP32_REG(BPF_JNE, R0, R1, 1),
5497                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5498                         BPF_EXIT_INSN(),
5499                 },
5500                 INTERNAL,
5501                 { },
5502                 { { 0, 8 } }
5503         },
5504         /* BPF_JMP32 | BPF_JGT | BPF_K */
5505         {
5506                 "JMP32_JGT_K: Small immediate",
5507                 .u.insns_int = {
5508                         BPF_ALU32_IMM(BPF_MOV, R0, 123),
5509                         BPF_JMP32_IMM(BPF_JGT, R0, 123, 1),
5510                         BPF_JMP32_IMM(BPF_JGT, R0, 122, 1),
5511                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5512                         BPF_EXIT_INSN(),
5513                 },
5514                 INTERNAL,
5515                 { },
5516                 { { 0, 123 } }
5517         },
5518         {
5519                 "JMP32_JGT_K: Large immediate",
5520                 .u.insns_int = {
5521                         BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
5522                         BPF_JMP32_IMM(BPF_JGT, R0, 0xffffffff, 1),
5523                         BPF_JMP32_IMM(BPF_JGT, R0, 0xfffffffd, 1),
5524                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5525                         BPF_EXIT_INSN(),
5526                 },
5527                 INTERNAL,
5528                 { },
5529                 { { 0, 0xfffffffe } }
5530         },
5531         /* BPF_JMP32 | BPF_JGT | BPF_X */
5532         {
5533                 "JMP32_JGT_X",
5534                 .u.insns_int = {
5535                         BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
5536                         BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
5537                         BPF_JMP32_REG(BPF_JGT, R0, R1, 2),
5538                         BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
5539                         BPF_JMP32_REG(BPF_JGT, R0, R1, 1),
5540                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5541                         BPF_EXIT_INSN(),
5542                 },
5543                 INTERNAL,
5544                 { },
5545                 { { 0, 0xfffffffe } }
5546         },
5547         /* BPF_JMP32 | BPF_JGE | BPF_K */
5548         {
5549                 "JMP32_JGE_K: Small immediate",
5550                 .u.insns_int = {
5551                         BPF_ALU32_IMM(BPF_MOV, R0, 123),
5552                         BPF_JMP32_IMM(BPF_JGE, R0, 124, 1),
5553                         BPF_JMP32_IMM(BPF_JGE, R0, 123, 1),
5554                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5555                         BPF_EXIT_INSN(),
5556                 },
5557                 INTERNAL,
5558                 { },
5559                 { { 0, 123 } }
5560         },
5561         {
5562                 "JMP32_JGE_K: Large immediate",
5563                 .u.insns_int = {
5564                         BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
5565                         BPF_JMP32_IMM(BPF_JGE, R0, 0xffffffff, 1),
5566                         BPF_JMP32_IMM(BPF_JGE, R0, 0xfffffffe, 1),
5567                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5568                         BPF_EXIT_INSN(),
5569                 },
5570                 INTERNAL,
5571                 { },
5572                 { { 0, 0xfffffffe } }
5573         },
5574         /* BPF_JMP32 | BPF_JGE | BPF_X */
5575         {
5576                 "JMP32_JGE_X",
5577                 .u.insns_int = {
5578                         BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
5579                         BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
5580                         BPF_JMP32_REG(BPF_JGE, R0, R1, 2),
5581                         BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffe),
5582                         BPF_JMP32_REG(BPF_JGE, R0, R1, 1),
5583                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5584                         BPF_EXIT_INSN(),
5585                 },
5586                 INTERNAL,
5587                 { },
5588                 { { 0, 0xfffffffe } }
5589         },
5590         /* BPF_JMP32 | BPF_JLT | BPF_K */
5591         {
5592                 "JMP32_JLT_K: Small immediate",
5593                 .u.insns_int = {
5594                         BPF_ALU32_IMM(BPF_MOV, R0, 123),
5595                         BPF_JMP32_IMM(BPF_JLT, R0, 123, 1),
5596                         BPF_JMP32_IMM(BPF_JLT, R0, 124, 1),
5597                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5598                         BPF_EXIT_INSN(),
5599                 },
5600                 INTERNAL,
5601                 { },
5602                 { { 0, 123 } }
5603         },
5604         {
5605                 "JMP32_JLT_K: Large immediate",
5606                 .u.insns_int = {
5607                         BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
5608                         BPF_JMP32_IMM(BPF_JLT, R0, 0xfffffffd, 1),
5609                         BPF_JMP32_IMM(BPF_JLT, R0, 0xffffffff, 1),
5610                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5611                         BPF_EXIT_INSN(),
5612                 },
5613                 INTERNAL,
5614                 { },
5615                 { { 0, 0xfffffffe } }
5616         },
5617         /* BPF_JMP32 | BPF_JLT | BPF_X */
5618         {
5619                 "JMP32_JLT_X",
5620                 .u.insns_int = {
5621                         BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
5622                         BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
5623                         BPF_JMP32_REG(BPF_JLT, R0, R1, 2),
5624                         BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
5625                         BPF_JMP32_REG(BPF_JLT, R0, R1, 1),
5626                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5627                         BPF_EXIT_INSN(),
5628                 },
5629                 INTERNAL,
5630                 { },
5631                 { { 0, 0xfffffffe } }
5632         },
5633         /* BPF_JMP32 | BPF_JLE | BPF_K */
5634         {
5635                 "JMP32_JLE_K: Small immediate",
5636                 .u.insns_int = {
5637                         BPF_ALU32_IMM(BPF_MOV, R0, 123),
5638                         BPF_JMP32_IMM(BPF_JLE, R0, 122, 1),
5639                         BPF_JMP32_IMM(BPF_JLE, R0, 123, 1),
5640                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5641                         BPF_EXIT_INSN(),
5642                 },
5643                 INTERNAL,
5644                 { },
5645                 { { 0, 123 } }
5646         },
5647         {
5648                 "JMP32_JLE_K: Large immediate",
5649                 .u.insns_int = {
5650                         BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
5651                         BPF_JMP32_IMM(BPF_JLE, R0, 0xfffffffd, 1),
5652                         BPF_JMP32_IMM(BPF_JLE, R0, 0xfffffffe, 1),
5653                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5654                         BPF_EXIT_INSN(),
5655                 },
5656                 INTERNAL,
5657                 { },
5658                 { { 0, 0xfffffffe } }
5659         },
5660         /* BPF_JMP32 | BPF_JLE | BPF_X */
5661         {
5662                 "JMP32_JLE_X",
5663                 .u.insns_int = {
5664                         BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
5665                         BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
5666                         BPF_JMP32_REG(BPF_JLE, R0, R1, 2),
5667                         BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffe),
5668                         BPF_JMP32_REG(BPF_JLE, R0, R1, 1),
5669                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5670                         BPF_EXIT_INSN(),
5671                 },
5672                 INTERNAL,
5673                 { },
5674                 { { 0, 0xfffffffe } }
5675         },
5676         /* BPF_JMP32 | BPF_JSGT | BPF_K */
5677         {
5678                 "JMP32_JSGT_K: Small immediate",
5679                 .u.insns_int = {
5680                         BPF_ALU32_IMM(BPF_MOV, R0, -123),
5681                         BPF_JMP32_IMM(BPF_JSGT, R0, -123, 1),
5682                         BPF_JMP32_IMM(BPF_JSGT, R0, -124, 1),
5683                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5684                         BPF_EXIT_INSN(),
5685                 },
5686                 INTERNAL,
5687                 { },
5688                 { { 0, -123 } }
5689         },
5690         {
5691                 "JMP32_JSGT_K: Large immediate",
5692                 .u.insns_int = {
5693                         BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
5694                         BPF_JMP32_IMM(BPF_JSGT, R0, -12345678, 1),
5695                         BPF_JMP32_IMM(BPF_JSGT, R0, -12345679, 1),
5696                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5697                         BPF_EXIT_INSN(),
5698                 },
5699                 INTERNAL,
5700                 { },
5701                 { { 0, -12345678 } }
5702         },
5703         /* BPF_JMP32 | BPF_JSGT | BPF_X */
5704         {
5705                 "JMP32_JSGT_X",
5706                 .u.insns_int = {
5707                         BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
5708                         BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
5709                         BPF_JMP32_REG(BPF_JSGT, R0, R1, 2),
5710                         BPF_ALU32_IMM(BPF_MOV, R1, -12345679),
5711                         BPF_JMP32_REG(BPF_JSGT, R0, R1, 1),
5712                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5713                         BPF_EXIT_INSN(),
5714                 },
5715                 INTERNAL,
5716                 { },
5717                 { { 0, -12345678 } }
5718         },
5719         /* BPF_JMP32 | BPF_JSGE | BPF_K */
5720         {
5721                 "JMP32_JSGE_K: Small immediate",
5722                 .u.insns_int = {
5723                         BPF_ALU32_IMM(BPF_MOV, R0, -123),
5724                         BPF_JMP32_IMM(BPF_JSGE, R0, -122, 1),
5725                         BPF_JMP32_IMM(BPF_JSGE, R0, -123, 1),
5726                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5727                         BPF_EXIT_INSN(),
5728                 },
5729                 INTERNAL,
5730                 { },
5731                 { { 0, -123 } }
5732         },
5733         {
5734                 "JMP32_JSGE_K: Large immediate",
5735                 .u.insns_int = {
5736                         BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
5737                         BPF_JMP32_IMM(BPF_JSGE, R0, -12345677, 1),
5738                         BPF_JMP32_IMM(BPF_JSGE, R0, -12345678, 1),
5739                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5740                         BPF_EXIT_INSN(),
5741                 },
5742                 INTERNAL,
5743                 { },
5744                 { { 0, -12345678 } }
5745         },
5746         /* BPF_JMP32 | BPF_JSGE | BPF_X */
5747         {
5748                 "JMP32_JSGE_X",
5749                 .u.insns_int = {
5750                         BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
5751                         BPF_ALU32_IMM(BPF_MOV, R1, -12345677),
5752                         BPF_JMP32_REG(BPF_JSGE, R0, R1, 2),
5753                         BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
5754                         BPF_JMP32_REG(BPF_JSGE, R0, R1, 1),
5755                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5756                         BPF_EXIT_INSN(),
5757                 },
5758                 INTERNAL,
5759                 { },
5760                 { { 0, -12345678 } }
5761         },
5762         /* BPF_JMP32 | BPF_JSLT | BPF_K */
5763         {
5764                 "JMP32_JSLT_K: Small immediate",
5765                 .u.insns_int = {
5766                         BPF_ALU32_IMM(BPF_MOV, R0, -123),
5767                         BPF_JMP32_IMM(BPF_JSLT, R0, -123, 1),
5768                         BPF_JMP32_IMM(BPF_JSLT, R0, -122, 1),
5769                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5770                         BPF_EXIT_INSN(),
5771                 },
5772                 INTERNAL,
5773                 { },
5774                 { { 0, -123 } }
5775         },
5776         {
5777                 "JMP32_JSLT_K: Large immediate",
5778                 .u.insns_int = {
5779                         BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
5780                         BPF_JMP32_IMM(BPF_JSLT, R0, -12345678, 1),
5781                         BPF_JMP32_IMM(BPF_JSLT, R0, -12345677, 1),
5782                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5783                         BPF_EXIT_INSN(),
5784                 },
5785                 INTERNAL,
5786                 { },
5787                 { { 0, -12345678 } }
5788         },
5789         /* BPF_JMP32 | BPF_JSLT | BPF_X */
5790         {
5791                 "JMP32_JSLT_X",
5792                 .u.insns_int = {
5793                         BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
5794                         BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
5795                         BPF_JMP32_REG(BPF_JSLT, R0, R1, 2),
5796                         BPF_ALU32_IMM(BPF_MOV, R1, -12345677),
5797                         BPF_JMP32_REG(BPF_JSLT, R0, R1, 1),
5798                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5799                         BPF_EXIT_INSN(),
5800                 },
5801                 INTERNAL,
5802                 { },
5803                 { { 0, -12345678 } }
5804         },
5805         /* BPF_JMP32 | BPF_JSLE | BPF_K */
5806         {
5807                 "JMP32_JSLE_K: Small immediate",
5808                 .u.insns_int = {
5809                         BPF_ALU32_IMM(BPF_MOV, R0, -123),
5810                         BPF_JMP32_IMM(BPF_JSLE, R0, -124, 1),
5811                         BPF_JMP32_IMM(BPF_JSLE, R0, -123, 1),
5812                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5813                         BPF_EXIT_INSN(),
5814                 },
5815                 INTERNAL,
5816                 { },
5817                 { { 0, -123 } }
5818         },
5819         {
5820                 "JMP32_JSLE_K: Large immediate",
5821                 .u.insns_int = {
5822                         BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
5823                         BPF_JMP32_IMM(BPF_JSLE, R0, -12345679, 1),
5824                         BPF_JMP32_IMM(BPF_JSLE, R0, -12345678, 1),
5825                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5826                         BPF_EXIT_INSN(),
5827                 },
5828                 INTERNAL,
5829                 { },
5830                 { { 0, -12345678 } }
5831         },
5832         /* BPF_JMP32 | BPF_JSLE | BPF_K */
5833         {
5834                 "JMP32_JSLE_X",
5835                 .u.insns_int = {
5836                         BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
5837                         BPF_ALU32_IMM(BPF_MOV, R1, -12345679),
5838                         BPF_JMP32_REG(BPF_JSLE, R0, R1, 2),
5839                         BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
5840                         BPF_JMP32_REG(BPF_JSLE, R0, R1, 1),
5841                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5842                         BPF_EXIT_INSN(),
5843                 },
5844                 INTERNAL,
5845                 { },
5846                 { { 0, -12345678 } }
5847         },
5848         /* BPF_JMP | BPF_EXIT */
5849         {
5850                 "JMP_EXIT",
5851                 .u.insns_int = {
5852                         BPF_ALU32_IMM(BPF_MOV, R0, 0x4711),
5853                         BPF_EXIT_INSN(),
5854                         BPF_ALU32_IMM(BPF_MOV, R0, 0x4712),
5855                 },
5856                 INTERNAL,
5857                 { },
5858                 { { 0, 0x4711 } },
5859         },
5860         /* BPF_JMP | BPF_JA */
5861         {
5862                 "JMP_JA: Unconditional jump: if (true) return 1",
5863                 .u.insns_int = {
5864                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5865                         BPF_JMP_IMM(BPF_JA, 0, 0, 1),
5866                         BPF_EXIT_INSN(),
5867                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
5868                         BPF_EXIT_INSN(),
5869                 },
5870                 INTERNAL,
5871                 { },
5872                 { { 0, 1 } },
5873         },
5874         /* BPF_JMP | BPF_JSLT | BPF_K */
5875         {
5876                 "JMP_JSLT_K: Signed jump: if (-2 < -1) return 1",
5877                 .u.insns_int = {
5878                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5879                         BPF_LD_IMM64(R1, 0xfffffffffffffffeLL),
5880                         BPF_JMP_IMM(BPF_JSLT, R1, -1, 1),
5881                         BPF_EXIT_INSN(),
5882                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
5883                         BPF_EXIT_INSN(),
5884                 },
5885                 INTERNAL,
5886                 { },
5887                 { { 0, 1 } },
5888         },
5889         {
5890                 "JMP_JSLT_K: Signed jump: if (-1 < -1) return 0",
5891                 .u.insns_int = {
5892                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
5893                         BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
5894                         BPF_JMP_IMM(BPF_JSLT, R1, -1, 1),
5895                         BPF_EXIT_INSN(),
5896                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5897                         BPF_EXIT_INSN(),
5898                 },
5899                 INTERNAL,
5900                 { },
5901                 { { 0, 1 } },
5902         },
5903         /* BPF_JMP | BPF_JSGT | BPF_K */
5904         {
5905                 "JMP_JSGT_K: Signed jump: if (-1 > -2) return 1",
5906                 .u.insns_int = {
5907                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5908                         BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
5909                         BPF_JMP_IMM(BPF_JSGT, R1, -2, 1),
5910                         BPF_EXIT_INSN(),
5911                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
5912                         BPF_EXIT_INSN(),
5913                 },
5914                 INTERNAL,
5915                 { },
5916                 { { 0, 1 } },
5917         },
5918         {
5919                 "JMP_JSGT_K: Signed jump: if (-1 > -1) return 0",
5920                 .u.insns_int = {
5921                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
5922                         BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
5923                         BPF_JMP_IMM(BPF_JSGT, R1, -1, 1),
5924                         BPF_EXIT_INSN(),
5925                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5926                         BPF_EXIT_INSN(),
5927                 },
5928                 INTERNAL,
5929                 { },
5930                 { { 0, 1 } },
5931         },
5932         /* BPF_JMP | BPF_JSLE | BPF_K */
5933         {
5934                 "JMP_JSLE_K: Signed jump: if (-2 <= -1) return 1",
5935                 .u.insns_int = {
5936                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5937                         BPF_LD_IMM64(R1, 0xfffffffffffffffeLL),
5938                         BPF_JMP_IMM(BPF_JSLE, R1, -1, 1),
5939                         BPF_EXIT_INSN(),
5940                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
5941                         BPF_EXIT_INSN(),
5942                 },
5943                 INTERNAL,
5944                 { },
5945                 { { 0, 1 } },
5946         },
5947         {
5948                 "JMP_JSLE_K: Signed jump: if (-1 <= -1) return 1",
5949                 .u.insns_int = {
5950                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5951                         BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
5952                         BPF_JMP_IMM(BPF_JSLE, R1, -1, 1),
5953                         BPF_EXIT_INSN(),
5954                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
5955                         BPF_EXIT_INSN(),
5956                 },
5957                 INTERNAL,
5958                 { },
5959                 { { 0, 1 } },
5960         },
5961         {
5962                 "JMP_JSLE_K: Signed jump: value walk 1",
5963                 .u.insns_int = {
5964                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5965                         BPF_LD_IMM64(R1, 3),
5966                         BPF_JMP_IMM(BPF_JSLE, R1, 0, 6),
5967                         BPF_ALU64_IMM(BPF_SUB, R1, 1),
5968                         BPF_JMP_IMM(BPF_JSLE, R1, 0, 4),
5969                         BPF_ALU64_IMM(BPF_SUB, R1, 1),
5970                         BPF_JMP_IMM(BPF_JSLE, R1, 0, 2),
5971                         BPF_ALU64_IMM(BPF_SUB, R1, 1),
5972                         BPF_JMP_IMM(BPF_JSLE, R1, 0, 1),
5973                         BPF_EXIT_INSN(),                /* bad exit */
5974                         BPF_ALU32_IMM(BPF_MOV, R0, 1),  /* good exit */
5975                         BPF_EXIT_INSN(),
5976                 },
5977                 INTERNAL,
5978                 { },
5979                 { { 0, 1 } },
5980         },
5981         {
5982                 "JMP_JSLE_K: Signed jump: value walk 2",
5983                 .u.insns_int = {
5984                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5985                         BPF_LD_IMM64(R1, 3),
5986                         BPF_JMP_IMM(BPF_JSLE, R1, 0, 4),
5987                         BPF_ALU64_IMM(BPF_SUB, R1, 2),
5988                         BPF_JMP_IMM(BPF_JSLE, R1, 0, 2),
5989                         BPF_ALU64_IMM(BPF_SUB, R1, 2),
5990                         BPF_JMP_IMM(BPF_JSLE, R1, 0, 1),
5991                         BPF_EXIT_INSN(),                /* bad exit */
5992                         BPF_ALU32_IMM(BPF_MOV, R0, 1),  /* good exit */
5993                         BPF_EXIT_INSN(),
5994                 },
5995                 INTERNAL,
5996                 { },
5997                 { { 0, 1 } },
5998         },
5999         /* BPF_JMP | BPF_JSGE | BPF_K */
6000         {
6001                 "JMP_JSGE_K: Signed jump: if (-1 >= -2) return 1",
6002                 .u.insns_int = {
6003                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6004                         BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
6005                         BPF_JMP_IMM(BPF_JSGE, R1, -2, 1),
6006                         BPF_EXIT_INSN(),
6007                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6008                         BPF_EXIT_INSN(),
6009                 },
6010                 INTERNAL,
6011                 { },
6012                 { { 0, 1 } },
6013         },
6014         {
6015                 "JMP_JSGE_K: Signed jump: if (-1 >= -1) return 1",
6016                 .u.insns_int = {
6017                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6018                         BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
6019                         BPF_JMP_IMM(BPF_JSGE, R1, -1, 1),
6020                         BPF_EXIT_INSN(),
6021                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6022                         BPF_EXIT_INSN(),
6023                 },
6024                 INTERNAL,
6025                 { },
6026                 { { 0, 1 } },
6027         },
6028         {
6029                 "JMP_JSGE_K: Signed jump: value walk 1",
6030                 .u.insns_int = {
6031                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6032                         BPF_LD_IMM64(R1, -3),
6033                         BPF_JMP_IMM(BPF_JSGE, R1, 0, 6),
6034                         BPF_ALU64_IMM(BPF_ADD, R1, 1),
6035                         BPF_JMP_IMM(BPF_JSGE, R1, 0, 4),
6036                         BPF_ALU64_IMM(BPF_ADD, R1, 1),
6037                         BPF_JMP_IMM(BPF_JSGE, R1, 0, 2),
6038                         BPF_ALU64_IMM(BPF_ADD, R1, 1),
6039                         BPF_JMP_IMM(BPF_JSGE, R1, 0, 1),
6040                         BPF_EXIT_INSN(),                /* bad exit */
6041                         BPF_ALU32_IMM(BPF_MOV, R0, 1),  /* good exit */
6042                         BPF_EXIT_INSN(),
6043                 },
6044                 INTERNAL,
6045                 { },
6046                 { { 0, 1 } },
6047         },
6048         {
6049                 "JMP_JSGE_K: Signed jump: value walk 2",
6050                 .u.insns_int = {
6051                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6052                         BPF_LD_IMM64(R1, -3),
6053                         BPF_JMP_IMM(BPF_JSGE, R1, 0, 4),
6054                         BPF_ALU64_IMM(BPF_ADD, R1, 2),
6055                         BPF_JMP_IMM(BPF_JSGE, R1, 0, 2),
6056                         BPF_ALU64_IMM(BPF_ADD, R1, 2),
6057                         BPF_JMP_IMM(BPF_JSGE, R1, 0, 1),
6058                         BPF_EXIT_INSN(),                /* bad exit */
6059                         BPF_ALU32_IMM(BPF_MOV, R0, 1),  /* good exit */
6060                         BPF_EXIT_INSN(),
6061                 },
6062                 INTERNAL,
6063                 { },
6064                 { { 0, 1 } },
6065         },
6066         /* BPF_JMP | BPF_JGT | BPF_K */
6067         {
6068                 "JMP_JGT_K: if (3 > 2) return 1",
6069                 .u.insns_int = {
6070                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6071                         BPF_LD_IMM64(R1, 3),
6072                         BPF_JMP_IMM(BPF_JGT, R1, 2, 1),
6073                         BPF_EXIT_INSN(),
6074                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6075                         BPF_EXIT_INSN(),
6076                 },
6077                 INTERNAL,
6078                 { },
6079                 { { 0, 1 } },
6080         },
6081         {
6082                 "JMP_JGT_K: Unsigned jump: if (-1 > 1) return 1",
6083                 .u.insns_int = {
6084                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6085                         BPF_LD_IMM64(R1, -1),
6086                         BPF_JMP_IMM(BPF_JGT, R1, 1, 1),
6087                         BPF_EXIT_INSN(),
6088                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6089                         BPF_EXIT_INSN(),
6090                 },
6091                 INTERNAL,
6092                 { },
6093                 { { 0, 1 } },
6094         },
6095         /* BPF_JMP | BPF_JLT | BPF_K */
6096         {
6097                 "JMP_JLT_K: if (2 < 3) return 1",
6098                 .u.insns_int = {
6099                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6100                         BPF_LD_IMM64(R1, 2),
6101                         BPF_JMP_IMM(BPF_JLT, R1, 3, 1),
6102                         BPF_EXIT_INSN(),
6103                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6104                         BPF_EXIT_INSN(),
6105                 },
6106                 INTERNAL,
6107                 { },
6108                 { { 0, 1 } },
6109         },
6110         {
6111                 "JMP_JGT_K: Unsigned jump: if (1 < -1) return 1",
6112                 .u.insns_int = {
6113                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6114                         BPF_LD_IMM64(R1, 1),
6115                         BPF_JMP_IMM(BPF_JLT, R1, -1, 1),
6116                         BPF_EXIT_INSN(),
6117                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6118                         BPF_EXIT_INSN(),
6119                 },
6120                 INTERNAL,
6121                 { },
6122                 { { 0, 1 } },
6123         },
6124         /* BPF_JMP | BPF_JGE | BPF_K */
6125         {
6126                 "JMP_JGE_K: if (3 >= 2) return 1",
6127                 .u.insns_int = {
6128                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6129                         BPF_LD_IMM64(R1, 3),
6130                         BPF_JMP_IMM(BPF_JGE, R1, 2, 1),
6131                         BPF_EXIT_INSN(),
6132                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6133                         BPF_EXIT_INSN(),
6134                 },
6135                 INTERNAL,
6136                 { },
6137                 { { 0, 1 } },
6138         },
6139         /* BPF_JMP | BPF_JLE | BPF_K */
6140         {
6141                 "JMP_JLE_K: if (2 <= 3) return 1",
6142                 .u.insns_int = {
6143                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6144                         BPF_LD_IMM64(R1, 2),
6145                         BPF_JMP_IMM(BPF_JLE, R1, 3, 1),
6146                         BPF_EXIT_INSN(),
6147                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6148                         BPF_EXIT_INSN(),
6149                 },
6150                 INTERNAL,
6151                 { },
6152                 { { 0, 1 } },
6153         },
6154         /* BPF_JMP | BPF_JGT | BPF_K jump backwards */
6155         {
6156                 "JMP_JGT_K: if (3 > 2) return 1 (jump backwards)",
6157                 .u.insns_int = {
6158                         BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
6159                         BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */
6160                         BPF_EXIT_INSN(),
6161                         BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
6162                         BPF_LD_IMM64(R1, 3), /* note: this takes 2 insns */
6163                         BPF_JMP_IMM(BPF_JGT, R1, 2, -6), /* goto out */
6164                         BPF_EXIT_INSN(),
6165                 },
6166                 INTERNAL,
6167                 { },
6168                 { { 0, 1 } },
6169         },
6170         {
6171                 "JMP_JGE_K: if (3 >= 3) return 1",
6172                 .u.insns_int = {
6173                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6174                         BPF_LD_IMM64(R1, 3),
6175                         BPF_JMP_IMM(BPF_JGE, R1, 3, 1),
6176                         BPF_EXIT_INSN(),
6177                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6178                         BPF_EXIT_INSN(),
6179                 },
6180                 INTERNAL,
6181                 { },
6182                 { { 0, 1 } },
6183         },
6184         /* BPF_JMP | BPF_JLT | BPF_K jump backwards */
6185         {
6186                 "JMP_JGT_K: if (2 < 3) return 1 (jump backwards)",
6187                 .u.insns_int = {
6188                         BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
6189                         BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */
6190                         BPF_EXIT_INSN(),
6191                         BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
6192                         BPF_LD_IMM64(R1, 2), /* note: this takes 2 insns */
6193                         BPF_JMP_IMM(BPF_JLT, R1, 3, -6), /* goto out */
6194                         BPF_EXIT_INSN(),
6195                 },
6196                 INTERNAL,
6197                 { },
6198                 { { 0, 1 } },
6199         },
6200         {
6201                 "JMP_JLE_K: if (3 <= 3) return 1",
6202                 .u.insns_int = {
6203                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6204                         BPF_LD_IMM64(R1, 3),
6205                         BPF_JMP_IMM(BPF_JLE, R1, 3, 1),
6206                         BPF_EXIT_INSN(),
6207                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6208                         BPF_EXIT_INSN(),
6209                 },
6210                 INTERNAL,
6211                 { },
6212                 { { 0, 1 } },
6213         },
6214         /* BPF_JMP | BPF_JNE | BPF_K */
6215         {
6216                 "JMP_JNE_K: if (3 != 2) return 1",
6217                 .u.insns_int = {
6218                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6219                         BPF_LD_IMM64(R1, 3),
6220                         BPF_JMP_IMM(BPF_JNE, R1, 2, 1),
6221                         BPF_EXIT_INSN(),
6222                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6223                         BPF_EXIT_INSN(),
6224                 },
6225                 INTERNAL,
6226                 { },
6227                 { { 0, 1 } },
6228         },
6229         /* BPF_JMP | BPF_JEQ | BPF_K */
6230         {
6231                 "JMP_JEQ_K: if (3 == 3) return 1",
6232                 .u.insns_int = {
6233                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6234                         BPF_LD_IMM64(R1, 3),
6235                         BPF_JMP_IMM(BPF_JEQ, R1, 3, 1),
6236                         BPF_EXIT_INSN(),
6237                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6238                         BPF_EXIT_INSN(),
6239                 },
6240                 INTERNAL,
6241                 { },
6242                 { { 0, 1 } },
6243         },
6244         /* BPF_JMP | BPF_JSET | BPF_K */
6245         {
6246                 "JMP_JSET_K: if (0x3 & 0x2) return 1",
6247                 .u.insns_int = {
6248                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6249                         BPF_LD_IMM64(R1, 3),
6250                         BPF_JMP_IMM(BPF_JSET, R1, 2, 1),
6251                         BPF_EXIT_INSN(),
6252                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6253                         BPF_EXIT_INSN(),
6254                 },
6255                 INTERNAL,
6256                 { },
6257                 { { 0, 1 } },
6258         },
6259         {
6260                 "JMP_JSET_K: if (0x3 & 0xffffffff) return 1",
6261                 .u.insns_int = {
6262                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6263                         BPF_LD_IMM64(R1, 3),
6264                         BPF_JMP_IMM(BPF_JSET, R1, 0xffffffff, 1),
6265                         BPF_EXIT_INSN(),
6266                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6267                         BPF_EXIT_INSN(),
6268                 },
6269                 INTERNAL,
6270                 { },
6271                 { { 0, 1 } },
6272         },
6273         /* BPF_JMP | BPF_JSGT | BPF_X */
6274         {
6275                 "JMP_JSGT_X: Signed jump: if (-1 > -2) return 1",
6276                 .u.insns_int = {
6277                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6278                         BPF_LD_IMM64(R1, -1),
6279                         BPF_LD_IMM64(R2, -2),
6280                         BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
6281                         BPF_EXIT_INSN(),
6282                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6283                         BPF_EXIT_INSN(),
6284                 },
6285                 INTERNAL,
6286                 { },
6287                 { { 0, 1 } },
6288         },
6289         {
6290                 "JMP_JSGT_X: Signed jump: if (-1 > -1) return 0",
6291                 .u.insns_int = {
6292                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6293                         BPF_LD_IMM64(R1, -1),
6294                         BPF_LD_IMM64(R2, -1),
6295                         BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
6296                         BPF_EXIT_INSN(),
6297                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6298                         BPF_EXIT_INSN(),
6299                 },
6300                 INTERNAL,
6301                 { },
6302                 { { 0, 1 } },
6303         },
6304         /* BPF_JMP | BPF_JSLT | BPF_X */
6305         {
6306                 "JMP_JSLT_X: Signed jump: if (-2 < -1) return 1",
6307                 .u.insns_int = {
6308                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6309                         BPF_LD_IMM64(R1, -1),
6310                         BPF_LD_IMM64(R2, -2),
6311                         BPF_JMP_REG(BPF_JSLT, R2, R1, 1),
6312                         BPF_EXIT_INSN(),
6313                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6314                         BPF_EXIT_INSN(),
6315                 },
6316                 INTERNAL,
6317                 { },
6318                 { { 0, 1 } },
6319         },
6320         {
6321                 "JMP_JSLT_X: Signed jump: if (-1 < -1) return 0",
6322                 .u.insns_int = {
6323                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6324                         BPF_LD_IMM64(R1, -1),
6325                         BPF_LD_IMM64(R2, -1),
6326                         BPF_JMP_REG(BPF_JSLT, R1, R2, 1),
6327                         BPF_EXIT_INSN(),
6328                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6329                         BPF_EXIT_INSN(),
6330                 },
6331                 INTERNAL,
6332                 { },
6333                 { { 0, 1 } },
6334         },
6335         /* BPF_JMP | BPF_JSGE | BPF_X */
6336         {
6337                 "JMP_JSGE_X: Signed jump: if (-1 >= -2) return 1",
6338                 .u.insns_int = {
6339                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6340                         BPF_LD_IMM64(R1, -1),
6341                         BPF_LD_IMM64(R2, -2),
6342                         BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
6343                         BPF_EXIT_INSN(),
6344                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6345                         BPF_EXIT_INSN(),
6346                 },
6347                 INTERNAL,
6348                 { },
6349                 { { 0, 1 } },
6350         },
6351         {
6352                 "JMP_JSGE_X: Signed jump: if (-1 >= -1) return 1",
6353                 .u.insns_int = {
6354                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6355                         BPF_LD_IMM64(R1, -1),
6356                         BPF_LD_IMM64(R2, -1),
6357                         BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
6358                         BPF_EXIT_INSN(),
6359                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6360                         BPF_EXIT_INSN(),
6361                 },
6362                 INTERNAL,
6363                 { },
6364                 { { 0, 1 } },
6365         },
6366         /* BPF_JMP | BPF_JSLE | BPF_X */
6367         {
6368                 "JMP_JSLE_X: Signed jump: if (-2 <= -1) return 1",
6369                 .u.insns_int = {
6370                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6371                         BPF_LD_IMM64(R1, -1),
6372                         BPF_LD_IMM64(R2, -2),
6373                         BPF_JMP_REG(BPF_JSLE, R2, R1, 1),
6374                         BPF_EXIT_INSN(),
6375                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6376                         BPF_EXIT_INSN(),
6377                 },
6378                 INTERNAL,
6379                 { },
6380                 { { 0, 1 } },
6381         },
6382         {
6383                 "JMP_JSLE_X: Signed jump: if (-1 <= -1) return 1",
6384                 .u.insns_int = {
6385                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6386                         BPF_LD_IMM64(R1, -1),
6387                         BPF_LD_IMM64(R2, -1),
6388                         BPF_JMP_REG(BPF_JSLE, R1, R2, 1),
6389                         BPF_EXIT_INSN(),
6390                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6391                         BPF_EXIT_INSN(),
6392                 },
6393                 INTERNAL,
6394                 { },
6395                 { { 0, 1 } },
6396         },
6397         /* BPF_JMP | BPF_JGT | BPF_X */
6398         {
6399                 "JMP_JGT_X: if (3 > 2) return 1",
6400                 .u.insns_int = {
6401                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6402                         BPF_LD_IMM64(R1, 3),
6403                         BPF_LD_IMM64(R2, 2),
6404                         BPF_JMP_REG(BPF_JGT, R1, R2, 1),
6405                         BPF_EXIT_INSN(),
6406                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6407                         BPF_EXIT_INSN(),
6408                 },
6409                 INTERNAL,
6410                 { },
6411                 { { 0, 1 } },
6412         },
6413         {
6414                 "JMP_JGT_X: Unsigned jump: if (-1 > 1) return 1",
6415                 .u.insns_int = {
6416                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6417                         BPF_LD_IMM64(R1, -1),
6418                         BPF_LD_IMM64(R2, 1),
6419                         BPF_JMP_REG(BPF_JGT, R1, R2, 1),
6420                         BPF_EXIT_INSN(),
6421                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6422                         BPF_EXIT_INSN(),
6423                 },
6424                 INTERNAL,
6425                 { },
6426                 { { 0, 1 } },
6427         },
6428         /* BPF_JMP | BPF_JLT | BPF_X */
6429         {
6430                 "JMP_JLT_X: if (2 < 3) return 1",
6431                 .u.insns_int = {
6432                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6433                         BPF_LD_IMM64(R1, 3),
6434                         BPF_LD_IMM64(R2, 2),
6435                         BPF_JMP_REG(BPF_JLT, R2, R1, 1),
6436                         BPF_EXIT_INSN(),
6437                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6438                         BPF_EXIT_INSN(),
6439                 },
6440                 INTERNAL,
6441                 { },
6442                 { { 0, 1 } },
6443         },
6444         {
6445                 "JMP_JLT_X: Unsigned jump: if (1 < -1) return 1",
6446                 .u.insns_int = {
6447                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6448                         BPF_LD_IMM64(R1, -1),
6449                         BPF_LD_IMM64(R2, 1),
6450                         BPF_JMP_REG(BPF_JLT, R2, R1, 1),
6451                         BPF_EXIT_INSN(),
6452                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6453                         BPF_EXIT_INSN(),
6454                 },
6455                 INTERNAL,
6456                 { },
6457                 { { 0, 1 } },
6458         },
6459         /* BPF_JMP | BPF_JGE | BPF_X */
6460         {
6461                 "JMP_JGE_X: if (3 >= 2) return 1",
6462                 .u.insns_int = {
6463                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6464                         BPF_LD_IMM64(R1, 3),
6465                         BPF_LD_IMM64(R2, 2),
6466                         BPF_JMP_REG(BPF_JGE, R1, R2, 1),
6467                         BPF_EXIT_INSN(),
6468                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6469                         BPF_EXIT_INSN(),
6470                 },
6471                 INTERNAL,
6472                 { },
6473                 { { 0, 1 } },
6474         },
6475         {
6476                 "JMP_JGE_X: if (3 >= 3) return 1",
6477                 .u.insns_int = {
6478                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6479                         BPF_LD_IMM64(R1, 3),
6480                         BPF_LD_IMM64(R2, 3),
6481                         BPF_JMP_REG(BPF_JGE, R1, R2, 1),
6482                         BPF_EXIT_INSN(),
6483                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6484                         BPF_EXIT_INSN(),
6485                 },
6486                 INTERNAL,
6487                 { },
6488                 { { 0, 1 } },
6489         },
6490         /* BPF_JMP | BPF_JLE | BPF_X */
6491         {
6492                 "JMP_JLE_X: if (2 <= 3) return 1",
6493                 .u.insns_int = {
6494                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6495                         BPF_LD_IMM64(R1, 3),
6496                         BPF_LD_IMM64(R2, 2),
6497                         BPF_JMP_REG(BPF_JLE, R2, R1, 1),
6498                         BPF_EXIT_INSN(),
6499                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6500                         BPF_EXIT_INSN(),
6501                 },
6502                 INTERNAL,
6503                 { },
6504                 { { 0, 1 } },
6505         },
6506         {
6507                 "JMP_JLE_X: if (3 <= 3) return 1",
6508                 .u.insns_int = {
6509                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6510                         BPF_LD_IMM64(R1, 3),
6511                         BPF_LD_IMM64(R2, 3),
6512                         BPF_JMP_REG(BPF_JLE, R1, R2, 1),
6513                         BPF_EXIT_INSN(),
6514                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6515                         BPF_EXIT_INSN(),
6516                 },
6517                 INTERNAL,
6518                 { },
6519                 { { 0, 1 } },
6520         },
6521         {
6522                 /* Mainly testing JIT + imm64 here. */
6523                 "JMP_JGE_X: ldimm64 test 1",
6524                 .u.insns_int = {
6525                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6526                         BPF_LD_IMM64(R1, 3),
6527                         BPF_LD_IMM64(R2, 2),
6528                         BPF_JMP_REG(BPF_JGE, R1, R2, 2),
6529                         BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
6530                         BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
6531                         BPF_EXIT_INSN(),
6532                 },
6533                 INTERNAL,
6534                 { },
6535                 { { 0, 0xeeeeeeeeU } },
6536         },
6537         {
6538                 "JMP_JGE_X: ldimm64 test 2",
6539                 .u.insns_int = {
6540                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6541                         BPF_LD_IMM64(R1, 3),
6542                         BPF_LD_IMM64(R2, 2),
6543                         BPF_JMP_REG(BPF_JGE, R1, R2, 0),
6544                         BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
6545                         BPF_EXIT_INSN(),
6546                 },
6547                 INTERNAL,
6548                 { },
6549                 { { 0, 0xffffffffU } },
6550         },
6551         {
6552                 "JMP_JGE_X: ldimm64 test 3",
6553                 .u.insns_int = {
6554                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6555                         BPF_LD_IMM64(R1, 3),
6556                         BPF_LD_IMM64(R2, 2),
6557                         BPF_JMP_REG(BPF_JGE, R1, R2, 4),
6558                         BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
6559                         BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
6560                         BPF_EXIT_INSN(),
6561                 },
6562                 INTERNAL,
6563                 { },
6564                 { { 0, 1 } },
6565         },
6566         {
6567                 "JMP_JLE_X: ldimm64 test 1",
6568                 .u.insns_int = {
6569                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6570                         BPF_LD_IMM64(R1, 3),
6571                         BPF_LD_IMM64(R2, 2),
6572                         BPF_JMP_REG(BPF_JLE, R2, R1, 2),
6573                         BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
6574                         BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
6575                         BPF_EXIT_INSN(),
6576                 },
6577                 INTERNAL,
6578                 { },
6579                 { { 0, 0xeeeeeeeeU } },
6580         },
6581         {
6582                 "JMP_JLE_X: ldimm64 test 2",
6583                 .u.insns_int = {
6584                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6585                         BPF_LD_IMM64(R1, 3),
6586                         BPF_LD_IMM64(R2, 2),
6587                         BPF_JMP_REG(BPF_JLE, R2, R1, 0),
6588                         BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
6589                         BPF_EXIT_INSN(),
6590                 },
6591                 INTERNAL,
6592                 { },
6593                 { { 0, 0xffffffffU } },
6594         },
6595         {
6596                 "JMP_JLE_X: ldimm64 test 3",
6597                 .u.insns_int = {
6598                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6599                         BPF_LD_IMM64(R1, 3),
6600                         BPF_LD_IMM64(R2, 2),
6601                         BPF_JMP_REG(BPF_JLE, R2, R1, 4),
6602                         BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
6603                         BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
6604                         BPF_EXIT_INSN(),
6605                 },
6606                 INTERNAL,
6607                 { },
6608                 { { 0, 1 } },
6609         },
6610         /* BPF_JMP | BPF_JNE | BPF_X */
6611         {
6612                 "JMP_JNE_X: if (3 != 2) return 1",
6613                 .u.insns_int = {
6614                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6615                         BPF_LD_IMM64(R1, 3),
6616                         BPF_LD_IMM64(R2, 2),
6617                         BPF_JMP_REG(BPF_JNE, R1, R2, 1),
6618                         BPF_EXIT_INSN(),
6619                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6620                         BPF_EXIT_INSN(),
6621                 },
6622                 INTERNAL,
6623                 { },
6624                 { { 0, 1 } },
6625         },
6626         /* BPF_JMP | BPF_JEQ | BPF_X */
6627         {
6628                 "JMP_JEQ_X: if (3 == 3) return 1",
6629                 .u.insns_int = {
6630                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6631                         BPF_LD_IMM64(R1, 3),
6632                         BPF_LD_IMM64(R2, 3),
6633                         BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
6634                         BPF_EXIT_INSN(),
6635                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6636                         BPF_EXIT_INSN(),
6637                 },
6638                 INTERNAL,
6639                 { },
6640                 { { 0, 1 } },
6641         },
6642         /* BPF_JMP | BPF_JSET | BPF_X */
6643         {
6644                 "JMP_JSET_X: if (0x3 & 0x2) return 1",
6645                 .u.insns_int = {
6646                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6647                         BPF_LD_IMM64(R1, 3),
6648                         BPF_LD_IMM64(R2, 2),
6649                         BPF_JMP_REG(BPF_JSET, R1, R2, 1),
6650                         BPF_EXIT_INSN(),
6651                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6652                         BPF_EXIT_INSN(),
6653                 },
6654                 INTERNAL,
6655                 { },
6656                 { { 0, 1 } },
6657         },
6658         {
6659                 "JMP_JSET_X: if (0x3 & 0xffffffff) return 1",
6660                 .u.insns_int = {
6661                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6662                         BPF_LD_IMM64(R1, 3),
6663                         BPF_LD_IMM64(R2, 0xffffffff),
6664                         BPF_JMP_REG(BPF_JSET, R1, R2, 1),
6665                         BPF_EXIT_INSN(),
6666                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6667                         BPF_EXIT_INSN(),
6668                 },
6669                 INTERNAL,
6670                 { },
6671                 { { 0, 1 } },
6672         },
6673         {
6674                 "JMP_JA: Jump, gap, jump, ...",
6675                 { },
6676                 CLASSIC | FLAG_NO_DATA,
6677                 { },
6678                 { { 0, 0xababcbac } },
6679                 .fill_helper = bpf_fill_ja,
6680         },
6681         {       /* Mainly checking JIT here. */
6682                 "BPF_MAXINSNS: Maximum possible literals",
6683                 { },
6684                 CLASSIC | FLAG_NO_DATA,
6685                 { },
6686                 { { 0, 0xffffffff } },
6687                 .fill_helper = bpf_fill_maxinsns1,
6688         },
6689         {       /* Mainly checking JIT here. */
6690                 "BPF_MAXINSNS: Single literal",
6691                 { },
6692                 CLASSIC | FLAG_NO_DATA,
6693                 { },
6694                 { { 0, 0xfefefefe } },
6695                 .fill_helper = bpf_fill_maxinsns2,
6696         },
6697         {       /* Mainly checking JIT here. */
6698                 "BPF_MAXINSNS: Run/add until end",
6699                 { },
6700                 CLASSIC | FLAG_NO_DATA,
6701                 { },
6702                 { { 0, 0x947bf368 } },
6703                 .fill_helper = bpf_fill_maxinsns3,
6704         },
6705         {
6706                 "BPF_MAXINSNS: Too many instructions",
6707                 { },
6708                 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
6709                 { },
6710                 { },
6711                 .fill_helper = bpf_fill_maxinsns4,
6712                 .expected_errcode = -EINVAL,
6713         },
6714         {       /* Mainly checking JIT here. */
6715                 "BPF_MAXINSNS: Very long jump",
6716                 { },
6717                 CLASSIC | FLAG_NO_DATA,
6718                 { },
6719                 { { 0, 0xabababab } },
6720                 .fill_helper = bpf_fill_maxinsns5,
6721         },
6722         {       /* Mainly checking JIT here. */
6723                 "BPF_MAXINSNS: Ctx heavy transformations",
6724                 { },
6725                 CLASSIC,
6726                 { },
6727                 {
6728                         {  1, SKB_VLAN_PRESENT },
6729                         { 10, SKB_VLAN_PRESENT }
6730                 },
6731                 .fill_helper = bpf_fill_maxinsns6,
6732         },
6733         {       /* Mainly checking JIT here. */
6734                 "BPF_MAXINSNS: Call heavy transformations",
6735                 { },
6736                 CLASSIC | FLAG_NO_DATA,
6737                 { },
6738                 { { 1, 0 }, { 10, 0 } },
6739                 .fill_helper = bpf_fill_maxinsns7,
6740         },
6741         {       /* Mainly checking JIT here. */
6742                 "BPF_MAXINSNS: Jump heavy test",
6743                 { },
6744                 CLASSIC | FLAG_NO_DATA,
6745                 { },
6746                 { { 0, 0xffffffff } },
6747                 .fill_helper = bpf_fill_maxinsns8,
6748         },
6749         {       /* Mainly checking JIT here. */
6750                 "BPF_MAXINSNS: Very long jump backwards",
6751                 { },
6752                 INTERNAL | FLAG_NO_DATA,
6753                 { },
6754                 { { 0, 0xcbababab } },
6755                 .fill_helper = bpf_fill_maxinsns9,
6756         },
6757         {       /* Mainly checking JIT here. */
6758                 "BPF_MAXINSNS: Edge hopping nuthouse",
6759                 { },
6760                 INTERNAL | FLAG_NO_DATA,
6761                 { },
6762                 { { 0, 0xabababac } },
6763                 .fill_helper = bpf_fill_maxinsns10,
6764         },
6765         {
6766                 "BPF_MAXINSNS: Jump, gap, jump, ...",
6767                 { },
6768                 CLASSIC | FLAG_NO_DATA,
6769                 { },
6770                 { { 0, 0xababcbac } },
6771                 .fill_helper = bpf_fill_maxinsns11,
6772         },
6773         {
6774                 "BPF_MAXINSNS: jump over MSH",
6775                 { },
6776                 CLASSIC | FLAG_EXPECTED_FAIL,
6777                 { 0xfa, 0xfb, 0xfc, 0xfd, },
6778                 { { 4, 0xabababab } },
6779                 .fill_helper = bpf_fill_maxinsns12,
6780                 .expected_errcode = -EINVAL,
6781         },
6782         {
6783                 "BPF_MAXINSNS: exec all MSH",
6784                 { },
6785                 CLASSIC,
6786                 { 0xfa, 0xfb, 0xfc, 0xfd, },
6787                 { { 4, 0xababab83 } },
6788                 .fill_helper = bpf_fill_maxinsns13,
6789         },
6790         {
6791                 "BPF_MAXINSNS: ld_abs+get_processor_id",
6792                 { },
6793                 CLASSIC,
6794                 { },
6795                 { { 1, 0xbee } },
6796                 .fill_helper = bpf_fill_ld_abs_get_processor_id,
6797         },
6798         /*
6799          * LD_IND / LD_ABS on fragmented SKBs
6800          */
6801         {
6802                 "LD_IND byte frag",
6803                 .u.insns = {
6804                         BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
6805                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x0),
6806                         BPF_STMT(BPF_RET | BPF_A, 0x0),
6807                 },
6808                 CLASSIC | FLAG_SKB_FRAG,
6809                 { },
6810                 { {0x40, 0x42} },
6811                 .frag_data = {
6812                         0x42, 0x00, 0x00, 0x00,
6813                         0x43, 0x44, 0x00, 0x00,
6814                         0x21, 0x07, 0x19, 0x83,
6815                 },
6816         },
6817         {
6818                 "LD_IND halfword frag",
6819                 .u.insns = {
6820                         BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
6821                         BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x4),
6822                         BPF_STMT(BPF_RET | BPF_A, 0x0),
6823                 },
6824                 CLASSIC | FLAG_SKB_FRAG,
6825                 { },
6826                 { {0x40, 0x4344} },
6827                 .frag_data = {
6828                         0x42, 0x00, 0x00, 0x00,
6829                         0x43, 0x44, 0x00, 0x00,
6830                         0x21, 0x07, 0x19, 0x83,
6831                 },
6832         },
6833         {
6834                 "LD_IND word frag",
6835                 .u.insns = {
6836                         BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
6837                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x8),
6838                         BPF_STMT(BPF_RET | BPF_A, 0x0),
6839                 },
6840                 CLASSIC | FLAG_SKB_FRAG,
6841                 { },
6842                 { {0x40, 0x21071983} },
6843                 .frag_data = {
6844                         0x42, 0x00, 0x00, 0x00,
6845                         0x43, 0x44, 0x00, 0x00,
6846                         0x21, 0x07, 0x19, 0x83,
6847                 },
6848         },
6849         {
6850                 "LD_IND halfword mixed head/frag",
6851                 .u.insns = {
6852                         BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
6853                         BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
6854                         BPF_STMT(BPF_RET | BPF_A, 0x0),
6855                 },
6856                 CLASSIC | FLAG_SKB_FRAG,
6857                 { [0x3e] = 0x25, [0x3f] = 0x05, },
6858                 { {0x40, 0x0519} },
6859                 .frag_data = { 0x19, 0x82 },
6860         },
6861         {
6862                 "LD_IND word mixed head/frag",
6863                 .u.insns = {
6864                         BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
6865                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
6866                         BPF_STMT(BPF_RET | BPF_A, 0x0),
6867                 },
6868                 CLASSIC | FLAG_SKB_FRAG,
6869                 { [0x3e] = 0x25, [0x3f] = 0x05, },
6870                 { {0x40, 0x25051982} },
6871                 .frag_data = { 0x19, 0x82 },
6872         },
6873         {
6874                 "LD_ABS byte frag",
6875                 .u.insns = {
6876                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x40),
6877                         BPF_STMT(BPF_RET | BPF_A, 0x0),
6878                 },
6879                 CLASSIC | FLAG_SKB_FRAG,
6880                 { },
6881                 { {0x40, 0x42} },
6882                 .frag_data = {
6883                         0x42, 0x00, 0x00, 0x00,
6884                         0x43, 0x44, 0x00, 0x00,
6885                         0x21, 0x07, 0x19, 0x83,
6886                 },
6887         },
6888         {
6889                 "LD_ABS halfword frag",
6890                 .u.insns = {
6891                         BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x44),
6892                         BPF_STMT(BPF_RET | BPF_A, 0x0),
6893                 },
6894                 CLASSIC | FLAG_SKB_FRAG,
6895                 { },
6896                 { {0x40, 0x4344} },
6897                 .frag_data = {
6898                         0x42, 0x00, 0x00, 0x00,
6899                         0x43, 0x44, 0x00, 0x00,
6900                         0x21, 0x07, 0x19, 0x83,
6901                 },
6902         },
6903         {
6904                 "LD_ABS word frag",
6905                 .u.insns = {
6906                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x48),
6907                         BPF_STMT(BPF_RET | BPF_A, 0x0),
6908                 },
6909                 CLASSIC | FLAG_SKB_FRAG,
6910                 { },
6911                 { {0x40, 0x21071983} },
6912                 .frag_data = {
6913                         0x42, 0x00, 0x00, 0x00,
6914                         0x43, 0x44, 0x00, 0x00,
6915                         0x21, 0x07, 0x19, 0x83,
6916                 },
6917         },
6918         {
6919                 "LD_ABS halfword mixed head/frag",
6920                 .u.insns = {
6921                         BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f),
6922                         BPF_STMT(BPF_RET | BPF_A, 0x0),
6923                 },
6924                 CLASSIC | FLAG_SKB_FRAG,
6925                 { [0x3e] = 0x25, [0x3f] = 0x05, },
6926                 { {0x40, 0x0519} },
6927                 .frag_data = { 0x19, 0x82 },
6928         },
6929         {
6930                 "LD_ABS word mixed head/frag",
6931                 .u.insns = {
6932                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3e),
6933                         BPF_STMT(BPF_RET | BPF_A, 0x0),
6934                 },
6935                 CLASSIC | FLAG_SKB_FRAG,
6936                 { [0x3e] = 0x25, [0x3f] = 0x05, },
6937                 { {0x40, 0x25051982} },
6938                 .frag_data = { 0x19, 0x82 },
6939         },
6940         /*
6941          * LD_IND / LD_ABS on non fragmented SKBs
6942          */
6943         {
6944                 /*
6945                  * this tests that the JIT/interpreter correctly resets X
6946                  * before using it in an LD_IND instruction.
6947                  */
6948                 "LD_IND byte default X",
6949                 .u.insns = {
6950                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
6951                         BPF_STMT(BPF_RET | BPF_A, 0x0),
6952                 },
6953                 CLASSIC,
6954                 { [0x1] = 0x42 },
6955                 { {0x40, 0x42 } },
6956         },
6957         {
6958                 "LD_IND byte positive offset",
6959                 .u.insns = {
6960                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
6961                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
6962                         BPF_STMT(BPF_RET | BPF_A, 0x0),
6963                 },
6964                 CLASSIC,
6965                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
6966                 { {0x40, 0x82 } },
6967         },
6968         {
6969                 "LD_IND byte negative offset",
6970                 .u.insns = {
6971                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
6972                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x1),
6973                         BPF_STMT(BPF_RET | BPF_A, 0x0),
6974                 },
6975                 CLASSIC,
6976                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
6977                 { {0x40, 0x05 } },
6978         },
6979         {
6980                 "LD_IND byte positive offset, all ff",
6981                 .u.insns = {
6982                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
6983                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
6984                         BPF_STMT(BPF_RET | BPF_A, 0x0),
6985                 },
6986                 CLASSIC,
6987                 { [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
6988                 { {0x40, 0xff } },
6989         },
6990         {
6991                 "LD_IND byte positive offset, out of bounds",
6992                 .u.insns = {
6993                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
6994                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
6995                         BPF_STMT(BPF_RET | BPF_A, 0x0),
6996                 },
6997                 CLASSIC,
6998                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
6999                 { {0x3f, 0 }, },
7000         },
7001         {
7002                 "LD_IND byte negative offset, out of bounds",
7003                 .u.insns = {
7004                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
7005                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x3f),
7006                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7007                 },
7008                 CLASSIC,
7009                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7010                 { {0x3f, 0 } },
7011         },
7012         {
7013                 "LD_IND byte negative offset, multiple calls",
7014                 .u.insns = {
7015                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3b),
7016                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 1),
7017                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 2),
7018                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 3),
7019                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 4),
7020                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7021                 },
7022                 CLASSIC,
7023                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7024                 { {0x40, 0x82 }, },
7025         },
7026         {
7027                 "LD_IND halfword positive offset",
7028                 .u.insns = {
7029                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
7030                         BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x2),
7031                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7032                 },
7033                 CLASSIC,
7034                 {
7035                         [0x1c] = 0xaa, [0x1d] = 0x55,
7036                         [0x1e] = 0xbb, [0x1f] = 0x66,
7037                         [0x20] = 0xcc, [0x21] = 0x77,
7038                         [0x22] = 0xdd, [0x23] = 0x88,
7039                 },
7040                 { {0x40, 0xdd88 } },
7041         },
7042         {
7043                 "LD_IND halfword negative offset",
7044                 .u.insns = {
7045                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
7046                         BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x2),
7047                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7048                 },
7049                 CLASSIC,
7050                 {
7051                         [0x1c] = 0xaa, [0x1d] = 0x55,
7052                         [0x1e] = 0xbb, [0x1f] = 0x66,
7053                         [0x20] = 0xcc, [0x21] = 0x77,
7054                         [0x22] = 0xdd, [0x23] = 0x88,
7055                 },
7056                 { {0x40, 0xbb66 } },
7057         },
7058         {
7059                 "LD_IND halfword unaligned",
7060                 .u.insns = {
7061                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
7062                         BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
7063                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7064                 },
7065                 CLASSIC,
7066                 {
7067                         [0x1c] = 0xaa, [0x1d] = 0x55,
7068                         [0x1e] = 0xbb, [0x1f] = 0x66,
7069                         [0x20] = 0xcc, [0x21] = 0x77,
7070                         [0x22] = 0xdd, [0x23] = 0x88,
7071                 },
7072                 { {0x40, 0x66cc } },
7073         },
7074         {
7075                 "LD_IND halfword positive offset, all ff",
7076                 .u.insns = {
7077                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3d),
7078                         BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1),
7079                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7080                 },
7081                 CLASSIC,
7082                 { [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
7083                 { {0x40, 0xffff } },
7084         },
7085         {
7086                 "LD_IND halfword positive offset, out of bounds",
7087                 .u.insns = {
7088                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
7089                         BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1),
7090                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7091                 },
7092                 CLASSIC,
7093                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7094                 { {0x3f, 0 }, },
7095         },
7096         {
7097                 "LD_IND halfword negative offset, out of bounds",
7098                 .u.insns = {
7099                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
7100                         BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x3f),
7101                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7102                 },
7103                 CLASSIC,
7104                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7105                 { {0x3f, 0 } },
7106         },
7107         {
7108                 "LD_IND word positive offset",
7109                 .u.insns = {
7110                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
7111                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x4),
7112                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7113                 },
7114                 CLASSIC,
7115                 {
7116                         [0x1c] = 0xaa, [0x1d] = 0x55,
7117                         [0x1e] = 0xbb, [0x1f] = 0x66,
7118                         [0x20] = 0xcc, [0x21] = 0x77,
7119                         [0x22] = 0xdd, [0x23] = 0x88,
7120                         [0x24] = 0xee, [0x25] = 0x99,
7121                         [0x26] = 0xff, [0x27] = 0xaa,
7122                 },
7123                 { {0x40, 0xee99ffaa } },
7124         },
7125         {
7126                 "LD_IND word negative offset",
7127                 .u.insns = {
7128                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
7129                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x4),
7130                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7131                 },
7132                 CLASSIC,
7133                 {
7134                         [0x1c] = 0xaa, [0x1d] = 0x55,
7135                         [0x1e] = 0xbb, [0x1f] = 0x66,
7136                         [0x20] = 0xcc, [0x21] = 0x77,
7137                         [0x22] = 0xdd, [0x23] = 0x88,
7138                         [0x24] = 0xee, [0x25] = 0x99,
7139                         [0x26] = 0xff, [0x27] = 0xaa,
7140                 },
7141                 { {0x40, 0xaa55bb66 } },
7142         },
7143         {
7144                 "LD_IND word unaligned (addr & 3 == 2)",
7145                 .u.insns = {
7146                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
7147                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
7148                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7149                 },
7150                 CLASSIC,
7151                 {
7152                         [0x1c] = 0xaa, [0x1d] = 0x55,
7153                         [0x1e] = 0xbb, [0x1f] = 0x66,
7154                         [0x20] = 0xcc, [0x21] = 0x77,
7155                         [0x22] = 0xdd, [0x23] = 0x88,
7156                         [0x24] = 0xee, [0x25] = 0x99,
7157                         [0x26] = 0xff, [0x27] = 0xaa,
7158                 },
7159                 { {0x40, 0xbb66cc77 } },
7160         },
7161         {
7162                 "LD_IND word unaligned (addr & 3 == 1)",
7163                 .u.insns = {
7164                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
7165                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3),
7166                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7167                 },
7168                 CLASSIC,
7169                 {
7170                         [0x1c] = 0xaa, [0x1d] = 0x55,
7171                         [0x1e] = 0xbb, [0x1f] = 0x66,
7172                         [0x20] = 0xcc, [0x21] = 0x77,
7173                         [0x22] = 0xdd, [0x23] = 0x88,
7174                         [0x24] = 0xee, [0x25] = 0x99,
7175                         [0x26] = 0xff, [0x27] = 0xaa,
7176                 },
7177                 { {0x40, 0x55bb66cc } },
7178         },
7179         {
7180                 "LD_IND word unaligned (addr & 3 == 3)",
7181                 .u.insns = {
7182                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
7183                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x1),
7184                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7185                 },
7186                 CLASSIC,
7187                 {
7188                         [0x1c] = 0xaa, [0x1d] = 0x55,
7189                         [0x1e] = 0xbb, [0x1f] = 0x66,
7190                         [0x20] = 0xcc, [0x21] = 0x77,
7191                         [0x22] = 0xdd, [0x23] = 0x88,
7192                         [0x24] = 0xee, [0x25] = 0x99,
7193                         [0x26] = 0xff, [0x27] = 0xaa,
7194                 },
7195                 { {0x40, 0x66cc77dd } },
7196         },
7197         {
7198                 "LD_IND word positive offset, all ff",
7199                 .u.insns = {
7200                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3b),
7201                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1),
7202                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7203                 },
7204                 CLASSIC,
7205                 { [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
7206                 { {0x40, 0xffffffff } },
7207         },
7208         {
7209                 "LD_IND word positive offset, out of bounds",
7210                 .u.insns = {
7211                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
7212                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1),
7213                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7214                 },
7215                 CLASSIC,
7216                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7217                 { {0x3f, 0 }, },
7218         },
7219         {
7220                 "LD_IND word negative offset, out of bounds",
7221                 .u.insns = {
7222                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
7223                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3f),
7224                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7225                 },
7226                 CLASSIC,
7227                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7228                 { {0x3f, 0 } },
7229         },
7230         {
7231                 "LD_ABS byte",
7232                 .u.insns = {
7233                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x20),
7234                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7235                 },
7236                 CLASSIC,
7237                 {
7238                         [0x1c] = 0xaa, [0x1d] = 0x55,
7239                         [0x1e] = 0xbb, [0x1f] = 0x66,
7240                         [0x20] = 0xcc, [0x21] = 0x77,
7241                         [0x22] = 0xdd, [0x23] = 0x88,
7242                         [0x24] = 0xee, [0x25] = 0x99,
7243                         [0x26] = 0xff, [0x27] = 0xaa,
7244                 },
7245                 { {0x40, 0xcc } },
7246         },
7247         {
7248                 "LD_ABS byte positive offset, all ff",
7249                 .u.insns = {
7250                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f),
7251                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7252                 },
7253                 CLASSIC,
7254                 { [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
7255                 { {0x40, 0xff } },
7256         },
7257         {
7258                 "LD_ABS byte positive offset, out of bounds",
7259                 .u.insns = {
7260                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f),
7261                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7262                 },
7263                 CLASSIC,
7264                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7265                 { {0x3f, 0 }, },
7266         },
7267         {
7268                 "LD_ABS byte negative offset, out of bounds load",
7269                 .u.insns = {
7270                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, -1),
7271                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7272                 },
7273                 CLASSIC | FLAG_EXPECTED_FAIL,
7274                 .expected_errcode = -EINVAL,
7275         },
7276         {
7277                 "LD_ABS byte negative offset, in bounds",
7278                 .u.insns = {
7279                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
7280                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7281                 },
7282                 CLASSIC,
7283                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7284                 { {0x40, 0x82 }, },
7285         },
7286         {
7287                 "LD_ABS byte negative offset, out of bounds",
7288                 .u.insns = {
7289                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
7290                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7291                 },
7292                 CLASSIC,
7293                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7294                 { {0x3f, 0 }, },
7295         },
7296         {
7297                 "LD_ABS byte negative offset, multiple calls",
7298                 .u.insns = {
7299                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3c),
7300                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3d),
7301                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3e),
7302                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
7303                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7304                 },
7305                 CLASSIC,
7306                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7307                 { {0x40, 0x82 }, },
7308         },
7309         {
7310                 "LD_ABS halfword",
7311                 .u.insns = {
7312                         BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x22),
7313                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7314                 },
7315                 CLASSIC,
7316                 {
7317                         [0x1c] = 0xaa, [0x1d] = 0x55,
7318                         [0x1e] = 0xbb, [0x1f] = 0x66,
7319                         [0x20] = 0xcc, [0x21] = 0x77,
7320                         [0x22] = 0xdd, [0x23] = 0x88,
7321                         [0x24] = 0xee, [0x25] = 0x99,
7322                         [0x26] = 0xff, [0x27] = 0xaa,
7323                 },
7324                 { {0x40, 0xdd88 } },
7325         },
7326         {
7327                 "LD_ABS halfword unaligned",
7328                 .u.insns = {
7329                         BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x25),
7330                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7331                 },
7332                 CLASSIC,
7333                 {
7334                         [0x1c] = 0xaa, [0x1d] = 0x55,
7335                         [0x1e] = 0xbb, [0x1f] = 0x66,
7336                         [0x20] = 0xcc, [0x21] = 0x77,
7337                         [0x22] = 0xdd, [0x23] = 0x88,
7338                         [0x24] = 0xee, [0x25] = 0x99,
7339                         [0x26] = 0xff, [0x27] = 0xaa,
7340                 },
7341                 { {0x40, 0x99ff } },
7342         },
7343         {
7344                 "LD_ABS halfword positive offset, all ff",
7345                 .u.insns = {
7346                         BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3e),
7347                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7348                 },
7349                 CLASSIC,
7350                 { [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
7351                 { {0x40, 0xffff } },
7352         },
7353         {
7354                 "LD_ABS halfword positive offset, out of bounds",
7355                 .u.insns = {
7356                         BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f),
7357                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7358                 },
7359                 CLASSIC,
7360                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7361                 { {0x3f, 0 }, },
7362         },
7363         {
7364                 "LD_ABS halfword negative offset, out of bounds load",
7365                 .u.insns = {
7366                         BPF_STMT(BPF_LD | BPF_ABS | BPF_H, -1),
7367                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7368                 },
7369                 CLASSIC | FLAG_EXPECTED_FAIL,
7370                 .expected_errcode = -EINVAL,
7371         },
7372         {
7373                 "LD_ABS halfword negative offset, in bounds",
7374                 .u.insns = {
7375                         BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e),
7376                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7377                 },
7378                 CLASSIC,
7379                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7380                 { {0x40, 0x1982 }, },
7381         },
7382         {
7383                 "LD_ABS halfword negative offset, out of bounds",
7384                 .u.insns = {
7385                         BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e),
7386                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7387                 },
7388                 CLASSIC,
7389                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7390                 { {0x3f, 0 }, },
7391         },
7392         {
7393                 "LD_ABS word",
7394                 .u.insns = {
7395                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x1c),
7396                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7397                 },
7398                 CLASSIC,
7399                 {
7400                         [0x1c] = 0xaa, [0x1d] = 0x55,
7401                         [0x1e] = 0xbb, [0x1f] = 0x66,
7402                         [0x20] = 0xcc, [0x21] = 0x77,
7403                         [0x22] = 0xdd, [0x23] = 0x88,
7404                         [0x24] = 0xee, [0x25] = 0x99,
7405                         [0x26] = 0xff, [0x27] = 0xaa,
7406                 },
7407                 { {0x40, 0xaa55bb66 } },
7408         },
7409         {
7410                 "LD_ABS word unaligned (addr & 3 == 2)",
7411                 .u.insns = {
7412                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x22),
7413                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7414                 },
7415                 CLASSIC,
7416                 {
7417                         [0x1c] = 0xaa, [0x1d] = 0x55,
7418                         [0x1e] = 0xbb, [0x1f] = 0x66,
7419                         [0x20] = 0xcc, [0x21] = 0x77,
7420                         [0x22] = 0xdd, [0x23] = 0x88,
7421                         [0x24] = 0xee, [0x25] = 0x99,
7422                         [0x26] = 0xff, [0x27] = 0xaa,
7423                 },
7424                 { {0x40, 0xdd88ee99 } },
7425         },
7426         {
7427                 "LD_ABS word unaligned (addr & 3 == 1)",
7428                 .u.insns = {
7429                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x21),
7430                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7431                 },
7432                 CLASSIC,
7433                 {
7434                         [0x1c] = 0xaa, [0x1d] = 0x55,
7435                         [0x1e] = 0xbb, [0x1f] = 0x66,
7436                         [0x20] = 0xcc, [0x21] = 0x77,
7437                         [0x22] = 0xdd, [0x23] = 0x88,
7438                         [0x24] = 0xee, [0x25] = 0x99,
7439                         [0x26] = 0xff, [0x27] = 0xaa,
7440                 },
7441                 { {0x40, 0x77dd88ee } },
7442         },
7443         {
7444                 "LD_ABS word unaligned (addr & 3 == 3)",
7445                 .u.insns = {
7446                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x23),
7447                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7448                 },
7449                 CLASSIC,
7450                 {
7451                         [0x1c] = 0xaa, [0x1d] = 0x55,
7452                         [0x1e] = 0xbb, [0x1f] = 0x66,
7453                         [0x20] = 0xcc, [0x21] = 0x77,
7454                         [0x22] = 0xdd, [0x23] = 0x88,
7455                         [0x24] = 0xee, [0x25] = 0x99,
7456                         [0x26] = 0xff, [0x27] = 0xaa,
7457                 },
7458                 { {0x40, 0x88ee99ff } },
7459         },
7460         {
7461                 "LD_ABS word positive offset, all ff",
7462                 .u.insns = {
7463                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3c),
7464                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7465                 },
7466                 CLASSIC,
7467                 { [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
7468                 { {0x40, 0xffffffff } },
7469         },
7470         {
7471                 "LD_ABS word positive offset, out of bounds",
7472                 .u.insns = {
7473                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3f),
7474                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7475                 },
7476                 CLASSIC,
7477                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7478                 { {0x3f, 0 }, },
7479         },
7480         {
7481                 "LD_ABS word negative offset, out of bounds load",
7482                 .u.insns = {
7483                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, -1),
7484                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7485                 },
7486                 CLASSIC | FLAG_EXPECTED_FAIL,
7487                 .expected_errcode = -EINVAL,
7488         },
7489         {
7490                 "LD_ABS word negative offset, in bounds",
7491                 .u.insns = {
7492                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c),
7493                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7494                 },
7495                 CLASSIC,
7496                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7497                 { {0x40, 0x25051982 }, },
7498         },
7499         {
7500                 "LD_ABS word negative offset, out of bounds",
7501                 .u.insns = {
7502                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c),
7503                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7504                 },
7505                 CLASSIC,
7506                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7507                 { {0x3f, 0 }, },
7508         },
7509         {
7510                 "LDX_MSH standalone, preserved A",
7511                 .u.insns = {
7512                         BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
7513                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
7514                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7515                 },
7516                 CLASSIC,
7517                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7518                 { {0x40, 0xffeebbaa }, },
7519         },
7520         {
7521                 "LDX_MSH standalone, preserved A 2",
7522                 .u.insns = {
7523                         BPF_STMT(BPF_LD | BPF_IMM, 0x175e9d63),
7524                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
7525                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3d),
7526                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e),
7527                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3f),
7528                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7529                 },
7530                 CLASSIC,
7531                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7532                 { {0x40, 0x175e9d63 }, },
7533         },
7534         {
7535                 "LDX_MSH standalone, test result 1",
7536                 .u.insns = {
7537                         BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
7538                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
7539                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
7540                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7541                 },
7542                 CLASSIC,
7543                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7544                 { {0x40, 0x14 }, },
7545         },
7546         {
7547                 "LDX_MSH standalone, test result 2",
7548                 .u.insns = {
7549                         BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
7550                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e),
7551                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
7552                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7553                 },
7554                 CLASSIC,
7555                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7556                 { {0x40, 0x24 }, },
7557         },
7558         {
7559                 "LDX_MSH standalone, negative offset",
7560                 .u.insns = {
7561                         BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
7562                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, -1),
7563                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
7564                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7565                 },
7566                 CLASSIC,
7567                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7568                 { {0x40, 0 }, },
7569         },
7570         {
7571                 "LDX_MSH standalone, negative offset 2",
7572                 .u.insns = {
7573                         BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
7574                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, SKF_LL_OFF + 0x3e),
7575                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
7576                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7577                 },
7578                 CLASSIC,
7579                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7580                 { {0x40, 0x24 }, },
7581         },
7582         {
7583                 "LDX_MSH standalone, out of bounds",
7584                 .u.insns = {
7585                         BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
7586                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x40),
7587                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
7588                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7589                 },
7590                 CLASSIC,
7591                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7592                 { {0x40, 0 }, },
7593         },
7594         /*
7595          * verify that the interpreter or JIT correctly sets A and X
7596          * to 0.
7597          */
7598         {
7599                 "ADD default X",
7600                 .u.insns = {
7601                         /*
7602                          * A = 0x42
7603                          * A = A + X
7604                          * ret A
7605                          */
7606                         BPF_STMT(BPF_LD | BPF_IMM, 0x42),
7607                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
7608                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7609                 },
7610                 CLASSIC | FLAG_NO_DATA,
7611                 {},
7612                 { {0x1, 0x42 } },
7613         },
7614         {
7615                 "ADD default A",
7616                 .u.insns = {
7617                         /*
7618                          * A = A + 0x42
7619                          * ret A
7620                          */
7621                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0x42),
7622                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7623                 },
7624                 CLASSIC | FLAG_NO_DATA,
7625                 {},
7626                 { {0x1, 0x42 } },
7627         },
7628         {
7629                 "SUB default X",
7630                 .u.insns = {
7631                         /*
7632                          * A = 0x66
7633                          * A = A - X
7634                          * ret A
7635                          */
7636                         BPF_STMT(BPF_LD | BPF_IMM, 0x66),
7637                         BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
7638                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7639                 },
7640                 CLASSIC | FLAG_NO_DATA,
7641                 {},
7642                 { {0x1, 0x66 } },
7643         },
7644         {
7645                 "SUB default A",
7646                 .u.insns = {
7647                         /*
7648                          * A = A - -0x66
7649                          * ret A
7650                          */
7651                         BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, -0x66),
7652                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7653                 },
7654                 CLASSIC | FLAG_NO_DATA,
7655                 {},
7656                 { {0x1, 0x66 } },
7657         },
7658         {
7659                 "MUL default X",
7660                 .u.insns = {
7661                         /*
7662                          * A = 0x42
7663                          * A = A * X
7664                          * ret A
7665                          */
7666                         BPF_STMT(BPF_LD | BPF_IMM, 0x42),
7667                         BPF_STMT(BPF_ALU | BPF_MUL | BPF_X, 0),
7668                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7669                 },
7670                 CLASSIC | FLAG_NO_DATA,
7671                 {},
7672                 { {0x1, 0x0 } },
7673         },
7674         {
7675                 "MUL default A",
7676                 .u.insns = {
7677                         /*
7678                          * A = A * 0x66
7679                          * ret A
7680                          */
7681                         BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 0x66),
7682                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7683                 },
7684                 CLASSIC | FLAG_NO_DATA,
7685                 {},
7686                 { {0x1, 0x0 } },
7687         },
7688         {
7689                 "DIV default X",
7690                 .u.insns = {
7691                         /*
7692                          * A = 0x42
7693                          * A = A / X ; this halt the filter execution if X is 0
7694                          * ret 0x42
7695                          */
7696                         BPF_STMT(BPF_LD | BPF_IMM, 0x42),
7697                         BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
7698                         BPF_STMT(BPF_RET | BPF_K, 0x42),
7699                 },
7700                 CLASSIC | FLAG_NO_DATA,
7701                 {},
7702                 { {0x1, 0x0 } },
7703         },
7704         {
7705                 "DIV default A",
7706                 .u.insns = {
7707                         /*
7708                          * A = A / 1
7709                          * ret A
7710                          */
7711                         BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x1),
7712                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7713                 },
7714                 CLASSIC | FLAG_NO_DATA,
7715                 {},
7716                 { {0x1, 0x0 } },
7717         },
7718         {
7719                 "MOD default X",
7720                 .u.insns = {
7721                         /*
7722                          * A = 0x42
7723                          * A = A mod X ; this halt the filter execution if X is 0
7724                          * ret 0x42
7725                          */
7726                         BPF_STMT(BPF_LD | BPF_IMM, 0x42),
7727                         BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
7728                         BPF_STMT(BPF_RET | BPF_K, 0x42),
7729                 },
7730                 CLASSIC | FLAG_NO_DATA,
7731                 {},
7732                 { {0x1, 0x0 } },
7733         },
7734         {
7735                 "MOD default A",
7736                 .u.insns = {
7737                         /*
7738                          * A = A mod 1
7739                          * ret A
7740                          */
7741                         BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x1),
7742                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7743                 },
7744                 CLASSIC | FLAG_NO_DATA,
7745                 {},
7746                 { {0x1, 0x0 } },
7747         },
7748         {
7749                 "JMP EQ default A",
7750                 .u.insns = {
7751                         /*
7752                          * cmp A, 0x0, 0, 1
7753                          * ret 0x42
7754                          * ret 0x66
7755                          */
7756                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0, 0, 1),
7757                         BPF_STMT(BPF_RET | BPF_K, 0x42),
7758                         BPF_STMT(BPF_RET | BPF_K, 0x66),
7759                 },
7760                 CLASSIC | FLAG_NO_DATA,
7761                 {},
7762                 { {0x1, 0x42 } },
7763         },
7764         {
7765                 "JMP EQ default X",
7766                 .u.insns = {
7767                         /*
7768                          * A = 0x0
7769                          * cmp A, X, 0, 1
7770                          * ret 0x42
7771                          * ret 0x66
7772                          */
7773                         BPF_STMT(BPF_LD | BPF_IMM, 0x0),
7774                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0x0, 0, 1),
7775                         BPF_STMT(BPF_RET | BPF_K, 0x42),
7776                         BPF_STMT(BPF_RET | BPF_K, 0x66),
7777                 },
7778                 CLASSIC | FLAG_NO_DATA,
7779                 {},
7780                 { {0x1, 0x42 } },
7781         },
7782         /* Checking interpreter vs JIT wrt signed extended imms. */
7783         {
7784                 "JNE signed compare, test 1",
7785                 .u.insns_int = {
7786                         BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
7787                         BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
7788                         BPF_MOV64_REG(R2, R1),
7789                         BPF_ALU64_REG(BPF_AND, R2, R3),
7790                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
7791                         BPF_JMP_IMM(BPF_JNE, R2, -17104896, 1),
7792                         BPF_ALU32_IMM(BPF_MOV, R0, 2),
7793                         BPF_EXIT_INSN(),
7794                 },
7795                 INTERNAL,
7796                 { },
7797                 { { 0, 1 } },
7798         },
7799         {
7800                 "JNE signed compare, test 2",
7801                 .u.insns_int = {
7802                         BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
7803                         BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
7804                         BPF_MOV64_REG(R2, R1),
7805                         BPF_ALU64_REG(BPF_AND, R2, R3),
7806                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
7807                         BPF_JMP_IMM(BPF_JNE, R2, 0xfefb0000, 1),
7808                         BPF_ALU32_IMM(BPF_MOV, R0, 2),
7809                         BPF_EXIT_INSN(),
7810                 },
7811                 INTERNAL,
7812                 { },
7813                 { { 0, 1 } },
7814         },
7815         {
7816                 "JNE signed compare, test 3",
7817                 .u.insns_int = {
7818                         BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
7819                         BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
7820                         BPF_ALU32_IMM(BPF_MOV, R4, 0xfefb0000),
7821                         BPF_MOV64_REG(R2, R1),
7822                         BPF_ALU64_REG(BPF_AND, R2, R3),
7823                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
7824                         BPF_JMP_REG(BPF_JNE, R2, R4, 1),
7825                         BPF_ALU32_IMM(BPF_MOV, R0, 2),
7826                         BPF_EXIT_INSN(),
7827                 },
7828                 INTERNAL,
7829                 { },
7830                 { { 0, 2 } },
7831         },
7832         {
7833                 "JNE signed compare, test 4",
7834                 .u.insns_int = {
7835                         BPF_LD_IMM64(R1, -17104896),
7836                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
7837                         BPF_JMP_IMM(BPF_JNE, R1, -17104896, 1),
7838                         BPF_ALU32_IMM(BPF_MOV, R0, 2),
7839                         BPF_EXIT_INSN(),
7840                 },
7841                 INTERNAL,
7842                 { },
7843                 { { 0, 2 } },
7844         },
7845         {
7846                 "JNE signed compare, test 5",
7847                 .u.insns_int = {
7848                         BPF_LD_IMM64(R1, 0xfefb0000),
7849                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
7850                         BPF_JMP_IMM(BPF_JNE, R1, 0xfefb0000, 1),
7851                         BPF_ALU32_IMM(BPF_MOV, R0, 2),
7852                         BPF_EXIT_INSN(),
7853                 },
7854                 INTERNAL,
7855                 { },
7856                 { { 0, 1 } },
7857         },
7858         {
7859                 "JNE signed compare, test 6",
7860                 .u.insns_int = {
7861                         BPF_LD_IMM64(R1, 0x7efb0000),
7862                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
7863                         BPF_JMP_IMM(BPF_JNE, R1, 0x7efb0000, 1),
7864                         BPF_ALU32_IMM(BPF_MOV, R0, 2),
7865                         BPF_EXIT_INSN(),
7866                 },
7867                 INTERNAL,
7868                 { },
7869                 { { 0, 2 } },
7870         },
7871         {
7872                 "JNE signed compare, test 7",
7873                 .u.insns = {
7874                         BPF_STMT(BPF_LD | BPF_IMM, 0xffff0000),
7875                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
7876                         BPF_STMT(BPF_LD | BPF_IMM, 0xfefbbc12),
7877                         BPF_STMT(BPF_ALU | BPF_AND | BPF_X, 0),
7878                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0xfefb0000, 1, 0),
7879                         BPF_STMT(BPF_RET | BPF_K, 1),
7880                         BPF_STMT(BPF_RET | BPF_K, 2),
7881                 },
7882                 CLASSIC | FLAG_NO_DATA,
7883                 {},
7884                 { { 0, 2 } },
7885         },
7886 };
7887
7888 static struct net_device dev;
7889
7890 static struct sk_buff *populate_skb(char *buf, int size)
7891 {
7892         struct sk_buff *skb;
7893
7894         if (size >= MAX_DATA)
7895                 return NULL;
7896
7897         skb = alloc_skb(MAX_DATA, GFP_KERNEL);
7898         if (!skb)
7899                 return NULL;
7900
7901         __skb_put_data(skb, buf, size);
7902
7903         /* Initialize a fake skb with test pattern. */
7904         skb_reset_mac_header(skb);
7905         skb->protocol = htons(ETH_P_IP);
7906         skb->pkt_type = SKB_TYPE;
7907         skb->mark = SKB_MARK;
7908         skb->hash = SKB_HASH;
7909         skb->queue_mapping = SKB_QUEUE_MAP;
7910         skb->vlan_tci = SKB_VLAN_TCI;
7911         skb->vlan_present = SKB_VLAN_PRESENT;
7912         skb->vlan_proto = htons(ETH_P_IP);
7913         dev_net_set(&dev, &init_net);
7914         skb->dev = &dev;
7915         skb->dev->ifindex = SKB_DEV_IFINDEX;
7916         skb->dev->type = SKB_DEV_TYPE;
7917         skb_set_network_header(skb, min(size, ETH_HLEN));
7918
7919         return skb;
7920 }
7921
7922 static void *generate_test_data(struct bpf_test *test, int sub)
7923 {
7924         struct sk_buff *skb;
7925         struct page *page;
7926
7927         if (test->aux & FLAG_NO_DATA)
7928                 return NULL;
7929
7930         /* Test case expects an skb, so populate one. Various
7931          * subtests generate skbs of different sizes based on
7932          * the same data.
7933          */
7934         skb = populate_skb(test->data, test->test[sub].data_size);
7935         if (!skb)
7936                 return NULL;
7937
7938         if (test->aux & FLAG_SKB_FRAG) {
7939                 /*
7940                  * when the test requires a fragmented skb, add a
7941                  * single fragment to the skb, filled with
7942                  * test->frag_data.
7943                  */
7944                 void *ptr;
7945
7946                 page = alloc_page(GFP_KERNEL);
7947
7948                 if (!page)
7949                         goto err_kfree_skb;
7950
7951                 ptr = kmap(page);
7952                 if (!ptr)
7953                         goto err_free_page;
7954                 memcpy(ptr, test->frag_data, MAX_DATA);
7955                 kunmap(page);
7956                 skb_add_rx_frag(skb, 0, page, 0, MAX_DATA, MAX_DATA);
7957         }
7958
7959         return skb;
7960
7961 err_free_page:
7962         __free_page(page);
7963 err_kfree_skb:
7964         kfree_skb(skb);
7965         return NULL;
7966 }
7967
7968 static void release_test_data(const struct bpf_test *test, void *data)
7969 {
7970         if (test->aux & FLAG_NO_DATA)
7971                 return;
7972
7973         kfree_skb(data);
7974 }
7975
7976 static int filter_length(int which)
7977 {
7978         struct sock_filter *fp;
7979         int len;
7980
7981         if (tests[which].fill_helper)
7982                 return tests[which].u.ptr.len;
7983
7984         fp = tests[which].u.insns;
7985         for (len = MAX_INSNS - 1; len > 0; --len)
7986                 if (fp[len].code != 0 || fp[len].k != 0)
7987                         break;
7988
7989         return len + 1;
7990 }
7991
7992 static void *filter_pointer(int which)
7993 {
7994         if (tests[which].fill_helper)
7995                 return tests[which].u.ptr.insns;
7996         else
7997                 return tests[which].u.insns;
7998 }
7999
8000 static struct bpf_prog *generate_filter(int which, int *err)
8001 {
8002         __u8 test_type = tests[which].aux & TEST_TYPE_MASK;
8003         unsigned int flen = filter_length(which);
8004         void *fptr = filter_pointer(which);
8005         struct sock_fprog_kern fprog;
8006         struct bpf_prog *fp;
8007
8008         switch (test_type) {
8009         case CLASSIC:
8010                 fprog.filter = fptr;
8011                 fprog.len = flen;
8012
8013                 *err = bpf_prog_create(&fp, &fprog);
8014                 if (tests[which].aux & FLAG_EXPECTED_FAIL) {
8015                         if (*err == tests[which].expected_errcode) {
8016                                 pr_cont("PASS\n");
8017                                 /* Verifier rejected filter as expected. */
8018                                 *err = 0;
8019                                 return NULL;
8020                         } else {
8021                                 pr_cont("UNEXPECTED_PASS\n");
8022                                 /* Verifier didn't reject the test that's
8023                                  * bad enough, just return!
8024                                  */
8025                                 *err = -EINVAL;
8026                                 return NULL;
8027                         }
8028                 }
8029                 if (*err) {
8030                         pr_cont("FAIL to prog_create err=%d len=%d\n",
8031                                 *err, fprog.len);
8032                         return NULL;
8033                 }
8034                 break;
8035
8036         case INTERNAL:
8037                 fp = bpf_prog_alloc(bpf_prog_size(flen), 0);
8038                 if (fp == NULL) {
8039                         pr_cont("UNEXPECTED_FAIL no memory left\n");
8040                         *err = -ENOMEM;
8041                         return NULL;
8042                 }
8043
8044                 fp->len = flen;
8045                 /* Type doesn't really matter here as long as it's not unspec. */
8046                 fp->type = BPF_PROG_TYPE_SOCKET_FILTER;
8047                 memcpy(fp->insnsi, fptr, fp->len * sizeof(struct bpf_insn));
8048                 fp->aux->stack_depth = tests[which].stack_depth;
8049
8050                 /* We cannot error here as we don't need type compatibility
8051                  * checks.
8052                  */
8053                 fp = bpf_prog_select_runtime(fp, err);
8054                 if (*err) {
8055                         pr_cont("FAIL to select_runtime err=%d\n", *err);
8056                         return NULL;
8057                 }
8058                 break;
8059         }
8060
8061         *err = 0;
8062         return fp;
8063 }
8064
8065 static void release_filter(struct bpf_prog *fp, int which)
8066 {
8067         __u8 test_type = tests[which].aux & TEST_TYPE_MASK;
8068
8069         switch (test_type) {
8070         case CLASSIC:
8071                 bpf_prog_destroy(fp);
8072                 break;
8073         case INTERNAL:
8074                 bpf_prog_free(fp);
8075                 break;
8076         }
8077 }
8078
8079 static int __run_one(const struct bpf_prog *fp, const void *data,
8080                      int runs, u64 *duration)
8081 {
8082         u64 start, finish;
8083         int ret = 0, i;
8084
8085         migrate_disable();
8086         start = ktime_get_ns();
8087
8088         for (i = 0; i < runs; i++)
8089                 ret = BPF_PROG_RUN(fp, data);
8090
8091         finish = ktime_get_ns();
8092         migrate_enable();
8093
8094         *duration = finish - start;
8095         do_div(*duration, runs);
8096
8097         return ret;
8098 }
8099
8100 static int run_one(const struct bpf_prog *fp, struct bpf_test *test)
8101 {
8102         int err_cnt = 0, i, runs = MAX_TESTRUNS;
8103
8104         for (i = 0; i < MAX_SUBTESTS; i++) {
8105                 void *data;
8106                 u64 duration;
8107                 u32 ret;
8108
8109                 /*
8110                  * NOTE: Several sub-tests may be present, in which case
8111                  * a zero {data_size, result} tuple indicates the end of
8112                  * the sub-test array. The first test is always run,
8113                  * even if both data_size and result happen to be zero.
8114                  */
8115                 if (i > 0 &&
8116                     test->test[i].data_size == 0 &&
8117                     test->test[i].result == 0)
8118                         break;
8119
8120                 data = generate_test_data(test, i);
8121                 if (!data && !(test->aux & FLAG_NO_DATA)) {
8122                         pr_cont("data generation failed ");
8123                         err_cnt++;
8124                         break;
8125                 }
8126                 ret = __run_one(fp, data, runs, &duration);
8127                 release_test_data(test, data);
8128
8129                 if (ret == test->test[i].result) {
8130                         pr_cont("%lld ", duration);
8131                 } else {
8132                         pr_cont("ret %d != %d ", ret,
8133                                 test->test[i].result);
8134                         err_cnt++;
8135                 }
8136         }
8137
8138         return err_cnt;
8139 }
8140
8141 static char test_name[64];
8142 module_param_string(test_name, test_name, sizeof(test_name), 0);
8143
8144 static int test_id = -1;
8145 module_param(test_id, int, 0);
8146
8147 static int test_range[2] = { 0, ARRAY_SIZE(tests) - 1 };
8148 module_param_array(test_range, int, NULL, 0);
8149
8150 static __init int find_test_index(const char *test_name)
8151 {
8152         int i;
8153
8154         for (i = 0; i < ARRAY_SIZE(tests); i++) {
8155                 if (!strcmp(tests[i].descr, test_name))
8156                         return i;
8157         }
8158         return -1;
8159 }
8160
8161 static __init int prepare_bpf_tests(void)
8162 {
8163         int i;
8164
8165         if (test_id >= 0) {
8166                 /*
8167                  * if a test_id was specified, use test_range to
8168                  * cover only that test.
8169                  */
8170                 if (test_id >= ARRAY_SIZE(tests)) {
8171                         pr_err("test_bpf: invalid test_id specified.\n");
8172                         return -EINVAL;
8173                 }
8174
8175                 test_range[0] = test_id;
8176                 test_range[1] = test_id;
8177         } else if (*test_name) {
8178                 /*
8179                  * if a test_name was specified, find it and setup
8180                  * test_range to cover only that test.
8181                  */
8182                 int idx = find_test_index(test_name);
8183
8184                 if (idx < 0) {
8185                         pr_err("test_bpf: no test named '%s' found.\n",
8186                                test_name);
8187                         return -EINVAL;
8188                 }
8189                 test_range[0] = idx;
8190                 test_range[1] = idx;
8191         } else {
8192                 /*
8193                  * check that the supplied test_range is valid.
8194                  */
8195                 if (test_range[0] >= ARRAY_SIZE(tests) ||
8196                     test_range[1] >= ARRAY_SIZE(tests) ||
8197                     test_range[0] < 0 || test_range[1] < 0) {
8198                         pr_err("test_bpf: test_range is out of bound.\n");
8199                         return -EINVAL;
8200                 }
8201
8202                 if (test_range[1] < test_range[0]) {
8203                         pr_err("test_bpf: test_range is ending before it starts.\n");
8204                         return -EINVAL;
8205                 }
8206         }
8207
8208         for (i = 0; i < ARRAY_SIZE(tests); i++) {
8209                 if (tests[i].fill_helper &&
8210                     tests[i].fill_helper(&tests[i]) < 0)
8211                         return -ENOMEM;
8212         }
8213
8214         return 0;
8215 }
8216
8217 static __init void destroy_bpf_tests(void)
8218 {
8219         int i;
8220
8221         for (i = 0; i < ARRAY_SIZE(tests); i++) {
8222                 if (tests[i].fill_helper)
8223                         kfree(tests[i].u.ptr.insns);
8224         }
8225 }
8226
8227 static bool exclude_test(int test_id)
8228 {
8229         return test_id < test_range[0] || test_id > test_range[1];
8230 }
8231
8232 static __init struct sk_buff *build_test_skb(void)
8233 {
8234         u32 headroom = NET_SKB_PAD + NET_IP_ALIGN + ETH_HLEN;
8235         struct sk_buff *skb[2];
8236         struct page *page[2];
8237         int i, data_size = 8;
8238
8239         for (i = 0; i < 2; i++) {
8240                 page[i] = alloc_page(GFP_KERNEL);
8241                 if (!page[i]) {
8242                         if (i == 0)
8243                                 goto err_page0;
8244                         else
8245                                 goto err_page1;
8246                 }
8247
8248                 /* this will set skb[i]->head_frag */
8249                 skb[i] = dev_alloc_skb(headroom + data_size);
8250                 if (!skb[i]) {
8251                         if (i == 0)
8252                                 goto err_skb0;
8253                         else
8254                                 goto err_skb1;
8255                 }
8256
8257                 skb_reserve(skb[i], headroom);
8258                 skb_put(skb[i], data_size);
8259                 skb[i]->protocol = htons(ETH_P_IP);
8260                 skb_reset_network_header(skb[i]);
8261                 skb_set_mac_header(skb[i], -ETH_HLEN);
8262
8263                 skb_add_rx_frag(skb[i], 0, page[i], 0, 64, 64);
8264                 // skb_headlen(skb[i]): 8, skb[i]->head_frag = 1
8265         }
8266
8267         /* setup shinfo */
8268         skb_shinfo(skb[0])->gso_size = 1448;
8269         skb_shinfo(skb[0])->gso_type = SKB_GSO_TCPV4;
8270         skb_shinfo(skb[0])->gso_type |= SKB_GSO_DODGY;
8271         skb_shinfo(skb[0])->gso_segs = 0;
8272         skb_shinfo(skb[0])->frag_list = skb[1];
8273
8274         /* adjust skb[0]'s len */
8275         skb[0]->len += skb[1]->len;
8276         skb[0]->data_len += skb[1]->data_len;
8277         skb[0]->truesize += skb[1]->truesize;
8278
8279         return skb[0];
8280
8281 err_skb1:
8282         __free_page(page[1]);
8283 err_page1:
8284         kfree_skb(skb[0]);
8285 err_skb0:
8286         __free_page(page[0]);
8287 err_page0:
8288         return NULL;
8289 }
8290
8291 static __init struct sk_buff *build_test_skb_linear_no_head_frag(void)
8292 {
8293         unsigned int alloc_size = 2000;
8294         unsigned int headroom = 102, doffset = 72, data_size = 1308;
8295         struct sk_buff *skb[2];
8296         int i;
8297
8298         /* skbs linked in a frag_list, both with linear data, with head_frag=0
8299          * (data allocated by kmalloc), both have tcp data of 1308 bytes
8300          * (total payload is 2616 bytes).
8301          * Data offset is 72 bytes (40 ipv6 hdr, 32 tcp hdr). Some headroom.
8302          */
8303         for (i = 0; i < 2; i++) {
8304                 skb[i] = alloc_skb(alloc_size, GFP_KERNEL);
8305                 if (!skb[i]) {
8306                         if (i == 0)
8307                                 goto err_skb0;
8308                         else
8309                                 goto err_skb1;
8310                 }
8311
8312                 skb[i]->protocol = htons(ETH_P_IPV6);
8313                 skb_reserve(skb[i], headroom);
8314                 skb_put(skb[i], doffset + data_size);
8315                 skb_reset_network_header(skb[i]);
8316                 if (i == 0)
8317                         skb_reset_mac_header(skb[i]);
8318                 else
8319                         skb_set_mac_header(skb[i], -ETH_HLEN);
8320                 __skb_pull(skb[i], doffset);
8321         }
8322
8323         /* setup shinfo.
8324          * mimic bpf_skb_proto_4_to_6, which resets gso_segs and assigns a
8325          * reduced gso_size.
8326          */
8327         skb_shinfo(skb[0])->gso_size = 1288;
8328         skb_shinfo(skb[0])->gso_type = SKB_GSO_TCPV6 | SKB_GSO_DODGY;
8329         skb_shinfo(skb[0])->gso_segs = 0;
8330         skb_shinfo(skb[0])->frag_list = skb[1];
8331
8332         /* adjust skb[0]'s len */
8333         skb[0]->len += skb[1]->len;
8334         skb[0]->data_len += skb[1]->len;
8335         skb[0]->truesize += skb[1]->truesize;
8336
8337         return skb[0];
8338
8339 err_skb1:
8340         kfree_skb(skb[0]);
8341 err_skb0:
8342         return NULL;
8343 }
8344
8345 struct skb_segment_test {
8346         const char *descr;
8347         struct sk_buff *(*build_skb)(void);
8348         netdev_features_t features;
8349 };
8350
8351 static struct skb_segment_test skb_segment_tests[] __initconst = {
8352         {
8353                 .descr = "gso_with_rx_frags",
8354                 .build_skb = build_test_skb,
8355                 .features = NETIF_F_SG | NETIF_F_GSO_PARTIAL | NETIF_F_IP_CSUM |
8356                             NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM
8357         },
8358         {
8359                 .descr = "gso_linear_no_head_frag",
8360                 .build_skb = build_test_skb_linear_no_head_frag,
8361                 .features = NETIF_F_SG | NETIF_F_FRAGLIST |
8362                             NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_GSO |
8363                             NETIF_F_LLTX_BIT | NETIF_F_GRO |
8364                             NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM |
8365                             NETIF_F_HW_VLAN_STAG_TX_BIT
8366         }
8367 };
8368
8369 static __init int test_skb_segment_single(const struct skb_segment_test *test)
8370 {
8371         struct sk_buff *skb, *segs;
8372         int ret = -1;
8373
8374         skb = test->build_skb();
8375         if (!skb) {
8376                 pr_info("%s: failed to build_test_skb", __func__);
8377                 goto done;
8378         }
8379
8380         segs = skb_segment(skb, test->features);
8381         if (!IS_ERR(segs)) {
8382                 kfree_skb_list(segs);
8383                 ret = 0;
8384         }
8385         kfree_skb(skb);
8386 done:
8387         return ret;
8388 }
8389
8390 static __init int test_skb_segment(void)
8391 {
8392         int i, err_cnt = 0, pass_cnt = 0;
8393
8394         for (i = 0; i < ARRAY_SIZE(skb_segment_tests); i++) {
8395                 const struct skb_segment_test *test = &skb_segment_tests[i];
8396
8397                 pr_info("#%d %s ", i, test->descr);
8398
8399                 if (test_skb_segment_single(test)) {
8400                         pr_cont("FAIL\n");
8401                         err_cnt++;
8402                 } else {
8403                         pr_cont("PASS\n");
8404                         pass_cnt++;
8405                 }
8406         }
8407
8408         pr_info("%s: Summary: %d PASSED, %d FAILED\n", __func__,
8409                 pass_cnt, err_cnt);
8410         return err_cnt ? -EINVAL : 0;
8411 }
8412
8413 static __init int test_bpf(void)
8414 {
8415         int i, err_cnt = 0, pass_cnt = 0;
8416         int jit_cnt = 0, run_cnt = 0;
8417
8418         for (i = 0; i < ARRAY_SIZE(tests); i++) {
8419                 struct bpf_prog *fp;
8420                 int err;
8421
8422                 cond_resched();
8423                 if (exclude_test(i))
8424                         continue;
8425
8426                 pr_info("#%d %s ", i, tests[i].descr);
8427
8428                 fp = generate_filter(i, &err);
8429                 if (fp == NULL) {
8430                         if (err == 0) {
8431                                 pass_cnt++;
8432                                 continue;
8433                         }
8434                         err_cnt++;
8435                         continue;
8436                 }
8437
8438                 pr_cont("jited:%u ", fp->jited);
8439
8440                 run_cnt++;
8441                 if (fp->jited)
8442                         jit_cnt++;
8443
8444                 err = run_one(fp, &tests[i]);
8445                 release_filter(fp, i);
8446
8447                 if (err) {
8448                         pr_cont("FAIL (%d times)\n", err);
8449                         err_cnt++;
8450                 } else {
8451                         pr_cont("PASS\n");
8452                         pass_cnt++;
8453                 }
8454         }
8455
8456         pr_info("Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n",
8457                 pass_cnt, err_cnt, jit_cnt, run_cnt);
8458
8459         return err_cnt ? -EINVAL : 0;
8460 }
8461
8462 static int __init test_bpf_init(void)
8463 {
8464         int ret;
8465
8466         ret = prepare_bpf_tests();
8467         if (ret < 0)
8468                 return ret;
8469
8470         ret = test_bpf();
8471         destroy_bpf_tests();
8472         if (ret)
8473                 return ret;
8474
8475         return test_skb_segment();
8476 }
8477
8478 static void __exit test_bpf_exit(void)
8479 {
8480 }
8481
8482 module_init(test_bpf_init);
8483 module_exit(test_bpf_exit);
8484
8485 MODULE_LICENSE("GPL");