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