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 #ifdef CONFIG_32BIT
2096         {
2097                 "INT: 32-bit context pointer word order and zero-extension",
2098                 .u.insns_int = {
2099                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
2100                         BPF_JMP32_IMM(BPF_JEQ, R1, 0, 3),
2101                         BPF_ALU64_IMM(BPF_RSH, R1, 32),
2102                         BPF_JMP32_IMM(BPF_JNE, R1, 0, 1),
2103                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
2104                         BPF_EXIT_INSN(),
2105                 },
2106                 INTERNAL,
2107                 { },
2108                 { { 0, 1 } }
2109         },
2110 #endif
2111         {
2112                 "check: missing ret",
2113                 .u.insns = {
2114                         BPF_STMT(BPF_LD | BPF_IMM, 1),
2115                 },
2116                 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2117                 { },
2118                 { },
2119                 .fill_helper = NULL,
2120                 .expected_errcode = -EINVAL,
2121         },
2122         {
2123                 "check: div_k_0",
2124                 .u.insns = {
2125                         BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0),
2126                         BPF_STMT(BPF_RET | BPF_K, 0)
2127                 },
2128                 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2129                 { },
2130                 { },
2131                 .fill_helper = NULL,
2132                 .expected_errcode = -EINVAL,
2133         },
2134         {
2135                 "check: unknown insn",
2136                 .u.insns = {
2137                         /* seccomp insn, rejected in socket filter */
2138                         BPF_STMT(BPF_LDX | BPF_W | BPF_ABS, 0),
2139                         BPF_STMT(BPF_RET | BPF_K, 0)
2140                 },
2141                 CLASSIC | FLAG_EXPECTED_FAIL,
2142                 { },
2143                 { },
2144                 .fill_helper = NULL,
2145                 .expected_errcode = -EINVAL,
2146         },
2147         {
2148                 "check: out of range spill/fill",
2149                 .u.insns = {
2150                         BPF_STMT(BPF_STX, 16),
2151                         BPF_STMT(BPF_RET | BPF_K, 0)
2152                 },
2153                 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2154                 { },
2155                 { },
2156                 .fill_helper = NULL,
2157                 .expected_errcode = -EINVAL,
2158         },
2159         {
2160                 "JUMPS + HOLES",
2161                 .u.insns = {
2162                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2163                         BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 15),
2164                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2165                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2166                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
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_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 3, 4),
2178                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2179                         BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 1, 2),
2180                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2181                         BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
2182                         BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
2183                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2184                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
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_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 2, 3),
2197                         BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 1, 2),
2198                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2199                         BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
2200                         BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
2201                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2202                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2203                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2204                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2205                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2206                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2207                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2208                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2209                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2210                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2211                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2212                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2213                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2214                         BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 2, 3),
2215                         BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 1, 2),
2216                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2217                         BPF_STMT(BPF_RET | BPF_A, 0),
2218                         BPF_STMT(BPF_RET | BPF_A, 0),
2219                 },
2220                 CLASSIC,
2221                 { 0x00, 0x1b, 0x21, 0x3c, 0x9d, 0xf8,
2222                   0x90, 0xe2, 0xba, 0x0a, 0x56, 0xb4,
2223                   0x08, 0x00,
2224                   0x45, 0x00, 0x00, 0x28, 0x00, 0x00,
2225                   0x20, 0x00, 0x40, 0x11, 0x00, 0x00, /* IP header */
2226                   0xc0, 0xa8, 0x33, 0x01,
2227                   0xc0, 0xa8, 0x33, 0x02,
2228                   0xbb, 0xb6,
2229                   0xa9, 0xfa,
2230                   0x00, 0x14, 0x00, 0x00,
2231                   0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2232                   0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2233                   0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2234                   0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2235                   0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2236                   0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2237                   0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2238                   0xcc, 0xcc, 0xcc, 0xcc },
2239                 { { 88, 0x001b } }
2240         },
2241         {
2242                 "check: RET X",
2243                 .u.insns = {
2244                         BPF_STMT(BPF_RET | BPF_X, 0),
2245                 },
2246                 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2247                 { },
2248                 { },
2249                 .fill_helper = NULL,
2250                 .expected_errcode = -EINVAL,
2251         },
2252         {
2253                 "check: LDX + RET X",
2254                 .u.insns = {
2255                         BPF_STMT(BPF_LDX | BPF_IMM, 42),
2256                         BPF_STMT(BPF_RET | BPF_X, 0),
2257                 },
2258                 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2259                 { },
2260                 { },
2261                 .fill_helper = NULL,
2262                 .expected_errcode = -EINVAL,
2263         },
2264         {       /* Mainly checking JIT here. */
2265                 "M[]: alt STX + LDX",
2266                 .u.insns = {
2267                         BPF_STMT(BPF_LDX | BPF_IMM, 100),
2268                         BPF_STMT(BPF_STX, 0),
2269                         BPF_STMT(BPF_LDX | BPF_MEM, 0),
2270                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2271                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2272                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2273                         BPF_STMT(BPF_STX, 1),
2274                         BPF_STMT(BPF_LDX | BPF_MEM, 1),
2275                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2276                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2277                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2278                         BPF_STMT(BPF_STX, 2),
2279                         BPF_STMT(BPF_LDX | BPF_MEM, 2),
2280                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2281                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2282                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2283                         BPF_STMT(BPF_STX, 3),
2284                         BPF_STMT(BPF_LDX | BPF_MEM, 3),
2285                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2286                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2287                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2288                         BPF_STMT(BPF_STX, 4),
2289                         BPF_STMT(BPF_LDX | BPF_MEM, 4),
2290                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2291                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2292                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2293                         BPF_STMT(BPF_STX, 5),
2294                         BPF_STMT(BPF_LDX | BPF_MEM, 5),
2295                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2296                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2297                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2298                         BPF_STMT(BPF_STX, 6),
2299                         BPF_STMT(BPF_LDX | BPF_MEM, 6),
2300                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2301                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2302                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2303                         BPF_STMT(BPF_STX, 7),
2304                         BPF_STMT(BPF_LDX | BPF_MEM, 7),
2305                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2306                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2307                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2308                         BPF_STMT(BPF_STX, 8),
2309                         BPF_STMT(BPF_LDX | BPF_MEM, 8),
2310                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2311                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2312                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2313                         BPF_STMT(BPF_STX, 9),
2314                         BPF_STMT(BPF_LDX | BPF_MEM, 9),
2315                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2316                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2317                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2318                         BPF_STMT(BPF_STX, 10),
2319                         BPF_STMT(BPF_LDX | BPF_MEM, 10),
2320                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2321                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2322                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2323                         BPF_STMT(BPF_STX, 11),
2324                         BPF_STMT(BPF_LDX | BPF_MEM, 11),
2325                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2326                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2327                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2328                         BPF_STMT(BPF_STX, 12),
2329                         BPF_STMT(BPF_LDX | BPF_MEM, 12),
2330                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2331                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2332                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2333                         BPF_STMT(BPF_STX, 13),
2334                         BPF_STMT(BPF_LDX | BPF_MEM, 13),
2335                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2336                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2337                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2338                         BPF_STMT(BPF_STX, 14),
2339                         BPF_STMT(BPF_LDX | BPF_MEM, 14),
2340                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2341                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2342                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2343                         BPF_STMT(BPF_STX, 15),
2344                         BPF_STMT(BPF_LDX | BPF_MEM, 15),
2345                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2346                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2347                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
2348                         BPF_STMT(BPF_RET | BPF_A, 0),
2349                 },
2350                 CLASSIC | FLAG_NO_DATA,
2351                 { },
2352                 { { 0, 116 } },
2353         },
2354         {       /* Mainly checking JIT here. */
2355                 "M[]: full STX + full LDX",
2356                 .u.insns = {
2357                         BPF_STMT(BPF_LDX | BPF_IMM, 0xbadfeedb),
2358                         BPF_STMT(BPF_STX, 0),
2359                         BPF_STMT(BPF_LDX | BPF_IMM, 0xecabedae),
2360                         BPF_STMT(BPF_STX, 1),
2361                         BPF_STMT(BPF_LDX | BPF_IMM, 0xafccfeaf),
2362                         BPF_STMT(BPF_STX, 2),
2363                         BPF_STMT(BPF_LDX | BPF_IMM, 0xbffdcedc),
2364                         BPF_STMT(BPF_STX, 3),
2365                         BPF_STMT(BPF_LDX | BPF_IMM, 0xfbbbdccb),
2366                         BPF_STMT(BPF_STX, 4),
2367                         BPF_STMT(BPF_LDX | BPF_IMM, 0xfbabcbda),
2368                         BPF_STMT(BPF_STX, 5),
2369                         BPF_STMT(BPF_LDX | BPF_IMM, 0xaedecbdb),
2370                         BPF_STMT(BPF_STX, 6),
2371                         BPF_STMT(BPF_LDX | BPF_IMM, 0xadebbade),
2372                         BPF_STMT(BPF_STX, 7),
2373                         BPF_STMT(BPF_LDX | BPF_IMM, 0xfcfcfaec),
2374                         BPF_STMT(BPF_STX, 8),
2375                         BPF_STMT(BPF_LDX | BPF_IMM, 0xbcdddbdc),
2376                         BPF_STMT(BPF_STX, 9),
2377                         BPF_STMT(BPF_LDX | BPF_IMM, 0xfeefdfac),
2378                         BPF_STMT(BPF_STX, 10),
2379                         BPF_STMT(BPF_LDX | BPF_IMM, 0xcddcdeea),
2380                         BPF_STMT(BPF_STX, 11),
2381                         BPF_STMT(BPF_LDX | BPF_IMM, 0xaccfaebb),
2382                         BPF_STMT(BPF_STX, 12),
2383                         BPF_STMT(BPF_LDX | BPF_IMM, 0xbdcccdcf),
2384                         BPF_STMT(BPF_STX, 13),
2385                         BPF_STMT(BPF_LDX | BPF_IMM, 0xaaedecde),
2386                         BPF_STMT(BPF_STX, 14),
2387                         BPF_STMT(BPF_LDX | BPF_IMM, 0xfaeacdad),
2388                         BPF_STMT(BPF_STX, 15),
2389                         BPF_STMT(BPF_LDX | BPF_MEM, 0),
2390                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
2391                         BPF_STMT(BPF_LDX | BPF_MEM, 1),
2392                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2393                         BPF_STMT(BPF_LDX | BPF_MEM, 2),
2394                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2395                         BPF_STMT(BPF_LDX | BPF_MEM, 3),
2396                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2397                         BPF_STMT(BPF_LDX | BPF_MEM, 4),
2398                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2399                         BPF_STMT(BPF_LDX | BPF_MEM, 5),
2400                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2401                         BPF_STMT(BPF_LDX | BPF_MEM, 6),
2402                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2403                         BPF_STMT(BPF_LDX | BPF_MEM, 7),
2404                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2405                         BPF_STMT(BPF_LDX | BPF_MEM, 8),
2406                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2407                         BPF_STMT(BPF_LDX | BPF_MEM, 9),
2408                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2409                         BPF_STMT(BPF_LDX | BPF_MEM, 10),
2410                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2411                         BPF_STMT(BPF_LDX | BPF_MEM, 11),
2412                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2413                         BPF_STMT(BPF_LDX | BPF_MEM, 12),
2414                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2415                         BPF_STMT(BPF_LDX | BPF_MEM, 13),
2416                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2417                         BPF_STMT(BPF_LDX | BPF_MEM, 14),
2418                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2419                         BPF_STMT(BPF_LDX | BPF_MEM, 15),
2420                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2421                         BPF_STMT(BPF_RET | BPF_A, 0),
2422                 },
2423                 CLASSIC | FLAG_NO_DATA,
2424                 { },
2425                 { { 0, 0x2a5a5e5 } },
2426         },
2427         {
2428                 "check: SKF_AD_MAX",
2429                 .u.insns = {
2430                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2431                                  SKF_AD_OFF + SKF_AD_MAX),
2432                         BPF_STMT(BPF_RET | BPF_A, 0),
2433                 },
2434                 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2435                 { },
2436                 { },
2437                 .fill_helper = NULL,
2438                 .expected_errcode = -EINVAL,
2439         },
2440         {       /* Passes checker but fails during runtime. */
2441                 "LD [SKF_AD_OFF-1]",
2442                 .u.insns = {
2443                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2444                                  SKF_AD_OFF - 1),
2445                         BPF_STMT(BPF_RET | BPF_K, 1),
2446                 },
2447                 CLASSIC,
2448                 { },
2449                 { { 1, 0 } },
2450         },
2451         {
2452                 "load 64-bit immediate",
2453                 .u.insns_int = {
2454                         BPF_LD_IMM64(R1, 0x567800001234LL),
2455                         BPF_MOV64_REG(R2, R1),
2456                         BPF_MOV64_REG(R3, R2),
2457                         BPF_ALU64_IMM(BPF_RSH, R2, 32),
2458                         BPF_ALU64_IMM(BPF_LSH, R3, 32),
2459                         BPF_ALU64_IMM(BPF_RSH, R3, 32),
2460                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
2461                         BPF_JMP_IMM(BPF_JEQ, R2, 0x5678, 1),
2462                         BPF_EXIT_INSN(),
2463                         BPF_JMP_IMM(BPF_JEQ, R3, 0x1234, 1),
2464                         BPF_EXIT_INSN(),
2465                         BPF_LD_IMM64(R0, 0x1ffffffffLL),
2466                         BPF_ALU64_IMM(BPF_RSH, R0, 32), /* R0 = 1 */
2467                         BPF_EXIT_INSN(),
2468                 },
2469                 INTERNAL,
2470                 { },
2471                 { { 0, 1 } }
2472         },
2473         /* BPF_ALU | BPF_MOV | BPF_X */
2474         {
2475                 "ALU_MOV_X: dst = 2",
2476                 .u.insns_int = {
2477                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
2478                         BPF_ALU32_REG(BPF_MOV, R0, R1),
2479                         BPF_EXIT_INSN(),
2480                 },
2481                 INTERNAL,
2482                 { },
2483                 { { 0, 2 } },
2484         },
2485         {
2486                 "ALU_MOV_X: dst = 4294967295",
2487                 .u.insns_int = {
2488                         BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
2489                         BPF_ALU32_REG(BPF_MOV, R0, R1),
2490                         BPF_EXIT_INSN(),
2491                 },
2492                 INTERNAL,
2493                 { },
2494                 { { 0, 4294967295U } },
2495         },
2496         {
2497                 "ALU64_MOV_X: dst = 2",
2498                 .u.insns_int = {
2499                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
2500                         BPF_ALU64_REG(BPF_MOV, R0, R1),
2501                         BPF_EXIT_INSN(),
2502                 },
2503                 INTERNAL,
2504                 { },
2505                 { { 0, 2 } },
2506         },
2507         {
2508                 "ALU64_MOV_X: dst = 4294967295",
2509                 .u.insns_int = {
2510                         BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
2511                         BPF_ALU64_REG(BPF_MOV, R0, R1),
2512                         BPF_EXIT_INSN(),
2513                 },
2514                 INTERNAL,
2515                 { },
2516                 { { 0, 4294967295U } },
2517         },
2518         /* BPF_ALU | BPF_MOV | BPF_K */
2519         {
2520                 "ALU_MOV_K: dst = 2",
2521                 .u.insns_int = {
2522                         BPF_ALU32_IMM(BPF_MOV, R0, 2),
2523                         BPF_EXIT_INSN(),
2524                 },
2525                 INTERNAL,
2526                 { },
2527                 { { 0, 2 } },
2528         },
2529         {
2530                 "ALU_MOV_K: dst = 4294967295",
2531                 .u.insns_int = {
2532                         BPF_ALU32_IMM(BPF_MOV, R0, 4294967295U),
2533                         BPF_EXIT_INSN(),
2534                 },
2535                 INTERNAL,
2536                 { },
2537                 { { 0, 4294967295U } },
2538         },
2539         {
2540                 "ALU_MOV_K: 0x0000ffffffff0000 = 0x00000000ffffffff",
2541                 .u.insns_int = {
2542                         BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
2543                         BPF_LD_IMM64(R3, 0x00000000ffffffffLL),
2544                         BPF_ALU32_IMM(BPF_MOV, R2, 0xffffffff),
2545                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2546                         BPF_MOV32_IMM(R0, 2),
2547                         BPF_EXIT_INSN(),
2548                         BPF_MOV32_IMM(R0, 1),
2549                         BPF_EXIT_INSN(),
2550                 },
2551                 INTERNAL,
2552                 { },
2553                 { { 0, 0x1 } },
2554         },
2555         {
2556                 "ALU_MOV_K: small negative",
2557                 .u.insns_int = {
2558                         BPF_ALU32_IMM(BPF_MOV, R0, -123),
2559                         BPF_EXIT_INSN(),
2560                 },
2561                 INTERNAL,
2562                 { },
2563                 { { 0, -123 } }
2564         },
2565         {
2566                 "ALU_MOV_K: small negative zero extension",
2567                 .u.insns_int = {
2568                         BPF_ALU32_IMM(BPF_MOV, R0, -123),
2569                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
2570                         BPF_EXIT_INSN(),
2571                 },
2572                 INTERNAL,
2573                 { },
2574                 { { 0, 0 } }
2575         },
2576         {
2577                 "ALU_MOV_K: large negative",
2578                 .u.insns_int = {
2579                         BPF_ALU32_IMM(BPF_MOV, R0, -123456789),
2580                         BPF_EXIT_INSN(),
2581                 },
2582                 INTERNAL,
2583                 { },
2584                 { { 0, -123456789 } }
2585         },
2586         {
2587                 "ALU_MOV_K: large negative zero extension",
2588                 .u.insns_int = {
2589                         BPF_ALU32_IMM(BPF_MOV, R0, -123456789),
2590                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
2591                         BPF_EXIT_INSN(),
2592                 },
2593                 INTERNAL,
2594                 { },
2595                 { { 0, 0 } }
2596         },
2597         {
2598                 "ALU64_MOV_K: dst = 2",
2599                 .u.insns_int = {
2600                         BPF_ALU64_IMM(BPF_MOV, R0, 2),
2601                         BPF_EXIT_INSN(),
2602                 },
2603                 INTERNAL,
2604                 { },
2605                 { { 0, 2 } },
2606         },
2607         {
2608                 "ALU64_MOV_K: dst = 2147483647",
2609                 .u.insns_int = {
2610                         BPF_ALU64_IMM(BPF_MOV, R0, 2147483647),
2611                         BPF_EXIT_INSN(),
2612                 },
2613                 INTERNAL,
2614                 { },
2615                 { { 0, 2147483647 } },
2616         },
2617         {
2618                 "ALU64_OR_K: dst = 0x0",
2619                 .u.insns_int = {
2620                         BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
2621                         BPF_LD_IMM64(R3, 0x0),
2622                         BPF_ALU64_IMM(BPF_MOV, R2, 0x0),
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: dst = -1",
2635                 .u.insns_int = {
2636                         BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
2637                         BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
2638                         BPF_ALU64_IMM(BPF_MOV, R2, 0xffffffff),
2639                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2640                         BPF_MOV32_IMM(R0, 2),
2641                         BPF_EXIT_INSN(),
2642                         BPF_MOV32_IMM(R0, 1),
2643                         BPF_EXIT_INSN(),
2644                 },
2645                 INTERNAL,
2646                 { },
2647                 { { 0, 0x1 } },
2648         },
2649         {
2650                 "ALU64_MOV_K: small negative",
2651                 .u.insns_int = {
2652                         BPF_ALU64_IMM(BPF_MOV, R0, -123),
2653                         BPF_EXIT_INSN(),
2654                 },
2655                 INTERNAL,
2656                 { },
2657                 { { 0, -123 } }
2658         },
2659         {
2660                 "ALU64_MOV_K: small negative sign extension",
2661                 .u.insns_int = {
2662                         BPF_ALU64_IMM(BPF_MOV, R0, -123),
2663                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
2664                         BPF_EXIT_INSN(),
2665                 },
2666                 INTERNAL,
2667                 { },
2668                 { { 0, 0xffffffff } }
2669         },
2670         {
2671                 "ALU64_MOV_K: large negative",
2672                 .u.insns_int = {
2673                         BPF_ALU64_IMM(BPF_MOV, R0, -123456789),
2674                         BPF_EXIT_INSN(),
2675                 },
2676                 INTERNAL,
2677                 { },
2678                 { { 0, -123456789 } }
2679         },
2680         {
2681                 "ALU64_MOV_K: large negative sign extension",
2682                 .u.insns_int = {
2683                         BPF_ALU64_IMM(BPF_MOV, R0, -123456789),
2684                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
2685                         BPF_EXIT_INSN(),
2686                 },
2687                 INTERNAL,
2688                 { },
2689                 { { 0, 0xffffffff } }
2690         },
2691         /* BPF_ALU | BPF_ADD | BPF_X */
2692         {
2693                 "ALU_ADD_X: 1 + 2 = 3",
2694                 .u.insns_int = {
2695                         BPF_LD_IMM64(R0, 1),
2696                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
2697                         BPF_ALU32_REG(BPF_ADD, R0, R1),
2698                         BPF_EXIT_INSN(),
2699                 },
2700                 INTERNAL,
2701                 { },
2702                 { { 0, 3 } },
2703         },
2704         {
2705                 "ALU_ADD_X: 1 + 4294967294 = 4294967295",
2706                 .u.insns_int = {
2707                         BPF_LD_IMM64(R0, 1),
2708                         BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
2709                         BPF_ALU32_REG(BPF_ADD, R0, R1),
2710                         BPF_EXIT_INSN(),
2711                 },
2712                 INTERNAL,
2713                 { },
2714                 { { 0, 4294967295U } },
2715         },
2716         {
2717                 "ALU_ADD_X: 2 + 4294967294 = 0",
2718                 .u.insns_int = {
2719                         BPF_LD_IMM64(R0, 2),
2720                         BPF_LD_IMM64(R1, 4294967294U),
2721                         BPF_ALU32_REG(BPF_ADD, R0, R1),
2722                         BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
2723                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
2724                         BPF_EXIT_INSN(),
2725                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
2726                         BPF_EXIT_INSN(),
2727                 },
2728                 INTERNAL,
2729                 { },
2730                 { { 0, 1 } },
2731         },
2732         {
2733                 "ALU64_ADD_X: 1 + 2 = 3",
2734                 .u.insns_int = {
2735                         BPF_LD_IMM64(R0, 1),
2736                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
2737                         BPF_ALU64_REG(BPF_ADD, R0, R1),
2738                         BPF_EXIT_INSN(),
2739                 },
2740                 INTERNAL,
2741                 { },
2742                 { { 0, 3 } },
2743         },
2744         {
2745                 "ALU64_ADD_X: 1 + 4294967294 = 4294967295",
2746                 .u.insns_int = {
2747                         BPF_LD_IMM64(R0, 1),
2748                         BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
2749                         BPF_ALU64_REG(BPF_ADD, R0, R1),
2750                         BPF_EXIT_INSN(),
2751                 },
2752                 INTERNAL,
2753                 { },
2754                 { { 0, 4294967295U } },
2755         },
2756         {
2757                 "ALU64_ADD_X: 2 + 4294967294 = 4294967296",
2758                 .u.insns_int = {
2759                         BPF_LD_IMM64(R0, 2),
2760                         BPF_LD_IMM64(R1, 4294967294U),
2761                         BPF_LD_IMM64(R2, 4294967296ULL),
2762                         BPF_ALU64_REG(BPF_ADD, R0, R1),
2763                         BPF_JMP_REG(BPF_JEQ, R0, R2, 2),
2764                         BPF_MOV32_IMM(R0, 0),
2765                         BPF_EXIT_INSN(),
2766                         BPF_MOV32_IMM(R0, 1),
2767                         BPF_EXIT_INSN(),
2768                 },
2769                 INTERNAL,
2770                 { },
2771                 { { 0, 1 } },
2772         },
2773         /* BPF_ALU | BPF_ADD | BPF_K */
2774         {
2775                 "ALU_ADD_K: 1 + 2 = 3",
2776                 .u.insns_int = {
2777                         BPF_LD_IMM64(R0, 1),
2778                         BPF_ALU32_IMM(BPF_ADD, R0, 2),
2779                         BPF_EXIT_INSN(),
2780                 },
2781                 INTERNAL,
2782                 { },
2783                 { { 0, 3 } },
2784         },
2785         {
2786                 "ALU_ADD_K: 3 + 0 = 3",
2787                 .u.insns_int = {
2788                         BPF_LD_IMM64(R0, 3),
2789                         BPF_ALU32_IMM(BPF_ADD, R0, 0),
2790                         BPF_EXIT_INSN(),
2791                 },
2792                 INTERNAL,
2793                 { },
2794                 { { 0, 3 } },
2795         },
2796         {
2797                 "ALU_ADD_K: 1 + 4294967294 = 4294967295",
2798                 .u.insns_int = {
2799                         BPF_LD_IMM64(R0, 1),
2800                         BPF_ALU32_IMM(BPF_ADD, R0, 4294967294U),
2801                         BPF_EXIT_INSN(),
2802                 },
2803                 INTERNAL,
2804                 { },
2805                 { { 0, 4294967295U } },
2806         },
2807         {
2808                 "ALU_ADD_K: 4294967294 + 2 = 0",
2809                 .u.insns_int = {
2810                         BPF_LD_IMM64(R0, 4294967294U),
2811                         BPF_ALU32_IMM(BPF_ADD, R0, 2),
2812                         BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
2813                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
2814                         BPF_EXIT_INSN(),
2815                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
2816                         BPF_EXIT_INSN(),
2817                 },
2818                 INTERNAL,
2819                 { },
2820                 { { 0, 1 } },
2821         },
2822         {
2823                 "ALU_ADD_K: 0 + (-1) = 0x00000000ffffffff",
2824                 .u.insns_int = {
2825                         BPF_LD_IMM64(R2, 0x0),
2826                         BPF_LD_IMM64(R3, 0x00000000ffffffff),
2827                         BPF_ALU32_IMM(BPF_ADD, R2, 0xffffffff),
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 + 0xffff = 0xffff",
2840                 .u.insns_int = {
2841                         BPF_LD_IMM64(R2, 0x0),
2842                         BPF_LD_IMM64(R3, 0xffff),
2843                         BPF_ALU32_IMM(BPF_ADD, R2, 0xffff),
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 + 0x7fffffff = 0x7fffffff",
2856                 .u.insns_int = {
2857                         BPF_LD_IMM64(R2, 0x0),
2858                         BPF_LD_IMM64(R3, 0x7fffffff),
2859                         BPF_ALU32_IMM(BPF_ADD, R2, 0x7fffffff),
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 + 0x80000000 = 0x80000000",
2872                 .u.insns_int = {
2873                         BPF_LD_IMM64(R2, 0x0),
2874                         BPF_LD_IMM64(R3, 0x80000000),
2875                         BPF_ALU32_IMM(BPF_ADD, R2, 0x80000000),
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                 "ALU_ADD_K: 0 + 0x80008000 = 0x80008000",
2888                 .u.insns_int = {
2889                         BPF_LD_IMM64(R2, 0x0),
2890                         BPF_LD_IMM64(R3, 0x80008000),
2891                         BPF_ALU32_IMM(BPF_ADD, R2, 0x80008000),
2892                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2893                         BPF_MOV32_IMM(R0, 2),
2894                         BPF_EXIT_INSN(),
2895                         BPF_MOV32_IMM(R0, 1),
2896                         BPF_EXIT_INSN(),
2897                 },
2898                 INTERNAL,
2899                 { },
2900                 { { 0, 0x1 } },
2901         },
2902         {
2903                 "ALU64_ADD_K: 1 + 2 = 3",
2904                 .u.insns_int = {
2905                         BPF_LD_IMM64(R0, 1),
2906                         BPF_ALU64_IMM(BPF_ADD, R0, 2),
2907                         BPF_EXIT_INSN(),
2908                 },
2909                 INTERNAL,
2910                 { },
2911                 { { 0, 3 } },
2912         },
2913         {
2914                 "ALU64_ADD_K: 3 + 0 = 3",
2915                 .u.insns_int = {
2916                         BPF_LD_IMM64(R0, 3),
2917                         BPF_ALU64_IMM(BPF_ADD, R0, 0),
2918                         BPF_EXIT_INSN(),
2919                 },
2920                 INTERNAL,
2921                 { },
2922                 { { 0, 3 } },
2923         },
2924         {
2925                 "ALU64_ADD_K: 1 + 2147483646 = 2147483647",
2926                 .u.insns_int = {
2927                         BPF_LD_IMM64(R0, 1),
2928                         BPF_ALU64_IMM(BPF_ADD, R0, 2147483646),
2929                         BPF_EXIT_INSN(),
2930                 },
2931                 INTERNAL,
2932                 { },
2933                 { { 0, 2147483647 } },
2934         },
2935         {
2936                 "ALU64_ADD_K: 4294967294 + 2 = 4294967296",
2937                 .u.insns_int = {
2938                         BPF_LD_IMM64(R0, 4294967294U),
2939                         BPF_LD_IMM64(R1, 4294967296ULL),
2940                         BPF_ALU64_IMM(BPF_ADD, R0, 2),
2941                         BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
2942                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
2943                         BPF_EXIT_INSN(),
2944                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
2945                         BPF_EXIT_INSN(),
2946                 },
2947                 INTERNAL,
2948                 { },
2949                 { { 0, 1 } },
2950         },
2951         {
2952                 "ALU64_ADD_K: 2147483646 + -2147483647 = -1",
2953                 .u.insns_int = {
2954                         BPF_LD_IMM64(R0, 2147483646),
2955                         BPF_ALU64_IMM(BPF_ADD, R0, -2147483647),
2956                         BPF_EXIT_INSN(),
2957                 },
2958                 INTERNAL,
2959                 { },
2960                 { { 0, -1 } },
2961         },
2962         {
2963                 "ALU64_ADD_K: 1 + 0 = 1",
2964                 .u.insns_int = {
2965                         BPF_LD_IMM64(R2, 0x1),
2966                         BPF_LD_IMM64(R3, 0x1),
2967                         BPF_ALU64_IMM(BPF_ADD, R2, 0x0),
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 + (-1) = 0xffffffffffffffff",
2980                 .u.insns_int = {
2981                         BPF_LD_IMM64(R2, 0x0),
2982                         BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
2983                         BPF_ALU64_IMM(BPF_ADD, R2, 0xffffffff),
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 + 0xffff = 0xffff",
2996                 .u.insns_int = {
2997                         BPF_LD_IMM64(R2, 0x0),
2998                         BPF_LD_IMM64(R3, 0xffff),
2999                         BPF_ALU64_IMM(BPF_ADD, R2, 0xffff),
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 + 0x7fffffff = 0x7fffffff",
3012                 .u.insns_int = {
3013                         BPF_LD_IMM64(R2, 0x0),
3014                         BPF_LD_IMM64(R3, 0x7fffffff),
3015                         BPF_ALU64_IMM(BPF_ADD, R2, 0x7fffffff),
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                 "ALU64_ADD_K: 0 + 0x80000000 = 0xffffffff80000000",
3028                 .u.insns_int = {
3029                         BPF_LD_IMM64(R2, 0x0),
3030                         BPF_LD_IMM64(R3, 0xffffffff80000000LL),
3031                         BPF_ALU64_IMM(BPF_ADD, R2, 0x80000000),
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         {
3043                 "ALU_ADD_K: 0 + 0x80008000 = 0xffffffff80008000",
3044                 .u.insns_int = {
3045                         BPF_LD_IMM64(R2, 0x0),
3046                         BPF_LD_IMM64(R3, 0xffffffff80008000LL),
3047                         BPF_ALU64_IMM(BPF_ADD, R2, 0x80008000),
3048                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3049                         BPF_MOV32_IMM(R0, 2),
3050                         BPF_EXIT_INSN(),
3051                         BPF_MOV32_IMM(R0, 1),
3052                         BPF_EXIT_INSN(),
3053                 },
3054                 INTERNAL,
3055                 { },
3056                 { { 0, 0x1 } },
3057         },
3058         /* BPF_ALU | BPF_SUB | BPF_X */
3059         {
3060                 "ALU_SUB_X: 3 - 1 = 2",
3061                 .u.insns_int = {
3062                         BPF_LD_IMM64(R0, 3),
3063                         BPF_ALU32_IMM(BPF_MOV, R1, 1),
3064                         BPF_ALU32_REG(BPF_SUB, R0, R1),
3065                         BPF_EXIT_INSN(),
3066                 },
3067                 INTERNAL,
3068                 { },
3069                 { { 0, 2 } },
3070         },
3071         {
3072                 "ALU_SUB_X: 4294967295 - 4294967294 = 1",
3073                 .u.insns_int = {
3074                         BPF_LD_IMM64(R0, 4294967295U),
3075                         BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
3076                         BPF_ALU32_REG(BPF_SUB, R0, R1),
3077                         BPF_EXIT_INSN(),
3078                 },
3079                 INTERNAL,
3080                 { },
3081                 { { 0, 1 } },
3082         },
3083         {
3084                 "ALU64_SUB_X: 3 - 1 = 2",
3085                 .u.insns_int = {
3086                         BPF_LD_IMM64(R0, 3),
3087                         BPF_ALU32_IMM(BPF_MOV, R1, 1),
3088                         BPF_ALU64_REG(BPF_SUB, R0, R1),
3089                         BPF_EXIT_INSN(),
3090                 },
3091                 INTERNAL,
3092                 { },
3093                 { { 0, 2 } },
3094         },
3095         {
3096                 "ALU64_SUB_X: 4294967295 - 4294967294 = 1",
3097                 .u.insns_int = {
3098                         BPF_LD_IMM64(R0, 4294967295U),
3099                         BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
3100                         BPF_ALU64_REG(BPF_SUB, R0, R1),
3101                         BPF_EXIT_INSN(),
3102                 },
3103                 INTERNAL,
3104                 { },
3105                 { { 0, 1 } },
3106         },
3107         /* BPF_ALU | BPF_SUB | BPF_K */
3108         {
3109                 "ALU_SUB_K: 3 - 1 = 2",
3110                 .u.insns_int = {
3111                         BPF_LD_IMM64(R0, 3),
3112                         BPF_ALU32_IMM(BPF_SUB, R0, 1),
3113                         BPF_EXIT_INSN(),
3114                 },
3115                 INTERNAL,
3116                 { },
3117                 { { 0, 2 } },
3118         },
3119         {
3120                 "ALU_SUB_K: 3 - 0 = 3",
3121                 .u.insns_int = {
3122                         BPF_LD_IMM64(R0, 3),
3123                         BPF_ALU32_IMM(BPF_SUB, R0, 0),
3124                         BPF_EXIT_INSN(),
3125                 },
3126                 INTERNAL,
3127                 { },
3128                 { { 0, 3 } },
3129         },
3130         {
3131                 "ALU_SUB_K: 4294967295 - 4294967294 = 1",
3132                 .u.insns_int = {
3133                         BPF_LD_IMM64(R0, 4294967295U),
3134                         BPF_ALU32_IMM(BPF_SUB, R0, 4294967294U),
3135                         BPF_EXIT_INSN(),
3136                 },
3137                 INTERNAL,
3138                 { },
3139                 { { 0, 1 } },
3140         },
3141         {
3142                 "ALU64_SUB_K: 3 - 1 = 2",
3143                 .u.insns_int = {
3144                         BPF_LD_IMM64(R0, 3),
3145                         BPF_ALU64_IMM(BPF_SUB, R0, 1),
3146                         BPF_EXIT_INSN(),
3147                 },
3148                 INTERNAL,
3149                 { },
3150                 { { 0, 2 } },
3151         },
3152         {
3153                 "ALU64_SUB_K: 3 - 0 = 3",
3154                 .u.insns_int = {
3155                         BPF_LD_IMM64(R0, 3),
3156                         BPF_ALU64_IMM(BPF_SUB, R0, 0),
3157                         BPF_EXIT_INSN(),
3158                 },
3159                 INTERNAL,
3160                 { },
3161                 { { 0, 3 } },
3162         },
3163         {
3164                 "ALU64_SUB_K: 4294967294 - 4294967295 = -1",
3165                 .u.insns_int = {
3166                         BPF_LD_IMM64(R0, 4294967294U),
3167                         BPF_ALU64_IMM(BPF_SUB, R0, 4294967295U),
3168                         BPF_EXIT_INSN(),
3169                 },
3170                 INTERNAL,
3171                 { },
3172                 { { 0, -1 } },
3173         },
3174         {
3175                 "ALU64_ADD_K: 2147483646 - 2147483647 = -1",
3176                 .u.insns_int = {
3177                         BPF_LD_IMM64(R0, 2147483646),
3178                         BPF_ALU64_IMM(BPF_SUB, R0, 2147483647),
3179                         BPF_EXIT_INSN(),
3180                 },
3181                 INTERNAL,
3182                 { },
3183                 { { 0, -1 } },
3184         },
3185         /* BPF_ALU | BPF_MUL | BPF_X */
3186         {
3187                 "ALU_MUL_X: 2 * 3 = 6",
3188                 .u.insns_int = {
3189                         BPF_LD_IMM64(R0, 2),
3190                         BPF_ALU32_IMM(BPF_MOV, R1, 3),
3191                         BPF_ALU32_REG(BPF_MUL, R0, R1),
3192                         BPF_EXIT_INSN(),
3193                 },
3194                 INTERNAL,
3195                 { },
3196                 { { 0, 6 } },
3197         },
3198         {
3199                 "ALU_MUL_X: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
3200                 .u.insns_int = {
3201                         BPF_LD_IMM64(R0, 2),
3202                         BPF_ALU32_IMM(BPF_MOV, R1, 0x7FFFFFF8),
3203                         BPF_ALU32_REG(BPF_MUL, R0, R1),
3204                         BPF_EXIT_INSN(),
3205                 },
3206                 INTERNAL,
3207                 { },
3208                 { { 0, 0xFFFFFFF0 } },
3209         },
3210         {
3211                 "ALU_MUL_X: -1 * -1 = 1",
3212                 .u.insns_int = {
3213                         BPF_LD_IMM64(R0, -1),
3214                         BPF_ALU32_IMM(BPF_MOV, R1, -1),
3215                         BPF_ALU32_REG(BPF_MUL, R0, R1),
3216                         BPF_EXIT_INSN(),
3217                 },
3218                 INTERNAL,
3219                 { },
3220                 { { 0, 1 } },
3221         },
3222         {
3223                 "ALU64_MUL_X: 2 * 3 = 6",
3224                 .u.insns_int = {
3225                         BPF_LD_IMM64(R0, 2),
3226                         BPF_ALU32_IMM(BPF_MOV, R1, 3),
3227                         BPF_ALU64_REG(BPF_MUL, R0, R1),
3228                         BPF_EXIT_INSN(),
3229                 },
3230                 INTERNAL,
3231                 { },
3232                 { { 0, 6 } },
3233         },
3234         {
3235                 "ALU64_MUL_X: 1 * 2147483647 = 2147483647",
3236                 .u.insns_int = {
3237                         BPF_LD_IMM64(R0, 1),
3238                         BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
3239                         BPF_ALU64_REG(BPF_MUL, R0, R1),
3240                         BPF_EXIT_INSN(),
3241                 },
3242                 INTERNAL,
3243                 { },
3244                 { { 0, 2147483647 } },
3245         },
3246         {
3247                 "ALU64_MUL_X: 64x64 multiply, low word",
3248                 .u.insns_int = {
3249                         BPF_LD_IMM64(R0, 0x0fedcba987654321LL),
3250                         BPF_LD_IMM64(R1, 0x123456789abcdef0LL),
3251                         BPF_ALU64_REG(BPF_MUL, R0, R1),
3252                         BPF_EXIT_INSN(),
3253                 },
3254                 INTERNAL,
3255                 { },
3256                 { { 0, 0xe5618cf0 } }
3257         },
3258         {
3259                 "ALU64_MUL_X: 64x64 multiply, high word",
3260                 .u.insns_int = {
3261                         BPF_LD_IMM64(R0, 0x0fedcba987654321LL),
3262                         BPF_LD_IMM64(R1, 0x123456789abcdef0LL),
3263                         BPF_ALU64_REG(BPF_MUL, R0, R1),
3264                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
3265                         BPF_EXIT_INSN(),
3266                 },
3267                 INTERNAL,
3268                 { },
3269                 { { 0, 0x2236d88f } }
3270         },
3271         /* BPF_ALU | BPF_MUL | BPF_K */
3272         {
3273                 "ALU_MUL_K: 2 * 3 = 6",
3274                 .u.insns_int = {
3275                         BPF_LD_IMM64(R0, 2),
3276                         BPF_ALU32_IMM(BPF_MUL, R0, 3),
3277                         BPF_EXIT_INSN(),
3278                 },
3279                 INTERNAL,
3280                 { },
3281                 { { 0, 6 } },
3282         },
3283         {
3284                 "ALU_MUL_K: 3 * 1 = 3",
3285                 .u.insns_int = {
3286                         BPF_LD_IMM64(R0, 3),
3287                         BPF_ALU32_IMM(BPF_MUL, R0, 1),
3288                         BPF_EXIT_INSN(),
3289                 },
3290                 INTERNAL,
3291                 { },
3292                 { { 0, 3 } },
3293         },
3294         {
3295                 "ALU_MUL_K: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
3296                 .u.insns_int = {
3297                         BPF_LD_IMM64(R0, 2),
3298                         BPF_ALU32_IMM(BPF_MUL, R0, 0x7FFFFFF8),
3299                         BPF_EXIT_INSN(),
3300                 },
3301                 INTERNAL,
3302                 { },
3303                 { { 0, 0xFFFFFFF0 } },
3304         },
3305         {
3306                 "ALU_MUL_K: 1 * (-1) = 0x00000000ffffffff",
3307                 .u.insns_int = {
3308                         BPF_LD_IMM64(R2, 0x1),
3309                         BPF_LD_IMM64(R3, 0x00000000ffffffff),
3310                         BPF_ALU32_IMM(BPF_MUL, R2, 0xffffffff),
3311                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3312                         BPF_MOV32_IMM(R0, 2),
3313                         BPF_EXIT_INSN(),
3314                         BPF_MOV32_IMM(R0, 1),
3315                         BPF_EXIT_INSN(),
3316                 },
3317                 INTERNAL,
3318                 { },
3319                 { { 0, 0x1 } },
3320         },
3321         {
3322                 "ALU64_MUL_K: 2 * 3 = 6",
3323                 .u.insns_int = {
3324                         BPF_LD_IMM64(R0, 2),
3325                         BPF_ALU64_IMM(BPF_MUL, R0, 3),
3326                         BPF_EXIT_INSN(),
3327                 },
3328                 INTERNAL,
3329                 { },
3330                 { { 0, 6 } },
3331         },
3332         {
3333                 "ALU64_MUL_K: 3 * 1 = 3",
3334                 .u.insns_int = {
3335                         BPF_LD_IMM64(R0, 3),
3336                         BPF_ALU64_IMM(BPF_MUL, R0, 1),
3337                         BPF_EXIT_INSN(),
3338                 },
3339                 INTERNAL,
3340                 { },
3341                 { { 0, 3 } },
3342         },
3343         {
3344                 "ALU64_MUL_K: 1 * 2147483647 = 2147483647",
3345                 .u.insns_int = {
3346                         BPF_LD_IMM64(R0, 1),
3347                         BPF_ALU64_IMM(BPF_MUL, R0, 2147483647),
3348                         BPF_EXIT_INSN(),
3349                 },
3350                 INTERNAL,
3351                 { },
3352                 { { 0, 2147483647 } },
3353         },
3354         {
3355                 "ALU64_MUL_K: 1 * -2147483647 = -2147483647",
3356                 .u.insns_int = {
3357                         BPF_LD_IMM64(R0, 1),
3358                         BPF_ALU64_IMM(BPF_MUL, R0, -2147483647),
3359                         BPF_EXIT_INSN(),
3360                 },
3361                 INTERNAL,
3362                 { },
3363                 { { 0, -2147483647 } },
3364         },
3365         {
3366                 "ALU64_MUL_K: 1 * (-1) = 0xffffffffffffffff",
3367                 .u.insns_int = {
3368                         BPF_LD_IMM64(R2, 0x1),
3369                         BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
3370                         BPF_ALU64_IMM(BPF_MUL, R2, 0xffffffff),
3371                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3372                         BPF_MOV32_IMM(R0, 2),
3373                         BPF_EXIT_INSN(),
3374                         BPF_MOV32_IMM(R0, 1),
3375                         BPF_EXIT_INSN(),
3376                 },
3377                 INTERNAL,
3378                 { },
3379                 { { 0, 0x1 } },
3380         },
3381         {
3382                 "ALU64_MUL_K: 64x32 multiply, low word",
3383                 .u.insns_int = {
3384                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
3385                         BPF_ALU64_IMM(BPF_MUL, R0, 0x12345678),
3386                         BPF_EXIT_INSN(),
3387                 },
3388                 INTERNAL,
3389                 { },
3390                 { { 0, 0xe242d208 } }
3391         },
3392         {
3393                 "ALU64_MUL_K: 64x32 multiply, high word",
3394                 .u.insns_int = {
3395                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
3396                         BPF_ALU64_IMM(BPF_MUL, R0, 0x12345678),
3397                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
3398                         BPF_EXIT_INSN(),
3399                 },
3400                 INTERNAL,
3401                 { },
3402                 { { 0, 0xc28f5c28 } }
3403         },
3404         /* BPF_ALU | BPF_DIV | BPF_X */
3405         {
3406                 "ALU_DIV_X: 6 / 2 = 3",
3407                 .u.insns_int = {
3408                         BPF_LD_IMM64(R0, 6),
3409                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
3410                         BPF_ALU32_REG(BPF_DIV, R0, R1),
3411                         BPF_EXIT_INSN(),
3412                 },
3413                 INTERNAL,
3414                 { },
3415                 { { 0, 3 } },
3416         },
3417         {
3418                 "ALU_DIV_X: 4294967295 / 4294967295 = 1",
3419                 .u.insns_int = {
3420                         BPF_LD_IMM64(R0, 4294967295U),
3421                         BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
3422                         BPF_ALU32_REG(BPF_DIV, R0, R1),
3423                         BPF_EXIT_INSN(),
3424                 },
3425                 INTERNAL,
3426                 { },
3427                 { { 0, 1 } },
3428         },
3429         {
3430                 "ALU64_DIV_X: 6 / 2 = 3",
3431                 .u.insns_int = {
3432                         BPF_LD_IMM64(R0, 6),
3433                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
3434                         BPF_ALU64_REG(BPF_DIV, R0, R1),
3435                         BPF_EXIT_INSN(),
3436                 },
3437                 INTERNAL,
3438                 { },
3439                 { { 0, 3 } },
3440         },
3441         {
3442                 "ALU64_DIV_X: 2147483647 / 2147483647 = 1",
3443                 .u.insns_int = {
3444                         BPF_LD_IMM64(R0, 2147483647),
3445                         BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
3446                         BPF_ALU64_REG(BPF_DIV, R0, R1),
3447                         BPF_EXIT_INSN(),
3448                 },
3449                 INTERNAL,
3450                 { },
3451                 { { 0, 1 } },
3452         },
3453         {
3454                 "ALU64_DIV_X: 0xffffffffffffffff / (-1) = 0x0000000000000001",
3455                 .u.insns_int = {
3456                         BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
3457                         BPF_LD_IMM64(R4, 0xffffffffffffffffLL),
3458                         BPF_LD_IMM64(R3, 0x0000000000000001LL),
3459                         BPF_ALU64_REG(BPF_DIV, R2, R4),
3460                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3461                         BPF_MOV32_IMM(R0, 2),
3462                         BPF_EXIT_INSN(),
3463                         BPF_MOV32_IMM(R0, 1),
3464                         BPF_EXIT_INSN(),
3465                 },
3466                 INTERNAL,
3467                 { },
3468                 { { 0, 0x1 } },
3469         },
3470         /* BPF_ALU | BPF_DIV | BPF_K */
3471         {
3472                 "ALU_DIV_K: 6 / 2 = 3",
3473                 .u.insns_int = {
3474                         BPF_LD_IMM64(R0, 6),
3475                         BPF_ALU32_IMM(BPF_DIV, R0, 2),
3476                         BPF_EXIT_INSN(),
3477                 },
3478                 INTERNAL,
3479                 { },
3480                 { { 0, 3 } },
3481         },
3482         {
3483                 "ALU_DIV_K: 3 / 1 = 3",
3484                 .u.insns_int = {
3485                         BPF_LD_IMM64(R0, 3),
3486                         BPF_ALU32_IMM(BPF_DIV, R0, 1),
3487                         BPF_EXIT_INSN(),
3488                 },
3489                 INTERNAL,
3490                 { },
3491                 { { 0, 3 } },
3492         },
3493         {
3494                 "ALU_DIV_K: 4294967295 / 4294967295 = 1",
3495                 .u.insns_int = {
3496                         BPF_LD_IMM64(R0, 4294967295U),
3497                         BPF_ALU32_IMM(BPF_DIV, R0, 4294967295U),
3498                         BPF_EXIT_INSN(),
3499                 },
3500                 INTERNAL,
3501                 { },
3502                 { { 0, 1 } },
3503         },
3504         {
3505                 "ALU_DIV_K: 0xffffffffffffffff / (-1) = 0x1",
3506                 .u.insns_int = {
3507                         BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
3508                         BPF_LD_IMM64(R3, 0x1UL),
3509                         BPF_ALU32_IMM(BPF_DIV, R2, 0xffffffff),
3510                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3511                         BPF_MOV32_IMM(R0, 2),
3512                         BPF_EXIT_INSN(),
3513                         BPF_MOV32_IMM(R0, 1),
3514                         BPF_EXIT_INSN(),
3515                 },
3516                 INTERNAL,
3517                 { },
3518                 { { 0, 0x1 } },
3519         },
3520         {
3521                 "ALU64_DIV_K: 6 / 2 = 3",
3522                 .u.insns_int = {
3523                         BPF_LD_IMM64(R0, 6),
3524                         BPF_ALU64_IMM(BPF_DIV, R0, 2),
3525                         BPF_EXIT_INSN(),
3526                 },
3527                 INTERNAL,
3528                 { },
3529                 { { 0, 3 } },
3530         },
3531         {
3532                 "ALU64_DIV_K: 3 / 1 = 3",
3533                 .u.insns_int = {
3534                         BPF_LD_IMM64(R0, 3),
3535                         BPF_ALU64_IMM(BPF_DIV, R0, 1),
3536                         BPF_EXIT_INSN(),
3537                 },
3538                 INTERNAL,
3539                 { },
3540                 { { 0, 3 } },
3541         },
3542         {
3543                 "ALU64_DIV_K: 2147483647 / 2147483647 = 1",
3544                 .u.insns_int = {
3545                         BPF_LD_IMM64(R0, 2147483647),
3546                         BPF_ALU64_IMM(BPF_DIV, R0, 2147483647),
3547                         BPF_EXIT_INSN(),
3548                 },
3549                 INTERNAL,
3550                 { },
3551                 { { 0, 1 } },
3552         },
3553         {
3554                 "ALU64_DIV_K: 0xffffffffffffffff / (-1) = 0x0000000000000001",
3555                 .u.insns_int = {
3556                         BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
3557                         BPF_LD_IMM64(R3, 0x0000000000000001LL),
3558                         BPF_ALU64_IMM(BPF_DIV, R2, 0xffffffff),
3559                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3560                         BPF_MOV32_IMM(R0, 2),
3561                         BPF_EXIT_INSN(),
3562                         BPF_MOV32_IMM(R0, 1),
3563                         BPF_EXIT_INSN(),
3564                 },
3565                 INTERNAL,
3566                 { },
3567                 { { 0, 0x1 } },
3568         },
3569         /* BPF_ALU | BPF_MOD | BPF_X */
3570         {
3571                 "ALU_MOD_X: 3 % 2 = 1",
3572                 .u.insns_int = {
3573                         BPF_LD_IMM64(R0, 3),
3574                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
3575                         BPF_ALU32_REG(BPF_MOD, R0, R1),
3576                         BPF_EXIT_INSN(),
3577                 },
3578                 INTERNAL,
3579                 { },
3580                 { { 0, 1 } },
3581         },
3582         {
3583                 "ALU_MOD_X: 4294967295 % 4294967293 = 2",
3584                 .u.insns_int = {
3585                         BPF_LD_IMM64(R0, 4294967295U),
3586                         BPF_ALU32_IMM(BPF_MOV, R1, 4294967293U),
3587                         BPF_ALU32_REG(BPF_MOD, R0, R1),
3588                         BPF_EXIT_INSN(),
3589                 },
3590                 INTERNAL,
3591                 { },
3592                 { { 0, 2 } },
3593         },
3594         {
3595                 "ALU64_MOD_X: 3 % 2 = 1",
3596                 .u.insns_int = {
3597                         BPF_LD_IMM64(R0, 3),
3598                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
3599                         BPF_ALU64_REG(BPF_MOD, R0, R1),
3600                         BPF_EXIT_INSN(),
3601                 },
3602                 INTERNAL,
3603                 { },
3604                 { { 0, 1 } },
3605         },
3606         {
3607                 "ALU64_MOD_X: 2147483647 % 2147483645 = 2",
3608                 .u.insns_int = {
3609                         BPF_LD_IMM64(R0, 2147483647),
3610                         BPF_ALU32_IMM(BPF_MOV, R1, 2147483645),
3611                         BPF_ALU64_REG(BPF_MOD, R0, R1),
3612                         BPF_EXIT_INSN(),
3613                 },
3614                 INTERNAL,
3615                 { },
3616                 { { 0, 2 } },
3617         },
3618         /* BPF_ALU | BPF_MOD | BPF_K */
3619         {
3620                 "ALU_MOD_K: 3 % 2 = 1",
3621                 .u.insns_int = {
3622                         BPF_LD_IMM64(R0, 3),
3623                         BPF_ALU32_IMM(BPF_MOD, R0, 2),
3624                         BPF_EXIT_INSN(),
3625                 },
3626                 INTERNAL,
3627                 { },
3628                 { { 0, 1 } },
3629         },
3630         {
3631                 "ALU_MOD_K: 3 % 1 = 0",
3632                 .u.insns_int = {
3633                         BPF_LD_IMM64(R0, 3),
3634                         BPF_ALU32_IMM(BPF_MOD, R0, 1),
3635                         BPF_EXIT_INSN(),
3636                 },
3637                 INTERNAL,
3638                 { },
3639                 { { 0, 0 } },
3640         },
3641         {
3642                 "ALU_MOD_K: 4294967295 % 4294967293 = 2",
3643                 .u.insns_int = {
3644                         BPF_LD_IMM64(R0, 4294967295U),
3645                         BPF_ALU32_IMM(BPF_MOD, R0, 4294967293U),
3646                         BPF_EXIT_INSN(),
3647                 },
3648                 INTERNAL,
3649                 { },
3650                 { { 0, 2 } },
3651         },
3652         {
3653                 "ALU64_MOD_K: 3 % 2 = 1",
3654                 .u.insns_int = {
3655                         BPF_LD_IMM64(R0, 3),
3656                         BPF_ALU64_IMM(BPF_MOD, R0, 2),
3657                         BPF_EXIT_INSN(),
3658                 },
3659                 INTERNAL,
3660                 { },
3661                 { { 0, 1 } },
3662         },
3663         {
3664                 "ALU64_MOD_K: 3 % 1 = 0",
3665                 .u.insns_int = {
3666                         BPF_LD_IMM64(R0, 3),
3667                         BPF_ALU64_IMM(BPF_MOD, R0, 1),
3668                         BPF_EXIT_INSN(),
3669                 },
3670                 INTERNAL,
3671                 { },
3672                 { { 0, 0 } },
3673         },
3674         {
3675                 "ALU64_MOD_K: 2147483647 % 2147483645 = 2",
3676                 .u.insns_int = {
3677                         BPF_LD_IMM64(R0, 2147483647),
3678                         BPF_ALU64_IMM(BPF_MOD, R0, 2147483645),
3679                         BPF_EXIT_INSN(),
3680                 },
3681                 INTERNAL,
3682                 { },
3683                 { { 0, 2 } },
3684         },
3685         /* BPF_ALU | BPF_AND | BPF_X */
3686         {
3687                 "ALU_AND_X: 3 & 2 = 2",
3688                 .u.insns_int = {
3689                         BPF_LD_IMM64(R0, 3),
3690                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
3691                         BPF_ALU32_REG(BPF_AND, R0, R1),
3692                         BPF_EXIT_INSN(),
3693                 },
3694                 INTERNAL,
3695                 { },
3696                 { { 0, 2 } },
3697         },
3698         {
3699                 "ALU_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
3700                 .u.insns_int = {
3701                         BPF_LD_IMM64(R0, 0xffffffff),
3702                         BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3703                         BPF_ALU32_REG(BPF_AND, R0, R1),
3704                         BPF_EXIT_INSN(),
3705                 },
3706                 INTERNAL,
3707                 { },
3708                 { { 0, 0xffffffff } },
3709         },
3710         {
3711                 "ALU64_AND_X: 3 & 2 = 2",
3712                 .u.insns_int = {
3713                         BPF_LD_IMM64(R0, 3),
3714                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
3715                         BPF_ALU64_REG(BPF_AND, R0, R1),
3716                         BPF_EXIT_INSN(),
3717                 },
3718                 INTERNAL,
3719                 { },
3720                 { { 0, 2 } },
3721         },
3722         {
3723                 "ALU64_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
3724                 .u.insns_int = {
3725                         BPF_LD_IMM64(R0, 0xffffffff),
3726                         BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3727                         BPF_ALU64_REG(BPF_AND, R0, R1),
3728                         BPF_EXIT_INSN(),
3729                 },
3730                 INTERNAL,
3731                 { },
3732                 { { 0, 0xffffffff } },
3733         },
3734         /* BPF_ALU | BPF_AND | BPF_K */
3735         {
3736                 "ALU_AND_K: 3 & 2 = 2",
3737                 .u.insns_int = {
3738                         BPF_LD_IMM64(R0, 3),
3739                         BPF_ALU32_IMM(BPF_AND, R0, 2),
3740                         BPF_EXIT_INSN(),
3741                 },
3742                 INTERNAL,
3743                 { },
3744                 { { 0, 2 } },
3745         },
3746         {
3747                 "ALU_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
3748                 .u.insns_int = {
3749                         BPF_LD_IMM64(R0, 0xffffffff),
3750                         BPF_ALU32_IMM(BPF_AND, R0, 0xffffffff),
3751                         BPF_EXIT_INSN(),
3752                 },
3753                 INTERNAL,
3754                 { },
3755                 { { 0, 0xffffffff } },
3756         },
3757         {
3758                 "ALU_AND_K: Small immediate",
3759                 .u.insns_int = {
3760                         BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
3761                         BPF_ALU32_IMM(BPF_AND, R0, 15),
3762                         BPF_EXIT_INSN(),
3763                 },
3764                 INTERNAL,
3765                 { },
3766                 { { 0, 4 } }
3767         },
3768         {
3769                 "ALU_AND_K: Large immediate",
3770                 .u.insns_int = {
3771                         BPF_ALU32_IMM(BPF_MOV, R0, 0xf1f2f3f4),
3772                         BPF_ALU32_IMM(BPF_AND, R0, 0xafbfcfdf),
3773                         BPF_EXIT_INSN(),
3774                 },
3775                 INTERNAL,
3776                 { },
3777                 { { 0, 0xa1b2c3d4 } }
3778         },
3779         {
3780                 "ALU_AND_K: Zero extension",
3781                 .u.insns_int = {
3782                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
3783                         BPF_LD_IMM64(R1, 0x0000000080a0c0e0LL),
3784                         BPF_ALU32_IMM(BPF_AND, R0, 0xf0f0f0f0),
3785                         BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
3786                         BPF_MOV32_IMM(R0, 2),
3787                         BPF_EXIT_INSN(),
3788                         BPF_MOV32_IMM(R0, 1),
3789                         BPF_EXIT_INSN(),
3790                 },
3791                 INTERNAL,
3792                 { },
3793                 { { 0, 1 } }
3794         },
3795         {
3796                 "ALU64_AND_K: 3 & 2 = 2",
3797                 .u.insns_int = {
3798                         BPF_LD_IMM64(R0, 3),
3799                         BPF_ALU64_IMM(BPF_AND, R0, 2),
3800                         BPF_EXIT_INSN(),
3801                 },
3802                 INTERNAL,
3803                 { },
3804                 { { 0, 2 } },
3805         },
3806         {
3807                 "ALU64_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
3808                 .u.insns_int = {
3809                         BPF_LD_IMM64(R0, 0xffffffff),
3810                         BPF_ALU64_IMM(BPF_AND, R0, 0xffffffff),
3811                         BPF_EXIT_INSN(),
3812                 },
3813                 INTERNAL,
3814                 { },
3815                 { { 0, 0xffffffff } },
3816         },
3817         {
3818                 "ALU64_AND_K: 0x0000ffffffff0000 & 0x0 = 0x0000000000000000",
3819                 .u.insns_int = {
3820                         BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3821                         BPF_LD_IMM64(R3, 0x0000000000000000LL),
3822                         BPF_ALU64_IMM(BPF_AND, R2, 0x0),
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: 0x0000ffffffff0000 & -1 = 0x0000ffffffff0000",
3835                 .u.insns_int = {
3836                         BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3837                         BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
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: 0xffffffffffffffff & -1 = 0xffffffffffffffff",
3851                 .u.insns_int = {
3852                         BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
3853                         BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
3854                         BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
3855                         BPF_JMP_REG(BPF_JEQ, R2, R3, 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, 0x1 } },
3864         },
3865         {
3866                 "ALU64_AND_K: Sign extension 1",
3867                 .u.insns_int = {
3868                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
3869                         BPF_LD_IMM64(R1, 0x00000000090b0d0fLL),
3870                         BPF_ALU64_IMM(BPF_AND, R0, 0x0f0f0f0f),
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         {
3882                 "ALU64_AND_K: Sign extension 2",
3883                 .u.insns_int = {
3884                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
3885                         BPF_LD_IMM64(R1, 0x0123456780a0c0e0LL),
3886                         BPF_ALU64_IMM(BPF_AND, R0, 0xf0f0f0f0),
3887                         BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
3888                         BPF_MOV32_IMM(R0, 2),
3889                         BPF_EXIT_INSN(),
3890                         BPF_MOV32_IMM(R0, 1),
3891                         BPF_EXIT_INSN(),
3892                 },
3893                 INTERNAL,
3894                 { },
3895                 { { 0, 1 } }
3896         },
3897         /* BPF_ALU | BPF_OR | BPF_X */
3898         {
3899                 "ALU_OR_X: 1 | 2 = 3",
3900                 .u.insns_int = {
3901                         BPF_LD_IMM64(R0, 1),
3902                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
3903                         BPF_ALU32_REG(BPF_OR, R0, R1),
3904                         BPF_EXIT_INSN(),
3905                 },
3906                 INTERNAL,
3907                 { },
3908                 { { 0, 3 } },
3909         },
3910         {
3911                 "ALU_OR_X: 0x0 | 0xffffffff = 0xffffffff",
3912                 .u.insns_int = {
3913                         BPF_LD_IMM64(R0, 0),
3914                         BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3915                         BPF_ALU32_REG(BPF_OR, R0, R1),
3916                         BPF_EXIT_INSN(),
3917                 },
3918                 INTERNAL,
3919                 { },
3920                 { { 0, 0xffffffff } },
3921         },
3922         {
3923                 "ALU64_OR_X: 1 | 2 = 3",
3924                 .u.insns_int = {
3925                         BPF_LD_IMM64(R0, 1),
3926                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
3927                         BPF_ALU64_REG(BPF_OR, R0, R1),
3928                         BPF_EXIT_INSN(),
3929                 },
3930                 INTERNAL,
3931                 { },
3932                 { { 0, 3 } },
3933         },
3934         {
3935                 "ALU64_OR_X: 0 | 0xffffffff = 0xffffffff",
3936                 .u.insns_int = {
3937                         BPF_LD_IMM64(R0, 0),
3938                         BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3939                         BPF_ALU64_REG(BPF_OR, R0, R1),
3940                         BPF_EXIT_INSN(),
3941                 },
3942                 INTERNAL,
3943                 { },
3944                 { { 0, 0xffffffff } },
3945         },
3946         /* BPF_ALU | BPF_OR | BPF_K */
3947         {
3948                 "ALU_OR_K: 1 | 2 = 3",
3949                 .u.insns_int = {
3950                         BPF_LD_IMM64(R0, 1),
3951                         BPF_ALU32_IMM(BPF_OR, R0, 2),
3952                         BPF_EXIT_INSN(),
3953                 },
3954                 INTERNAL,
3955                 { },
3956                 { { 0, 3 } },
3957         },
3958         {
3959                 "ALU_OR_K: 0 & 0xffffffff = 0xffffffff",
3960                 .u.insns_int = {
3961                         BPF_LD_IMM64(R0, 0),
3962                         BPF_ALU32_IMM(BPF_OR, R0, 0xffffffff),
3963                         BPF_EXIT_INSN(),
3964                 },
3965                 INTERNAL,
3966                 { },
3967                 { { 0, 0xffffffff } },
3968         },
3969         {
3970                 "ALU_OR_K: Small immediate",
3971                 .u.insns_int = {
3972                         BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
3973                         BPF_ALU32_IMM(BPF_OR, R0, 1),
3974                         BPF_EXIT_INSN(),
3975                 },
3976                 INTERNAL,
3977                 { },
3978                 { { 0, 0x01020305 } }
3979         },
3980         {
3981                 "ALU_OR_K: Large immediate",
3982                 .u.insns_int = {
3983                         BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
3984                         BPF_ALU32_IMM(BPF_OR, R0, 0xa0b0c0d0),
3985                         BPF_EXIT_INSN(),
3986                 },
3987                 INTERNAL,
3988                 { },
3989                 { { 0, 0xa1b2c3d4 } }
3990         },
3991         {
3992                 "ALU_OR_K: Zero extension",
3993                 .u.insns_int = {
3994                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
3995                         BPF_LD_IMM64(R1, 0x00000000f9fbfdffLL),
3996                         BPF_ALU32_IMM(BPF_OR, R0, 0xf0f0f0f0),
3997                         BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
3998                         BPF_MOV32_IMM(R0, 2),
3999                         BPF_EXIT_INSN(),
4000                         BPF_MOV32_IMM(R0, 1),
4001                         BPF_EXIT_INSN(),
4002                 },
4003                 INTERNAL,
4004                 { },
4005                 { { 0, 1 } }
4006         },
4007         {
4008                 "ALU64_OR_K: 1 | 2 = 3",
4009                 .u.insns_int = {
4010                         BPF_LD_IMM64(R0, 1),
4011                         BPF_ALU64_IMM(BPF_OR, R0, 2),
4012                         BPF_EXIT_INSN(),
4013                 },
4014                 INTERNAL,
4015                 { },
4016                 { { 0, 3 } },
4017         },
4018         {
4019                 "ALU64_OR_K: 0 & 0xffffffff = 0xffffffff",
4020                 .u.insns_int = {
4021                         BPF_LD_IMM64(R0, 0),
4022                         BPF_ALU64_IMM(BPF_OR, R0, 0xffffffff),
4023                         BPF_EXIT_INSN(),
4024                 },
4025                 INTERNAL,
4026                 { },
4027                 { { 0, 0xffffffff } },
4028         },
4029         {
4030                 "ALU64_OR_K: 0x0000ffffffff0000 | 0x0 = 0x0000ffffffff0000",
4031                 .u.insns_int = {
4032                         BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
4033                         BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
4034                         BPF_ALU64_IMM(BPF_OR, R2, 0x0),
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: 0x0000ffffffff0000 | -1 = 0xffffffffffffffff",
4047                 .u.insns_int = {
4048                         BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
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: 0x000000000000000 | -1 = 0xffffffffffffffff",
4063                 .u.insns_int = {
4064                         BPF_LD_IMM64(R2, 0x0000000000000000LL),
4065                         BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
4066                         BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
4067                         BPF_JMP_REG(BPF_JEQ, R2, R3, 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, 0x1 } },
4076         },
4077         {
4078                 "ALU64_OR_K: Sign extension 1",
4079                 .u.insns_int = {
4080                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4081                         BPF_LD_IMM64(R1, 0x012345678fafcfefLL),
4082                         BPF_ALU64_IMM(BPF_OR, R0, 0x0f0f0f0f),
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         {
4094                 "ALU64_OR_K: Sign extension 2",
4095                 .u.insns_int = {
4096                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4097                         BPF_LD_IMM64(R1, 0xfffffffff9fbfdffLL),
4098                         BPF_ALU64_IMM(BPF_OR, R0, 0xf0f0f0f0),
4099                         BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
4100                         BPF_MOV32_IMM(R0, 2),
4101                         BPF_EXIT_INSN(),
4102                         BPF_MOV32_IMM(R0, 1),
4103                         BPF_EXIT_INSN(),
4104                 },
4105                 INTERNAL,
4106                 { },
4107                 { { 0, 1 } }
4108         },
4109         /* BPF_ALU | BPF_XOR | BPF_X */
4110         {
4111                 "ALU_XOR_X: 5 ^ 6 = 3",
4112                 .u.insns_int = {
4113                         BPF_LD_IMM64(R0, 5),
4114                         BPF_ALU32_IMM(BPF_MOV, R1, 6),
4115                         BPF_ALU32_REG(BPF_XOR, R0, R1),
4116                         BPF_EXIT_INSN(),
4117                 },
4118                 INTERNAL,
4119                 { },
4120                 { { 0, 3 } },
4121         },
4122         {
4123                 "ALU_XOR_X: 0x1 ^ 0xffffffff = 0xfffffffe",
4124                 .u.insns_int = {
4125                         BPF_LD_IMM64(R0, 1),
4126                         BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
4127                         BPF_ALU32_REG(BPF_XOR, R0, R1),
4128                         BPF_EXIT_INSN(),
4129                 },
4130                 INTERNAL,
4131                 { },
4132                 { { 0, 0xfffffffe } },
4133         },
4134         {
4135                 "ALU64_XOR_X: 5 ^ 6 = 3",
4136                 .u.insns_int = {
4137                         BPF_LD_IMM64(R0, 5),
4138                         BPF_ALU32_IMM(BPF_MOV, R1, 6),
4139                         BPF_ALU64_REG(BPF_XOR, R0, R1),
4140                         BPF_EXIT_INSN(),
4141                 },
4142                 INTERNAL,
4143                 { },
4144                 { { 0, 3 } },
4145         },
4146         {
4147                 "ALU64_XOR_X: 1 ^ 0xffffffff = 0xfffffffe",
4148                 .u.insns_int = {
4149                         BPF_LD_IMM64(R0, 1),
4150                         BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
4151                         BPF_ALU64_REG(BPF_XOR, R0, R1),
4152                         BPF_EXIT_INSN(),
4153                 },
4154                 INTERNAL,
4155                 { },
4156                 { { 0, 0xfffffffe } },
4157         },
4158         /* BPF_ALU | BPF_XOR | BPF_K */
4159         {
4160                 "ALU_XOR_K: 5 ^ 6 = 3",
4161                 .u.insns_int = {
4162                         BPF_LD_IMM64(R0, 5),
4163                         BPF_ALU32_IMM(BPF_XOR, R0, 6),
4164                         BPF_EXIT_INSN(),
4165                 },
4166                 INTERNAL,
4167                 { },
4168                 { { 0, 3 } },
4169         },
4170         {
4171                 "ALU_XOR_K: 1 ^ 0xffffffff = 0xfffffffe",
4172                 .u.insns_int = {
4173                         BPF_LD_IMM64(R0, 1),
4174                         BPF_ALU32_IMM(BPF_XOR, R0, 0xffffffff),
4175                         BPF_EXIT_INSN(),
4176                 },
4177                 INTERNAL,
4178                 { },
4179                 { { 0, 0xfffffffe } },
4180         },
4181         {
4182                 "ALU_XOR_K: Small immediate",
4183                 .u.insns_int = {
4184                         BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
4185                         BPF_ALU32_IMM(BPF_XOR, R0, 15),
4186                         BPF_EXIT_INSN(),
4187                 },
4188                 INTERNAL,
4189                 { },
4190                 { { 0, 0x0102030b } }
4191         },
4192         {
4193                 "ALU_XOR_K: Large immediate",
4194                 .u.insns_int = {
4195                         BPF_ALU32_IMM(BPF_MOV, R0, 0xf1f2f3f4),
4196                         BPF_ALU32_IMM(BPF_XOR, R0, 0xafbfcfdf),
4197                         BPF_EXIT_INSN(),
4198                 },
4199                 INTERNAL,
4200                 { },
4201                 { { 0, 0x5e4d3c2b } }
4202         },
4203         {
4204                 "ALU_XOR_K: Zero extension",
4205                 .u.insns_int = {
4206                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4207                         BPF_LD_IMM64(R1, 0x00000000795b3d1fLL),
4208                         BPF_ALU32_IMM(BPF_XOR, R0, 0xf0f0f0f0),
4209                         BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
4210                         BPF_MOV32_IMM(R0, 2),
4211                         BPF_EXIT_INSN(),
4212                         BPF_MOV32_IMM(R0, 1),
4213                         BPF_EXIT_INSN(),
4214                 },
4215                 INTERNAL,
4216                 { },
4217                 { { 0, 1 } }
4218         },
4219         {
4220                 "ALU64_XOR_K: 5 ^ 6 = 3",
4221                 .u.insns_int = {
4222                         BPF_LD_IMM64(R0, 5),
4223                         BPF_ALU64_IMM(BPF_XOR, R0, 6),
4224                         BPF_EXIT_INSN(),
4225                 },
4226                 INTERNAL,
4227                 { },
4228                 { { 0, 3 } },
4229         },
4230         {
4231                 "ALU64_XOR_K: 1 ^ 0xffffffff = 0xfffffffe",
4232                 .u.insns_int = {
4233                         BPF_LD_IMM64(R0, 1),
4234                         BPF_ALU64_IMM(BPF_XOR, R0, 0xffffffff),
4235                         BPF_EXIT_INSN(),
4236                 },
4237                 INTERNAL,
4238                 { },
4239                 { { 0, 0xfffffffe } },
4240         },
4241         {
4242                 "ALU64_XOR_K: 0x0000ffffffff0000 ^ 0x0 = 0x0000ffffffff0000",
4243                 .u.insns_int = {
4244                         BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
4245                         BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
4246                         BPF_ALU64_IMM(BPF_XOR, R2, 0x0),
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: 0x0000ffffffff0000 ^ -1 = 0xffff00000000ffff",
4259                 .u.insns_int = {
4260                         BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
4261                         BPF_LD_IMM64(R3, 0xffff00000000ffffLL),
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: 0x000000000000000 ^ -1 = 0xffffffffffffffff",
4275                 .u.insns_int = {
4276                         BPF_LD_IMM64(R2, 0x0000000000000000LL),
4277                         BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
4278                         BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
4279                         BPF_JMP_REG(BPF_JEQ, R2, R3, 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, 0x1 } },
4288         },
4289         {
4290                 "ALU64_XOR_K: Sign extension 1",
4291                 .u.insns_int = {
4292                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4293                         BPF_LD_IMM64(R1, 0x0123456786a4c2e0LL),
4294                         BPF_ALU64_IMM(BPF_XOR, R0, 0x0f0f0f0f),
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         {
4306                 "ALU64_XOR_K: Sign extension 2",
4307                 .u.insns_int = {
4308                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4309                         BPF_LD_IMM64(R1, 0xfedcba98795b3d1fLL),
4310                         BPF_ALU64_IMM(BPF_XOR, R0, 0xf0f0f0f0),
4311                         BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
4312                         BPF_MOV32_IMM(R0, 2),
4313                         BPF_EXIT_INSN(),
4314                         BPF_MOV32_IMM(R0, 1),
4315                         BPF_EXIT_INSN(),
4316                 },
4317                 INTERNAL,
4318                 { },
4319                 { { 0, 1 } }
4320         },
4321         /* BPF_ALU | BPF_LSH | BPF_X */
4322         {
4323                 "ALU_LSH_X: 1 << 1 = 2",
4324                 .u.insns_int = {
4325                         BPF_LD_IMM64(R0, 1),
4326                         BPF_ALU32_IMM(BPF_MOV, R1, 1),
4327                         BPF_ALU32_REG(BPF_LSH, R0, R1),
4328                         BPF_EXIT_INSN(),
4329                 },
4330                 INTERNAL,
4331                 { },
4332                 { { 0, 2 } },
4333         },
4334         {
4335                 "ALU_LSH_X: 1 << 31 = 0x80000000",
4336                 .u.insns_int = {
4337                         BPF_LD_IMM64(R0, 1),
4338                         BPF_ALU32_IMM(BPF_MOV, R1, 31),
4339                         BPF_ALU32_REG(BPF_LSH, R0, R1),
4340                         BPF_EXIT_INSN(),
4341                 },
4342                 INTERNAL,
4343                 { },
4344                 { { 0, 0x80000000 } },
4345         },
4346         {
4347                 "ALU_LSH_X: 0x12345678 << 12 = 0x45678000",
4348                 .u.insns_int = {
4349                         BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
4350                         BPF_ALU32_IMM(BPF_MOV, R1, 12),
4351                         BPF_ALU32_REG(BPF_LSH, R0, R1),
4352                         BPF_EXIT_INSN(),
4353                 },
4354                 INTERNAL,
4355                 { },
4356                 { { 0, 0x45678000 } }
4357         },
4358         {
4359                 "ALU64_LSH_X: 1 << 1 = 2",
4360                 .u.insns_int = {
4361                         BPF_LD_IMM64(R0, 1),
4362                         BPF_ALU32_IMM(BPF_MOV, R1, 1),
4363                         BPF_ALU64_REG(BPF_LSH, R0, R1),
4364                         BPF_EXIT_INSN(),
4365                 },
4366                 INTERNAL,
4367                 { },
4368                 { { 0, 2 } },
4369         },
4370         {
4371                 "ALU64_LSH_X: 1 << 31 = 0x80000000",
4372                 .u.insns_int = {
4373                         BPF_LD_IMM64(R0, 1),
4374                         BPF_ALU32_IMM(BPF_MOV, R1, 31),
4375                         BPF_ALU64_REG(BPF_LSH, R0, R1),
4376                         BPF_EXIT_INSN(),
4377                 },
4378                 INTERNAL,
4379                 { },
4380                 { { 0, 0x80000000 } },
4381         },
4382         {
4383                 "ALU64_LSH_X: Shift < 32, low word",
4384                 .u.insns_int = {
4385                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4386                         BPF_ALU32_IMM(BPF_MOV, R1, 12),
4387                         BPF_ALU64_REG(BPF_LSH, R0, R1),
4388                         BPF_EXIT_INSN(),
4389                 },
4390                 INTERNAL,
4391                 { },
4392                 { { 0, 0xbcdef000 } }
4393         },
4394         {
4395                 "ALU64_LSH_X: Shift < 32, high word",
4396                 .u.insns_int = {
4397                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4398                         BPF_ALU32_IMM(BPF_MOV, R1, 12),
4399                         BPF_ALU64_REG(BPF_LSH, R0, R1),
4400                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4401                         BPF_EXIT_INSN(),
4402                 },
4403                 INTERNAL,
4404                 { },
4405                 { { 0, 0x3456789a } }
4406         },
4407         {
4408                 "ALU64_LSH_X: Shift > 32, low word",
4409                 .u.insns_int = {
4410                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4411                         BPF_ALU32_IMM(BPF_MOV, R1, 36),
4412                         BPF_ALU64_REG(BPF_LSH, R0, R1),
4413                         BPF_EXIT_INSN(),
4414                 },
4415                 INTERNAL,
4416                 { },
4417                 { { 0, 0 } }
4418         },
4419         {
4420                 "ALU64_LSH_X: Shift > 32, high word",
4421                 .u.insns_int = {
4422                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4423                         BPF_ALU32_IMM(BPF_MOV, R1, 36),
4424                         BPF_ALU64_REG(BPF_LSH, R0, R1),
4425                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4426                         BPF_EXIT_INSN(),
4427                 },
4428                 INTERNAL,
4429                 { },
4430                 { { 0, 0x9abcdef0 } }
4431         },
4432         {
4433                 "ALU64_LSH_X: Shift == 32, low word",
4434                 .u.insns_int = {
4435                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4436                         BPF_ALU32_IMM(BPF_MOV, R1, 32),
4437                         BPF_ALU64_REG(BPF_LSH, R0, R1),
4438                         BPF_EXIT_INSN(),
4439                 },
4440                 INTERNAL,
4441                 { },
4442                 { { 0, 0 } }
4443         },
4444         {
4445                 "ALU64_LSH_X: Shift == 32, high word",
4446                 .u.insns_int = {
4447                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4448                         BPF_ALU32_IMM(BPF_MOV, R1, 32),
4449                         BPF_ALU64_REG(BPF_LSH, R0, R1),
4450                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4451                         BPF_EXIT_INSN(),
4452                 },
4453                 INTERNAL,
4454                 { },
4455                 { { 0, 0x89abcdef } }
4456         },
4457         {
4458                 "ALU64_LSH_X: Zero shift, low word",
4459                 .u.insns_int = {
4460                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4461                         BPF_ALU32_IMM(BPF_MOV, R1, 0),
4462                         BPF_ALU64_REG(BPF_LSH, R0, R1),
4463                         BPF_EXIT_INSN(),
4464                 },
4465                 INTERNAL,
4466                 { },
4467                 { { 0, 0x89abcdef } }
4468         },
4469         {
4470                 "ALU64_LSH_X: Zero shift, high word",
4471                 .u.insns_int = {
4472                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4473                         BPF_ALU32_IMM(BPF_MOV, R1, 0),
4474                         BPF_ALU64_REG(BPF_LSH, R0, R1),
4475                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4476                         BPF_EXIT_INSN(),
4477                 },
4478                 INTERNAL,
4479                 { },
4480                 { { 0, 0x01234567 } }
4481         },
4482         /* BPF_ALU | BPF_LSH | BPF_K */
4483         {
4484                 "ALU_LSH_K: 1 << 1 = 2",
4485                 .u.insns_int = {
4486                         BPF_LD_IMM64(R0, 1),
4487                         BPF_ALU32_IMM(BPF_LSH, R0, 1),
4488                         BPF_EXIT_INSN(),
4489                 },
4490                 INTERNAL,
4491                 { },
4492                 { { 0, 2 } },
4493         },
4494         {
4495                 "ALU_LSH_K: 1 << 31 = 0x80000000",
4496                 .u.insns_int = {
4497                         BPF_LD_IMM64(R0, 1),
4498                         BPF_ALU32_IMM(BPF_LSH, R0, 31),
4499                         BPF_EXIT_INSN(),
4500                 },
4501                 INTERNAL,
4502                 { },
4503                 { { 0, 0x80000000 } },
4504         },
4505         {
4506                 "ALU_LSH_K: 0x12345678 << 12 = 0x45678000",
4507                 .u.insns_int = {
4508                         BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
4509                         BPF_ALU32_IMM(BPF_LSH, R0, 12),
4510                         BPF_EXIT_INSN(),
4511                 },
4512                 INTERNAL,
4513                 { },
4514                 { { 0, 0x45678000 } }
4515         },
4516         {
4517                 "ALU_LSH_K: 0x12345678 << 0 = 0x12345678",
4518                 .u.insns_int = {
4519                         BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
4520                         BPF_ALU32_IMM(BPF_LSH, R0, 0),
4521                         BPF_EXIT_INSN(),
4522                 },
4523                 INTERNAL,
4524                 { },
4525                 { { 0, 0x12345678 } }
4526         },
4527         {
4528                 "ALU64_LSH_K: 1 << 1 = 2",
4529                 .u.insns_int = {
4530                         BPF_LD_IMM64(R0, 1),
4531                         BPF_ALU64_IMM(BPF_LSH, R0, 1),
4532                         BPF_EXIT_INSN(),
4533                 },
4534                 INTERNAL,
4535                 { },
4536                 { { 0, 2 } },
4537         },
4538         {
4539                 "ALU64_LSH_K: 1 << 31 = 0x80000000",
4540                 .u.insns_int = {
4541                         BPF_LD_IMM64(R0, 1),
4542                         BPF_ALU64_IMM(BPF_LSH, R0, 31),
4543                         BPF_EXIT_INSN(),
4544                 },
4545                 INTERNAL,
4546                 { },
4547                 { { 0, 0x80000000 } },
4548         },
4549         {
4550                 "ALU64_LSH_K: Shift < 32, low word",
4551                 .u.insns_int = {
4552                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4553                         BPF_ALU64_IMM(BPF_LSH, R0, 12),
4554                         BPF_EXIT_INSN(),
4555                 },
4556                 INTERNAL,
4557                 { },
4558                 { { 0, 0xbcdef000 } }
4559         },
4560         {
4561                 "ALU64_LSH_K: Shift < 32, high word",
4562                 .u.insns_int = {
4563                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4564                         BPF_ALU64_IMM(BPF_LSH, R0, 12),
4565                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4566                         BPF_EXIT_INSN(),
4567                 },
4568                 INTERNAL,
4569                 { },
4570                 { { 0, 0x3456789a } }
4571         },
4572         {
4573                 "ALU64_LSH_K: Shift > 32, low word",
4574                 .u.insns_int = {
4575                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4576                         BPF_ALU64_IMM(BPF_LSH, R0, 36),
4577                         BPF_EXIT_INSN(),
4578                 },
4579                 INTERNAL,
4580                 { },
4581                 { { 0, 0 } }
4582         },
4583         {
4584                 "ALU64_LSH_K: Shift > 32, high word",
4585                 .u.insns_int = {
4586                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4587                         BPF_ALU64_IMM(BPF_LSH, R0, 36),
4588                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4589                         BPF_EXIT_INSN(),
4590                 },
4591                 INTERNAL,
4592                 { },
4593                 { { 0, 0x9abcdef0 } }
4594         },
4595         {
4596                 "ALU64_LSH_K: Shift == 32, low word",
4597                 .u.insns_int = {
4598                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4599                         BPF_ALU64_IMM(BPF_LSH, R0, 32),
4600                         BPF_EXIT_INSN(),
4601                 },
4602                 INTERNAL,
4603                 { },
4604                 { { 0, 0 } }
4605         },
4606         {
4607                 "ALU64_LSH_K: Shift == 32, high word",
4608                 .u.insns_int = {
4609                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4610                         BPF_ALU64_IMM(BPF_LSH, R0, 32),
4611                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4612                         BPF_EXIT_INSN(),
4613                 },
4614                 INTERNAL,
4615                 { },
4616                 { { 0, 0x89abcdef } }
4617         },
4618         {
4619                 "ALU64_LSH_K: Zero shift",
4620                 .u.insns_int = {
4621                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4622                         BPF_ALU64_IMM(BPF_LSH, R0, 0),
4623                         BPF_EXIT_INSN(),
4624                 },
4625                 INTERNAL,
4626                 { },
4627                 { { 0, 0x89abcdef } }
4628         },
4629         /* BPF_ALU | BPF_RSH | BPF_X */
4630         {
4631                 "ALU_RSH_X: 2 >> 1 = 1",
4632                 .u.insns_int = {
4633                         BPF_LD_IMM64(R0, 2),
4634                         BPF_ALU32_IMM(BPF_MOV, R1, 1),
4635                         BPF_ALU32_REG(BPF_RSH, R0, R1),
4636                         BPF_EXIT_INSN(),
4637                 },
4638                 INTERNAL,
4639                 { },
4640                 { { 0, 1 } },
4641         },
4642         {
4643                 "ALU_RSH_X: 0x80000000 >> 31 = 1",
4644                 .u.insns_int = {
4645                         BPF_LD_IMM64(R0, 0x80000000),
4646                         BPF_ALU32_IMM(BPF_MOV, R1, 31),
4647                         BPF_ALU32_REG(BPF_RSH, R0, R1),
4648                         BPF_EXIT_INSN(),
4649                 },
4650                 INTERNAL,
4651                 { },
4652                 { { 0, 1 } },
4653         },
4654         {
4655                 "ALU_RSH_X: 0x12345678 >> 20 = 0x123",
4656                 .u.insns_int = {
4657                         BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
4658                         BPF_ALU32_IMM(BPF_MOV, R1, 20),
4659                         BPF_ALU32_REG(BPF_RSH, R0, R1),
4660                         BPF_EXIT_INSN(),
4661                 },
4662                 INTERNAL,
4663                 { },
4664                 { { 0, 0x123 } }
4665         },
4666         {
4667                 "ALU64_RSH_X: 2 >> 1 = 1",
4668                 .u.insns_int = {
4669                         BPF_LD_IMM64(R0, 2),
4670                         BPF_ALU32_IMM(BPF_MOV, R1, 1),
4671                         BPF_ALU64_REG(BPF_RSH, R0, R1),
4672                         BPF_EXIT_INSN(),
4673                 },
4674                 INTERNAL,
4675                 { },
4676                 { { 0, 1 } },
4677         },
4678         {
4679                 "ALU64_RSH_X: 0x80000000 >> 31 = 1",
4680                 .u.insns_int = {
4681                         BPF_LD_IMM64(R0, 0x80000000),
4682                         BPF_ALU32_IMM(BPF_MOV, R1, 31),
4683                         BPF_ALU64_REG(BPF_RSH, R0, R1),
4684                         BPF_EXIT_INSN(),
4685                 },
4686                 INTERNAL,
4687                 { },
4688                 { { 0, 1 } },
4689         },
4690         {
4691                 "ALU64_RSH_X: Shift < 32, low word",
4692                 .u.insns_int = {
4693                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4694                         BPF_ALU32_IMM(BPF_MOV, R1, 12),
4695                         BPF_ALU64_REG(BPF_RSH, R0, R1),
4696                         BPF_EXIT_INSN(),
4697                 },
4698                 INTERNAL,
4699                 { },
4700                 { { 0, 0x56789abc } }
4701         },
4702         {
4703                 "ALU64_RSH_X: Shift < 32, high word",
4704                 .u.insns_int = {
4705                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4706                         BPF_ALU32_IMM(BPF_MOV, R1, 12),
4707                         BPF_ALU64_REG(BPF_RSH, R0, R1),
4708                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4709                         BPF_EXIT_INSN(),
4710                 },
4711                 INTERNAL,
4712                 { },
4713                 { { 0, 0x00081234 } }
4714         },
4715         {
4716                 "ALU64_RSH_X: Shift > 32, low word",
4717                 .u.insns_int = {
4718                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4719                         BPF_ALU32_IMM(BPF_MOV, R1, 36),
4720                         BPF_ALU64_REG(BPF_RSH, R0, R1),
4721                         BPF_EXIT_INSN(),
4722                 },
4723                 INTERNAL,
4724                 { },
4725                 { { 0, 0x08123456 } }
4726         },
4727         {
4728                 "ALU64_RSH_X: Shift > 32, high word",
4729                 .u.insns_int = {
4730                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4731                         BPF_ALU32_IMM(BPF_MOV, R1, 36),
4732                         BPF_ALU64_REG(BPF_RSH, R0, R1),
4733                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4734                         BPF_EXIT_INSN(),
4735                 },
4736                 INTERNAL,
4737                 { },
4738                 { { 0, 0 } }
4739         },
4740         {
4741                 "ALU64_RSH_X: Shift == 32, low word",
4742                 .u.insns_int = {
4743                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4744                         BPF_ALU32_IMM(BPF_MOV, R1, 32),
4745                         BPF_ALU64_REG(BPF_RSH, R0, R1),
4746                         BPF_EXIT_INSN(),
4747                 },
4748                 INTERNAL,
4749                 { },
4750                 { { 0, 0x81234567 } }
4751         },
4752         {
4753                 "ALU64_RSH_X: Shift == 32, high word",
4754                 .u.insns_int = {
4755                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4756                         BPF_ALU32_IMM(BPF_MOV, R1, 32),
4757                         BPF_ALU64_REG(BPF_RSH, R0, R1),
4758                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4759                         BPF_EXIT_INSN(),
4760                 },
4761                 INTERNAL,
4762                 { },
4763                 { { 0, 0 } }
4764         },
4765         {
4766                 "ALU64_RSH_X: Zero shift, low word",
4767                 .u.insns_int = {
4768                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4769                         BPF_ALU32_IMM(BPF_MOV, R1, 0),
4770                         BPF_ALU64_REG(BPF_RSH, R0, R1),
4771                         BPF_EXIT_INSN(),
4772                 },
4773                 INTERNAL,
4774                 { },
4775                 { { 0, 0x89abcdef } }
4776         },
4777         {
4778                 "ALU64_RSH_X: Zero shift, high word",
4779                 .u.insns_int = {
4780                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4781                         BPF_ALU32_IMM(BPF_MOV, R1, 0),
4782                         BPF_ALU64_REG(BPF_RSH, R0, R1),
4783                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4784                         BPF_EXIT_INSN(),
4785                 },
4786                 INTERNAL,
4787                 { },
4788                 { { 0, 0x81234567 } }
4789         },
4790         /* BPF_ALU | BPF_RSH | BPF_K */
4791         {
4792                 "ALU_RSH_K: 2 >> 1 = 1",
4793                 .u.insns_int = {
4794                         BPF_LD_IMM64(R0, 2),
4795                         BPF_ALU32_IMM(BPF_RSH, R0, 1),
4796                         BPF_EXIT_INSN(),
4797                 },
4798                 INTERNAL,
4799                 { },
4800                 { { 0, 1 } },
4801         },
4802         {
4803                 "ALU_RSH_K: 0x80000000 >> 31 = 1",
4804                 .u.insns_int = {
4805                         BPF_LD_IMM64(R0, 0x80000000),
4806                         BPF_ALU32_IMM(BPF_RSH, R0, 31),
4807                         BPF_EXIT_INSN(),
4808                 },
4809                 INTERNAL,
4810                 { },
4811                 { { 0, 1 } },
4812         },
4813         {
4814                 "ALU_RSH_K: 0x12345678 >> 20 = 0x123",
4815                 .u.insns_int = {
4816                         BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
4817                         BPF_ALU32_IMM(BPF_RSH, R0, 20),
4818                         BPF_EXIT_INSN(),
4819                 },
4820                 INTERNAL,
4821                 { },
4822                 { { 0, 0x123 } }
4823         },
4824         {
4825                 "ALU_RSH_K: 0x12345678 >> 0 = 0x12345678",
4826                 .u.insns_int = {
4827                         BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
4828                         BPF_ALU32_IMM(BPF_RSH, R0, 0),
4829                         BPF_EXIT_INSN(),
4830                 },
4831                 INTERNAL,
4832                 { },
4833                 { { 0, 0x12345678 } }
4834         },
4835         {
4836                 "ALU64_RSH_K: 2 >> 1 = 1",
4837                 .u.insns_int = {
4838                         BPF_LD_IMM64(R0, 2),
4839                         BPF_ALU64_IMM(BPF_RSH, R0, 1),
4840                         BPF_EXIT_INSN(),
4841                 },
4842                 INTERNAL,
4843                 { },
4844                 { { 0, 1 } },
4845         },
4846         {
4847                 "ALU64_RSH_K: 0x80000000 >> 31 = 1",
4848                 .u.insns_int = {
4849                         BPF_LD_IMM64(R0, 0x80000000),
4850                         BPF_ALU64_IMM(BPF_RSH, R0, 31),
4851                         BPF_EXIT_INSN(),
4852                 },
4853                 INTERNAL,
4854                 { },
4855                 { { 0, 1 } },
4856         },
4857         {
4858                 "ALU64_RSH_K: Shift < 32, low word",
4859                 .u.insns_int = {
4860                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4861                         BPF_ALU64_IMM(BPF_RSH, R0, 12),
4862                         BPF_EXIT_INSN(),
4863                 },
4864                 INTERNAL,
4865                 { },
4866                 { { 0, 0x56789abc } }
4867         },
4868         {
4869                 "ALU64_RSH_K: Shift < 32, high word",
4870                 .u.insns_int = {
4871                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4872                         BPF_ALU64_IMM(BPF_RSH, R0, 12),
4873                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4874                         BPF_EXIT_INSN(),
4875                 },
4876                 INTERNAL,
4877                 { },
4878                 { { 0, 0x00081234 } }
4879         },
4880         {
4881                 "ALU64_RSH_K: Shift > 32, low word",
4882                 .u.insns_int = {
4883                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4884                         BPF_ALU64_IMM(BPF_RSH, R0, 36),
4885                         BPF_EXIT_INSN(),
4886                 },
4887                 INTERNAL,
4888                 { },
4889                 { { 0, 0x08123456 } }
4890         },
4891         {
4892                 "ALU64_RSH_K: Shift > 32, high word",
4893                 .u.insns_int = {
4894                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4895                         BPF_ALU64_IMM(BPF_RSH, R0, 36),
4896                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4897                         BPF_EXIT_INSN(),
4898                 },
4899                 INTERNAL,
4900                 { },
4901                 { { 0, 0 } }
4902         },
4903         {
4904                 "ALU64_RSH_K: Shift == 32, low word",
4905                 .u.insns_int = {
4906                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4907                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4908                         BPF_EXIT_INSN(),
4909                 },
4910                 INTERNAL,
4911                 { },
4912                 { { 0, 0x81234567 } }
4913         },
4914         {
4915                 "ALU64_RSH_K: Shift == 32, high word",
4916                 .u.insns_int = {
4917                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4918                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4919                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4920                         BPF_EXIT_INSN(),
4921                 },
4922                 INTERNAL,
4923                 { },
4924                 { { 0, 0 } }
4925         },
4926         {
4927                 "ALU64_RSH_K: Zero shift",
4928                 .u.insns_int = {
4929                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4930                         BPF_ALU64_IMM(BPF_RSH, R0, 0),
4931                         BPF_EXIT_INSN(),
4932                 },
4933                 INTERNAL,
4934                 { },
4935                 { { 0, 0x89abcdef } }
4936         },
4937         /* BPF_ALU | BPF_ARSH | BPF_X */
4938         {
4939                 "ALU32_ARSH_X: -1234 >> 7 = -10",
4940                 .u.insns_int = {
4941                         BPF_ALU32_IMM(BPF_MOV, R0, -1234),
4942                         BPF_ALU32_IMM(BPF_MOV, R1, 7),
4943                         BPF_ALU32_REG(BPF_ARSH, R0, R1),
4944                         BPF_EXIT_INSN(),
4945                 },
4946                 INTERNAL,
4947                 { },
4948                 { { 0, -10 } }
4949         },
4950         {
4951                 "ALU64_ARSH_X: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
4952                 .u.insns_int = {
4953                         BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
4954                         BPF_ALU32_IMM(BPF_MOV, R1, 40),
4955                         BPF_ALU64_REG(BPF_ARSH, R0, R1),
4956                         BPF_EXIT_INSN(),
4957                 },
4958                 INTERNAL,
4959                 { },
4960                 { { 0, 0xffff00ff } },
4961         },
4962         {
4963                 "ALU64_ARSH_X: Shift < 32, low word",
4964                 .u.insns_int = {
4965                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4966                         BPF_ALU32_IMM(BPF_MOV, R1, 12),
4967                         BPF_ALU64_REG(BPF_ARSH, R0, R1),
4968                         BPF_EXIT_INSN(),
4969                 },
4970                 INTERNAL,
4971                 { },
4972                 { { 0, 0x56789abc } }
4973         },
4974         {
4975                 "ALU64_ARSH_X: Shift < 32, high word",
4976                 .u.insns_int = {
4977                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4978                         BPF_ALU32_IMM(BPF_MOV, R1, 12),
4979                         BPF_ALU64_REG(BPF_ARSH, R0, R1),
4980                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4981                         BPF_EXIT_INSN(),
4982                 },
4983                 INTERNAL,
4984                 { },
4985                 { { 0, 0xfff81234 } }
4986         },
4987         {
4988                 "ALU64_ARSH_X: Shift > 32, low word",
4989                 .u.insns_int = {
4990                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4991                         BPF_ALU32_IMM(BPF_MOV, R1, 36),
4992                         BPF_ALU64_REG(BPF_ARSH, R0, R1),
4993                         BPF_EXIT_INSN(),
4994                 },
4995                 INTERNAL,
4996                 { },
4997                 { { 0, 0xf8123456 } }
4998         },
4999         {
5000                 "ALU64_ARSH_X: Shift > 32, high word",
5001                 .u.insns_int = {
5002                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
5003                         BPF_ALU32_IMM(BPF_MOV, R1, 36),
5004                         BPF_ALU64_REG(BPF_ARSH, R0, R1),
5005                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
5006                         BPF_EXIT_INSN(),
5007                 },
5008                 INTERNAL,
5009                 { },
5010                 { { 0, -1 } }
5011         },
5012         {
5013                 "ALU64_ARSH_X: Shift == 32, low word",
5014                 .u.insns_int = {
5015                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
5016                         BPF_ALU32_IMM(BPF_MOV, R1, 32),
5017                         BPF_ALU64_REG(BPF_ARSH, R0, R1),
5018                         BPF_EXIT_INSN(),
5019                 },
5020                 INTERNAL,
5021                 { },
5022                 { { 0, 0x81234567 } }
5023         },
5024         {
5025                 "ALU64_ARSH_X: Shift == 32, high word",
5026                 .u.insns_int = {
5027                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
5028                         BPF_ALU32_IMM(BPF_MOV, R1, 32),
5029                         BPF_ALU64_REG(BPF_ARSH, R0, R1),
5030                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
5031                         BPF_EXIT_INSN(),
5032                 },
5033                 INTERNAL,
5034                 { },
5035                 { { 0, -1 } }
5036         },
5037         {
5038                 "ALU64_ARSH_X: Zero shift, low word",
5039                 .u.insns_int = {
5040                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
5041                         BPF_ALU32_IMM(BPF_MOV, R1, 0),
5042                         BPF_ALU64_REG(BPF_ARSH, R0, R1),
5043                         BPF_EXIT_INSN(),
5044                 },
5045                 INTERNAL,
5046                 { },
5047                 { { 0, 0x89abcdef } }
5048         },
5049         {
5050                 "ALU64_ARSH_X: Zero shift, high word",
5051                 .u.insns_int = {
5052                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
5053                         BPF_ALU32_IMM(BPF_MOV, R1, 0),
5054                         BPF_ALU64_REG(BPF_ARSH, R0, R1),
5055                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
5056                         BPF_EXIT_INSN(),
5057                 },
5058                 INTERNAL,
5059                 { },
5060                 { { 0, 0x81234567 } }
5061         },
5062         /* BPF_ALU | BPF_ARSH | BPF_K */
5063         {
5064                 "ALU32_ARSH_K: -1234 >> 7 = -10",
5065                 .u.insns_int = {
5066                         BPF_ALU32_IMM(BPF_MOV, R0, -1234),
5067                         BPF_ALU32_IMM(BPF_ARSH, R0, 7),
5068                         BPF_EXIT_INSN(),
5069                 },
5070                 INTERNAL,
5071                 { },
5072                 { { 0, -10 } }
5073         },
5074         {
5075                 "ALU32_ARSH_K: -1234 >> 0 = -1234",
5076                 .u.insns_int = {
5077                         BPF_ALU32_IMM(BPF_MOV, R0, -1234),
5078                         BPF_ALU32_IMM(BPF_ARSH, R0, 0),
5079                         BPF_EXIT_INSN(),
5080                 },
5081                 INTERNAL,
5082                 { },
5083                 { { 0, -1234 } }
5084         },
5085         {
5086                 "ALU64_ARSH_K: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
5087                 .u.insns_int = {
5088                         BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
5089                         BPF_ALU64_IMM(BPF_ARSH, R0, 40),
5090                         BPF_EXIT_INSN(),
5091                 },
5092                 INTERNAL,
5093                 { },
5094                 { { 0, 0xffff00ff } },
5095         },
5096         {
5097                 "ALU64_ARSH_K: Shift < 32, low word",
5098                 .u.insns_int = {
5099                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
5100                         BPF_ALU64_IMM(BPF_RSH, R0, 12),
5101                         BPF_EXIT_INSN(),
5102                 },
5103                 INTERNAL,
5104                 { },
5105                 { { 0, 0x56789abc } }
5106         },
5107         {
5108                 "ALU64_ARSH_K: Shift < 32, high word",
5109                 .u.insns_int = {
5110                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
5111                         BPF_ALU64_IMM(BPF_ARSH, R0, 12),
5112                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
5113                         BPF_EXIT_INSN(),
5114                 },
5115                 INTERNAL,
5116                 { },
5117                 { { 0, 0xfff81234 } }
5118         },
5119         {
5120                 "ALU64_ARSH_K: Shift > 32, low word",
5121                 .u.insns_int = {
5122                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
5123                         BPF_ALU64_IMM(BPF_ARSH, R0, 36),
5124                         BPF_EXIT_INSN(),
5125                 },
5126                 INTERNAL,
5127                 { },
5128                 { { 0, 0xf8123456 } }
5129         },
5130         {
5131                 "ALU64_ARSH_K: Shift > 32, high word",
5132                 .u.insns_int = {
5133                         BPF_LD_IMM64(R0, 0xf123456789abcdefLL),
5134                         BPF_ALU64_IMM(BPF_ARSH, R0, 36),
5135                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
5136                         BPF_EXIT_INSN(),
5137                 },
5138                 INTERNAL,
5139                 { },
5140                 { { 0, -1 } }
5141         },
5142         {
5143                 "ALU64_ARSH_K: Shift == 32, low word",
5144                 .u.insns_int = {
5145                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
5146                         BPF_ALU64_IMM(BPF_ARSH, R0, 32),
5147                         BPF_EXIT_INSN(),
5148                 },
5149                 INTERNAL,
5150                 { },
5151                 { { 0, 0x81234567 } }
5152         },
5153         {
5154                 "ALU64_ARSH_K: Shift == 32, high word",
5155                 .u.insns_int = {
5156                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
5157                         BPF_ALU64_IMM(BPF_ARSH, R0, 32),
5158                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
5159                         BPF_EXIT_INSN(),
5160                 },
5161                 INTERNAL,
5162                 { },
5163                 { { 0, -1 } }
5164         },
5165         {
5166                 "ALU64_ARSH_K: Zero shift",
5167                 .u.insns_int = {
5168                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
5169                         BPF_ALU64_IMM(BPF_ARSH, R0, 0),
5170                         BPF_EXIT_INSN(),
5171                 },
5172                 INTERNAL,
5173                 { },
5174                 { { 0, 0x89abcdef } }
5175         },
5176         /* BPF_ALU | BPF_NEG */
5177         {
5178                 "ALU_NEG: -(3) = -3",
5179                 .u.insns_int = {
5180                         BPF_ALU32_IMM(BPF_MOV, R0, 3),
5181                         BPF_ALU32_IMM(BPF_NEG, R0, 0),
5182                         BPF_EXIT_INSN(),
5183                 },
5184                 INTERNAL,
5185                 { },
5186                 { { 0, -3 } },
5187         },
5188         {
5189                 "ALU_NEG: -(-3) = 3",
5190                 .u.insns_int = {
5191                         BPF_ALU32_IMM(BPF_MOV, R0, -3),
5192                         BPF_ALU32_IMM(BPF_NEG, R0, 0),
5193                         BPF_EXIT_INSN(),
5194                 },
5195                 INTERNAL,
5196                 { },
5197                 { { 0, 3 } },
5198         },
5199         {
5200                 "ALU64_NEG: -(3) = -3",
5201                 .u.insns_int = {
5202                         BPF_LD_IMM64(R0, 3),
5203                         BPF_ALU64_IMM(BPF_NEG, R0, 0),
5204                         BPF_EXIT_INSN(),
5205                 },
5206                 INTERNAL,
5207                 { },
5208                 { { 0, -3 } },
5209         },
5210         {
5211                 "ALU64_NEG: -(-3) = 3",
5212                 .u.insns_int = {
5213                         BPF_LD_IMM64(R0, -3),
5214                         BPF_ALU64_IMM(BPF_NEG, R0, 0),
5215                         BPF_EXIT_INSN(),
5216                 },
5217                 INTERNAL,
5218                 { },
5219                 { { 0, 3 } },
5220         },
5221         /* BPF_ALU | BPF_END | BPF_FROM_BE */
5222         {
5223                 "ALU_END_FROM_BE 16: 0x0123456789abcdef -> 0xcdef",
5224                 .u.insns_int = {
5225                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5226                         BPF_ENDIAN(BPF_FROM_BE, R0, 16),
5227                         BPF_EXIT_INSN(),
5228                 },
5229                 INTERNAL,
5230                 { },
5231                 { { 0,  cpu_to_be16(0xcdef) } },
5232         },
5233         {
5234                 "ALU_END_FROM_BE 32: 0x0123456789abcdef -> 0x89abcdef",
5235                 .u.insns_int = {
5236                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5237                         BPF_ENDIAN(BPF_FROM_BE, R0, 32),
5238                         BPF_ALU64_REG(BPF_MOV, R1, R0),
5239                         BPF_ALU64_IMM(BPF_RSH, R1, 32),
5240                         BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
5241                         BPF_EXIT_INSN(),
5242                 },
5243                 INTERNAL,
5244                 { },
5245                 { { 0, cpu_to_be32(0x89abcdef) } },
5246         },
5247         {
5248                 "ALU_END_FROM_BE 64: 0x0123456789abcdef -> 0x89abcdef",
5249                 .u.insns_int = {
5250                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5251                         BPF_ENDIAN(BPF_FROM_BE, R0, 64),
5252                         BPF_EXIT_INSN(),
5253                 },
5254                 INTERNAL,
5255                 { },
5256                 { { 0, (u32) cpu_to_be64(0x0123456789abcdefLL) } },
5257         },
5258         /* BPF_ALU | BPF_END | BPF_FROM_LE */
5259         {
5260                 "ALU_END_FROM_LE 16: 0x0123456789abcdef -> 0xefcd",
5261                 .u.insns_int = {
5262                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5263                         BPF_ENDIAN(BPF_FROM_LE, R0, 16),
5264                         BPF_EXIT_INSN(),
5265                 },
5266                 INTERNAL,
5267                 { },
5268                 { { 0, cpu_to_le16(0xcdef) } },
5269         },
5270         {
5271                 "ALU_END_FROM_LE 32: 0x0123456789abcdef -> 0xefcdab89",
5272                 .u.insns_int = {
5273                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5274                         BPF_ENDIAN(BPF_FROM_LE, R0, 32),
5275                         BPF_ALU64_REG(BPF_MOV, R1, R0),
5276                         BPF_ALU64_IMM(BPF_RSH, R1, 32),
5277                         BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
5278                         BPF_EXIT_INSN(),
5279                 },
5280                 INTERNAL,
5281                 { },
5282                 { { 0, cpu_to_le32(0x89abcdef) } },
5283         },
5284         {
5285                 "ALU_END_FROM_LE 64: 0x0123456789abcdef -> 0x67452301",
5286                 .u.insns_int = {
5287                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5288                         BPF_ENDIAN(BPF_FROM_LE, R0, 64),
5289                         BPF_EXIT_INSN(),
5290                 },
5291                 INTERNAL,
5292                 { },
5293                 { { 0, (u32) cpu_to_le64(0x0123456789abcdefLL) } },
5294         },
5295         /* BPF_ST(X) | BPF_MEM | BPF_B/H/W/DW */
5296         {
5297                 "ST_MEM_B: Store/Load byte: max negative",
5298                 .u.insns_int = {
5299                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
5300                         BPF_ST_MEM(BPF_B, R10, -40, 0xff),
5301                         BPF_LDX_MEM(BPF_B, R0, R10, -40),
5302                         BPF_EXIT_INSN(),
5303                 },
5304                 INTERNAL,
5305                 { },
5306                 { { 0, 0xff } },
5307                 .stack_depth = 40,
5308         },
5309         {
5310                 "ST_MEM_B: Store/Load byte: max positive",
5311                 .u.insns_int = {
5312                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
5313                         BPF_ST_MEM(BPF_H, R10, -40, 0x7f),
5314                         BPF_LDX_MEM(BPF_H, R0, R10, -40),
5315                         BPF_EXIT_INSN(),
5316                 },
5317                 INTERNAL,
5318                 { },
5319                 { { 0, 0x7f } },
5320                 .stack_depth = 40,
5321         },
5322         {
5323                 "STX_MEM_B: Store/Load byte: max negative",
5324                 .u.insns_int = {
5325                         BPF_LD_IMM64(R0, 0),
5326                         BPF_LD_IMM64(R1, 0xffLL),
5327                         BPF_STX_MEM(BPF_B, R10, R1, -40),
5328                         BPF_LDX_MEM(BPF_B, R0, R10, -40),
5329                         BPF_EXIT_INSN(),
5330                 },
5331                 INTERNAL,
5332                 { },
5333                 { { 0, 0xff } },
5334                 .stack_depth = 40,
5335         },
5336         {
5337                 "ST_MEM_H: Store/Load half word: max negative",
5338                 .u.insns_int = {
5339                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
5340                         BPF_ST_MEM(BPF_H, R10, -40, 0xffff),
5341                         BPF_LDX_MEM(BPF_H, R0, R10, -40),
5342                         BPF_EXIT_INSN(),
5343                 },
5344                 INTERNAL,
5345                 { },
5346                 { { 0, 0xffff } },
5347                 .stack_depth = 40,
5348         },
5349         {
5350                 "ST_MEM_H: Store/Load half word: max positive",
5351                 .u.insns_int = {
5352                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
5353                         BPF_ST_MEM(BPF_H, R10, -40, 0x7fff),
5354                         BPF_LDX_MEM(BPF_H, R0, R10, -40),
5355                         BPF_EXIT_INSN(),
5356                 },
5357                 INTERNAL,
5358                 { },
5359                 { { 0, 0x7fff } },
5360                 .stack_depth = 40,
5361         },
5362         {
5363                 "STX_MEM_H: Store/Load half word: max negative",
5364                 .u.insns_int = {
5365                         BPF_LD_IMM64(R0, 0),
5366                         BPF_LD_IMM64(R1, 0xffffLL),
5367                         BPF_STX_MEM(BPF_H, R10, R1, -40),
5368                         BPF_LDX_MEM(BPF_H, R0, R10, -40),
5369                         BPF_EXIT_INSN(),
5370                 },
5371                 INTERNAL,
5372                 { },
5373                 { { 0, 0xffff } },
5374                 .stack_depth = 40,
5375         },
5376         {
5377                 "ST_MEM_W: Store/Load word: max negative",
5378                 .u.insns_int = {
5379                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
5380                         BPF_ST_MEM(BPF_W, R10, -40, 0xffffffff),
5381                         BPF_LDX_MEM(BPF_W, R0, R10, -40),
5382                         BPF_EXIT_INSN(),
5383                 },
5384                 INTERNAL,
5385                 { },
5386                 { { 0, 0xffffffff } },
5387                 .stack_depth = 40,
5388         },
5389         {
5390                 "ST_MEM_W: Store/Load word: max positive",
5391                 .u.insns_int = {
5392                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
5393                         BPF_ST_MEM(BPF_W, R10, -40, 0x7fffffff),
5394                         BPF_LDX_MEM(BPF_W, R0, R10, -40),
5395                         BPF_EXIT_INSN(),
5396                 },
5397                 INTERNAL,
5398                 { },
5399                 { { 0, 0x7fffffff } },
5400                 .stack_depth = 40,
5401         },
5402         {
5403                 "STX_MEM_W: Store/Load word: max negative",
5404                 .u.insns_int = {
5405                         BPF_LD_IMM64(R0, 0),
5406                         BPF_LD_IMM64(R1, 0xffffffffLL),
5407                         BPF_STX_MEM(BPF_W, R10, R1, -40),
5408                         BPF_LDX_MEM(BPF_W, R0, R10, -40),
5409                         BPF_EXIT_INSN(),
5410                 },
5411                 INTERNAL,
5412                 { },
5413                 { { 0, 0xffffffff } },
5414                 .stack_depth = 40,
5415         },
5416         {
5417                 "ST_MEM_DW: Store/Load double word: max negative",
5418                 .u.insns_int = {
5419                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
5420                         BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
5421                         BPF_LDX_MEM(BPF_DW, R0, R10, -40),
5422                         BPF_EXIT_INSN(),
5423                 },
5424                 INTERNAL,
5425                 { },
5426                 { { 0, 0xffffffff } },
5427                 .stack_depth = 40,
5428         },
5429         {
5430                 "ST_MEM_DW: Store/Load double word: max negative 2",
5431                 .u.insns_int = {
5432                         BPF_LD_IMM64(R2, 0xffff00000000ffffLL),
5433                         BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
5434                         BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
5435                         BPF_LDX_MEM(BPF_DW, R2, R10, -40),
5436                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5437                         BPF_MOV32_IMM(R0, 2),
5438                         BPF_EXIT_INSN(),
5439                         BPF_MOV32_IMM(R0, 1),
5440                         BPF_EXIT_INSN(),
5441                 },
5442                 INTERNAL,
5443                 { },
5444                 { { 0, 0x1 } },
5445                 .stack_depth = 40,
5446         },
5447         {
5448                 "ST_MEM_DW: Store/Load double word: max positive",
5449                 .u.insns_int = {
5450                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
5451                         BPF_ST_MEM(BPF_DW, R10, -40, 0x7fffffff),
5452                         BPF_LDX_MEM(BPF_DW, R0, R10, -40),
5453                         BPF_EXIT_INSN(),
5454                 },
5455                 INTERNAL,
5456                 { },
5457                 { { 0, 0x7fffffff } },
5458                 .stack_depth = 40,
5459         },
5460         {
5461                 "STX_MEM_DW: Store/Load double word: max negative",
5462                 .u.insns_int = {
5463                         BPF_LD_IMM64(R0, 0),
5464                         BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
5465                         BPF_STX_MEM(BPF_DW, R10, R1, -40),
5466                         BPF_LDX_MEM(BPF_DW, R0, R10, -40),
5467                         BPF_EXIT_INSN(),
5468                 },
5469                 INTERNAL,
5470                 { },
5471                 { { 0, 0xffffffff } },
5472                 .stack_depth = 40,
5473         },
5474         {
5475                 "STX_MEM_DW: Store double word: first word in memory",
5476                 .u.insns_int = {
5477                         BPF_LD_IMM64(R0, 0),
5478                         BPF_LD_IMM64(R1, 0x0123456789abcdefLL),
5479                         BPF_STX_MEM(BPF_DW, R10, R1, -40),
5480                         BPF_LDX_MEM(BPF_W, R0, R10, -40),
5481                         BPF_EXIT_INSN(),
5482                 },
5483                 INTERNAL,
5484                 { },
5485 #ifdef __BIG_ENDIAN
5486                 { { 0, 0x01234567 } },
5487 #else
5488                 { { 0, 0x89abcdef } },
5489 #endif
5490                 .stack_depth = 40,
5491         },
5492         {
5493                 "STX_MEM_DW: Store double word: second word in memory",
5494                 .u.insns_int = {
5495                         BPF_LD_IMM64(R0, 0),
5496                         BPF_LD_IMM64(R1, 0x0123456789abcdefLL),
5497                         BPF_STX_MEM(BPF_DW, R10, R1, -40),
5498                         BPF_LDX_MEM(BPF_W, R0, R10, -36),
5499                         BPF_EXIT_INSN(),
5500                 },
5501                 INTERNAL,
5502                 { },
5503 #ifdef __BIG_ENDIAN
5504                 { { 0, 0x89abcdef } },
5505 #else
5506                 { { 0, 0x01234567 } },
5507 #endif
5508                 .stack_depth = 40,
5509         },
5510         /* BPF_STX | BPF_ATOMIC | BPF_W/DW */
5511         {
5512                 "STX_XADD_W: X + 1 + 1 + 1 + ...",
5513                 { },
5514                 INTERNAL,
5515                 { },
5516                 { { 0, 4134 } },
5517                 .fill_helper = bpf_fill_stxw,
5518         },
5519         {
5520                 "STX_XADD_DW: X + 1 + 1 + 1 + ...",
5521                 { },
5522                 INTERNAL,
5523                 { },
5524                 { { 0, 4134 } },
5525                 .fill_helper = bpf_fill_stxdw,
5526         },
5527         /*
5528          * Exhaustive tests of atomic operation variants.
5529          * Individual tests are expanded from template macros for all
5530          * combinations of ALU operation, word size and fetching.
5531          */
5532 #define BPF_ATOMIC_OP_TEST1(width, op, logic, old, update, result)      \
5533 {                                                                       \
5534         "BPF_ATOMIC | " #width ", " #op ": Test: "                      \
5535                 #old " " #logic " " #update " = " #result,              \
5536         .u.insns_int = {                                                \
5537                 BPF_ALU32_IMM(BPF_MOV, R5, update),                     \
5538                 BPF_ST_MEM(width, R10, -40, old),                       \
5539                 BPF_ATOMIC_OP(width, op, R10, R5, -40),                 \
5540                 BPF_LDX_MEM(width, R0, R10, -40),                       \
5541                 BPF_EXIT_INSN(),                                        \
5542         },                                                              \
5543         INTERNAL,                                                       \
5544         { },                                                            \
5545         { { 0, result } },                                              \
5546         .stack_depth = 40,                                              \
5547 }
5548 #define BPF_ATOMIC_OP_TEST2(width, op, logic, old, update, result)      \
5549 {                                                                       \
5550         "BPF_ATOMIC | " #width ", " #op ": Test side effects, r10: "    \
5551                 #old " " #logic " " #update " = " #result,              \
5552         .u.insns_int = {                                                \
5553                 BPF_ALU64_REG(BPF_MOV, R1, R10),                        \
5554                 BPF_ALU32_IMM(BPF_MOV, R0, update),                     \
5555                 BPF_ST_MEM(BPF_W, R10, -40, old),                       \
5556                 BPF_ATOMIC_OP(width, op, R10, R0, -40),                 \
5557                 BPF_ALU64_REG(BPF_MOV, R0, R10),                        \
5558                 BPF_ALU64_REG(BPF_SUB, R0, R1),                         \
5559                 BPF_EXIT_INSN(),                                        \
5560         },                                                              \
5561         INTERNAL,                                                       \
5562         { },                                                            \
5563         { { 0, 0 } },                                                   \
5564         .stack_depth = 40,                                              \
5565 }
5566 #define BPF_ATOMIC_OP_TEST3(width, op, logic, old, update, result)      \
5567 {                                                                       \
5568         "BPF_ATOMIC | " #width ", " #op ": Test side effects, r0: "     \
5569                 #old " " #logic " " #update " = " #result,              \
5570         .u.insns_int = {                                                \
5571                 BPF_ALU64_REG(BPF_MOV, R0, R10),                        \
5572                 BPF_ALU32_IMM(BPF_MOV, R1, update),                     \
5573                 BPF_ST_MEM(width, R10, -40, old),                       \
5574                 BPF_ATOMIC_OP(width, op, R10, R1, -40),                 \
5575                 BPF_ALU64_REG(BPF_SUB, R0, R10),                        \
5576                 BPF_EXIT_INSN(),                                        \
5577         },                                                              \
5578         INTERNAL,                                                       \
5579         { },                                                            \
5580         { { 0, 0 } },                                                   \
5581         .stack_depth = 40,                                              \
5582 }
5583 #define BPF_ATOMIC_OP_TEST4(width, op, logic, old, update, result)      \
5584 {                                                                       \
5585         "BPF_ATOMIC | " #width ", " #op ": Test fetch: "                \
5586                 #old " " #logic " " #update " = " #result,              \
5587         .u.insns_int = {                                                \
5588                 BPF_ALU32_IMM(BPF_MOV, R3, update),                     \
5589                 BPF_ST_MEM(width, R10, -40, old),                       \
5590                 BPF_ATOMIC_OP(width, op, R10, R3, -40),                 \
5591                 BPF_ALU64_REG(BPF_MOV, R0, R3),                         \
5592                 BPF_EXIT_INSN(),                                        \
5593         },                                                              \
5594         INTERNAL,                                                       \
5595         { },                                                            \
5596         { { 0, (op) & BPF_FETCH ? old : update } },                     \
5597         .stack_depth = 40,                                              \
5598 }
5599         /* BPF_ATOMIC | BPF_W: BPF_ADD */
5600         BPF_ATOMIC_OP_TEST1(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
5601         BPF_ATOMIC_OP_TEST2(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
5602         BPF_ATOMIC_OP_TEST3(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
5603         BPF_ATOMIC_OP_TEST4(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
5604         /* BPF_ATOMIC | BPF_W: BPF_ADD | BPF_FETCH */
5605         BPF_ATOMIC_OP_TEST1(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
5606         BPF_ATOMIC_OP_TEST2(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
5607         BPF_ATOMIC_OP_TEST3(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
5608         BPF_ATOMIC_OP_TEST4(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
5609         /* BPF_ATOMIC | BPF_DW: BPF_ADD */
5610         BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
5611         BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
5612         BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
5613         BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
5614         /* BPF_ATOMIC | BPF_DW: BPF_ADD | BPF_FETCH */
5615         BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
5616         BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
5617         BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
5618         BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
5619         /* BPF_ATOMIC | BPF_W: BPF_AND */
5620         BPF_ATOMIC_OP_TEST1(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
5621         BPF_ATOMIC_OP_TEST2(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
5622         BPF_ATOMIC_OP_TEST3(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
5623         BPF_ATOMIC_OP_TEST4(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
5624         /* BPF_ATOMIC | BPF_W: BPF_AND | BPF_FETCH */
5625         BPF_ATOMIC_OP_TEST1(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
5626         BPF_ATOMIC_OP_TEST2(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
5627         BPF_ATOMIC_OP_TEST3(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
5628         BPF_ATOMIC_OP_TEST4(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
5629         /* BPF_ATOMIC | BPF_DW: BPF_AND */
5630         BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
5631         BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
5632         BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
5633         BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
5634         /* BPF_ATOMIC | BPF_DW: BPF_AND | BPF_FETCH */
5635         BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
5636         BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
5637         BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
5638         BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
5639         /* BPF_ATOMIC | BPF_W: BPF_OR */
5640         BPF_ATOMIC_OP_TEST1(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
5641         BPF_ATOMIC_OP_TEST2(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
5642         BPF_ATOMIC_OP_TEST3(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
5643         BPF_ATOMIC_OP_TEST4(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
5644         /* BPF_ATOMIC | BPF_W: BPF_OR | BPF_FETCH */
5645         BPF_ATOMIC_OP_TEST1(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
5646         BPF_ATOMIC_OP_TEST2(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
5647         BPF_ATOMIC_OP_TEST3(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
5648         BPF_ATOMIC_OP_TEST4(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
5649         /* BPF_ATOMIC | BPF_DW: BPF_OR */
5650         BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
5651         BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
5652         BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
5653         BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
5654         /* BPF_ATOMIC | BPF_DW: BPF_OR | BPF_FETCH */
5655         BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
5656         BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
5657         BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
5658         BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
5659         /* BPF_ATOMIC | BPF_W: BPF_XOR */
5660         BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
5661         BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
5662         BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
5663         BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
5664         /* BPF_ATOMIC | BPF_W: BPF_XOR | BPF_FETCH */
5665         BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
5666         BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
5667         BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
5668         BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
5669         /* BPF_ATOMIC | BPF_DW: BPF_XOR */
5670         BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
5671         BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
5672         BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
5673         BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
5674         /* BPF_ATOMIC | BPF_DW: BPF_XOR | BPF_FETCH */
5675         BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
5676         BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
5677         BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
5678         BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
5679         /* BPF_ATOMIC | BPF_W: BPF_XCHG */
5680         BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
5681         BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
5682         BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
5683         BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
5684         /* BPF_ATOMIC | BPF_DW: BPF_XCHG */
5685         BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
5686         BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
5687         BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
5688         BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
5689 #undef BPF_ATOMIC_OP_TEST1
5690 #undef BPF_ATOMIC_OP_TEST2
5691 #undef BPF_ATOMIC_OP_TEST3
5692 #undef BPF_ATOMIC_OP_TEST4
5693         /* BPF_ATOMIC | BPF_W, BPF_CMPXCHG */
5694         {
5695                 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test successful return",
5696                 .u.insns_int = {
5697                         BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
5698                         BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
5699                         BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
5700                         BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
5701                         BPF_EXIT_INSN(),
5702                 },
5703                 INTERNAL,
5704                 { },
5705                 { { 0, 0x01234567 } },
5706                 .stack_depth = 40,
5707         },
5708         {
5709                 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test successful store",
5710                 .u.insns_int = {
5711                         BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
5712                         BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
5713                         BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
5714                         BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
5715                         BPF_LDX_MEM(BPF_W, R0, R10, -40),
5716                         BPF_EXIT_INSN(),
5717                 },
5718                 INTERNAL,
5719                 { },
5720                 { { 0, 0x89abcdef } },
5721                 .stack_depth = 40,
5722         },
5723         {
5724                 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test failure return",
5725                 .u.insns_int = {
5726                         BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
5727                         BPF_ALU32_IMM(BPF_MOV, R0, 0x76543210),
5728                         BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
5729                         BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
5730                         BPF_EXIT_INSN(),
5731                 },
5732                 INTERNAL,
5733                 { },
5734                 { { 0, 0x01234567 } },
5735                 .stack_depth = 40,
5736         },
5737         {
5738                 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test failure store",
5739                 .u.insns_int = {
5740                         BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
5741                         BPF_ALU32_IMM(BPF_MOV, R0, 0x76543210),
5742                         BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
5743                         BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
5744                         BPF_LDX_MEM(BPF_W, R0, R10, -40),
5745                         BPF_EXIT_INSN(),
5746                 },
5747                 INTERNAL,
5748                 { },
5749                 { { 0, 0x01234567 } },
5750                 .stack_depth = 40,
5751         },
5752         {
5753                 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test side effects",
5754                 .u.insns_int = {
5755                         BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
5756                         BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
5757                         BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
5758                         BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
5759                         BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
5760                         BPF_ALU32_REG(BPF_MOV, R0, R3),
5761                         BPF_EXIT_INSN(),
5762                 },
5763                 INTERNAL,
5764                 { },
5765                 { { 0, 0x89abcdef } },
5766                 .stack_depth = 40,
5767         },
5768         /* BPF_ATOMIC | BPF_DW, BPF_CMPXCHG */
5769         {
5770                 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test successful return",
5771                 .u.insns_int = {
5772                         BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
5773                         BPF_LD_IMM64(R2, 0xfecdba9876543210ULL),
5774                         BPF_ALU64_REG(BPF_MOV, R0, R1),
5775                         BPF_STX_MEM(BPF_DW, R10, R1, -40),
5776                         BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
5777                         BPF_JMP_REG(BPF_JNE, R0, R1, 1),
5778                         BPF_ALU64_REG(BPF_SUB, R0, R1),
5779                         BPF_EXIT_INSN(),
5780                 },
5781                 INTERNAL,
5782                 { },
5783                 { { 0, 0 } },
5784                 .stack_depth = 40,
5785         },
5786         {
5787                 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test successful store",
5788                 .u.insns_int = {
5789                         BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
5790                         BPF_LD_IMM64(R2, 0xfecdba9876543210ULL),
5791                         BPF_ALU64_REG(BPF_MOV, R0, R1),
5792                         BPF_STX_MEM(BPF_DW, R10, R0, -40),
5793                         BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
5794                         BPF_LDX_MEM(BPF_DW, R0, R10, -40),
5795                         BPF_JMP_REG(BPF_JNE, R0, R2, 1),
5796                         BPF_ALU64_REG(BPF_SUB, R0, R2),
5797                         BPF_EXIT_INSN(),
5798                 },
5799                 INTERNAL,
5800                 { },
5801                 { { 0, 0 } },
5802                 .stack_depth = 40,
5803         },
5804         {
5805                 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test failure return",
5806                 .u.insns_int = {
5807                         BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
5808                         BPF_LD_IMM64(R2, 0xfecdba9876543210ULL),
5809                         BPF_ALU64_REG(BPF_MOV, R0, R1),
5810                         BPF_ALU64_IMM(BPF_ADD, R0, 1),
5811                         BPF_STX_MEM(BPF_DW, R10, R1, -40),
5812                         BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
5813                         BPF_JMP_REG(BPF_JNE, R0, R1, 1),
5814                         BPF_ALU64_REG(BPF_SUB, R0, R1),
5815                         BPF_EXIT_INSN(),
5816                 },
5817                 INTERNAL,
5818                 { },
5819                 { { 0, 0 } },
5820                 .stack_depth = 40,
5821         },
5822         {
5823                 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test failure store",
5824                 .u.insns_int = {
5825                         BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
5826                         BPF_LD_IMM64(R2, 0xfecdba9876543210ULL),
5827                         BPF_ALU64_REG(BPF_MOV, R0, R1),
5828                         BPF_ALU64_IMM(BPF_ADD, R0, 1),
5829                         BPF_STX_MEM(BPF_DW, R10, R1, -40),
5830                         BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
5831                         BPF_LDX_MEM(BPF_DW, R0, R10, -40),
5832                         BPF_JMP_REG(BPF_JNE, R0, R1, 1),
5833                         BPF_ALU64_REG(BPF_SUB, R0, R1),
5834                         BPF_EXIT_INSN(),
5835                 },
5836                 INTERNAL,
5837                 { },
5838                 { { 0, 0 } },
5839                 .stack_depth = 40,
5840         },
5841         {
5842                 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test side effects",
5843                 .u.insns_int = {
5844                         BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
5845                         BPF_LD_IMM64(R2, 0xfecdba9876543210ULL),
5846                         BPF_ALU64_REG(BPF_MOV, R0, R1),
5847                         BPF_STX_MEM(BPF_DW, R10, R1, -40),
5848                         BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
5849                         BPF_LD_IMM64(R0, 0xfecdba9876543210ULL),
5850                         BPF_JMP_REG(BPF_JNE, R0, R2, 1),
5851                         BPF_ALU64_REG(BPF_SUB, R0, R2),
5852                         BPF_EXIT_INSN(),
5853                 },
5854                 INTERNAL,
5855                 { },
5856                 { { 0, 0 } },
5857                 .stack_depth = 40,
5858         },
5859         /* BPF_JMP32 | BPF_JEQ | BPF_K */
5860         {
5861                 "JMP32_JEQ_K: Small immediate",
5862                 .u.insns_int = {
5863                         BPF_ALU32_IMM(BPF_MOV, R0, 123),
5864                         BPF_JMP32_IMM(BPF_JEQ, R0, 321, 1),
5865                         BPF_JMP32_IMM(BPF_JEQ, R0, 123, 1),
5866                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5867                         BPF_EXIT_INSN(),
5868                 },
5869                 INTERNAL,
5870                 { },
5871                 { { 0, 123 } }
5872         },
5873         {
5874                 "JMP32_JEQ_K: Large immediate",
5875                 .u.insns_int = {
5876                         BPF_ALU32_IMM(BPF_MOV, R0, 12345678),
5877                         BPF_JMP32_IMM(BPF_JEQ, R0, 12345678 & 0xffff, 1),
5878                         BPF_JMP32_IMM(BPF_JEQ, R0, 12345678, 1),
5879                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5880                         BPF_EXIT_INSN(),
5881                 },
5882                 INTERNAL,
5883                 { },
5884                 { { 0, 12345678 } }
5885         },
5886         {
5887                 "JMP32_JEQ_K: negative immediate",
5888                 .u.insns_int = {
5889                         BPF_ALU32_IMM(BPF_MOV, R0, -123),
5890                         BPF_JMP32_IMM(BPF_JEQ, R0,  123, 1),
5891                         BPF_JMP32_IMM(BPF_JEQ, R0, -123, 1),
5892                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5893                         BPF_EXIT_INSN(),
5894                 },
5895                 INTERNAL,
5896                 { },
5897                 { { 0, -123 } }
5898         },
5899         /* BPF_JMP32 | BPF_JEQ | BPF_X */
5900         {
5901                 "JMP32_JEQ_X",
5902                 .u.insns_int = {
5903                         BPF_ALU32_IMM(BPF_MOV, R0, 1234),
5904                         BPF_ALU32_IMM(BPF_MOV, R1, 4321),
5905                         BPF_JMP32_REG(BPF_JEQ, R0, R1, 2),
5906                         BPF_ALU32_IMM(BPF_MOV, R1, 1234),
5907                         BPF_JMP32_REG(BPF_JEQ, R0, R1, 1),
5908                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5909                         BPF_EXIT_INSN(),
5910                 },
5911                 INTERNAL,
5912                 { },
5913                 { { 0, 1234 } }
5914         },
5915         /* BPF_JMP32 | BPF_JNE | BPF_K */
5916         {
5917                 "JMP32_JNE_K: Small immediate",
5918                 .u.insns_int = {
5919                         BPF_ALU32_IMM(BPF_MOV, R0, 123),
5920                         BPF_JMP32_IMM(BPF_JNE, R0, 123, 1),
5921                         BPF_JMP32_IMM(BPF_JNE, R0, 321, 1),
5922                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5923                         BPF_EXIT_INSN(),
5924                 },
5925                 INTERNAL,
5926                 { },
5927                 { { 0, 123 } }
5928         },
5929         {
5930                 "JMP32_JNE_K: Large immediate",
5931                 .u.insns_int = {
5932                         BPF_ALU32_IMM(BPF_MOV, R0, 12345678),
5933                         BPF_JMP32_IMM(BPF_JNE, R0, 12345678, 1),
5934                         BPF_JMP32_IMM(BPF_JNE, R0, 12345678 & 0xffff, 1),
5935                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5936                         BPF_EXIT_INSN(),
5937                 },
5938                 INTERNAL,
5939                 { },
5940                 { { 0, 12345678 } }
5941         },
5942         {
5943                 "JMP32_JNE_K: negative immediate",
5944                 .u.insns_int = {
5945                         BPF_ALU32_IMM(BPF_MOV, R0, -123),
5946                         BPF_JMP32_IMM(BPF_JNE, R0, -123, 1),
5947                         BPF_JMP32_IMM(BPF_JNE, R0,  123, 1),
5948                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5949                         BPF_EXIT_INSN(),
5950                 },
5951                 INTERNAL,
5952                 { },
5953                 { { 0, -123 } }
5954         },
5955         /* BPF_JMP32 | BPF_JNE | BPF_X */
5956         {
5957                 "JMP32_JNE_X",
5958                 .u.insns_int = {
5959                         BPF_ALU32_IMM(BPF_MOV, R0, 1234),
5960                         BPF_ALU32_IMM(BPF_MOV, R1, 1234),
5961                         BPF_JMP32_REG(BPF_JNE, R0, R1, 2),
5962                         BPF_ALU32_IMM(BPF_MOV, R1, 4321),
5963                         BPF_JMP32_REG(BPF_JNE, R0, R1, 1),
5964                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5965                         BPF_EXIT_INSN(),
5966                 },
5967                 INTERNAL,
5968                 { },
5969                 { { 0, 1234 } }
5970         },
5971         /* BPF_JMP32 | BPF_JSET | BPF_K */
5972         {
5973                 "JMP32_JSET_K: Small immediate",
5974                 .u.insns_int = {
5975                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
5976                         BPF_JMP32_IMM(BPF_JSET, R0, 2, 1),
5977                         BPF_JMP32_IMM(BPF_JSET, R0, 3, 1),
5978                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5979                         BPF_EXIT_INSN(),
5980                 },
5981                 INTERNAL,
5982                 { },
5983                 { { 0, 1 } }
5984         },
5985         {
5986                 "JMP32_JSET_K: Large immediate",
5987                 .u.insns_int = {
5988                         BPF_ALU32_IMM(BPF_MOV, R0, 0x40000000),
5989                         BPF_JMP32_IMM(BPF_JSET, R0, 0x3fffffff, 1),
5990                         BPF_JMP32_IMM(BPF_JSET, R0, 0x60000000, 1),
5991                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5992                         BPF_EXIT_INSN(),
5993                 },
5994                 INTERNAL,
5995                 { },
5996                 { { 0, 0x40000000 } }
5997         },
5998         {
5999                 "JMP32_JSET_K: negative immediate",
6000                 .u.insns_int = {
6001                         BPF_ALU32_IMM(BPF_MOV, R0, -123),
6002                         BPF_JMP32_IMM(BPF_JSET, R0, -1, 1),
6003                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6004                         BPF_EXIT_INSN(),
6005                 },
6006                 INTERNAL,
6007                 { },
6008                 { { 0, -123 } }
6009         },
6010         /* BPF_JMP32 | BPF_JSET | BPF_X */
6011         {
6012                 "JMP32_JSET_X",
6013                 .u.insns_int = {
6014                         BPF_ALU32_IMM(BPF_MOV, R0, 8),
6015                         BPF_ALU32_IMM(BPF_MOV, R1, 7),
6016                         BPF_JMP32_REG(BPF_JSET, R0, R1, 2),
6017                         BPF_ALU32_IMM(BPF_MOV, R1, 8 | 2),
6018                         BPF_JMP32_REG(BPF_JNE, R0, R1, 1),
6019                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6020                         BPF_EXIT_INSN(),
6021                 },
6022                 INTERNAL,
6023                 { },
6024                 { { 0, 8 } }
6025         },
6026         /* BPF_JMP32 | BPF_JGT | BPF_K */
6027         {
6028                 "JMP32_JGT_K: Small immediate",
6029                 .u.insns_int = {
6030                         BPF_ALU32_IMM(BPF_MOV, R0, 123),
6031                         BPF_JMP32_IMM(BPF_JGT, R0, 123, 1),
6032                         BPF_JMP32_IMM(BPF_JGT, R0, 122, 1),
6033                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6034                         BPF_EXIT_INSN(),
6035                 },
6036                 INTERNAL,
6037                 { },
6038                 { { 0, 123 } }
6039         },
6040         {
6041                 "JMP32_JGT_K: Large immediate",
6042                 .u.insns_int = {
6043                         BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
6044                         BPF_JMP32_IMM(BPF_JGT, R0, 0xffffffff, 1),
6045                         BPF_JMP32_IMM(BPF_JGT, R0, 0xfffffffd, 1),
6046                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6047                         BPF_EXIT_INSN(),
6048                 },
6049                 INTERNAL,
6050                 { },
6051                 { { 0, 0xfffffffe } }
6052         },
6053         /* BPF_JMP32 | BPF_JGT | BPF_X */
6054         {
6055                 "JMP32_JGT_X",
6056                 .u.insns_int = {
6057                         BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
6058                         BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6059                         BPF_JMP32_REG(BPF_JGT, R0, R1, 2),
6060                         BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
6061                         BPF_JMP32_REG(BPF_JGT, R0, R1, 1),
6062                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6063                         BPF_EXIT_INSN(),
6064                 },
6065                 INTERNAL,
6066                 { },
6067                 { { 0, 0xfffffffe } }
6068         },
6069         /* BPF_JMP32 | BPF_JGE | BPF_K */
6070         {
6071                 "JMP32_JGE_K: Small immediate",
6072                 .u.insns_int = {
6073                         BPF_ALU32_IMM(BPF_MOV, R0, 123),
6074                         BPF_JMP32_IMM(BPF_JGE, R0, 124, 1),
6075                         BPF_JMP32_IMM(BPF_JGE, R0, 123, 1),
6076                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6077                         BPF_EXIT_INSN(),
6078                 },
6079                 INTERNAL,
6080                 { },
6081                 { { 0, 123 } }
6082         },
6083         {
6084                 "JMP32_JGE_K: Large immediate",
6085                 .u.insns_int = {
6086                         BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
6087                         BPF_JMP32_IMM(BPF_JGE, R0, 0xffffffff, 1),
6088                         BPF_JMP32_IMM(BPF_JGE, R0, 0xfffffffe, 1),
6089                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6090                         BPF_EXIT_INSN(),
6091                 },
6092                 INTERNAL,
6093                 { },
6094                 { { 0, 0xfffffffe } }
6095         },
6096         /* BPF_JMP32 | BPF_JGE | BPF_X */
6097         {
6098                 "JMP32_JGE_X",
6099                 .u.insns_int = {
6100                         BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
6101                         BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6102                         BPF_JMP32_REG(BPF_JGE, R0, R1, 2),
6103                         BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffe),
6104                         BPF_JMP32_REG(BPF_JGE, R0, R1, 1),
6105                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6106                         BPF_EXIT_INSN(),
6107                 },
6108                 INTERNAL,
6109                 { },
6110                 { { 0, 0xfffffffe } }
6111         },
6112         /* BPF_JMP32 | BPF_JLT | BPF_K */
6113         {
6114                 "JMP32_JLT_K: Small immediate",
6115                 .u.insns_int = {
6116                         BPF_ALU32_IMM(BPF_MOV, R0, 123),
6117                         BPF_JMP32_IMM(BPF_JLT, R0, 123, 1),
6118                         BPF_JMP32_IMM(BPF_JLT, R0, 124, 1),
6119                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6120                         BPF_EXIT_INSN(),
6121                 },
6122                 INTERNAL,
6123                 { },
6124                 { { 0, 123 } }
6125         },
6126         {
6127                 "JMP32_JLT_K: Large immediate",
6128                 .u.insns_int = {
6129                         BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
6130                         BPF_JMP32_IMM(BPF_JLT, R0, 0xfffffffd, 1),
6131                         BPF_JMP32_IMM(BPF_JLT, R0, 0xffffffff, 1),
6132                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6133                         BPF_EXIT_INSN(),
6134                 },
6135                 INTERNAL,
6136                 { },
6137                 { { 0, 0xfffffffe } }
6138         },
6139         /* BPF_JMP32 | BPF_JLT | BPF_X */
6140         {
6141                 "JMP32_JLT_X",
6142                 .u.insns_int = {
6143                         BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
6144                         BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
6145                         BPF_JMP32_REG(BPF_JLT, R0, R1, 2),
6146                         BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6147                         BPF_JMP32_REG(BPF_JLT, R0, R1, 1),
6148                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6149                         BPF_EXIT_INSN(),
6150                 },
6151                 INTERNAL,
6152                 { },
6153                 { { 0, 0xfffffffe } }
6154         },
6155         /* BPF_JMP32 | BPF_JLE | BPF_K */
6156         {
6157                 "JMP32_JLE_K: Small immediate",
6158                 .u.insns_int = {
6159                         BPF_ALU32_IMM(BPF_MOV, R0, 123),
6160                         BPF_JMP32_IMM(BPF_JLE, R0, 122, 1),
6161                         BPF_JMP32_IMM(BPF_JLE, R0, 123, 1),
6162                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6163                         BPF_EXIT_INSN(),
6164                 },
6165                 INTERNAL,
6166                 { },
6167                 { { 0, 123 } }
6168         },
6169         {
6170                 "JMP32_JLE_K: Large immediate",
6171                 .u.insns_int = {
6172                         BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
6173                         BPF_JMP32_IMM(BPF_JLE, R0, 0xfffffffd, 1),
6174                         BPF_JMP32_IMM(BPF_JLE, R0, 0xfffffffe, 1),
6175                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6176                         BPF_EXIT_INSN(),
6177                 },
6178                 INTERNAL,
6179                 { },
6180                 { { 0, 0xfffffffe } }
6181         },
6182         /* BPF_JMP32 | BPF_JLE | BPF_X */
6183         {
6184                 "JMP32_JLE_X",
6185                 .u.insns_int = {
6186                         BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
6187                         BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
6188                         BPF_JMP32_REG(BPF_JLE, R0, R1, 2),
6189                         BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffe),
6190                         BPF_JMP32_REG(BPF_JLE, R0, R1, 1),
6191                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6192                         BPF_EXIT_INSN(),
6193                 },
6194                 INTERNAL,
6195                 { },
6196                 { { 0, 0xfffffffe } }
6197         },
6198         /* BPF_JMP32 | BPF_JSGT | BPF_K */
6199         {
6200                 "JMP32_JSGT_K: Small immediate",
6201                 .u.insns_int = {
6202                         BPF_ALU32_IMM(BPF_MOV, R0, -123),
6203                         BPF_JMP32_IMM(BPF_JSGT, R0, -123, 1),
6204                         BPF_JMP32_IMM(BPF_JSGT, R0, -124, 1),
6205                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6206                         BPF_EXIT_INSN(),
6207                 },
6208                 INTERNAL,
6209                 { },
6210                 { { 0, -123 } }
6211         },
6212         {
6213                 "JMP32_JSGT_K: Large immediate",
6214                 .u.insns_int = {
6215                         BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
6216                         BPF_JMP32_IMM(BPF_JSGT, R0, -12345678, 1),
6217                         BPF_JMP32_IMM(BPF_JSGT, R0, -12345679, 1),
6218                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6219                         BPF_EXIT_INSN(),
6220                 },
6221                 INTERNAL,
6222                 { },
6223                 { { 0, -12345678 } }
6224         },
6225         /* BPF_JMP32 | BPF_JSGT | BPF_X */
6226         {
6227                 "JMP32_JSGT_X",
6228                 .u.insns_int = {
6229                         BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
6230                         BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
6231                         BPF_JMP32_REG(BPF_JSGT, R0, R1, 2),
6232                         BPF_ALU32_IMM(BPF_MOV, R1, -12345679),
6233                         BPF_JMP32_REG(BPF_JSGT, R0, R1, 1),
6234                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6235                         BPF_EXIT_INSN(),
6236                 },
6237                 INTERNAL,
6238                 { },
6239                 { { 0, -12345678 } }
6240         },
6241         /* BPF_JMP32 | BPF_JSGE | BPF_K */
6242         {
6243                 "JMP32_JSGE_K: Small immediate",
6244                 .u.insns_int = {
6245                         BPF_ALU32_IMM(BPF_MOV, R0, -123),
6246                         BPF_JMP32_IMM(BPF_JSGE, R0, -122, 1),
6247                         BPF_JMP32_IMM(BPF_JSGE, R0, -123, 1),
6248                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6249                         BPF_EXIT_INSN(),
6250                 },
6251                 INTERNAL,
6252                 { },
6253                 { { 0, -123 } }
6254         },
6255         {
6256                 "JMP32_JSGE_K: Large immediate",
6257                 .u.insns_int = {
6258                         BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
6259                         BPF_JMP32_IMM(BPF_JSGE, R0, -12345677, 1),
6260                         BPF_JMP32_IMM(BPF_JSGE, R0, -12345678, 1),
6261                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6262                         BPF_EXIT_INSN(),
6263                 },
6264                 INTERNAL,
6265                 { },
6266                 { { 0, -12345678 } }
6267         },
6268         /* BPF_JMP32 | BPF_JSGE | BPF_X */
6269         {
6270                 "JMP32_JSGE_X",
6271                 .u.insns_int = {
6272                         BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
6273                         BPF_ALU32_IMM(BPF_MOV, R1, -12345677),
6274                         BPF_JMP32_REG(BPF_JSGE, R0, R1, 2),
6275                         BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
6276                         BPF_JMP32_REG(BPF_JSGE, R0, R1, 1),
6277                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6278                         BPF_EXIT_INSN(),
6279                 },
6280                 INTERNAL,
6281                 { },
6282                 { { 0, -12345678 } }
6283         },
6284         /* BPF_JMP32 | BPF_JSLT | BPF_K */
6285         {
6286                 "JMP32_JSLT_K: Small immediate",
6287                 .u.insns_int = {
6288                         BPF_ALU32_IMM(BPF_MOV, R0, -123),
6289                         BPF_JMP32_IMM(BPF_JSLT, R0, -123, 1),
6290                         BPF_JMP32_IMM(BPF_JSLT, R0, -122, 1),
6291                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6292                         BPF_EXIT_INSN(),
6293                 },
6294                 INTERNAL,
6295                 { },
6296                 { { 0, -123 } }
6297         },
6298         {
6299                 "JMP32_JSLT_K: Large immediate",
6300                 .u.insns_int = {
6301                         BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
6302                         BPF_JMP32_IMM(BPF_JSLT, R0, -12345678, 1),
6303                         BPF_JMP32_IMM(BPF_JSLT, R0, -12345677, 1),
6304                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6305                         BPF_EXIT_INSN(),
6306                 },
6307                 INTERNAL,
6308                 { },
6309                 { { 0, -12345678 } }
6310         },
6311         /* BPF_JMP32 | BPF_JSLT | BPF_X */
6312         {
6313                 "JMP32_JSLT_X",
6314                 .u.insns_int = {
6315                         BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
6316                         BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
6317                         BPF_JMP32_REG(BPF_JSLT, R0, R1, 2),
6318                         BPF_ALU32_IMM(BPF_MOV, R1, -12345677),
6319                         BPF_JMP32_REG(BPF_JSLT, R0, R1, 1),
6320                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6321                         BPF_EXIT_INSN(),
6322                 },
6323                 INTERNAL,
6324                 { },
6325                 { { 0, -12345678 } }
6326         },
6327         /* BPF_JMP32 | BPF_JSLE | BPF_K */
6328         {
6329                 "JMP32_JSLE_K: Small immediate",
6330                 .u.insns_int = {
6331                         BPF_ALU32_IMM(BPF_MOV, R0, -123),
6332                         BPF_JMP32_IMM(BPF_JSLE, R0, -124, 1),
6333                         BPF_JMP32_IMM(BPF_JSLE, R0, -123, 1),
6334                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6335                         BPF_EXIT_INSN(),
6336                 },
6337                 INTERNAL,
6338                 { },
6339                 { { 0, -123 } }
6340         },
6341         {
6342                 "JMP32_JSLE_K: Large immediate",
6343                 .u.insns_int = {
6344                         BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
6345                         BPF_JMP32_IMM(BPF_JSLE, R0, -12345679, 1),
6346                         BPF_JMP32_IMM(BPF_JSLE, R0, -12345678, 1),
6347                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6348                         BPF_EXIT_INSN(),
6349                 },
6350                 INTERNAL,
6351                 { },
6352                 { { 0, -12345678 } }
6353         },
6354         /* BPF_JMP32 | BPF_JSLE | BPF_K */
6355         {
6356                 "JMP32_JSLE_X",
6357                 .u.insns_int = {
6358                         BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
6359                         BPF_ALU32_IMM(BPF_MOV, R1, -12345679),
6360                         BPF_JMP32_REG(BPF_JSLE, R0, R1, 2),
6361                         BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
6362                         BPF_JMP32_REG(BPF_JSLE, R0, R1, 1),
6363                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6364                         BPF_EXIT_INSN(),
6365                 },
6366                 INTERNAL,
6367                 { },
6368                 { { 0, -12345678 } }
6369         },
6370         /* BPF_JMP | BPF_EXIT */
6371         {
6372                 "JMP_EXIT",
6373                 .u.insns_int = {
6374                         BPF_ALU32_IMM(BPF_MOV, R0, 0x4711),
6375                         BPF_EXIT_INSN(),
6376                         BPF_ALU32_IMM(BPF_MOV, R0, 0x4712),
6377                 },
6378                 INTERNAL,
6379                 { },
6380                 { { 0, 0x4711 } },
6381         },
6382         /* BPF_JMP | BPF_JA */
6383         {
6384                 "JMP_JA: Unconditional jump: if (true) return 1",
6385                 .u.insns_int = {
6386                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6387                         BPF_JMP_IMM(BPF_JA, 0, 0, 1),
6388                         BPF_EXIT_INSN(),
6389                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6390                         BPF_EXIT_INSN(),
6391                 },
6392                 INTERNAL,
6393                 { },
6394                 { { 0, 1 } },
6395         },
6396         /* BPF_JMP | BPF_JSLT | BPF_K */
6397         {
6398                 "JMP_JSLT_K: Signed jump: if (-2 < -1) return 1",
6399                 .u.insns_int = {
6400                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6401                         BPF_LD_IMM64(R1, 0xfffffffffffffffeLL),
6402                         BPF_JMP_IMM(BPF_JSLT, R1, -1, 1),
6403                         BPF_EXIT_INSN(),
6404                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6405                         BPF_EXIT_INSN(),
6406                 },
6407                 INTERNAL,
6408                 { },
6409                 { { 0, 1 } },
6410         },
6411         {
6412                 "JMP_JSLT_K: Signed jump: if (-1 < -1) return 0",
6413                 .u.insns_int = {
6414                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6415                         BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
6416                         BPF_JMP_IMM(BPF_JSLT, R1, -1, 1),
6417                         BPF_EXIT_INSN(),
6418                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6419                         BPF_EXIT_INSN(),
6420                 },
6421                 INTERNAL,
6422                 { },
6423                 { { 0, 1 } },
6424         },
6425         /* BPF_JMP | BPF_JSGT | BPF_K */
6426         {
6427                 "JMP_JSGT_K: Signed jump: if (-1 > -2) return 1",
6428                 .u.insns_int = {
6429                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6430                         BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
6431                         BPF_JMP_IMM(BPF_JSGT, R1, -2, 1),
6432                         BPF_EXIT_INSN(),
6433                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6434                         BPF_EXIT_INSN(),
6435                 },
6436                 INTERNAL,
6437                 { },
6438                 { { 0, 1 } },
6439         },
6440         {
6441                 "JMP_JSGT_K: Signed jump: if (-1 > -1) return 0",
6442                 .u.insns_int = {
6443                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6444                         BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
6445                         BPF_JMP_IMM(BPF_JSGT, R1, -1, 1),
6446                         BPF_EXIT_INSN(),
6447                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6448                         BPF_EXIT_INSN(),
6449                 },
6450                 INTERNAL,
6451                 { },
6452                 { { 0, 1 } },
6453         },
6454         /* BPF_JMP | BPF_JSLE | BPF_K */
6455         {
6456                 "JMP_JSLE_K: Signed jump: if (-2 <= -1) return 1",
6457                 .u.insns_int = {
6458                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6459                         BPF_LD_IMM64(R1, 0xfffffffffffffffeLL),
6460                         BPF_JMP_IMM(BPF_JSLE, R1, -1, 1),
6461                         BPF_EXIT_INSN(),
6462                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6463                         BPF_EXIT_INSN(),
6464                 },
6465                 INTERNAL,
6466                 { },
6467                 { { 0, 1 } },
6468         },
6469         {
6470                 "JMP_JSLE_K: Signed jump: if (-1 <= -1) return 1",
6471                 .u.insns_int = {
6472                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6473                         BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
6474                         BPF_JMP_IMM(BPF_JSLE, R1, -1, 1),
6475                         BPF_EXIT_INSN(),
6476                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6477                         BPF_EXIT_INSN(),
6478                 },
6479                 INTERNAL,
6480                 { },
6481                 { { 0, 1 } },
6482         },
6483         {
6484                 "JMP_JSLE_K: Signed jump: value walk 1",
6485                 .u.insns_int = {
6486                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6487                         BPF_LD_IMM64(R1, 3),
6488                         BPF_JMP_IMM(BPF_JSLE, R1, 0, 6),
6489                         BPF_ALU64_IMM(BPF_SUB, R1, 1),
6490                         BPF_JMP_IMM(BPF_JSLE, R1, 0, 4),
6491                         BPF_ALU64_IMM(BPF_SUB, R1, 1),
6492                         BPF_JMP_IMM(BPF_JSLE, R1, 0, 2),
6493                         BPF_ALU64_IMM(BPF_SUB, R1, 1),
6494                         BPF_JMP_IMM(BPF_JSLE, R1, 0, 1),
6495                         BPF_EXIT_INSN(),                /* bad exit */
6496                         BPF_ALU32_IMM(BPF_MOV, R0, 1),  /* good exit */
6497                         BPF_EXIT_INSN(),
6498                 },
6499                 INTERNAL,
6500                 { },
6501                 { { 0, 1 } },
6502         },
6503         {
6504                 "JMP_JSLE_K: Signed jump: value walk 2",
6505                 .u.insns_int = {
6506                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6507                         BPF_LD_IMM64(R1, 3),
6508                         BPF_JMP_IMM(BPF_JSLE, R1, 0, 4),
6509                         BPF_ALU64_IMM(BPF_SUB, R1, 2),
6510                         BPF_JMP_IMM(BPF_JSLE, R1, 0, 2),
6511                         BPF_ALU64_IMM(BPF_SUB, R1, 2),
6512                         BPF_JMP_IMM(BPF_JSLE, R1, 0, 1),
6513                         BPF_EXIT_INSN(),                /* bad exit */
6514                         BPF_ALU32_IMM(BPF_MOV, R0, 1),  /* good exit */
6515                         BPF_EXIT_INSN(),
6516                 },
6517                 INTERNAL,
6518                 { },
6519                 { { 0, 1 } },
6520         },
6521         /* BPF_JMP | BPF_JSGE | BPF_K */
6522         {
6523                 "JMP_JSGE_K: Signed jump: if (-1 >= -2) return 1",
6524                 .u.insns_int = {
6525                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6526                         BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
6527                         BPF_JMP_IMM(BPF_JSGE, R1, -2, 1),
6528                         BPF_EXIT_INSN(),
6529                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6530                         BPF_EXIT_INSN(),
6531                 },
6532                 INTERNAL,
6533                 { },
6534                 { { 0, 1 } },
6535         },
6536         {
6537                 "JMP_JSGE_K: Signed jump: if (-1 >= -1) return 1",
6538                 .u.insns_int = {
6539                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6540                         BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
6541                         BPF_JMP_IMM(BPF_JSGE, R1, -1, 1),
6542                         BPF_EXIT_INSN(),
6543                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6544                         BPF_EXIT_INSN(),
6545                 },
6546                 INTERNAL,
6547                 { },
6548                 { { 0, 1 } },
6549         },
6550         {
6551                 "JMP_JSGE_K: Signed jump: value walk 1",
6552                 .u.insns_int = {
6553                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6554                         BPF_LD_IMM64(R1, -3),
6555                         BPF_JMP_IMM(BPF_JSGE, R1, 0, 6),
6556                         BPF_ALU64_IMM(BPF_ADD, R1, 1),
6557                         BPF_JMP_IMM(BPF_JSGE, R1, 0, 4),
6558                         BPF_ALU64_IMM(BPF_ADD, R1, 1),
6559                         BPF_JMP_IMM(BPF_JSGE, R1, 0, 2),
6560                         BPF_ALU64_IMM(BPF_ADD, R1, 1),
6561                         BPF_JMP_IMM(BPF_JSGE, R1, 0, 1),
6562                         BPF_EXIT_INSN(),                /* bad exit */
6563                         BPF_ALU32_IMM(BPF_MOV, R0, 1),  /* good exit */
6564                         BPF_EXIT_INSN(),
6565                 },
6566                 INTERNAL,
6567                 { },
6568                 { { 0, 1 } },
6569         },
6570         {
6571                 "JMP_JSGE_K: Signed jump: value walk 2",
6572                 .u.insns_int = {
6573                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6574                         BPF_LD_IMM64(R1, -3),
6575                         BPF_JMP_IMM(BPF_JSGE, R1, 0, 4),
6576                         BPF_ALU64_IMM(BPF_ADD, R1, 2),
6577                         BPF_JMP_IMM(BPF_JSGE, R1, 0, 2),
6578                         BPF_ALU64_IMM(BPF_ADD, R1, 2),
6579                         BPF_JMP_IMM(BPF_JSGE, R1, 0, 1),
6580                         BPF_EXIT_INSN(),                /* bad exit */
6581                         BPF_ALU32_IMM(BPF_MOV, R0, 1),  /* good exit */
6582                         BPF_EXIT_INSN(),
6583                 },
6584                 INTERNAL,
6585                 { },
6586                 { { 0, 1 } },
6587         },
6588         /* BPF_JMP | BPF_JGT | BPF_K */
6589         {
6590                 "JMP_JGT_K: if (3 > 2) return 1",
6591                 .u.insns_int = {
6592                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6593                         BPF_LD_IMM64(R1, 3),
6594                         BPF_JMP_IMM(BPF_JGT, R1, 2, 1),
6595                         BPF_EXIT_INSN(),
6596                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6597                         BPF_EXIT_INSN(),
6598                 },
6599                 INTERNAL,
6600                 { },
6601                 { { 0, 1 } },
6602         },
6603         {
6604                 "JMP_JGT_K: Unsigned jump: if (-1 > 1) return 1",
6605                 .u.insns_int = {
6606                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6607                         BPF_LD_IMM64(R1, -1),
6608                         BPF_JMP_IMM(BPF_JGT, R1, 1, 1),
6609                         BPF_EXIT_INSN(),
6610                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6611                         BPF_EXIT_INSN(),
6612                 },
6613                 INTERNAL,
6614                 { },
6615                 { { 0, 1 } },
6616         },
6617         /* BPF_JMP | BPF_JLT | BPF_K */
6618         {
6619                 "JMP_JLT_K: if (2 < 3) return 1",
6620                 .u.insns_int = {
6621                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6622                         BPF_LD_IMM64(R1, 2),
6623                         BPF_JMP_IMM(BPF_JLT, R1, 3, 1),
6624                         BPF_EXIT_INSN(),
6625                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6626                         BPF_EXIT_INSN(),
6627                 },
6628                 INTERNAL,
6629                 { },
6630                 { { 0, 1 } },
6631         },
6632         {
6633                 "JMP_JGT_K: Unsigned jump: if (1 < -1) return 1",
6634                 .u.insns_int = {
6635                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6636                         BPF_LD_IMM64(R1, 1),
6637                         BPF_JMP_IMM(BPF_JLT, R1, -1, 1),
6638                         BPF_EXIT_INSN(),
6639                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6640                         BPF_EXIT_INSN(),
6641                 },
6642                 INTERNAL,
6643                 { },
6644                 { { 0, 1 } },
6645         },
6646         /* BPF_JMP | BPF_JGE | BPF_K */
6647         {
6648                 "JMP_JGE_K: if (3 >= 2) return 1",
6649                 .u.insns_int = {
6650                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6651                         BPF_LD_IMM64(R1, 3),
6652                         BPF_JMP_IMM(BPF_JGE, R1, 2, 1),
6653                         BPF_EXIT_INSN(),
6654                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6655                         BPF_EXIT_INSN(),
6656                 },
6657                 INTERNAL,
6658                 { },
6659                 { { 0, 1 } },
6660         },
6661         /* BPF_JMP | BPF_JLE | BPF_K */
6662         {
6663                 "JMP_JLE_K: if (2 <= 3) return 1",
6664                 .u.insns_int = {
6665                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6666                         BPF_LD_IMM64(R1, 2),
6667                         BPF_JMP_IMM(BPF_JLE, R1, 3, 1),
6668                         BPF_EXIT_INSN(),
6669                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6670                         BPF_EXIT_INSN(),
6671                 },
6672                 INTERNAL,
6673                 { },
6674                 { { 0, 1 } },
6675         },
6676         /* BPF_JMP | BPF_JGT | BPF_K jump backwards */
6677         {
6678                 "JMP_JGT_K: if (3 > 2) return 1 (jump backwards)",
6679                 .u.insns_int = {
6680                         BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
6681                         BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */
6682                         BPF_EXIT_INSN(),
6683                         BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
6684                         BPF_LD_IMM64(R1, 3), /* note: this takes 2 insns */
6685                         BPF_JMP_IMM(BPF_JGT, R1, 2, -6), /* goto out */
6686                         BPF_EXIT_INSN(),
6687                 },
6688                 INTERNAL,
6689                 { },
6690                 { { 0, 1 } },
6691         },
6692         {
6693                 "JMP_JGE_K: if (3 >= 3) return 1",
6694                 .u.insns_int = {
6695                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6696                         BPF_LD_IMM64(R1, 3),
6697                         BPF_JMP_IMM(BPF_JGE, R1, 3, 1),
6698                         BPF_EXIT_INSN(),
6699                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6700                         BPF_EXIT_INSN(),
6701                 },
6702                 INTERNAL,
6703                 { },
6704                 { { 0, 1 } },
6705         },
6706         /* BPF_JMP | BPF_JLT | BPF_K jump backwards */
6707         {
6708                 "JMP_JGT_K: if (2 < 3) return 1 (jump backwards)",
6709                 .u.insns_int = {
6710                         BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
6711                         BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */
6712                         BPF_EXIT_INSN(),
6713                         BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
6714                         BPF_LD_IMM64(R1, 2), /* note: this takes 2 insns */
6715                         BPF_JMP_IMM(BPF_JLT, R1, 3, -6), /* goto out */
6716                         BPF_EXIT_INSN(),
6717                 },
6718                 INTERNAL,
6719                 { },
6720                 { { 0, 1 } },
6721         },
6722         {
6723                 "JMP_JLE_K: if (3 <= 3) return 1",
6724                 .u.insns_int = {
6725                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6726                         BPF_LD_IMM64(R1, 3),
6727                         BPF_JMP_IMM(BPF_JLE, R1, 3, 1),
6728                         BPF_EXIT_INSN(),
6729                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6730                         BPF_EXIT_INSN(),
6731                 },
6732                 INTERNAL,
6733                 { },
6734                 { { 0, 1 } },
6735         },
6736         /* BPF_JMP | BPF_JNE | BPF_K */
6737         {
6738                 "JMP_JNE_K: if (3 != 2) return 1",
6739                 .u.insns_int = {
6740                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6741                         BPF_LD_IMM64(R1, 3),
6742                         BPF_JMP_IMM(BPF_JNE, R1, 2, 1),
6743                         BPF_EXIT_INSN(),
6744                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6745                         BPF_EXIT_INSN(),
6746                 },
6747                 INTERNAL,
6748                 { },
6749                 { { 0, 1 } },
6750         },
6751         /* BPF_JMP | BPF_JEQ | BPF_K */
6752         {
6753                 "JMP_JEQ_K: if (3 == 3) return 1",
6754                 .u.insns_int = {
6755                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6756                         BPF_LD_IMM64(R1, 3),
6757                         BPF_JMP_IMM(BPF_JEQ, R1, 3, 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         /* BPF_JMP | BPF_JSET | BPF_K */
6767         {
6768                 "JMP_JSET_K: if (0x3 & 0x2) return 1",
6769                 .u.insns_int = {
6770                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6771                         BPF_LD_IMM64(R1, 3),
6772                         BPF_JMP_IMM(BPF_JSET, R1, 2, 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                 "JMP_JSET_K: if (0x3 & 0xffffffff) return 1",
6783                 .u.insns_int = {
6784                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6785                         BPF_LD_IMM64(R1, 3),
6786                         BPF_JMP_IMM(BPF_JSET, R1, 0xffffffff, 1),
6787                         BPF_EXIT_INSN(),
6788                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6789                         BPF_EXIT_INSN(),
6790                 },
6791                 INTERNAL,
6792                 { },
6793                 { { 0, 1 } },
6794         },
6795         /* BPF_JMP | BPF_JSGT | BPF_X */
6796         {
6797                 "JMP_JSGT_X: Signed jump: if (-1 > -2) return 1",
6798                 .u.insns_int = {
6799                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6800                         BPF_LD_IMM64(R1, -1),
6801                         BPF_LD_IMM64(R2, -2),
6802                         BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
6803                         BPF_EXIT_INSN(),
6804                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6805                         BPF_EXIT_INSN(),
6806                 },
6807                 INTERNAL,
6808                 { },
6809                 { { 0, 1 } },
6810         },
6811         {
6812                 "JMP_JSGT_X: Signed jump: if (-1 > -1) return 0",
6813                 .u.insns_int = {
6814                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6815                         BPF_LD_IMM64(R1, -1),
6816                         BPF_LD_IMM64(R2, -1),
6817                         BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
6818                         BPF_EXIT_INSN(),
6819                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6820                         BPF_EXIT_INSN(),
6821                 },
6822                 INTERNAL,
6823                 { },
6824                 { { 0, 1 } },
6825         },
6826         /* BPF_JMP | BPF_JSLT | BPF_X */
6827         {
6828                 "JMP_JSLT_X: Signed jump: if (-2 < -1) return 1",
6829                 .u.insns_int = {
6830                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6831                         BPF_LD_IMM64(R1, -1),
6832                         BPF_LD_IMM64(R2, -2),
6833                         BPF_JMP_REG(BPF_JSLT, R2, R1, 1),
6834                         BPF_EXIT_INSN(),
6835                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6836                         BPF_EXIT_INSN(),
6837                 },
6838                 INTERNAL,
6839                 { },
6840                 { { 0, 1 } },
6841         },
6842         {
6843                 "JMP_JSLT_X: Signed jump: if (-1 < -1) return 0",
6844                 .u.insns_int = {
6845                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6846                         BPF_LD_IMM64(R1, -1),
6847                         BPF_LD_IMM64(R2, -1),
6848                         BPF_JMP_REG(BPF_JSLT, R1, R2, 1),
6849                         BPF_EXIT_INSN(),
6850                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6851                         BPF_EXIT_INSN(),
6852                 },
6853                 INTERNAL,
6854                 { },
6855                 { { 0, 1 } },
6856         },
6857         /* BPF_JMP | BPF_JSGE | BPF_X */
6858         {
6859                 "JMP_JSGE_X: Signed jump: if (-1 >= -2) return 1",
6860                 .u.insns_int = {
6861                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6862                         BPF_LD_IMM64(R1, -1),
6863                         BPF_LD_IMM64(R2, -2),
6864                         BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
6865                         BPF_EXIT_INSN(),
6866                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6867                         BPF_EXIT_INSN(),
6868                 },
6869                 INTERNAL,
6870                 { },
6871                 { { 0, 1 } },
6872         },
6873         {
6874                 "JMP_JSGE_X: Signed jump: if (-1 >= -1) return 1",
6875                 .u.insns_int = {
6876                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6877                         BPF_LD_IMM64(R1, -1),
6878                         BPF_LD_IMM64(R2, -1),
6879                         BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
6880                         BPF_EXIT_INSN(),
6881                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6882                         BPF_EXIT_INSN(),
6883                 },
6884                 INTERNAL,
6885                 { },
6886                 { { 0, 1 } },
6887         },
6888         /* BPF_JMP | BPF_JSLE | BPF_X */
6889         {
6890                 "JMP_JSLE_X: Signed jump: if (-2 <= -1) return 1",
6891                 .u.insns_int = {
6892                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6893                         BPF_LD_IMM64(R1, -1),
6894                         BPF_LD_IMM64(R2, -2),
6895                         BPF_JMP_REG(BPF_JSLE, R2, R1, 1),
6896                         BPF_EXIT_INSN(),
6897                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6898                         BPF_EXIT_INSN(),
6899                 },
6900                 INTERNAL,
6901                 { },
6902                 { { 0, 1 } },
6903         },
6904         {
6905                 "JMP_JSLE_X: Signed jump: if (-1 <= -1) return 1",
6906                 .u.insns_int = {
6907                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6908                         BPF_LD_IMM64(R1, -1),
6909                         BPF_LD_IMM64(R2, -1),
6910                         BPF_JMP_REG(BPF_JSLE, R1, R2, 1),
6911                         BPF_EXIT_INSN(),
6912                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6913                         BPF_EXIT_INSN(),
6914                 },
6915                 INTERNAL,
6916                 { },
6917                 { { 0, 1 } },
6918         },
6919         /* BPF_JMP | BPF_JGT | BPF_X */
6920         {
6921                 "JMP_JGT_X: if (3 > 2) return 1",
6922                 .u.insns_int = {
6923                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6924                         BPF_LD_IMM64(R1, 3),
6925                         BPF_LD_IMM64(R2, 2),
6926                         BPF_JMP_REG(BPF_JGT, R1, R2, 1),
6927                         BPF_EXIT_INSN(),
6928                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6929                         BPF_EXIT_INSN(),
6930                 },
6931                 INTERNAL,
6932                 { },
6933                 { { 0, 1 } },
6934         },
6935         {
6936                 "JMP_JGT_X: Unsigned jump: if (-1 > 1) return 1",
6937                 .u.insns_int = {
6938                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6939                         BPF_LD_IMM64(R1, -1),
6940                         BPF_LD_IMM64(R2, 1),
6941                         BPF_JMP_REG(BPF_JGT, R1, R2, 1),
6942                         BPF_EXIT_INSN(),
6943                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6944                         BPF_EXIT_INSN(),
6945                 },
6946                 INTERNAL,
6947                 { },
6948                 { { 0, 1 } },
6949         },
6950         /* BPF_JMP | BPF_JLT | BPF_X */
6951         {
6952                 "JMP_JLT_X: if (2 < 3) return 1",
6953                 .u.insns_int = {
6954                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6955                         BPF_LD_IMM64(R1, 3),
6956                         BPF_LD_IMM64(R2, 2),
6957                         BPF_JMP_REG(BPF_JLT, R2, R1, 1),
6958                         BPF_EXIT_INSN(),
6959                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6960                         BPF_EXIT_INSN(),
6961                 },
6962                 INTERNAL,
6963                 { },
6964                 { { 0, 1 } },
6965         },
6966         {
6967                 "JMP_JLT_X: Unsigned jump: if (1 < -1) return 1",
6968                 .u.insns_int = {
6969                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6970                         BPF_LD_IMM64(R1, -1),
6971                         BPF_LD_IMM64(R2, 1),
6972                         BPF_JMP_REG(BPF_JLT, R2, R1, 1),
6973                         BPF_EXIT_INSN(),
6974                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6975                         BPF_EXIT_INSN(),
6976                 },
6977                 INTERNAL,
6978                 { },
6979                 { { 0, 1 } },
6980         },
6981         /* BPF_JMP | BPF_JGE | BPF_X */
6982         {
6983                 "JMP_JGE_X: if (3 >= 2) return 1",
6984                 .u.insns_int = {
6985                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
6986                         BPF_LD_IMM64(R1, 3),
6987                         BPF_LD_IMM64(R2, 2),
6988                         BPF_JMP_REG(BPF_JGE, R1, R2, 1),
6989                         BPF_EXIT_INSN(),
6990                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
6991                         BPF_EXIT_INSN(),
6992                 },
6993                 INTERNAL,
6994                 { },
6995                 { { 0, 1 } },
6996         },
6997         {
6998                 "JMP_JGE_X: if (3 >= 3) return 1",
6999                 .u.insns_int = {
7000                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
7001                         BPF_LD_IMM64(R1, 3),
7002                         BPF_LD_IMM64(R2, 3),
7003                         BPF_JMP_REG(BPF_JGE, R1, R2, 1),
7004                         BPF_EXIT_INSN(),
7005                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
7006                         BPF_EXIT_INSN(),
7007                 },
7008                 INTERNAL,
7009                 { },
7010                 { { 0, 1 } },
7011         },
7012         /* BPF_JMP | BPF_JLE | BPF_X */
7013         {
7014                 "JMP_JLE_X: if (2 <= 3) return 1",
7015                 .u.insns_int = {
7016                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
7017                         BPF_LD_IMM64(R1, 3),
7018                         BPF_LD_IMM64(R2, 2),
7019                         BPF_JMP_REG(BPF_JLE, R2, R1, 1),
7020                         BPF_EXIT_INSN(),
7021                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
7022                         BPF_EXIT_INSN(),
7023                 },
7024                 INTERNAL,
7025                 { },
7026                 { { 0, 1 } },
7027         },
7028         {
7029                 "JMP_JLE_X: if (3 <= 3) return 1",
7030                 .u.insns_int = {
7031                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
7032                         BPF_LD_IMM64(R1, 3),
7033                         BPF_LD_IMM64(R2, 3),
7034                         BPF_JMP_REG(BPF_JLE, R1, R2, 1),
7035                         BPF_EXIT_INSN(),
7036                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
7037                         BPF_EXIT_INSN(),
7038                 },
7039                 INTERNAL,
7040                 { },
7041                 { { 0, 1 } },
7042         },
7043         {
7044                 /* Mainly testing JIT + imm64 here. */
7045                 "JMP_JGE_X: ldimm64 test 1",
7046                 .u.insns_int = {
7047                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
7048                         BPF_LD_IMM64(R1, 3),
7049                         BPF_LD_IMM64(R2, 2),
7050                         BPF_JMP_REG(BPF_JGE, R1, R2, 2),
7051                         BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
7052                         BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
7053                         BPF_EXIT_INSN(),
7054                 },
7055                 INTERNAL,
7056                 { },
7057                 { { 0, 0xeeeeeeeeU } },
7058         },
7059         {
7060                 "JMP_JGE_X: ldimm64 test 2",
7061                 .u.insns_int = {
7062                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
7063                         BPF_LD_IMM64(R1, 3),
7064                         BPF_LD_IMM64(R2, 2),
7065                         BPF_JMP_REG(BPF_JGE, R1, R2, 0),
7066                         BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
7067                         BPF_EXIT_INSN(),
7068                 },
7069                 INTERNAL,
7070                 { },
7071                 { { 0, 0xffffffffU } },
7072         },
7073         {
7074                 "JMP_JGE_X: ldimm64 test 3",
7075                 .u.insns_int = {
7076                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
7077                         BPF_LD_IMM64(R1, 3),
7078                         BPF_LD_IMM64(R2, 2),
7079                         BPF_JMP_REG(BPF_JGE, R1, R2, 4),
7080                         BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
7081                         BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
7082                         BPF_EXIT_INSN(),
7083                 },
7084                 INTERNAL,
7085                 { },
7086                 { { 0, 1 } },
7087         },
7088         {
7089                 "JMP_JLE_X: ldimm64 test 1",
7090                 .u.insns_int = {
7091                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
7092                         BPF_LD_IMM64(R1, 3),
7093                         BPF_LD_IMM64(R2, 2),
7094                         BPF_JMP_REG(BPF_JLE, R2, R1, 2),
7095                         BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
7096                         BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
7097                         BPF_EXIT_INSN(),
7098                 },
7099                 INTERNAL,
7100                 { },
7101                 { { 0, 0xeeeeeeeeU } },
7102         },
7103         {
7104                 "JMP_JLE_X: ldimm64 test 2",
7105                 .u.insns_int = {
7106                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
7107                         BPF_LD_IMM64(R1, 3),
7108                         BPF_LD_IMM64(R2, 2),
7109                         BPF_JMP_REG(BPF_JLE, R2, R1, 0),
7110                         BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
7111                         BPF_EXIT_INSN(),
7112                 },
7113                 INTERNAL,
7114                 { },
7115                 { { 0, 0xffffffffU } },
7116         },
7117         {
7118                 "JMP_JLE_X: ldimm64 test 3",
7119                 .u.insns_int = {
7120                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
7121                         BPF_LD_IMM64(R1, 3),
7122                         BPF_LD_IMM64(R2, 2),
7123                         BPF_JMP_REG(BPF_JLE, R2, R1, 4),
7124                         BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
7125                         BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
7126                         BPF_EXIT_INSN(),
7127                 },
7128                 INTERNAL,
7129                 { },
7130                 { { 0, 1 } },
7131         },
7132         /* BPF_JMP | BPF_JNE | BPF_X */
7133         {
7134                 "JMP_JNE_X: if (3 != 2) return 1",
7135                 .u.insns_int = {
7136                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
7137                         BPF_LD_IMM64(R1, 3),
7138                         BPF_LD_IMM64(R2, 2),
7139                         BPF_JMP_REG(BPF_JNE, R1, R2, 1),
7140                         BPF_EXIT_INSN(),
7141                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
7142                         BPF_EXIT_INSN(),
7143                 },
7144                 INTERNAL,
7145                 { },
7146                 { { 0, 1 } },
7147         },
7148         /* BPF_JMP | BPF_JEQ | BPF_X */
7149         {
7150                 "JMP_JEQ_X: if (3 == 3) return 1",
7151                 .u.insns_int = {
7152                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
7153                         BPF_LD_IMM64(R1, 3),
7154                         BPF_LD_IMM64(R2, 3),
7155                         BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
7156                         BPF_EXIT_INSN(),
7157                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
7158                         BPF_EXIT_INSN(),
7159                 },
7160                 INTERNAL,
7161                 { },
7162                 { { 0, 1 } },
7163         },
7164         /* BPF_JMP | BPF_JSET | BPF_X */
7165         {
7166                 "JMP_JSET_X: if (0x3 & 0x2) return 1",
7167                 .u.insns_int = {
7168                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
7169                         BPF_LD_IMM64(R1, 3),
7170                         BPF_LD_IMM64(R2, 2),
7171                         BPF_JMP_REG(BPF_JSET, R1, R2, 1),
7172                         BPF_EXIT_INSN(),
7173                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
7174                         BPF_EXIT_INSN(),
7175                 },
7176                 INTERNAL,
7177                 { },
7178                 { { 0, 1 } },
7179         },
7180         {
7181                 "JMP_JSET_X: if (0x3 & 0xffffffff) return 1",
7182                 .u.insns_int = {
7183                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
7184                         BPF_LD_IMM64(R1, 3),
7185                         BPF_LD_IMM64(R2, 0xffffffff),
7186                         BPF_JMP_REG(BPF_JSET, R1, R2, 1),
7187                         BPF_EXIT_INSN(),
7188                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
7189                         BPF_EXIT_INSN(),
7190                 },
7191                 INTERNAL,
7192                 { },
7193                 { { 0, 1 } },
7194         },
7195         {       /* Mainly checking JIT here. */
7196                 "BPF_MAXINSNS: Very long conditional jump",
7197                 { },
7198                 INTERNAL | FLAG_NO_DATA,
7199                 { },
7200                 { { 0, 1 } },
7201                 .fill_helper = bpf_fill_long_jmp,
7202         },
7203         {
7204                 "JMP_JA: Jump, gap, jump, ...",
7205                 { },
7206                 CLASSIC | FLAG_NO_DATA,
7207                 { },
7208                 { { 0, 0xababcbac } },
7209                 .fill_helper = bpf_fill_ja,
7210         },
7211         {       /* Mainly checking JIT here. */
7212                 "BPF_MAXINSNS: Maximum possible literals",
7213                 { },
7214                 CLASSIC | FLAG_NO_DATA,
7215                 { },
7216                 { { 0, 0xffffffff } },
7217                 .fill_helper = bpf_fill_maxinsns1,
7218         },
7219         {       /* Mainly checking JIT here. */
7220                 "BPF_MAXINSNS: Single literal",
7221                 { },
7222                 CLASSIC | FLAG_NO_DATA,
7223                 { },
7224                 { { 0, 0xfefefefe } },
7225                 .fill_helper = bpf_fill_maxinsns2,
7226         },
7227         {       /* Mainly checking JIT here. */
7228                 "BPF_MAXINSNS: Run/add until end",
7229                 { },
7230                 CLASSIC | FLAG_NO_DATA,
7231                 { },
7232                 { { 0, 0x947bf368 } },
7233                 .fill_helper = bpf_fill_maxinsns3,
7234         },
7235         {
7236                 "BPF_MAXINSNS: Too many instructions",
7237                 { },
7238                 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
7239                 { },
7240                 { },
7241                 .fill_helper = bpf_fill_maxinsns4,
7242                 .expected_errcode = -EINVAL,
7243         },
7244         {       /* Mainly checking JIT here. */
7245                 "BPF_MAXINSNS: Very long jump",
7246                 { },
7247                 CLASSIC | FLAG_NO_DATA,
7248                 { },
7249                 { { 0, 0xabababab } },
7250                 .fill_helper = bpf_fill_maxinsns5,
7251         },
7252         {       /* Mainly checking JIT here. */
7253                 "BPF_MAXINSNS: Ctx heavy transformations",
7254                 { },
7255                 CLASSIC,
7256                 { },
7257                 {
7258                         {  1, SKB_VLAN_PRESENT },
7259                         { 10, SKB_VLAN_PRESENT }
7260                 },
7261                 .fill_helper = bpf_fill_maxinsns6,
7262         },
7263         {       /* Mainly checking JIT here. */
7264                 "BPF_MAXINSNS: Call heavy transformations",
7265                 { },
7266                 CLASSIC | FLAG_NO_DATA,
7267                 { },
7268                 { { 1, 0 }, { 10, 0 } },
7269                 .fill_helper = bpf_fill_maxinsns7,
7270         },
7271         {       /* Mainly checking JIT here. */
7272                 "BPF_MAXINSNS: Jump heavy test",
7273                 { },
7274                 CLASSIC | FLAG_NO_DATA,
7275                 { },
7276                 { { 0, 0xffffffff } },
7277                 .fill_helper = bpf_fill_maxinsns8,
7278         },
7279         {       /* Mainly checking JIT here. */
7280                 "BPF_MAXINSNS: Very long jump backwards",
7281                 { },
7282                 INTERNAL | FLAG_NO_DATA,
7283                 { },
7284                 { { 0, 0xcbababab } },
7285                 .fill_helper = bpf_fill_maxinsns9,
7286         },
7287         {       /* Mainly checking JIT here. */
7288                 "BPF_MAXINSNS: Edge hopping nuthouse",
7289                 { },
7290                 INTERNAL | FLAG_NO_DATA,
7291                 { },
7292                 { { 0, 0xabababac } },
7293                 .fill_helper = bpf_fill_maxinsns10,
7294         },
7295         {
7296                 "BPF_MAXINSNS: Jump, gap, jump, ...",
7297                 { },
7298                 CLASSIC | FLAG_NO_DATA,
7299                 { },
7300                 { { 0, 0xababcbac } },
7301                 .fill_helper = bpf_fill_maxinsns11,
7302         },
7303         {
7304                 "BPF_MAXINSNS: jump over MSH",
7305                 { },
7306                 CLASSIC | FLAG_EXPECTED_FAIL,
7307                 { 0xfa, 0xfb, 0xfc, 0xfd, },
7308                 { { 4, 0xabababab } },
7309                 .fill_helper = bpf_fill_maxinsns12,
7310                 .expected_errcode = -EINVAL,
7311         },
7312         {
7313                 "BPF_MAXINSNS: exec all MSH",
7314                 { },
7315                 CLASSIC,
7316                 { 0xfa, 0xfb, 0xfc, 0xfd, },
7317                 { { 4, 0xababab83 } },
7318                 .fill_helper = bpf_fill_maxinsns13,
7319         },
7320         {
7321                 "BPF_MAXINSNS: ld_abs+get_processor_id",
7322                 { },
7323                 CLASSIC,
7324                 { },
7325                 { { 1, 0xbee } },
7326                 .fill_helper = bpf_fill_ld_abs_get_processor_id,
7327         },
7328         /*
7329          * LD_IND / LD_ABS on fragmented SKBs
7330          */
7331         {
7332                 "LD_IND byte frag",
7333                 .u.insns = {
7334                         BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
7335                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x0),
7336                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7337                 },
7338                 CLASSIC | FLAG_SKB_FRAG,
7339                 { },
7340                 { {0x40, 0x42} },
7341                 .frag_data = {
7342                         0x42, 0x00, 0x00, 0x00,
7343                         0x43, 0x44, 0x00, 0x00,
7344                         0x21, 0x07, 0x19, 0x83,
7345                 },
7346         },
7347         {
7348                 "LD_IND halfword frag",
7349                 .u.insns = {
7350                         BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
7351                         BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x4),
7352                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7353                 },
7354                 CLASSIC | FLAG_SKB_FRAG,
7355                 { },
7356                 { {0x40, 0x4344} },
7357                 .frag_data = {
7358                         0x42, 0x00, 0x00, 0x00,
7359                         0x43, 0x44, 0x00, 0x00,
7360                         0x21, 0x07, 0x19, 0x83,
7361                 },
7362         },
7363         {
7364                 "LD_IND word frag",
7365                 .u.insns = {
7366                         BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
7367                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x8),
7368                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7369                 },
7370                 CLASSIC | FLAG_SKB_FRAG,
7371                 { },
7372                 { {0x40, 0x21071983} },
7373                 .frag_data = {
7374                         0x42, 0x00, 0x00, 0x00,
7375                         0x43, 0x44, 0x00, 0x00,
7376                         0x21, 0x07, 0x19, 0x83,
7377                 },
7378         },
7379         {
7380                 "LD_IND halfword mixed head/frag",
7381                 .u.insns = {
7382                         BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
7383                         BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
7384                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7385                 },
7386                 CLASSIC | FLAG_SKB_FRAG,
7387                 { [0x3e] = 0x25, [0x3f] = 0x05, },
7388                 { {0x40, 0x0519} },
7389                 .frag_data = { 0x19, 0x82 },
7390         },
7391         {
7392                 "LD_IND word mixed head/frag",
7393                 .u.insns = {
7394                         BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
7395                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
7396                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7397                 },
7398                 CLASSIC | FLAG_SKB_FRAG,
7399                 { [0x3e] = 0x25, [0x3f] = 0x05, },
7400                 { {0x40, 0x25051982} },
7401                 .frag_data = { 0x19, 0x82 },
7402         },
7403         {
7404                 "LD_ABS byte frag",
7405                 .u.insns = {
7406                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x40),
7407                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7408                 },
7409                 CLASSIC | FLAG_SKB_FRAG,
7410                 { },
7411                 { {0x40, 0x42} },
7412                 .frag_data = {
7413                         0x42, 0x00, 0x00, 0x00,
7414                         0x43, 0x44, 0x00, 0x00,
7415                         0x21, 0x07, 0x19, 0x83,
7416                 },
7417         },
7418         {
7419                 "LD_ABS halfword frag",
7420                 .u.insns = {
7421                         BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x44),
7422                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7423                 },
7424                 CLASSIC | FLAG_SKB_FRAG,
7425                 { },
7426                 { {0x40, 0x4344} },
7427                 .frag_data = {
7428                         0x42, 0x00, 0x00, 0x00,
7429                         0x43, 0x44, 0x00, 0x00,
7430                         0x21, 0x07, 0x19, 0x83,
7431                 },
7432         },
7433         {
7434                 "LD_ABS word frag",
7435                 .u.insns = {
7436                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x48),
7437                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7438                 },
7439                 CLASSIC | FLAG_SKB_FRAG,
7440                 { },
7441                 { {0x40, 0x21071983} },
7442                 .frag_data = {
7443                         0x42, 0x00, 0x00, 0x00,
7444                         0x43, 0x44, 0x00, 0x00,
7445                         0x21, 0x07, 0x19, 0x83,
7446                 },
7447         },
7448         {
7449                 "LD_ABS halfword mixed head/frag",
7450                 .u.insns = {
7451                         BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f),
7452                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7453                 },
7454                 CLASSIC | FLAG_SKB_FRAG,
7455                 { [0x3e] = 0x25, [0x3f] = 0x05, },
7456                 { {0x40, 0x0519} },
7457                 .frag_data = { 0x19, 0x82 },
7458         },
7459         {
7460                 "LD_ABS word mixed head/frag",
7461                 .u.insns = {
7462                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3e),
7463                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7464                 },
7465                 CLASSIC | FLAG_SKB_FRAG,
7466                 { [0x3e] = 0x25, [0x3f] = 0x05, },
7467                 { {0x40, 0x25051982} },
7468                 .frag_data = { 0x19, 0x82 },
7469         },
7470         /*
7471          * LD_IND / LD_ABS on non fragmented SKBs
7472          */
7473         {
7474                 /*
7475                  * this tests that the JIT/interpreter correctly resets X
7476                  * before using it in an LD_IND instruction.
7477                  */
7478                 "LD_IND byte default X",
7479                 .u.insns = {
7480                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
7481                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7482                 },
7483                 CLASSIC,
7484                 { [0x1] = 0x42 },
7485                 { {0x40, 0x42 } },
7486         },
7487         {
7488                 "LD_IND byte positive offset",
7489                 .u.insns = {
7490                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
7491                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
7492                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7493                 },
7494                 CLASSIC,
7495                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7496                 { {0x40, 0x82 } },
7497         },
7498         {
7499                 "LD_IND byte negative offset",
7500                 .u.insns = {
7501                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
7502                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x1),
7503                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7504                 },
7505                 CLASSIC,
7506                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7507                 { {0x40, 0x05 } },
7508         },
7509         {
7510                 "LD_IND byte positive offset, all ff",
7511                 .u.insns = {
7512                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
7513                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
7514                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7515                 },
7516                 CLASSIC,
7517                 { [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
7518                 { {0x40, 0xff } },
7519         },
7520         {
7521                 "LD_IND byte positive offset, out of bounds",
7522                 .u.insns = {
7523                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
7524                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
7525                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7526                 },
7527                 CLASSIC,
7528                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7529                 { {0x3f, 0 }, },
7530         },
7531         {
7532                 "LD_IND byte negative offset, out of bounds",
7533                 .u.insns = {
7534                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
7535                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x3f),
7536                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7537                 },
7538                 CLASSIC,
7539                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7540                 { {0x3f, 0 } },
7541         },
7542         {
7543                 "LD_IND byte negative offset, multiple calls",
7544                 .u.insns = {
7545                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3b),
7546                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 1),
7547                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 2),
7548                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 3),
7549                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 4),
7550                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7551                 },
7552                 CLASSIC,
7553                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7554                 { {0x40, 0x82 }, },
7555         },
7556         {
7557                 "LD_IND halfword positive offset",
7558                 .u.insns = {
7559                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
7560                         BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x2),
7561                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7562                 },
7563                 CLASSIC,
7564                 {
7565                         [0x1c] = 0xaa, [0x1d] = 0x55,
7566                         [0x1e] = 0xbb, [0x1f] = 0x66,
7567                         [0x20] = 0xcc, [0x21] = 0x77,
7568                         [0x22] = 0xdd, [0x23] = 0x88,
7569                 },
7570                 { {0x40, 0xdd88 } },
7571         },
7572         {
7573                 "LD_IND halfword negative offset",
7574                 .u.insns = {
7575                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
7576                         BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x2),
7577                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7578                 },
7579                 CLASSIC,
7580                 {
7581                         [0x1c] = 0xaa, [0x1d] = 0x55,
7582                         [0x1e] = 0xbb, [0x1f] = 0x66,
7583                         [0x20] = 0xcc, [0x21] = 0x77,
7584                         [0x22] = 0xdd, [0x23] = 0x88,
7585                 },
7586                 { {0x40, 0xbb66 } },
7587         },
7588         {
7589                 "LD_IND halfword unaligned",
7590                 .u.insns = {
7591                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
7592                         BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
7593                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7594                 },
7595                 CLASSIC,
7596                 {
7597                         [0x1c] = 0xaa, [0x1d] = 0x55,
7598                         [0x1e] = 0xbb, [0x1f] = 0x66,
7599                         [0x20] = 0xcc, [0x21] = 0x77,
7600                         [0x22] = 0xdd, [0x23] = 0x88,
7601                 },
7602                 { {0x40, 0x66cc } },
7603         },
7604         {
7605                 "LD_IND halfword positive offset, all ff",
7606                 .u.insns = {
7607                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3d),
7608                         BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1),
7609                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7610                 },
7611                 CLASSIC,
7612                 { [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
7613                 { {0x40, 0xffff } },
7614         },
7615         {
7616                 "LD_IND halfword positive offset, out of bounds",
7617                 .u.insns = {
7618                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
7619                         BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1),
7620                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7621                 },
7622                 CLASSIC,
7623                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7624                 { {0x3f, 0 }, },
7625         },
7626         {
7627                 "LD_IND halfword negative offset, out of bounds",
7628                 .u.insns = {
7629                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
7630                         BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x3f),
7631                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7632                 },
7633                 CLASSIC,
7634                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7635                 { {0x3f, 0 } },
7636         },
7637         {
7638                 "LD_IND word positive offset",
7639                 .u.insns = {
7640                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
7641                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x4),
7642                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7643                 },
7644                 CLASSIC,
7645                 {
7646                         [0x1c] = 0xaa, [0x1d] = 0x55,
7647                         [0x1e] = 0xbb, [0x1f] = 0x66,
7648                         [0x20] = 0xcc, [0x21] = 0x77,
7649                         [0x22] = 0xdd, [0x23] = 0x88,
7650                         [0x24] = 0xee, [0x25] = 0x99,
7651                         [0x26] = 0xff, [0x27] = 0xaa,
7652                 },
7653                 { {0x40, 0xee99ffaa } },
7654         },
7655         {
7656                 "LD_IND word negative offset",
7657                 .u.insns = {
7658                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
7659                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x4),
7660                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7661                 },
7662                 CLASSIC,
7663                 {
7664                         [0x1c] = 0xaa, [0x1d] = 0x55,
7665                         [0x1e] = 0xbb, [0x1f] = 0x66,
7666                         [0x20] = 0xcc, [0x21] = 0x77,
7667                         [0x22] = 0xdd, [0x23] = 0x88,
7668                         [0x24] = 0xee, [0x25] = 0x99,
7669                         [0x26] = 0xff, [0x27] = 0xaa,
7670                 },
7671                 { {0x40, 0xaa55bb66 } },
7672         },
7673         {
7674                 "LD_IND word unaligned (addr & 3 == 2)",
7675                 .u.insns = {
7676                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
7677                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
7678                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7679                 },
7680                 CLASSIC,
7681                 {
7682                         [0x1c] = 0xaa, [0x1d] = 0x55,
7683                         [0x1e] = 0xbb, [0x1f] = 0x66,
7684                         [0x20] = 0xcc, [0x21] = 0x77,
7685                         [0x22] = 0xdd, [0x23] = 0x88,
7686                         [0x24] = 0xee, [0x25] = 0x99,
7687                         [0x26] = 0xff, [0x27] = 0xaa,
7688                 },
7689                 { {0x40, 0xbb66cc77 } },
7690         },
7691         {
7692                 "LD_IND word unaligned (addr & 3 == 1)",
7693                 .u.insns = {
7694                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
7695                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3),
7696                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7697                 },
7698                 CLASSIC,
7699                 {
7700                         [0x1c] = 0xaa, [0x1d] = 0x55,
7701                         [0x1e] = 0xbb, [0x1f] = 0x66,
7702                         [0x20] = 0xcc, [0x21] = 0x77,
7703                         [0x22] = 0xdd, [0x23] = 0x88,
7704                         [0x24] = 0xee, [0x25] = 0x99,
7705                         [0x26] = 0xff, [0x27] = 0xaa,
7706                 },
7707                 { {0x40, 0x55bb66cc } },
7708         },
7709         {
7710                 "LD_IND word unaligned (addr & 3 == 3)",
7711                 .u.insns = {
7712                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
7713                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x1),
7714                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7715                 },
7716                 CLASSIC,
7717                 {
7718                         [0x1c] = 0xaa, [0x1d] = 0x55,
7719                         [0x1e] = 0xbb, [0x1f] = 0x66,
7720                         [0x20] = 0xcc, [0x21] = 0x77,
7721                         [0x22] = 0xdd, [0x23] = 0x88,
7722                         [0x24] = 0xee, [0x25] = 0x99,
7723                         [0x26] = 0xff, [0x27] = 0xaa,
7724                 },
7725                 { {0x40, 0x66cc77dd } },
7726         },
7727         {
7728                 "LD_IND word positive offset, all ff",
7729                 .u.insns = {
7730                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3b),
7731                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1),
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_IND word positive offset, out of bounds",
7740                 .u.insns = {
7741                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
7742                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1),
7743                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7744                 },
7745                 CLASSIC,
7746                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7747                 { {0x3f, 0 }, },
7748         },
7749         {
7750                 "LD_IND word negative offset, out of bounds",
7751                 .u.insns = {
7752                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
7753                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3f),
7754                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7755                 },
7756                 CLASSIC,
7757                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7758                 { {0x3f, 0 } },
7759         },
7760         {
7761                 "LD_ABS byte",
7762                 .u.insns = {
7763                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x20),
7764                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7765                 },
7766                 CLASSIC,
7767                 {
7768                         [0x1c] = 0xaa, [0x1d] = 0x55,
7769                         [0x1e] = 0xbb, [0x1f] = 0x66,
7770                         [0x20] = 0xcc, [0x21] = 0x77,
7771                         [0x22] = 0xdd, [0x23] = 0x88,
7772                         [0x24] = 0xee, [0x25] = 0x99,
7773                         [0x26] = 0xff, [0x27] = 0xaa,
7774                 },
7775                 { {0x40, 0xcc } },
7776         },
7777         {
7778                 "LD_ABS byte positive offset, all ff",
7779                 .u.insns = {
7780                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f),
7781                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7782                 },
7783                 CLASSIC,
7784                 { [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
7785                 { {0x40, 0xff } },
7786         },
7787         {
7788                 "LD_ABS byte positive offset, out of bounds",
7789                 .u.insns = {
7790                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f),
7791                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7792                 },
7793                 CLASSIC,
7794                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7795                 { {0x3f, 0 }, },
7796         },
7797         {
7798                 "LD_ABS byte negative offset, out of bounds load",
7799                 .u.insns = {
7800                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, -1),
7801                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7802                 },
7803                 CLASSIC | FLAG_EXPECTED_FAIL,
7804                 .expected_errcode = -EINVAL,
7805         },
7806         {
7807                 "LD_ABS byte negative offset, in bounds",
7808                 .u.insns = {
7809                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
7810                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7811                 },
7812                 CLASSIC,
7813                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7814                 { {0x40, 0x82 }, },
7815         },
7816         {
7817                 "LD_ABS byte negative offset, out of bounds",
7818                 .u.insns = {
7819                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
7820                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7821                 },
7822                 CLASSIC,
7823                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7824                 { {0x3f, 0 }, },
7825         },
7826         {
7827                 "LD_ABS byte negative offset, multiple calls",
7828                 .u.insns = {
7829                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3c),
7830                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3d),
7831                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3e),
7832                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
7833                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7834                 },
7835                 CLASSIC,
7836                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7837                 { {0x40, 0x82 }, },
7838         },
7839         {
7840                 "LD_ABS halfword",
7841                 .u.insns = {
7842                         BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x22),
7843                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7844                 },
7845                 CLASSIC,
7846                 {
7847                         [0x1c] = 0xaa, [0x1d] = 0x55,
7848                         [0x1e] = 0xbb, [0x1f] = 0x66,
7849                         [0x20] = 0xcc, [0x21] = 0x77,
7850                         [0x22] = 0xdd, [0x23] = 0x88,
7851                         [0x24] = 0xee, [0x25] = 0x99,
7852                         [0x26] = 0xff, [0x27] = 0xaa,
7853                 },
7854                 { {0x40, 0xdd88 } },
7855         },
7856         {
7857                 "LD_ABS halfword unaligned",
7858                 .u.insns = {
7859                         BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x25),
7860                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7861                 },
7862                 CLASSIC,
7863                 {
7864                         [0x1c] = 0xaa, [0x1d] = 0x55,
7865                         [0x1e] = 0xbb, [0x1f] = 0x66,
7866                         [0x20] = 0xcc, [0x21] = 0x77,
7867                         [0x22] = 0xdd, [0x23] = 0x88,
7868                         [0x24] = 0xee, [0x25] = 0x99,
7869                         [0x26] = 0xff, [0x27] = 0xaa,
7870                 },
7871                 { {0x40, 0x99ff } },
7872         },
7873         {
7874                 "LD_ABS halfword positive offset, all ff",
7875                 .u.insns = {
7876                         BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3e),
7877                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7878                 },
7879                 CLASSIC,
7880                 { [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
7881                 { {0x40, 0xffff } },
7882         },
7883         {
7884                 "LD_ABS halfword positive offset, out of bounds",
7885                 .u.insns = {
7886                         BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f),
7887                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7888                 },
7889                 CLASSIC,
7890                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7891                 { {0x3f, 0 }, },
7892         },
7893         {
7894                 "LD_ABS halfword negative offset, out of bounds load",
7895                 .u.insns = {
7896                         BPF_STMT(BPF_LD | BPF_ABS | BPF_H, -1),
7897                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7898                 },
7899                 CLASSIC | FLAG_EXPECTED_FAIL,
7900                 .expected_errcode = -EINVAL,
7901         },
7902         {
7903                 "LD_ABS halfword negative offset, in bounds",
7904                 .u.insns = {
7905                         BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e),
7906                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7907                 },
7908                 CLASSIC,
7909                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7910                 { {0x40, 0x1982 }, },
7911         },
7912         {
7913                 "LD_ABS halfword negative offset, out of bounds",
7914                 .u.insns = {
7915                         BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e),
7916                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7917                 },
7918                 CLASSIC,
7919                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7920                 { {0x3f, 0 }, },
7921         },
7922         {
7923                 "LD_ABS word",
7924                 .u.insns = {
7925                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x1c),
7926                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7927                 },
7928                 CLASSIC,
7929                 {
7930                         [0x1c] = 0xaa, [0x1d] = 0x55,
7931                         [0x1e] = 0xbb, [0x1f] = 0x66,
7932                         [0x20] = 0xcc, [0x21] = 0x77,
7933                         [0x22] = 0xdd, [0x23] = 0x88,
7934                         [0x24] = 0xee, [0x25] = 0x99,
7935                         [0x26] = 0xff, [0x27] = 0xaa,
7936                 },
7937                 { {0x40, 0xaa55bb66 } },
7938         },
7939         {
7940                 "LD_ABS word unaligned (addr & 3 == 2)",
7941                 .u.insns = {
7942                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x22),
7943                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7944                 },
7945                 CLASSIC,
7946                 {
7947                         [0x1c] = 0xaa, [0x1d] = 0x55,
7948                         [0x1e] = 0xbb, [0x1f] = 0x66,
7949                         [0x20] = 0xcc, [0x21] = 0x77,
7950                         [0x22] = 0xdd, [0x23] = 0x88,
7951                         [0x24] = 0xee, [0x25] = 0x99,
7952                         [0x26] = 0xff, [0x27] = 0xaa,
7953                 },
7954                 { {0x40, 0xdd88ee99 } },
7955         },
7956         {
7957                 "LD_ABS word unaligned (addr & 3 == 1)",
7958                 .u.insns = {
7959                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x21),
7960                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7961                 },
7962                 CLASSIC,
7963                 {
7964                         [0x1c] = 0xaa, [0x1d] = 0x55,
7965                         [0x1e] = 0xbb, [0x1f] = 0x66,
7966                         [0x20] = 0xcc, [0x21] = 0x77,
7967                         [0x22] = 0xdd, [0x23] = 0x88,
7968                         [0x24] = 0xee, [0x25] = 0x99,
7969                         [0x26] = 0xff, [0x27] = 0xaa,
7970                 },
7971                 { {0x40, 0x77dd88ee } },
7972         },
7973         {
7974                 "LD_ABS word unaligned (addr & 3 == 3)",
7975                 .u.insns = {
7976                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x23),
7977                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7978                 },
7979                 CLASSIC,
7980                 {
7981                         [0x1c] = 0xaa, [0x1d] = 0x55,
7982                         [0x1e] = 0xbb, [0x1f] = 0x66,
7983                         [0x20] = 0xcc, [0x21] = 0x77,
7984                         [0x22] = 0xdd, [0x23] = 0x88,
7985                         [0x24] = 0xee, [0x25] = 0x99,
7986                         [0x26] = 0xff, [0x27] = 0xaa,
7987                 },
7988                 { {0x40, 0x88ee99ff } },
7989         },
7990         {
7991                 "LD_ABS word positive offset, all ff",
7992                 .u.insns = {
7993                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3c),
7994                         BPF_STMT(BPF_RET | BPF_A, 0x0),
7995                 },
7996                 CLASSIC,
7997                 { [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
7998                 { {0x40, 0xffffffff } },
7999         },
8000         {
8001                 "LD_ABS word positive offset, out of bounds",
8002                 .u.insns = {
8003                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3f),
8004                         BPF_STMT(BPF_RET | BPF_A, 0x0),
8005                 },
8006                 CLASSIC,
8007                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
8008                 { {0x3f, 0 }, },
8009         },
8010         {
8011                 "LD_ABS word negative offset, out of bounds load",
8012                 .u.insns = {
8013                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, -1),
8014                         BPF_STMT(BPF_RET | BPF_A, 0x0),
8015                 },
8016                 CLASSIC | FLAG_EXPECTED_FAIL,
8017                 .expected_errcode = -EINVAL,
8018         },
8019         {
8020                 "LD_ABS word negative offset, in bounds",
8021                 .u.insns = {
8022                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c),
8023                         BPF_STMT(BPF_RET | BPF_A, 0x0),
8024                 },
8025                 CLASSIC,
8026                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
8027                 { {0x40, 0x25051982 }, },
8028         },
8029         {
8030                 "LD_ABS word negative offset, out of bounds",
8031                 .u.insns = {
8032                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c),
8033                         BPF_STMT(BPF_RET | BPF_A, 0x0),
8034                 },
8035                 CLASSIC,
8036                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
8037                 { {0x3f, 0 }, },
8038         },
8039         {
8040                 "LDX_MSH standalone, preserved A",
8041                 .u.insns = {
8042                         BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
8043                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
8044                         BPF_STMT(BPF_RET | BPF_A, 0x0),
8045                 },
8046                 CLASSIC,
8047                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
8048                 { {0x40, 0xffeebbaa }, },
8049         },
8050         {
8051                 "LDX_MSH standalone, preserved A 2",
8052                 .u.insns = {
8053                         BPF_STMT(BPF_LD | BPF_IMM, 0x175e9d63),
8054                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
8055                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3d),
8056                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e),
8057                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3f),
8058                         BPF_STMT(BPF_RET | BPF_A, 0x0),
8059                 },
8060                 CLASSIC,
8061                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
8062                 { {0x40, 0x175e9d63 }, },
8063         },
8064         {
8065                 "LDX_MSH standalone, test result 1",
8066                 .u.insns = {
8067                         BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
8068                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
8069                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
8070                         BPF_STMT(BPF_RET | BPF_A, 0x0),
8071                 },
8072                 CLASSIC,
8073                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
8074                 { {0x40, 0x14 }, },
8075         },
8076         {
8077                 "LDX_MSH standalone, test result 2",
8078                 .u.insns = {
8079                         BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
8080                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e),
8081                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
8082                         BPF_STMT(BPF_RET | BPF_A, 0x0),
8083                 },
8084                 CLASSIC,
8085                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
8086                 { {0x40, 0x24 }, },
8087         },
8088         {
8089                 "LDX_MSH standalone, negative offset",
8090                 .u.insns = {
8091                         BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
8092                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, -1),
8093                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
8094                         BPF_STMT(BPF_RET | BPF_A, 0x0),
8095                 },
8096                 CLASSIC,
8097                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
8098                 { {0x40, 0 }, },
8099         },
8100         {
8101                 "LDX_MSH standalone, negative offset 2",
8102                 .u.insns = {
8103                         BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
8104                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, SKF_LL_OFF + 0x3e),
8105                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
8106                         BPF_STMT(BPF_RET | BPF_A, 0x0),
8107                 },
8108                 CLASSIC,
8109                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
8110                 { {0x40, 0x24 }, },
8111         },
8112         {
8113                 "LDX_MSH standalone, out of bounds",
8114                 .u.insns = {
8115                         BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
8116                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x40),
8117                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
8118                         BPF_STMT(BPF_RET | BPF_A, 0x0),
8119                 },
8120                 CLASSIC,
8121                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
8122                 { {0x40, 0 }, },
8123         },
8124         /*
8125          * verify that the interpreter or JIT correctly sets A and X
8126          * to 0.
8127          */
8128         {
8129                 "ADD default X",
8130                 .u.insns = {
8131                         /*
8132                          * A = 0x42
8133                          * A = A + X
8134                          * ret A
8135                          */
8136                         BPF_STMT(BPF_LD | BPF_IMM, 0x42),
8137                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
8138                         BPF_STMT(BPF_RET | BPF_A, 0x0),
8139                 },
8140                 CLASSIC | FLAG_NO_DATA,
8141                 {},
8142                 { {0x1, 0x42 } },
8143         },
8144         {
8145                 "ADD default A",
8146                 .u.insns = {
8147                         /*
8148                          * A = A + 0x42
8149                          * ret A
8150                          */
8151                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0x42),
8152                         BPF_STMT(BPF_RET | BPF_A, 0x0),
8153                 },
8154                 CLASSIC | FLAG_NO_DATA,
8155                 {},
8156                 { {0x1, 0x42 } },
8157         },
8158         {
8159                 "SUB default X",
8160                 .u.insns = {
8161                         /*
8162                          * A = 0x66
8163                          * A = A - X
8164                          * ret A
8165                          */
8166                         BPF_STMT(BPF_LD | BPF_IMM, 0x66),
8167                         BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
8168                         BPF_STMT(BPF_RET | BPF_A, 0x0),
8169                 },
8170                 CLASSIC | FLAG_NO_DATA,
8171                 {},
8172                 { {0x1, 0x66 } },
8173         },
8174         {
8175                 "SUB default A",
8176                 .u.insns = {
8177                         /*
8178                          * A = A - -0x66
8179                          * ret A
8180                          */
8181                         BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, -0x66),
8182                         BPF_STMT(BPF_RET | BPF_A, 0x0),
8183                 },
8184                 CLASSIC | FLAG_NO_DATA,
8185                 {},
8186                 { {0x1, 0x66 } },
8187         },
8188         {
8189                 "MUL default X",
8190                 .u.insns = {
8191                         /*
8192                          * A = 0x42
8193                          * A = A * X
8194                          * ret A
8195                          */
8196                         BPF_STMT(BPF_LD | BPF_IMM, 0x42),
8197                         BPF_STMT(BPF_ALU | BPF_MUL | BPF_X, 0),
8198                         BPF_STMT(BPF_RET | BPF_A, 0x0),
8199                 },
8200                 CLASSIC | FLAG_NO_DATA,
8201                 {},
8202                 { {0x1, 0x0 } },
8203         },
8204         {
8205                 "MUL default A",
8206                 .u.insns = {
8207                         /*
8208                          * A = A * 0x66
8209                          * ret A
8210                          */
8211                         BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 0x66),
8212                         BPF_STMT(BPF_RET | BPF_A, 0x0),
8213                 },
8214                 CLASSIC | FLAG_NO_DATA,
8215                 {},
8216                 { {0x1, 0x0 } },
8217         },
8218         {
8219                 "DIV default X",
8220                 .u.insns = {
8221                         /*
8222                          * A = 0x42
8223                          * A = A / X ; this halt the filter execution if X is 0
8224                          * ret 0x42
8225                          */
8226                         BPF_STMT(BPF_LD | BPF_IMM, 0x42),
8227                         BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
8228                         BPF_STMT(BPF_RET | BPF_K, 0x42),
8229                 },
8230                 CLASSIC | FLAG_NO_DATA,
8231                 {},
8232                 { {0x1, 0x0 } },
8233         },
8234         {
8235                 "DIV default A",
8236                 .u.insns = {
8237                         /*
8238                          * A = A / 1
8239                          * ret A
8240                          */
8241                         BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x1),
8242                         BPF_STMT(BPF_RET | BPF_A, 0x0),
8243                 },
8244                 CLASSIC | FLAG_NO_DATA,
8245                 {},
8246                 { {0x1, 0x0 } },
8247         },
8248         {
8249                 "MOD default X",
8250                 .u.insns = {
8251                         /*
8252                          * A = 0x42
8253                          * A = A mod X ; this halt the filter execution if X is 0
8254                          * ret 0x42
8255                          */
8256                         BPF_STMT(BPF_LD | BPF_IMM, 0x42),
8257                         BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
8258                         BPF_STMT(BPF_RET | BPF_K, 0x42),
8259                 },
8260                 CLASSIC | FLAG_NO_DATA,
8261                 {},
8262                 { {0x1, 0x0 } },
8263         },
8264         {
8265                 "MOD default A",
8266                 .u.insns = {
8267                         /*
8268                          * A = A mod 1
8269                          * ret A
8270                          */
8271                         BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x1),
8272                         BPF_STMT(BPF_RET | BPF_A, 0x0),
8273                 },
8274                 CLASSIC | FLAG_NO_DATA,
8275                 {},
8276                 { {0x1, 0x0 } },
8277         },
8278         {
8279                 "JMP EQ default A",
8280                 .u.insns = {
8281                         /*
8282                          * cmp A, 0x0, 0, 1
8283                          * ret 0x42
8284                          * ret 0x66
8285                          */
8286                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0, 0, 1),
8287                         BPF_STMT(BPF_RET | BPF_K, 0x42),
8288                         BPF_STMT(BPF_RET | BPF_K, 0x66),
8289                 },
8290                 CLASSIC | FLAG_NO_DATA,
8291                 {},
8292                 { {0x1, 0x42 } },
8293         },
8294         {
8295                 "JMP EQ default X",
8296                 .u.insns = {
8297                         /*
8298                          * A = 0x0
8299                          * cmp A, X, 0, 1
8300                          * ret 0x42
8301                          * ret 0x66
8302                          */
8303                         BPF_STMT(BPF_LD | BPF_IMM, 0x0),
8304                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0x0, 0, 1),
8305                         BPF_STMT(BPF_RET | BPF_K, 0x42),
8306                         BPF_STMT(BPF_RET | BPF_K, 0x66),
8307                 },
8308                 CLASSIC | FLAG_NO_DATA,
8309                 {},
8310                 { {0x1, 0x42 } },
8311         },
8312         /* Checking interpreter vs JIT wrt signed extended imms. */
8313         {
8314                 "JNE signed compare, test 1",
8315                 .u.insns_int = {
8316                         BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
8317                         BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
8318                         BPF_MOV64_REG(R2, R1),
8319                         BPF_ALU64_REG(BPF_AND, R2, R3),
8320                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
8321                         BPF_JMP_IMM(BPF_JNE, R2, -17104896, 1),
8322                         BPF_ALU32_IMM(BPF_MOV, R0, 2),
8323                         BPF_EXIT_INSN(),
8324                 },
8325                 INTERNAL,
8326                 { },
8327                 { { 0, 1 } },
8328         },
8329         {
8330                 "JNE signed compare, test 2",
8331                 .u.insns_int = {
8332                         BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
8333                         BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
8334                         BPF_MOV64_REG(R2, R1),
8335                         BPF_ALU64_REG(BPF_AND, R2, R3),
8336                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
8337                         BPF_JMP_IMM(BPF_JNE, R2, 0xfefb0000, 1),
8338                         BPF_ALU32_IMM(BPF_MOV, R0, 2),
8339                         BPF_EXIT_INSN(),
8340                 },
8341                 INTERNAL,
8342                 { },
8343                 { { 0, 1 } },
8344         },
8345         {
8346                 "JNE signed compare, test 3",
8347                 .u.insns_int = {
8348                         BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
8349                         BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
8350                         BPF_ALU32_IMM(BPF_MOV, R4, 0xfefb0000),
8351                         BPF_MOV64_REG(R2, R1),
8352                         BPF_ALU64_REG(BPF_AND, R2, R3),
8353                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
8354                         BPF_JMP_REG(BPF_JNE, R2, R4, 1),
8355                         BPF_ALU32_IMM(BPF_MOV, R0, 2),
8356                         BPF_EXIT_INSN(),
8357                 },
8358                 INTERNAL,
8359                 { },
8360                 { { 0, 2 } },
8361         },
8362         {
8363                 "JNE signed compare, test 4",
8364                 .u.insns_int = {
8365                         BPF_LD_IMM64(R1, -17104896),
8366                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
8367                         BPF_JMP_IMM(BPF_JNE, R1, -17104896, 1),
8368                         BPF_ALU32_IMM(BPF_MOV, R0, 2),
8369                         BPF_EXIT_INSN(),
8370                 },
8371                 INTERNAL,
8372                 { },
8373                 { { 0, 2 } },
8374         },
8375         {
8376                 "JNE signed compare, test 5",
8377                 .u.insns_int = {
8378                         BPF_LD_IMM64(R1, 0xfefb0000),
8379                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
8380                         BPF_JMP_IMM(BPF_JNE, R1, 0xfefb0000, 1),
8381                         BPF_ALU32_IMM(BPF_MOV, R0, 2),
8382                         BPF_EXIT_INSN(),
8383                 },
8384                 INTERNAL,
8385                 { },
8386                 { { 0, 1 } },
8387         },
8388         {
8389                 "JNE signed compare, test 6",
8390                 .u.insns_int = {
8391                         BPF_LD_IMM64(R1, 0x7efb0000),
8392                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
8393                         BPF_JMP_IMM(BPF_JNE, R1, 0x7efb0000, 1),
8394                         BPF_ALU32_IMM(BPF_MOV, R0, 2),
8395                         BPF_EXIT_INSN(),
8396                 },
8397                 INTERNAL,
8398                 { },
8399                 { { 0, 2 } },
8400         },
8401         {
8402                 "JNE signed compare, test 7",
8403                 .u.insns = {
8404                         BPF_STMT(BPF_LD | BPF_IMM, 0xffff0000),
8405                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
8406                         BPF_STMT(BPF_LD | BPF_IMM, 0xfefbbc12),
8407                         BPF_STMT(BPF_ALU | BPF_AND | BPF_X, 0),
8408                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0xfefb0000, 1, 0),
8409                         BPF_STMT(BPF_RET | BPF_K, 1),
8410                         BPF_STMT(BPF_RET | BPF_K, 2),
8411                 },
8412                 CLASSIC | FLAG_NO_DATA,
8413                 {},
8414                 { { 0, 2 } },
8415         },
8416 };
8417
8418 static struct net_device dev;
8419
8420 static struct sk_buff *populate_skb(char *buf, int size)
8421 {
8422         struct sk_buff *skb;
8423
8424         if (size >= MAX_DATA)
8425                 return NULL;
8426
8427         skb = alloc_skb(MAX_DATA, GFP_KERNEL);
8428         if (!skb)
8429                 return NULL;
8430
8431         __skb_put_data(skb, buf, size);
8432
8433         /* Initialize a fake skb with test pattern. */
8434         skb_reset_mac_header(skb);
8435         skb->protocol = htons(ETH_P_IP);
8436         skb->pkt_type = SKB_TYPE;
8437         skb->mark = SKB_MARK;
8438         skb->hash = SKB_HASH;
8439         skb->queue_mapping = SKB_QUEUE_MAP;
8440         skb->vlan_tci = SKB_VLAN_TCI;
8441         skb->vlan_present = SKB_VLAN_PRESENT;
8442         skb->vlan_proto = htons(ETH_P_IP);
8443         dev_net_set(&dev, &init_net);
8444         skb->dev = &dev;
8445         skb->dev->ifindex = SKB_DEV_IFINDEX;
8446         skb->dev->type = SKB_DEV_TYPE;
8447         skb_set_network_header(skb, min(size, ETH_HLEN));
8448
8449         return skb;
8450 }
8451
8452 static void *generate_test_data(struct bpf_test *test, int sub)
8453 {
8454         struct sk_buff *skb;
8455         struct page *page;
8456
8457         if (test->aux & FLAG_NO_DATA)
8458                 return NULL;
8459
8460         /* Test case expects an skb, so populate one. Various
8461          * subtests generate skbs of different sizes based on
8462          * the same data.
8463          */
8464         skb = populate_skb(test->data, test->test[sub].data_size);
8465         if (!skb)
8466                 return NULL;
8467
8468         if (test->aux & FLAG_SKB_FRAG) {
8469                 /*
8470                  * when the test requires a fragmented skb, add a
8471                  * single fragment to the skb, filled with
8472                  * test->frag_data.
8473                  */
8474                 void *ptr;
8475
8476                 page = alloc_page(GFP_KERNEL);
8477
8478                 if (!page)
8479                         goto err_kfree_skb;
8480
8481                 ptr = kmap(page);
8482                 if (!ptr)
8483                         goto err_free_page;
8484                 memcpy(ptr, test->frag_data, MAX_DATA);
8485                 kunmap(page);
8486                 skb_add_rx_frag(skb, 0, page, 0, MAX_DATA, MAX_DATA);
8487         }
8488
8489         return skb;
8490
8491 err_free_page:
8492         __free_page(page);
8493 err_kfree_skb:
8494         kfree_skb(skb);
8495         return NULL;
8496 }
8497
8498 static void release_test_data(const struct bpf_test *test, void *data)
8499 {
8500         if (test->aux & FLAG_NO_DATA)
8501                 return;
8502
8503         kfree_skb(data);
8504 }
8505
8506 static int filter_length(int which)
8507 {
8508         struct sock_filter *fp;
8509         int len;
8510
8511         if (tests[which].fill_helper)
8512                 return tests[which].u.ptr.len;
8513
8514         fp = tests[which].u.insns;
8515         for (len = MAX_INSNS - 1; len > 0; --len)
8516                 if (fp[len].code != 0 || fp[len].k != 0)
8517                         break;
8518
8519         return len + 1;
8520 }
8521
8522 static void *filter_pointer(int which)
8523 {
8524         if (tests[which].fill_helper)
8525                 return tests[which].u.ptr.insns;
8526         else
8527                 return tests[which].u.insns;
8528 }
8529
8530 static struct bpf_prog *generate_filter(int which, int *err)
8531 {
8532         __u8 test_type = tests[which].aux & TEST_TYPE_MASK;
8533         unsigned int flen = filter_length(which);
8534         void *fptr = filter_pointer(which);
8535         struct sock_fprog_kern fprog;
8536         struct bpf_prog *fp;
8537
8538         switch (test_type) {
8539         case CLASSIC:
8540                 fprog.filter = fptr;
8541                 fprog.len = flen;
8542
8543                 *err = bpf_prog_create(&fp, &fprog);
8544                 if (tests[which].aux & FLAG_EXPECTED_FAIL) {
8545                         if (*err == tests[which].expected_errcode) {
8546                                 pr_cont("PASS\n");
8547                                 /* Verifier rejected filter as expected. */
8548                                 *err = 0;
8549                                 return NULL;
8550                         } else {
8551                                 pr_cont("UNEXPECTED_PASS\n");
8552                                 /* Verifier didn't reject the test that's
8553                                  * bad enough, just return!
8554                                  */
8555                                 *err = -EINVAL;
8556                                 return NULL;
8557                         }
8558                 }
8559                 if (*err) {
8560                         pr_cont("FAIL to prog_create err=%d len=%d\n",
8561                                 *err, fprog.len);
8562                         return NULL;
8563                 }
8564                 break;
8565
8566         case INTERNAL:
8567                 fp = bpf_prog_alloc(bpf_prog_size(flen), 0);
8568                 if (fp == NULL) {
8569                         pr_cont("UNEXPECTED_FAIL no memory left\n");
8570                         *err = -ENOMEM;
8571                         return NULL;
8572                 }
8573
8574                 fp->len = flen;
8575                 /* Type doesn't really matter here as long as it's not unspec. */
8576                 fp->type = BPF_PROG_TYPE_SOCKET_FILTER;
8577                 memcpy(fp->insnsi, fptr, fp->len * sizeof(struct bpf_insn));
8578                 fp->aux->stack_depth = tests[which].stack_depth;
8579
8580                 /* We cannot error here as we don't need type compatibility
8581                  * checks.
8582                  */
8583                 fp = bpf_prog_select_runtime(fp, err);
8584                 if (*err) {
8585                         pr_cont("FAIL to select_runtime err=%d\n", *err);
8586                         return NULL;
8587                 }
8588                 break;
8589         }
8590
8591         *err = 0;
8592         return fp;
8593 }
8594
8595 static void release_filter(struct bpf_prog *fp, int which)
8596 {
8597         __u8 test_type = tests[which].aux & TEST_TYPE_MASK;
8598
8599         switch (test_type) {
8600         case CLASSIC:
8601                 bpf_prog_destroy(fp);
8602                 break;
8603         case INTERNAL:
8604                 bpf_prog_free(fp);
8605                 break;
8606         }
8607 }
8608
8609 static int __run_one(const struct bpf_prog *fp, const void *data,
8610                      int runs, u64 *duration)
8611 {
8612         u64 start, finish;
8613         int ret = 0, i;
8614
8615         migrate_disable();
8616         start = ktime_get_ns();
8617
8618         for (i = 0; i < runs; i++)
8619                 ret = bpf_prog_run(fp, data);
8620
8621         finish = ktime_get_ns();
8622         migrate_enable();
8623
8624         *duration = finish - start;
8625         do_div(*duration, runs);
8626
8627         return ret;
8628 }
8629
8630 static int run_one(const struct bpf_prog *fp, struct bpf_test *test)
8631 {
8632         int err_cnt = 0, i, runs = MAX_TESTRUNS;
8633
8634         for (i = 0; i < MAX_SUBTESTS; i++) {
8635                 void *data;
8636                 u64 duration;
8637                 u32 ret;
8638
8639                 /*
8640                  * NOTE: Several sub-tests may be present, in which case
8641                  * a zero {data_size, result} tuple indicates the end of
8642                  * the sub-test array. The first test is always run,
8643                  * even if both data_size and result happen to be zero.
8644                  */
8645                 if (i > 0 &&
8646                     test->test[i].data_size == 0 &&
8647                     test->test[i].result == 0)
8648                         break;
8649
8650                 data = generate_test_data(test, i);
8651                 if (!data && !(test->aux & FLAG_NO_DATA)) {
8652                         pr_cont("data generation failed ");
8653                         err_cnt++;
8654                         break;
8655                 }
8656                 ret = __run_one(fp, data, runs, &duration);
8657                 release_test_data(test, data);
8658
8659                 if (ret == test->test[i].result) {
8660                         pr_cont("%lld ", duration);
8661                 } else {
8662                         pr_cont("ret %d != %d ", ret,
8663                                 test->test[i].result);
8664                         err_cnt++;
8665                 }
8666         }
8667
8668         return err_cnt;
8669 }
8670
8671 static char test_name[64];
8672 module_param_string(test_name, test_name, sizeof(test_name), 0);
8673
8674 static int test_id = -1;
8675 module_param(test_id, int, 0);
8676
8677 static int test_range[2] = { 0, ARRAY_SIZE(tests) - 1 };
8678 module_param_array(test_range, int, NULL, 0);
8679
8680 static __init int find_test_index(const char *test_name)
8681 {
8682         int i;
8683
8684         for (i = 0; i < ARRAY_SIZE(tests); i++) {
8685                 if (!strcmp(tests[i].descr, test_name))
8686                         return i;
8687         }
8688         return -1;
8689 }
8690
8691 static __init int prepare_bpf_tests(void)
8692 {
8693         int i;
8694
8695         if (test_id >= 0) {
8696                 /*
8697                  * if a test_id was specified, use test_range to
8698                  * cover only that test.
8699                  */
8700                 if (test_id >= ARRAY_SIZE(tests)) {
8701                         pr_err("test_bpf: invalid test_id specified.\n");
8702                         return -EINVAL;
8703                 }
8704
8705                 test_range[0] = test_id;
8706                 test_range[1] = test_id;
8707         } else if (*test_name) {
8708                 /*
8709                  * if a test_name was specified, find it and setup
8710                  * test_range to cover only that test.
8711                  */
8712                 int idx = find_test_index(test_name);
8713
8714                 if (idx < 0) {
8715                         pr_err("test_bpf: no test named '%s' found.\n",
8716                                test_name);
8717                         return -EINVAL;
8718                 }
8719                 test_range[0] = idx;
8720                 test_range[1] = idx;
8721         } else {
8722                 /*
8723                  * check that the supplied test_range is valid.
8724                  */
8725                 if (test_range[0] >= ARRAY_SIZE(tests) ||
8726                     test_range[1] >= ARRAY_SIZE(tests) ||
8727                     test_range[0] < 0 || test_range[1] < 0) {
8728                         pr_err("test_bpf: test_range is out of bound.\n");
8729                         return -EINVAL;
8730                 }
8731
8732                 if (test_range[1] < test_range[0]) {
8733                         pr_err("test_bpf: test_range is ending before it starts.\n");
8734                         return -EINVAL;
8735                 }
8736         }
8737
8738         for (i = 0; i < ARRAY_SIZE(tests); i++) {
8739                 if (tests[i].fill_helper &&
8740                     tests[i].fill_helper(&tests[i]) < 0)
8741                         return -ENOMEM;
8742         }
8743
8744         return 0;
8745 }
8746
8747 static __init void destroy_bpf_tests(void)
8748 {
8749         int i;
8750
8751         for (i = 0; i < ARRAY_SIZE(tests); i++) {
8752                 if (tests[i].fill_helper)
8753                         kfree(tests[i].u.ptr.insns);
8754         }
8755 }
8756
8757 static bool exclude_test(int test_id)
8758 {
8759         return test_id < test_range[0] || test_id > test_range[1];
8760 }
8761
8762 static __init struct sk_buff *build_test_skb(void)
8763 {
8764         u32 headroom = NET_SKB_PAD + NET_IP_ALIGN + ETH_HLEN;
8765         struct sk_buff *skb[2];
8766         struct page *page[2];
8767         int i, data_size = 8;
8768
8769         for (i = 0; i < 2; i++) {
8770                 page[i] = alloc_page(GFP_KERNEL);
8771                 if (!page[i]) {
8772                         if (i == 0)
8773                                 goto err_page0;
8774                         else
8775                                 goto err_page1;
8776                 }
8777
8778                 /* this will set skb[i]->head_frag */
8779                 skb[i] = dev_alloc_skb(headroom + data_size);
8780                 if (!skb[i]) {
8781                         if (i == 0)
8782                                 goto err_skb0;
8783                         else
8784                                 goto err_skb1;
8785                 }
8786
8787                 skb_reserve(skb[i], headroom);
8788                 skb_put(skb[i], data_size);
8789                 skb[i]->protocol = htons(ETH_P_IP);
8790                 skb_reset_network_header(skb[i]);
8791                 skb_set_mac_header(skb[i], -ETH_HLEN);
8792
8793                 skb_add_rx_frag(skb[i], 0, page[i], 0, 64, 64);
8794                 // skb_headlen(skb[i]): 8, skb[i]->head_frag = 1
8795         }
8796
8797         /* setup shinfo */
8798         skb_shinfo(skb[0])->gso_size = 1448;
8799         skb_shinfo(skb[0])->gso_type = SKB_GSO_TCPV4;
8800         skb_shinfo(skb[0])->gso_type |= SKB_GSO_DODGY;
8801         skb_shinfo(skb[0])->gso_segs = 0;
8802         skb_shinfo(skb[0])->frag_list = skb[1];
8803
8804         /* adjust skb[0]'s len */
8805         skb[0]->len += skb[1]->len;
8806         skb[0]->data_len += skb[1]->data_len;
8807         skb[0]->truesize += skb[1]->truesize;
8808
8809         return skb[0];
8810
8811 err_skb1:
8812         __free_page(page[1]);
8813 err_page1:
8814         kfree_skb(skb[0]);
8815 err_skb0:
8816         __free_page(page[0]);
8817 err_page0:
8818         return NULL;
8819 }
8820
8821 static __init struct sk_buff *build_test_skb_linear_no_head_frag(void)
8822 {
8823         unsigned int alloc_size = 2000;
8824         unsigned int headroom = 102, doffset = 72, data_size = 1308;
8825         struct sk_buff *skb[2];
8826         int i;
8827
8828         /* skbs linked in a frag_list, both with linear data, with head_frag=0
8829          * (data allocated by kmalloc), both have tcp data of 1308 bytes
8830          * (total payload is 2616 bytes).
8831          * Data offset is 72 bytes (40 ipv6 hdr, 32 tcp hdr). Some headroom.
8832          */
8833         for (i = 0; i < 2; i++) {
8834                 skb[i] = alloc_skb(alloc_size, GFP_KERNEL);
8835                 if (!skb[i]) {
8836                         if (i == 0)
8837                                 goto err_skb0;
8838                         else
8839                                 goto err_skb1;
8840                 }
8841
8842                 skb[i]->protocol = htons(ETH_P_IPV6);
8843                 skb_reserve(skb[i], headroom);
8844                 skb_put(skb[i], doffset + data_size);
8845                 skb_reset_network_header(skb[i]);
8846                 if (i == 0)
8847                         skb_reset_mac_header(skb[i]);
8848                 else
8849                         skb_set_mac_header(skb[i], -ETH_HLEN);
8850                 __skb_pull(skb[i], doffset);
8851         }
8852
8853         /* setup shinfo.
8854          * mimic bpf_skb_proto_4_to_6, which resets gso_segs and assigns a
8855          * reduced gso_size.
8856          */
8857         skb_shinfo(skb[0])->gso_size = 1288;
8858         skb_shinfo(skb[0])->gso_type = SKB_GSO_TCPV6 | SKB_GSO_DODGY;
8859         skb_shinfo(skb[0])->gso_segs = 0;
8860         skb_shinfo(skb[0])->frag_list = skb[1];
8861
8862         /* adjust skb[0]'s len */
8863         skb[0]->len += skb[1]->len;
8864         skb[0]->data_len += skb[1]->len;
8865         skb[0]->truesize += skb[1]->truesize;
8866
8867         return skb[0];
8868
8869 err_skb1:
8870         kfree_skb(skb[0]);
8871 err_skb0:
8872         return NULL;
8873 }
8874
8875 struct skb_segment_test {
8876         const char *descr;
8877         struct sk_buff *(*build_skb)(void);
8878         netdev_features_t features;
8879 };
8880
8881 static struct skb_segment_test skb_segment_tests[] __initconst = {
8882         {
8883                 .descr = "gso_with_rx_frags",
8884                 .build_skb = build_test_skb,
8885                 .features = NETIF_F_SG | NETIF_F_GSO_PARTIAL | NETIF_F_IP_CSUM |
8886                             NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM
8887         },
8888         {
8889                 .descr = "gso_linear_no_head_frag",
8890                 .build_skb = build_test_skb_linear_no_head_frag,
8891                 .features = NETIF_F_SG | NETIF_F_FRAGLIST |
8892                             NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_GSO |
8893                             NETIF_F_LLTX_BIT | NETIF_F_GRO |
8894                             NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM |
8895                             NETIF_F_HW_VLAN_STAG_TX_BIT
8896         }
8897 };
8898
8899 static __init int test_skb_segment_single(const struct skb_segment_test *test)
8900 {
8901         struct sk_buff *skb, *segs;
8902         int ret = -1;
8903
8904         skb = test->build_skb();
8905         if (!skb) {
8906                 pr_info("%s: failed to build_test_skb", __func__);
8907                 goto done;
8908         }
8909
8910         segs = skb_segment(skb, test->features);
8911         if (!IS_ERR(segs)) {
8912                 kfree_skb_list(segs);
8913                 ret = 0;
8914         }
8915         kfree_skb(skb);
8916 done:
8917         return ret;
8918 }
8919
8920 static __init int test_skb_segment(void)
8921 {
8922         int i, err_cnt = 0, pass_cnt = 0;
8923
8924         for (i = 0; i < ARRAY_SIZE(skb_segment_tests); i++) {
8925                 const struct skb_segment_test *test = &skb_segment_tests[i];
8926
8927                 pr_info("#%d %s ", i, test->descr);
8928
8929                 if (test_skb_segment_single(test)) {
8930                         pr_cont("FAIL\n");
8931                         err_cnt++;
8932                 } else {
8933                         pr_cont("PASS\n");
8934                         pass_cnt++;
8935                 }
8936         }
8937
8938         pr_info("%s: Summary: %d PASSED, %d FAILED\n", __func__,
8939                 pass_cnt, err_cnt);
8940         return err_cnt ? -EINVAL : 0;
8941 }
8942
8943 static __init int test_bpf(void)
8944 {
8945         int i, err_cnt = 0, pass_cnt = 0;
8946         int jit_cnt = 0, run_cnt = 0;
8947
8948         for (i = 0; i < ARRAY_SIZE(tests); i++) {
8949                 struct bpf_prog *fp;
8950                 int err;
8951
8952                 cond_resched();
8953                 if (exclude_test(i))
8954                         continue;
8955
8956                 pr_info("#%d %s ", i, tests[i].descr);
8957
8958                 fp = generate_filter(i, &err);
8959                 if (fp == NULL) {
8960                         if (err == 0) {
8961                                 pass_cnt++;
8962                                 continue;
8963                         }
8964                         err_cnt++;
8965                         continue;
8966                 }
8967
8968                 pr_cont("jited:%u ", fp->jited);
8969
8970                 run_cnt++;
8971                 if (fp->jited)
8972                         jit_cnt++;
8973
8974                 err = run_one(fp, &tests[i]);
8975                 release_filter(fp, i);
8976
8977                 if (err) {
8978                         pr_cont("FAIL (%d times)\n", err);
8979                         err_cnt++;
8980                 } else {
8981                         pr_cont("PASS\n");
8982                         pass_cnt++;
8983                 }
8984         }
8985
8986         pr_info("Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n",
8987                 pass_cnt, err_cnt, jit_cnt, run_cnt);
8988
8989         return err_cnt ? -EINVAL : 0;
8990 }
8991
8992 struct tail_call_test {
8993         const char *descr;
8994         struct bpf_insn insns[MAX_INSNS];
8995         int result;
8996         int stack_depth;
8997 };
8998
8999 /*
9000  * Magic marker used in test snippets for tail calls below.
9001  * BPF_LD/MOV to R2 and R2 with this immediate value is replaced
9002  * with the proper values by the test runner.
9003  */
9004 #define TAIL_CALL_MARKER 0x7a11ca11
9005
9006 /* Special offset to indicate a NULL call target */
9007 #define TAIL_CALL_NULL 0x7fff
9008
9009 /* Special offset to indicate an out-of-range index */
9010 #define TAIL_CALL_INVALID 0x7ffe
9011
9012 #define TAIL_CALL(offset)                              \
9013         BPF_LD_IMM64(R2, TAIL_CALL_MARKER),            \
9014         BPF_RAW_INSN(BPF_ALU | BPF_MOV | BPF_K, R3, 0, \
9015                      offset, TAIL_CALL_MARKER),        \
9016         BPF_JMP_IMM(BPF_TAIL_CALL, 0, 0, 0)
9017
9018 /*
9019  * Tail call tests. Each test case may call any other test in the table,
9020  * including itself, specified as a relative index offset from the calling
9021  * test. The index TAIL_CALL_NULL can be used to specify a NULL target
9022  * function to test the JIT error path. Similarly, the index TAIL_CALL_INVALID
9023  * results in a target index that is out of range.
9024  */
9025 static struct tail_call_test tail_call_tests[] = {
9026         {
9027                 "Tail call leaf",
9028                 .insns = {
9029                         BPF_ALU64_REG(BPF_MOV, R0, R1),
9030                         BPF_ALU64_IMM(BPF_ADD, R0, 1),
9031                         BPF_EXIT_INSN(),
9032                 },
9033                 .result = 1,
9034         },
9035         {
9036                 "Tail call 2",
9037                 .insns = {
9038                         BPF_ALU64_IMM(BPF_ADD, R1, 2),
9039                         TAIL_CALL(-1),
9040                         BPF_ALU64_IMM(BPF_MOV, R0, -1),
9041                         BPF_EXIT_INSN(),
9042                 },
9043                 .result = 3,
9044         },
9045         {
9046                 "Tail call 3",
9047                 .insns = {
9048                         BPF_ALU64_IMM(BPF_ADD, R1, 3),
9049                         TAIL_CALL(-1),
9050                         BPF_ALU64_IMM(BPF_MOV, R0, -1),
9051                         BPF_EXIT_INSN(),
9052                 },
9053                 .result = 6,
9054         },
9055         {
9056                 "Tail call 4",
9057                 .insns = {
9058                         BPF_ALU64_IMM(BPF_ADD, R1, 4),
9059                         TAIL_CALL(-1),
9060                         BPF_ALU64_IMM(BPF_MOV, R0, -1),
9061                         BPF_EXIT_INSN(),
9062                 },
9063                 .result = 10,
9064         },
9065         {
9066                 "Tail call error path, max count reached",
9067                 .insns = {
9068                         BPF_ALU64_IMM(BPF_ADD, R1, 1),
9069                         BPF_ALU64_REG(BPF_MOV, R0, R1),
9070                         TAIL_CALL(0),
9071                         BPF_EXIT_INSN(),
9072                 },
9073                 .result = MAX_TAIL_CALL_CNT + 1,
9074         },
9075         {
9076                 "Tail call error path, NULL target",
9077                 .insns = {
9078                         BPF_ALU64_IMM(BPF_MOV, R0, -1),
9079                         TAIL_CALL(TAIL_CALL_NULL),
9080                         BPF_ALU64_IMM(BPF_MOV, R0, 1),
9081                         BPF_EXIT_INSN(),
9082                 },
9083                 .result = 1,
9084         },
9085         {
9086                 "Tail call error path, index out of range",
9087                 .insns = {
9088                         BPF_ALU64_IMM(BPF_MOV, R0, -1),
9089                         TAIL_CALL(TAIL_CALL_INVALID),
9090                         BPF_ALU64_IMM(BPF_MOV, R0, 1),
9091                         BPF_EXIT_INSN(),
9092                 },
9093                 .result = 1,
9094         },
9095 };
9096
9097 static void __init destroy_tail_call_tests(struct bpf_array *progs)
9098 {
9099         int i;
9100
9101         for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++)
9102                 if (progs->ptrs[i])
9103                         bpf_prog_free(progs->ptrs[i]);
9104         kfree(progs);
9105 }
9106
9107 static __init int prepare_tail_call_tests(struct bpf_array **pprogs)
9108 {
9109         int ntests = ARRAY_SIZE(tail_call_tests);
9110         struct bpf_array *progs;
9111         int which, err;
9112
9113         /* Allocate the table of programs to be used for tall calls */
9114         progs = kzalloc(sizeof(*progs) + (ntests + 1) * sizeof(progs->ptrs[0]),
9115                         GFP_KERNEL);
9116         if (!progs)
9117                 goto out_nomem;
9118
9119         /* Create all eBPF programs and populate the table */
9120         for (which = 0; which < ntests; which++) {
9121                 struct tail_call_test *test = &tail_call_tests[which];
9122                 struct bpf_prog *fp;
9123                 int len, i;
9124
9125                 /* Compute the number of program instructions */
9126                 for (len = 0; len < MAX_INSNS; len++) {
9127                         struct bpf_insn *insn = &test->insns[len];
9128
9129                         if (len < MAX_INSNS - 1 &&
9130                             insn->code == (BPF_LD | BPF_DW | BPF_IMM))
9131                                 len++;
9132                         if (insn->code == 0)
9133                                 break;
9134                 }
9135
9136                 /* Allocate and initialize the program */
9137                 fp = bpf_prog_alloc(bpf_prog_size(len), 0);
9138                 if (!fp)
9139                         goto out_nomem;
9140
9141                 fp->len = len;
9142                 fp->type = BPF_PROG_TYPE_SOCKET_FILTER;
9143                 fp->aux->stack_depth = test->stack_depth;
9144                 memcpy(fp->insnsi, test->insns, len * sizeof(struct bpf_insn));
9145
9146                 /* Relocate runtime tail call offsets and addresses */
9147                 for (i = 0; i < len; i++) {
9148                         struct bpf_insn *insn = &fp->insnsi[i];
9149
9150                         if (insn->imm != TAIL_CALL_MARKER)
9151                                 continue;
9152
9153                         switch (insn->code) {
9154                         case BPF_LD | BPF_DW | BPF_IMM:
9155                                 insn[0].imm = (u32)(long)progs;
9156                                 insn[1].imm = ((u64)(long)progs) >> 32;
9157                                 break;
9158
9159                         case BPF_ALU | BPF_MOV | BPF_K:
9160                                 if (insn->off == TAIL_CALL_NULL)
9161                                         insn->imm = ntests;
9162                                 else if (insn->off == TAIL_CALL_INVALID)
9163                                         insn->imm = ntests + 1;
9164                                 else
9165                                         insn->imm = which + insn->off;
9166                                 insn->off = 0;
9167                         }
9168                 }
9169
9170                 fp = bpf_prog_select_runtime(fp, &err);
9171                 if (err)
9172                         goto out_err;
9173
9174                 progs->ptrs[which] = fp;
9175         }
9176
9177         /* The last entry contains a NULL program pointer */
9178         progs->map.max_entries = ntests + 1;
9179         *pprogs = progs;
9180         return 0;
9181
9182 out_nomem:
9183         err = -ENOMEM;
9184
9185 out_err:
9186         if (progs)
9187                 destroy_tail_call_tests(progs);
9188         return err;
9189 }
9190
9191 static __init int test_tail_calls(struct bpf_array *progs)
9192 {
9193         int i, err_cnt = 0, pass_cnt = 0;
9194         int jit_cnt = 0, run_cnt = 0;
9195
9196         for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++) {
9197                 struct tail_call_test *test = &tail_call_tests[i];
9198                 struct bpf_prog *fp = progs->ptrs[i];
9199                 u64 duration;
9200                 int ret;
9201
9202                 cond_resched();
9203
9204                 pr_info("#%d %s ", i, test->descr);
9205                 if (!fp) {
9206                         err_cnt++;
9207                         continue;
9208                 }
9209                 pr_cont("jited:%u ", fp->jited);
9210
9211                 run_cnt++;
9212                 if (fp->jited)
9213                         jit_cnt++;
9214
9215                 ret = __run_one(fp, NULL, MAX_TESTRUNS, &duration);
9216                 if (ret == test->result) {
9217                         pr_cont("%lld PASS", duration);
9218                         pass_cnt++;
9219                 } else {
9220                         pr_cont("ret %d != %d FAIL", ret, test->result);
9221                         err_cnt++;
9222                 }
9223         }
9224
9225         pr_info("%s: Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n",
9226                 __func__, pass_cnt, err_cnt, jit_cnt, run_cnt);
9227
9228         return err_cnt ? -EINVAL : 0;
9229 }
9230
9231 static int __init test_bpf_init(void)
9232 {
9233         struct bpf_array *progs = NULL;
9234         int ret;
9235
9236         ret = prepare_bpf_tests();
9237         if (ret < 0)
9238                 return ret;
9239
9240         ret = test_bpf();
9241         destroy_bpf_tests();
9242         if (ret)
9243                 return ret;
9244
9245         ret = prepare_tail_call_tests(&progs);
9246         if (ret)
9247                 return ret;
9248         ret = test_tail_calls(progs);
9249         destroy_tail_call_tests(progs);
9250         if (ret)
9251                 return ret;
9252
9253         return test_skb_segment();
9254 }
9255
9256 static void __exit test_bpf_exit(void)
9257 {
9258 }
9259
9260 module_init(test_bpf_init);
9261 module_exit(test_bpf_exit);
9262
9263 MODULE_LICENSE("GPL");