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 #define FLAG_VERIFIER_ZEXT      BIT(3)
  56 #define FLAG_LARGE_MEM          BIT(4)
  57
  58 enum {
  59         CLASSIC  = BIT(6),      /* Old BPF instructions only. */
  60         INTERNAL = BIT(7),      /* Extended instruction set.  */
  61 };
  62
  63 #define TEST_TYPE_MASK          (CLASSIC | INTERNAL)
  64
  65 struct bpf_test {
  66         const char *descr;
  67         union {
  68                 struct sock_filter insns[MAX_INSNS];
  69                 struct bpf_insn insns_int[MAX_INSNS];
  70                 struct {
  71                         void *insns;
  72                         unsigned int len;
  73                 } ptr;
  74         } u;
  75         __u8 aux;
  76         __u8 data[MAX_DATA];
  77         struct {
  78                 int data_size;
  79                 __u32 result;
  80         } test[MAX_SUBTESTS];
  81         int (*fill_helper)(struct bpf_test *self);
  82         int expected_errcode; /* used when FLAG_EXPECTED_FAIL is set in the aux */
  83         __u8 frag_data[MAX_DATA];
  84         int stack_depth; /* for eBPF only, since tests don't call verifier */
  85         int nr_testruns; /* Custom run count, defaults to MAX_TESTRUNS if 0 */
  86 };
  87
  88 /* Large test cases need separate allocation and fill handler. */
  89
  90 static int bpf_fill_maxinsns1(struct bpf_test *self)
  91 {
  92         unsigned int len = BPF_MAXINSNS;
  93         struct sock_filter *insn;
  94         __u32 k = ~0;
  95         int i;
  96
  97         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
  98         if (!insn)
  99                 return -ENOMEM;
 100
 101         for (i = 0; i < len; i++, k--)
 102                 insn[i] = __BPF_STMT(BPF_RET | BPF_K, k);
 103
 104         self->u.ptr.insns = insn;
 105         self->u.ptr.len = len;
 106
 107         return 0;
 108 }
 109
 110 static int bpf_fill_maxinsns2(struct bpf_test *self)
 111 {
 112         unsigned int len = BPF_MAXINSNS;
 113         struct sock_filter *insn;
 114         int i;
 115
 116         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
 117         if (!insn)
 118                 return -ENOMEM;
 119
 120         for (i = 0; i < len; i++)
 121                 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
 122
 123         self->u.ptr.insns = insn;
 124         self->u.ptr.len = len;
 125
 126         return 0;
 127 }
 128
 129 static int bpf_fill_maxinsns3(struct bpf_test *self)
 130 {
 131         unsigned int len = BPF_MAXINSNS;
 132         struct sock_filter *insn;
 133         struct rnd_state rnd;
 134         int i;
 135
 136         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
 137         if (!insn)
 138                 return -ENOMEM;
 139
 140         prandom_seed_state(&rnd, 3141592653589793238ULL);
 141
 142         for (i = 0; i < len - 1; i++) {
 143                 __u32 k = prandom_u32_state(&rnd);
 144
 145                 insn[i] = __BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, k);
 146         }
 147
 148         insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
 149
 150         self->u.ptr.insns = insn;
 151         self->u.ptr.len = len;
 152
 153         return 0;
 154 }
 155
 156 static int bpf_fill_maxinsns4(struct bpf_test *self)
 157 {
 158         unsigned int len = BPF_MAXINSNS + 1;
 159         struct sock_filter *insn;
 160         int i;
 161
 162         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
 163         if (!insn)
 164                 return -ENOMEM;
 165
 166         for (i = 0; i < len; i++)
 167                 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
 168
 169         self->u.ptr.insns = insn;
 170         self->u.ptr.len = len;
 171
 172         return 0;
 173 }
 174
 175 static int bpf_fill_maxinsns5(struct bpf_test *self)
 176 {
 177         unsigned int len = BPF_MAXINSNS;
 178         struct sock_filter *insn;
 179         int i;
 180
 181         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
 182         if (!insn)
 183                 return -ENOMEM;
 184
 185         insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0);
 186
 187         for (i = 1; i < len - 1; i++)
 188                 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
 189
 190         insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab);
 191
 192         self->u.ptr.insns = insn;
 193         self->u.ptr.len = len;
 194
 195         return 0;
 196 }
 197
 198 static int bpf_fill_maxinsns6(struct bpf_test *self)
 199 {
 200         unsigned int len = BPF_MAXINSNS;
 201         struct sock_filter *insn;
 202         int i;
 203
 204         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
 205         if (!insn)
 206                 return -ENOMEM;
 207
 208         for (i = 0; i < len - 1; i++)
 209                 insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
 210                                      SKF_AD_VLAN_TAG_PRESENT);
 211
 212         insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
 213
 214         self->u.ptr.insns = insn;
 215         self->u.ptr.len = len;
 216
 217         return 0;
 218 }
 219
 220 static int bpf_fill_maxinsns7(struct bpf_test *self)
 221 {
 222         unsigned int len = BPF_MAXINSNS;
 223         struct sock_filter *insn;
 224         int i;
 225
 226         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
 227         if (!insn)
 228                 return -ENOMEM;
 229
 230         for (i = 0; i < len - 4; i++)
 231                 insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
 232                                      SKF_AD_CPU);
 233
 234         insn[len - 4] = __BPF_STMT(BPF_MISC | BPF_TAX, 0);
 235         insn[len - 3] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
 236                                    SKF_AD_CPU);
 237         insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0);
 238         insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
 239
 240         self->u.ptr.insns = insn;
 241         self->u.ptr.len = len;
 242
 243         return 0;
 244 }
 245
 246 static int bpf_fill_maxinsns8(struct bpf_test *self)
 247 {
 248         unsigned int len = BPF_MAXINSNS;
 249         struct sock_filter *insn;
 250         int i, jmp_off = len - 3;
 251
 252         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
 253         if (!insn)
 254                 return -ENOMEM;
 255
 256         insn[0] = __BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff);
 257
 258         for (i = 1; i < len - 1; i++)
 259                 insn[i] = __BPF_JUMP(BPF_JMP | BPF_JGT, 0xffffffff, jmp_off--, 0);
 260
 261         insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
 262
 263         self->u.ptr.insns = insn;
 264         self->u.ptr.len = len;
 265
 266         return 0;
 267 }
 268
 269 static int bpf_fill_maxinsns9(struct bpf_test *self)
 270 {
 271         unsigned int len = BPF_MAXINSNS;
 272         struct bpf_insn *insn;
 273         int i;
 274
 275         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
 276         if (!insn)
 277                 return -ENOMEM;
 278
 279         insn[0] = BPF_JMP_IMM(BPF_JA, 0, 0, len - 2);
 280         insn[1] = BPF_ALU32_IMM(BPF_MOV, R0, 0xcbababab);
 281         insn[2] = BPF_EXIT_INSN();
 282
 283         for (i = 3; i < len - 2; i++)
 284                 insn[i] = BPF_ALU32_IMM(BPF_MOV, R0, 0xfefefefe);
 285
 286         insn[len - 2] = BPF_EXIT_INSN();
 287         insn[len - 1] = BPF_JMP_IMM(BPF_JA, 0, 0, -(len - 1));
 288
 289         self->u.ptr.insns = insn;
 290         self->u.ptr.len = len;
 291
 292         return 0;
 293 }
 294
 295 static int bpf_fill_maxinsns10(struct bpf_test *self)
 296 {
 297         unsigned int len = BPF_MAXINSNS, hlen = len - 2;
 298         struct bpf_insn *insn;
 299         int i;
 300
 301         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
 302         if (!insn)
 303                 return -ENOMEM;
 304
 305         for (i = 0; i < hlen / 2; i++)
 306                 insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 2 - 2 * i);
 307         for (i = hlen - 1; i > hlen / 2; i--)
 308                 insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 1 - 2 * i);
 309
 310         insn[hlen / 2] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen / 2 - 1);
 311         insn[hlen]     = BPF_ALU32_IMM(BPF_MOV, R0, 0xabababac);
 312         insn[hlen + 1] = BPF_EXIT_INSN();
 313
 314         self->u.ptr.insns = insn;
 315         self->u.ptr.len = len;
 316
 317         return 0;
 318 }
 319
 320 static int __bpf_fill_ja(struct bpf_test *self, unsigned int len,
 321                          unsigned int plen)
 322 {
 323         struct sock_filter *insn;
 324         unsigned int rlen;
 325         int i, j;
 326
 327         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
 328         if (!insn)
 329                 return -ENOMEM;
 330
 331         rlen = (len % plen) - 1;
 332
 333         for (i = 0; i + plen < len; i += plen)
 334                 for (j = 0; j < plen; j++)
 335                         insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA,
 336                                                  plen - 1 - j, 0, 0);
 337         for (j = 0; j < rlen; j++)
 338                 insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA, rlen - 1 - j,
 339                                          0, 0);
 340
 341         insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xababcbac);
 342
 343         self->u.ptr.insns = insn;
 344         self->u.ptr.len = len;
 345
 346         return 0;
 347 }
 348
 349 static int bpf_fill_maxinsns11(struct bpf_test *self)
 350 {
 351         /* Hits 70 passes on x86_64 and triggers NOPs padding. */
 352         return __bpf_fill_ja(self, BPF_MAXINSNS, 68);
 353 }
 354
 355 static int bpf_fill_maxinsns12(struct bpf_test *self)
 356 {
 357         unsigned int len = BPF_MAXINSNS;
 358         struct sock_filter *insn;
 359         int i = 0;
 360
 361         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
 362         if (!insn)
 363                 return -ENOMEM;
 364
 365         insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0);
 366
 367         for (i = 1; i < len - 1; i++)
 368                 insn[i] = __BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0);
 369
 370         insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab);
 371
 372         self->u.ptr.insns = insn;
 373         self->u.ptr.len = len;
 374
 375         return 0;
 376 }
 377
 378 static int bpf_fill_maxinsns13(struct bpf_test *self)
 379 {
 380         unsigned int len = BPF_MAXINSNS;
 381         struct sock_filter *insn;
 382         int i = 0;
 383
 384         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
 385         if (!insn)
 386                 return -ENOMEM;
 387
 388         for (i = 0; i < len - 3; i++)
 389                 insn[i] = __BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0);
 390
 391         insn[len - 3] = __BPF_STMT(BPF_LD | BPF_IMM, 0xabababab);
 392         insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0);
 393         insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
 394
 395         self->u.ptr.insns = insn;
 396         self->u.ptr.len = len;
 397
 398         return 0;
 399 }
 400
 401 static int bpf_fill_ja(struct bpf_test *self)
 402 {
 403         /* Hits exactly 11 passes on x86_64 JIT. */
 404         return __bpf_fill_ja(self, 12, 9);
 405 }
 406
 407 static int bpf_fill_ld_abs_get_processor_id(struct bpf_test *self)
 408 {
 409         unsigned int len = BPF_MAXINSNS;
 410         struct sock_filter *insn;
 411         int i;
 412
 413         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
 414         if (!insn)
 415                 return -ENOMEM;
 416
 417         for (i = 0; i < len - 1; i += 2) {
 418                 insn[i] = __BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 0);
 419                 insn[i + 1] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
 420                                          SKF_AD_OFF + SKF_AD_CPU);
 421         }
 422
 423         insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xbee);
 424
 425         self->u.ptr.insns = insn;
 426         self->u.ptr.len = len;
 427
 428         return 0;
 429 }
 430
 431 static int __bpf_fill_stxdw(struct bpf_test *self, int size)
 432 {
 433         unsigned int len = BPF_MAXINSNS;
 434         struct bpf_insn *insn;
 435         int i;
 436
 437         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
 438         if (!insn)
 439                 return -ENOMEM;
 440
 441         insn[0] = BPF_ALU32_IMM(BPF_MOV, R0, 1);
 442         insn[1] = BPF_ST_MEM(size, R10, -40, 42);
 443
 444         for (i = 2; i < len - 2; i++)
 445                 insn[i] = BPF_STX_XADD(size, R10, R0, -40);
 446
 447         insn[len - 2] = BPF_LDX_MEM(size, R0, R10, -40);
 448         insn[len - 1] = BPF_EXIT_INSN();
 449
 450         self->u.ptr.insns = insn;
 451         self->u.ptr.len = len;
 452         self->stack_depth = 40;
 453
 454         return 0;
 455 }
 456
 457 static int bpf_fill_stxw(struct bpf_test *self)
 458 {
 459         return __bpf_fill_stxdw(self, BPF_W);
 460 }
 461
 462 static int bpf_fill_stxdw(struct bpf_test *self)
 463 {
 464         return __bpf_fill_stxdw(self, BPF_DW);
 465 }
 466
 467 static int __bpf_ld_imm64(struct bpf_insn insns[2], u8 reg, s64 imm64)
 468 {
 469         struct bpf_insn tmp[] = {BPF_LD_IMM64(reg, imm64)};
 470
 471         memcpy(insns, tmp, sizeof(tmp));
 472         return 2;
 473 }
 474
 475 /*
 476  * Branch conversion tests. Complex operations can expand to a lot
 477  * of instructions when JITed. This in turn may cause jump offsets
 478  * to overflow the field size of the native instruction, triggering
 479  * a branch conversion mechanism in some JITs.
 480  */
 481 static int __bpf_fill_max_jmp(struct bpf_test *self, int jmp, int imm)
 482 {
 483         struct bpf_insn *insns;
 484         int len = S16_MAX + 5;
 485         int i;
 486
 487         insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL);
 488         if (!insns)
 489                 return -ENOMEM;
 490
 491         i = __bpf_ld_imm64(insns, R1, 0x0123456789abcdefULL);
 492         insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
 493         insns[i++] = BPF_JMP_IMM(jmp, R0, imm, S16_MAX);
 494         insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 2);
 495         insns[i++] = BPF_EXIT_INSN();
 496
 497         while (i < len - 1) {
 498                 static const int ops[] = {
 499                         BPF_LSH, BPF_RSH, BPF_ARSH, BPF_ADD,
 500                         BPF_SUB, BPF_MUL, BPF_DIV, BPF_MOD,
 501                 };
 502                 int op = ops[(i >> 1) % ARRAY_SIZE(ops)];
 503
 504                 if (i & 1)
 505                         insns[i++] = BPF_ALU32_REG(op, R0, R1);
 506                 else
 507                         insns[i++] = BPF_ALU64_REG(op, R0, R1);
 508         }
 509
 510         insns[i++] = BPF_EXIT_INSN();
 511         self->u.ptr.insns = insns;
 512         self->u.ptr.len = len;
 513         BUG_ON(i != len);
 514
 515         return 0;
 516 }
 517
 518 /* Branch taken by runtime decision */
 519 static int bpf_fill_max_jmp_taken(struct bpf_test *self)
 520 {
 521         return __bpf_fill_max_jmp(self, BPF_JEQ, 1);
 522 }
 523
 524 /* Branch not taken by runtime decision */
 525 static int bpf_fill_max_jmp_not_taken(struct bpf_test *self)
 526 {
 527         return __bpf_fill_max_jmp(self, BPF_JEQ, 0);
 528 }
 529
 530 /* Branch always taken, known at JIT time */
 531 static int bpf_fill_max_jmp_always_taken(struct bpf_test *self)
 532 {
 533         return __bpf_fill_max_jmp(self, BPF_JGE, 0);
 534 }
 535
 536 /* Branch never taken, known at JIT time */
 537 static int bpf_fill_max_jmp_never_taken(struct bpf_test *self)
 538 {
 539         return __bpf_fill_max_jmp(self, BPF_JLT, 0);
 540 }
 541
 542 /* ALU result computation used in tests */
 543 static bool __bpf_alu_result(u64 *res, u64 v1, u64 v2, u8 op)
 544 {
 545         *res = 0;
 546         switch (op) {
 547         case BPF_MOV:
 548                 *res = v2;
 549                 break;
 550         case BPF_AND:
 551                 *res = v1 & v2;
 552                 break;
 553         case BPF_OR:
 554                 *res = v1 | v2;
 555                 break;
 556         case BPF_XOR:
 557                 *res = v1 ^ v2;
 558                 break;
 559         case BPF_LSH:
 560                 *res = v1 << v2;
 561                 break;
 562         case BPF_RSH:
 563                 *res = v1 >> v2;
 564                 break;
 565         case BPF_ARSH:
 566                 *res = v1 >> v2;
 567                 if (v2 > 0 && v1 > S64_MAX)
 568                         *res |= ~0ULL << (64 - v2);
 569                 break;
 570         case BPF_ADD:
 571                 *res = v1 + v2;
 572                 break;
 573         case BPF_SUB:
 574                 *res = v1 - v2;
 575                 break;
 576         case BPF_MUL:
 577                 *res = v1 * v2;
 578                 break;
 579         case BPF_DIV:
 580                 if (v2 == 0)
 581                         return false;
 582                 *res = div64_u64(v1, v2);
 583                 break;
 584         case BPF_MOD:
 585                 if (v2 == 0)
 586                         return false;
 587                 div64_u64_rem(v1, v2, res);
 588                 break;
 589         }
 590         return true;
 591 }
 592
 593 /* Test an ALU shift operation for all valid shift values */
 594 static int __bpf_fill_alu_shift(struct bpf_test *self, u8 op,
 595                                 u8 mode, bool alu32)
 596 {
 597         static const s64 regs[] = {
 598                 0x0123456789abcdefLL, /* dword > 0, word < 0 */
 599                 0xfedcba9876543210LL, /* dword < 0, word > 0 */
 600                 0xfedcba0198765432LL, /* dword < 0, word < 0 */
 601                 0x0123458967abcdefLL, /* dword > 0, word > 0 */
 602         };
 603         int bits = alu32 ? 32 : 64;
 604         int len = (2 + 7 * bits) * ARRAY_SIZE(regs) + 3;
 605         struct bpf_insn *insn;
 606         int imm, k;
 607         int i = 0;
 608
 609         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
 610         if (!insn)
 611                 return -ENOMEM;
 612
 613         insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
 614
 615         for (k = 0; k < ARRAY_SIZE(regs); k++) {
 616                 s64 reg = regs[k];
 617
 618                 i += __bpf_ld_imm64(&insn[i], R3, reg);
 619
 620                 for (imm = 0; imm < bits; imm++) {
 621                         u64 val;
 622
 623                         /* Perform operation */
 624                         insn[i++] = BPF_ALU64_REG(BPF_MOV, R1, R3);
 625                         insn[i++] = BPF_ALU64_IMM(BPF_MOV, R2, imm);
 626                         if (alu32) {
 627                                 if (mode == BPF_K)
 628                                         insn[i++] = BPF_ALU32_IMM(op, R1, imm);
 629                                 else
 630                                         insn[i++] = BPF_ALU32_REG(op, R1, R2);
 631
 632                                 if (op == BPF_ARSH)
 633                                         reg = (s32)reg;
 634                                 else
 635                                         reg = (u32)reg;
 636                                 __bpf_alu_result(&val, reg, imm, op);
 637                                 val = (u32)val;
 638                         } else {
 639                                 if (mode == BPF_K)
 640                                         insn[i++] = BPF_ALU64_IMM(op, R1, imm);
 641                                 else
 642                                         insn[i++] = BPF_ALU64_REG(op, R1, R2);
 643                                 __bpf_alu_result(&val, reg, imm, op);
 644                         }
 645
 646                         /*
 647                          * When debugging a JIT that fails this test, one
 648                          * can write the immediate value to R0 here to find
 649                          * out which operand values that fail.
 650                          */
 651
 652                         /* Load reference and check the result */
 653                         i += __bpf_ld_imm64(&insn[i], R4, val);
 654                         insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R4, 1);
 655                         insn[i++] = BPF_EXIT_INSN();
 656                 }
 657         }
 658
 659         insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
 660         insn[i++] = BPF_EXIT_INSN();
 661
 662         self->u.ptr.insns = insn;
 663         self->u.ptr.len = len;
 664         BUG_ON(i != len);
 665
 666         return 0;
 667 }
 668
 669 static int bpf_fill_alu64_lsh_imm(struct bpf_test *self)
 670 {
 671         return __bpf_fill_alu_shift(self, BPF_LSH, BPF_K, false);
 672 }
 673
 674 static int bpf_fill_alu64_rsh_imm(struct bpf_test *self)
 675 {
 676         return __bpf_fill_alu_shift(self, BPF_RSH, BPF_K, false);
 677 }
 678
 679 static int bpf_fill_alu64_arsh_imm(struct bpf_test *self)
 680 {
 681         return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_K, false);
 682 }
 683
 684 static int bpf_fill_alu64_lsh_reg(struct bpf_test *self)
 685 {
 686         return __bpf_fill_alu_shift(self, BPF_LSH, BPF_X, false);
 687 }
 688
 689 static int bpf_fill_alu64_rsh_reg(struct bpf_test *self)
 690 {
 691         return __bpf_fill_alu_shift(self, BPF_RSH, BPF_X, false);
 692 }
 693
 694 static int bpf_fill_alu64_arsh_reg(struct bpf_test *self)
 695 {
 696         return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_X, false);
 697 }
 698
 699 static int bpf_fill_alu32_lsh_imm(struct bpf_test *self)
 700 {
 701         return __bpf_fill_alu_shift(self, BPF_LSH, BPF_K, true);
 702 }
 703
 704 static int bpf_fill_alu32_rsh_imm(struct bpf_test *self)
 705 {
 706         return __bpf_fill_alu_shift(self, BPF_RSH, BPF_K, true);
 707 }
 708
 709 static int bpf_fill_alu32_arsh_imm(struct bpf_test *self)
 710 {
 711         return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_K, true);
 712 }
 713
 714 static int bpf_fill_alu32_lsh_reg(struct bpf_test *self)
 715 {
 716         return __bpf_fill_alu_shift(self, BPF_LSH, BPF_X, true);
 717 }
 718
 719 static int bpf_fill_alu32_rsh_reg(struct bpf_test *self)
 720 {
 721         return __bpf_fill_alu_shift(self, BPF_RSH, BPF_X, true);
 722 }
 723
 724 static int bpf_fill_alu32_arsh_reg(struct bpf_test *self)
 725 {
 726         return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_X, true);
 727 }
 728
 729 /*
 730  * Test an ALU register shift operation for all valid shift values
 731  * for the case when the source and destination are the same.
 732  */
 733 static int __bpf_fill_alu_shift_same_reg(struct bpf_test *self, u8 op,
 734                                          bool alu32)
 735 {
 736         int bits = alu32 ? 32 : 64;
 737         int len = 3 + 6 * bits;
 738         struct bpf_insn *insn;
 739         int i = 0;
 740         u64 val;
 741
 742         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
 743         if (!insn)
 744                 return -ENOMEM;
 745
 746         insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
 747
 748         for (val = 0; val < bits; val++) {
 749                 u64 res;
 750
 751                 /* Perform operation */
 752                 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R1, val);
 753                 if (alu32)
 754                         insn[i++] = BPF_ALU32_REG(op, R1, R1);
 755                 else
 756                         insn[i++] = BPF_ALU64_REG(op, R1, R1);
 757
 758                 /* Compute the reference result */
 759                 __bpf_alu_result(&res, val, val, op);
 760                 if (alu32)
 761                         res = (u32)res;
 762                 i += __bpf_ld_imm64(&insn[i], R2, res);
 763
 764                 /* Check the actual result */
 765                 insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R2, 1);
 766                 insn[i++] = BPF_EXIT_INSN();
 767         }
 768
 769         insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
 770         insn[i++] = BPF_EXIT_INSN();
 771
 772         self->u.ptr.insns = insn;
 773         self->u.ptr.len = len;
 774         BUG_ON(i != len);
 775
 776         return 0;
 777 }
 778
 779 static int bpf_fill_alu64_lsh_same_reg(struct bpf_test *self)
 780 {
 781         return __bpf_fill_alu_shift_same_reg(self, BPF_LSH, false);
 782 }
 783
 784 static int bpf_fill_alu64_rsh_same_reg(struct bpf_test *self)
 785 {
 786         return __bpf_fill_alu_shift_same_reg(self, BPF_RSH, false);
 787 }
 788
 789 static int bpf_fill_alu64_arsh_same_reg(struct bpf_test *self)
 790 {
 791         return __bpf_fill_alu_shift_same_reg(self, BPF_ARSH, false);
 792 }
 793
 794 static int bpf_fill_alu32_lsh_same_reg(struct bpf_test *self)
 795 {
 796         return __bpf_fill_alu_shift_same_reg(self, BPF_LSH, true);
 797 }
 798
 799 static int bpf_fill_alu32_rsh_same_reg(struct bpf_test *self)
 800 {
 801         return __bpf_fill_alu_shift_same_reg(self, BPF_RSH, true);
 802 }
 803
 804 static int bpf_fill_alu32_arsh_same_reg(struct bpf_test *self)
 805 {
 806         return __bpf_fill_alu_shift_same_reg(self, BPF_ARSH, true);
 807 }
 808
 809 /*
 810  * Common operand pattern generator for exhaustive power-of-two magnitudes
 811  * tests. The block size parameters can be adjusted to increase/reduce the
 812  * number of combinatons tested and thereby execution speed and memory
 813  * footprint.
 814  */
 815
 816 static inline s64 value(int msb, int delta, int sign)
 817 {
 818         return sign * (1LL << msb) + delta;
 819 }
 820
 821 static int __bpf_fill_pattern(struct bpf_test *self, void *arg,
 822                               int dbits, int sbits, int block1, int block2,
 823                               int (*emit)(struct bpf_test*, void*,
 824                                           struct bpf_insn*, s64, s64))
 825 {
 826         static const int sgn[][2] = {{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
 827         struct bpf_insn *insns;
 828         int di, si, bt, db, sb;
 829         int count, len, k;
 830         int extra = 1 + 2;
 831         int i = 0;
 832
 833         /* Total number of iterations for the two pattern */
 834         count = (dbits - 1) * (sbits - 1) * block1 * block1 * ARRAY_SIZE(sgn);
 835         count += (max(dbits, sbits) - 1) * block2 * block2 * ARRAY_SIZE(sgn);
 836
 837         /* Compute the maximum number of insns and allocate the buffer */
 838         len = extra + count * (*emit)(self, arg, NULL, 0, 0);
 839         insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL);
 840         if (!insns)
 841                 return -ENOMEM;
 842
 843         /* Add head instruction(s) */
 844         insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
 845
 846         /*
 847          * Pattern 1: all combinations of power-of-two magnitudes and sign,
 848          * and with a block of contiguous values around each magnitude.
 849          */
 850         for (di = 0; di < dbits - 1; di++)                 /* Dst magnitudes */
 851                 for (si = 0; si < sbits - 1; si++)         /* Src magnitudes */
 852                         for (k = 0; k < ARRAY_SIZE(sgn); k++) /* Sign combos */
 853                                 for (db = -(block1 / 2);
 854                                      db < (block1 + 1) / 2; db++)
 855                                         for (sb = -(block1 / 2);
 856                                              sb < (block1 + 1) / 2; sb++) {
 857                                                 s64 dst, src;
 858
 859                                                 dst = value(di, db, sgn[k][0]);
 860                                                 src = value(si, sb, sgn[k][1]);
 861                                                 i += (*emit)(self, arg,
 862                                                              &insns[i],
 863                                                              dst, src);
 864                                         }
 865         /*
 866          * Pattern 2: all combinations for a larger block of values
 867          * for each power-of-two magnitude and sign, where the magnitude is
 868          * the same for both operands.
 869          */
 870         for (bt = 0; bt < max(dbits, sbits) - 1; bt++)        /* Magnitude   */
 871                 for (k = 0; k < ARRAY_SIZE(sgn); k++)         /* Sign combos */
 872                         for (db = -(block2 / 2); db < (block2 + 1) / 2; db++)
 873                                 for (sb = -(block2 / 2);
 874                                      sb < (block2 + 1) / 2; sb++) {
 875                                         s64 dst, src;
 876
 877                                         dst = value(bt % dbits, db, sgn[k][0]);
 878                                         src = value(bt % sbits, sb, sgn[k][1]);
 879                                         i += (*emit)(self, arg, &insns[i],
 880                                                      dst, src);
 881                                 }
 882
 883         /* Append tail instructions */
 884         insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
 885         insns[i++] = BPF_EXIT_INSN();
 886         BUG_ON(i > len);
 887
 888         self->u.ptr.insns = insns;
 889         self->u.ptr.len = i;
 890
 891         return 0;
 892 }
 893
 894 /*
 895  * Block size parameters used in pattern tests below. une as needed to
 896  * increase/reduce the number combinations tested, see following examples.
 897  *        block   values per operand MSB
 898  * ----------------------------------------
 899  *           0     none
 900  *           1     (1 << MSB)
 901  *           2     (1 << MSB) + [-1, 0]
 902  *           3     (1 << MSB) + [-1, 0, 1]
 903  */
 904 #define PATTERN_BLOCK1 1
 905 #define PATTERN_BLOCK2 5
 906
 907 /* Number of test runs for a pattern test */
 908 #define NR_PATTERN_RUNS 1
 909
 910 /*
 911  * Exhaustive tests of ALU operations for all combinations of power-of-two
 912  * magnitudes of the operands, both for positive and negative values. The
 913  * test is designed to verify e.g. the ALU and ALU64 operations for JITs that
 914  * emit different code depending on the magnitude of the immediate value.
 915  */
 916 static int __bpf_emit_alu64_imm(struct bpf_test *self, void *arg,
 917                                 struct bpf_insn *insns, s64 dst, s64 imm)
 918 {
 919         int op = *(int *)arg;
 920         int i = 0;
 921         u64 res;
 922
 923         if (!insns)
 924                 return 7;
 925
 926         if (__bpf_alu_result(&res, dst, (s32)imm, op)) {
 927                 i += __bpf_ld_imm64(&insns[i], R1, dst);
 928                 i += __bpf_ld_imm64(&insns[i], R3, res);
 929                 insns[i++] = BPF_ALU64_IMM(op, R1, imm);
 930                 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
 931                 insns[i++] = BPF_EXIT_INSN();
 932         }
 933
 934         return i;
 935 }
 936
 937 static int __bpf_emit_alu32_imm(struct bpf_test *self, void *arg,
 938                                 struct bpf_insn *insns, s64 dst, s64 imm)
 939 {
 940         int op = *(int *)arg;
 941         int i = 0;
 942         u64 res;
 943
 944         if (!insns)
 945                 return 7;
 946
 947         if (__bpf_alu_result(&res, (u32)dst, (u32)imm, op)) {
 948                 i += __bpf_ld_imm64(&insns[i], R1, dst);
 949                 i += __bpf_ld_imm64(&insns[i], R3, (u32)res);
 950                 insns[i++] = BPF_ALU32_IMM(op, R1, imm);
 951                 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
 952                 insns[i++] = BPF_EXIT_INSN();
 953         }
 954
 955         return i;
 956 }
 957
 958 static int __bpf_emit_alu64_reg(struct bpf_test *self, void *arg,
 959                                 struct bpf_insn *insns, s64 dst, s64 src)
 960 {
 961         int op = *(int *)arg;
 962         int i = 0;
 963         u64 res;
 964
 965         if (!insns)
 966                 return 9;
 967
 968         if (__bpf_alu_result(&res, dst, src, op)) {
 969                 i += __bpf_ld_imm64(&insns[i], R1, dst);
 970                 i += __bpf_ld_imm64(&insns[i], R2, src);
 971                 i += __bpf_ld_imm64(&insns[i], R3, res);
 972                 insns[i++] = BPF_ALU64_REG(op, R1, R2);
 973                 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
 974                 insns[i++] = BPF_EXIT_INSN();
 975         }
 976
 977         return i;
 978 }
 979
 980 static int __bpf_emit_alu32_reg(struct bpf_test *self, void *arg,
 981                                 struct bpf_insn *insns, s64 dst, s64 src)
 982 {
 983         int op = *(int *)arg;
 984         int i = 0;
 985         u64 res;
 986
 987         if (!insns)
 988                 return 9;
 989
 990         if (__bpf_alu_result(&res, (u32)dst, (u32)src, op)) {
 991                 i += __bpf_ld_imm64(&insns[i], R1, dst);
 992                 i += __bpf_ld_imm64(&insns[i], R2, src);
 993                 i += __bpf_ld_imm64(&insns[i], R3, (u32)res);
 994                 insns[i++] = BPF_ALU32_REG(op, R1, R2);
 995                 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
 996                 insns[i++] = BPF_EXIT_INSN();
 997         }
 998
 999         return i;
1000 }
1001
1002 static int __bpf_fill_alu64_imm(struct bpf_test *self, int op)
1003 {
1004         return __bpf_fill_pattern(self, &op, 64, 32,
1005                                   PATTERN_BLOCK1, PATTERN_BLOCK2,
1006                                   &__bpf_emit_alu64_imm);
1007 }
1008
1009 static int __bpf_fill_alu32_imm(struct bpf_test *self, int op)
1010 {
1011         return __bpf_fill_pattern(self, &op, 64, 32,
1012                                   PATTERN_BLOCK1, PATTERN_BLOCK2,
1013                                   &__bpf_emit_alu32_imm);
1014 }
1015
1016 static int __bpf_fill_alu64_reg(struct bpf_test *self, int op)
1017 {
1018         return __bpf_fill_pattern(self, &op, 64, 64,
1019                                   PATTERN_BLOCK1, PATTERN_BLOCK2,
1020                                   &__bpf_emit_alu64_reg);
1021 }
1022
1023 static int __bpf_fill_alu32_reg(struct bpf_test *self, int op)
1024 {
1025         return __bpf_fill_pattern(self, &op, 64, 64,
1026                                   PATTERN_BLOCK1, PATTERN_BLOCK2,
1027                                   &__bpf_emit_alu32_reg);
1028 }
1029
1030 /* ALU64 immediate operations */
1031 static int bpf_fill_alu64_mov_imm(struct bpf_test *self)
1032 {
1033         return __bpf_fill_alu64_imm(self, BPF_MOV);
1034 }
1035
1036 static int bpf_fill_alu64_and_imm(struct bpf_test *self)
1037 {
1038         return __bpf_fill_alu64_imm(self, BPF_AND);
1039 }
1040
1041 static int bpf_fill_alu64_or_imm(struct bpf_test *self)
1042 {
1043         return __bpf_fill_alu64_imm(self, BPF_OR);
1044 }
1045
1046 static int bpf_fill_alu64_xor_imm(struct bpf_test *self)
1047 {
1048         return __bpf_fill_alu64_imm(self, BPF_XOR);
1049 }
1050
1051 static int bpf_fill_alu64_add_imm(struct bpf_test *self)
1052 {
1053         return __bpf_fill_alu64_imm(self, BPF_ADD);
1054 }
1055
1056 static int bpf_fill_alu64_sub_imm(struct bpf_test *self)
1057 {
1058         return __bpf_fill_alu64_imm(self, BPF_SUB);
1059 }
1060
1061 static int bpf_fill_alu64_mul_imm(struct bpf_test *self)
1062 {
1063         return __bpf_fill_alu64_imm(self, BPF_MUL);
1064 }
1065
1066 static int bpf_fill_alu64_div_imm(struct bpf_test *self)
1067 {
1068         return __bpf_fill_alu64_imm(self, BPF_DIV);
1069 }
1070
1071 static int bpf_fill_alu64_mod_imm(struct bpf_test *self)
1072 {
1073         return __bpf_fill_alu64_imm(self, BPF_MOD);
1074 }
1075
1076 /* ALU32 immediate operations */
1077 static int bpf_fill_alu32_mov_imm(struct bpf_test *self)
1078 {
1079         return __bpf_fill_alu32_imm(self, BPF_MOV);
1080 }
1081
1082 static int bpf_fill_alu32_and_imm(struct bpf_test *self)
1083 {
1084         return __bpf_fill_alu32_imm(self, BPF_AND);
1085 }
1086
1087 static int bpf_fill_alu32_or_imm(struct bpf_test *self)
1088 {
1089         return __bpf_fill_alu32_imm(self, BPF_OR);
1090 }
1091
1092 static int bpf_fill_alu32_xor_imm(struct bpf_test *self)
1093 {
1094         return __bpf_fill_alu32_imm(self, BPF_XOR);
1095 }
1096
1097 static int bpf_fill_alu32_add_imm(struct bpf_test *self)
1098 {
1099         return __bpf_fill_alu32_imm(self, BPF_ADD);
1100 }
1101
1102 static int bpf_fill_alu32_sub_imm(struct bpf_test *self)
1103 {
1104         return __bpf_fill_alu32_imm(self, BPF_SUB);
1105 }
1106
1107 static int bpf_fill_alu32_mul_imm(struct bpf_test *self)
1108 {
1109         return __bpf_fill_alu32_imm(self, BPF_MUL);
1110 }
1111
1112 static int bpf_fill_alu32_div_imm(struct bpf_test *self)
1113 {
1114         return __bpf_fill_alu32_imm(self, BPF_DIV);
1115 }
1116
1117 static int bpf_fill_alu32_mod_imm(struct bpf_test *self)
1118 {
1119         return __bpf_fill_alu32_imm(self, BPF_MOD);
1120 }
1121
1122 /* ALU64 register operations */
1123 static int bpf_fill_alu64_mov_reg(struct bpf_test *self)
1124 {
1125         return __bpf_fill_alu64_reg(self, BPF_MOV);
1126 }
1127
1128 static int bpf_fill_alu64_and_reg(struct bpf_test *self)
1129 {
1130         return __bpf_fill_alu64_reg(self, BPF_AND);
1131 }
1132
1133 static int bpf_fill_alu64_or_reg(struct bpf_test *self)
1134 {
1135         return __bpf_fill_alu64_reg(self, BPF_OR);
1136 }
1137
1138 static int bpf_fill_alu64_xor_reg(struct bpf_test *self)
1139 {
1140         return __bpf_fill_alu64_reg(self, BPF_XOR);
1141 }
1142
1143 static int bpf_fill_alu64_add_reg(struct bpf_test *self)
1144 {
1145         return __bpf_fill_alu64_reg(self, BPF_ADD);
1146 }
1147
1148 static int bpf_fill_alu64_sub_reg(struct bpf_test *self)
1149 {
1150         return __bpf_fill_alu64_reg(self, BPF_SUB);
1151 }
1152
1153 static int bpf_fill_alu64_mul_reg(struct bpf_test *self)
1154 {
1155         return __bpf_fill_alu64_reg(self, BPF_MUL);
1156 }
1157
1158 static int bpf_fill_alu64_div_reg(struct bpf_test *self)
1159 {
1160         return __bpf_fill_alu64_reg(self, BPF_DIV);
1161 }
1162
1163 static int bpf_fill_alu64_mod_reg(struct bpf_test *self)
1164 {
1165         return __bpf_fill_alu64_reg(self, BPF_MOD);
1166 }
1167
1168 /* ALU32 register operations */
1169 static int bpf_fill_alu32_mov_reg(struct bpf_test *self)
1170 {
1171         return __bpf_fill_alu32_reg(self, BPF_MOV);
1172 }
1173
1174 static int bpf_fill_alu32_and_reg(struct bpf_test *self)
1175 {
1176         return __bpf_fill_alu32_reg(self, BPF_AND);
1177 }
1178
1179 static int bpf_fill_alu32_or_reg(struct bpf_test *self)
1180 {
1181         return __bpf_fill_alu32_reg(self, BPF_OR);
1182 }
1183
1184 static int bpf_fill_alu32_xor_reg(struct bpf_test *self)
1185 {
1186         return __bpf_fill_alu32_reg(self, BPF_XOR);
1187 }
1188
1189 static int bpf_fill_alu32_add_reg(struct bpf_test *self)
1190 {
1191         return __bpf_fill_alu32_reg(self, BPF_ADD);
1192 }
1193
1194 static int bpf_fill_alu32_sub_reg(struct bpf_test *self)
1195 {
1196         return __bpf_fill_alu32_reg(self, BPF_SUB);
1197 }
1198
1199 static int bpf_fill_alu32_mul_reg(struct bpf_test *self)
1200 {
1201         return __bpf_fill_alu32_reg(self, BPF_MUL);
1202 }
1203
1204 static int bpf_fill_alu32_div_reg(struct bpf_test *self)
1205 {
1206         return __bpf_fill_alu32_reg(self, BPF_DIV);
1207 }
1208
1209 static int bpf_fill_alu32_mod_reg(struct bpf_test *self)
1210 {
1211         return __bpf_fill_alu32_reg(self, BPF_MOD);
1212 }
1213
1214 /*
1215  * Test JITs that implement complex ALU operations as function
1216  * calls, and must re-arrange operands for argument passing.
1217  */
1218 static int __bpf_fill_alu_imm_regs(struct bpf_test *self, u8 op, bool alu32)
1219 {
1220         int len = 2 + 10 * 10;
1221         struct bpf_insn *insns;
1222         u64 dst, res;
1223         int i = 0;
1224         u32 imm;
1225         int rd;
1226
1227         insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL);
1228         if (!insns)
1229                 return -ENOMEM;
1230
1231         /* Operand and result values according to operation */
1232         if (alu32)
1233                 dst = 0x76543210U;
1234         else
1235                 dst = 0x7edcba9876543210ULL;
1236         imm = 0x01234567U;
1237
1238         if (op == BPF_LSH || op == BPF_RSH || op == BPF_ARSH)
1239                 imm &= 31;
1240
1241         __bpf_alu_result(&res, dst, imm, op);
1242
1243         if (alu32)
1244                 res = (u32)res;
1245
1246         /* Check all operand registers */
1247         for (rd = R0; rd <= R9; rd++) {
1248                 i += __bpf_ld_imm64(&insns[i], rd, dst);
1249
1250                 if (alu32)
1251                         insns[i++] = BPF_ALU32_IMM(op, rd, imm);
1252                 else
1253                         insns[i++] = BPF_ALU64_IMM(op, rd, imm);
1254
1255                 insns[i++] = BPF_JMP32_IMM(BPF_JEQ, rd, res, 2);
1256                 insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1257                 insns[i++] = BPF_EXIT_INSN();
1258
1259                 insns[i++] = BPF_ALU64_IMM(BPF_RSH, rd, 32);
1260                 insns[i++] = BPF_JMP32_IMM(BPF_JEQ, rd, res >> 32, 2);
1261                 insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1262                 insns[i++] = BPF_EXIT_INSN();
1263         }
1264
1265         insns[i++] = BPF_MOV64_IMM(R0, 1);
1266         insns[i++] = BPF_EXIT_INSN();
1267
1268         self->u.ptr.insns = insns;
1269         self->u.ptr.len = len;
1270         BUG_ON(i != len);
1271
1272         return 0;
1273 }
1274
1275 /* ALU64 K registers */
1276 static int bpf_fill_alu64_mov_imm_regs(struct bpf_test *self)
1277 {
1278         return __bpf_fill_alu_imm_regs(self, BPF_MOV, false);
1279 }
1280
1281 static int bpf_fill_alu64_and_imm_regs(struct bpf_test *self)
1282 {
1283         return __bpf_fill_alu_imm_regs(self, BPF_AND, false);
1284 }
1285
1286 static int bpf_fill_alu64_or_imm_regs(struct bpf_test *self)
1287 {
1288         return __bpf_fill_alu_imm_regs(self, BPF_OR, false);
1289 }
1290
1291 static int bpf_fill_alu64_xor_imm_regs(struct bpf_test *self)
1292 {
1293         return __bpf_fill_alu_imm_regs(self, BPF_XOR, false);
1294 }
1295
1296 static int bpf_fill_alu64_lsh_imm_regs(struct bpf_test *self)
1297 {
1298         return __bpf_fill_alu_imm_regs(self, BPF_LSH, false);
1299 }
1300
1301 static int bpf_fill_alu64_rsh_imm_regs(struct bpf_test *self)
1302 {
1303         return __bpf_fill_alu_imm_regs(self, BPF_RSH, false);
1304 }
1305
1306 static int bpf_fill_alu64_arsh_imm_regs(struct bpf_test *self)
1307 {
1308         return __bpf_fill_alu_imm_regs(self, BPF_ARSH, false);
1309 }
1310
1311 static int bpf_fill_alu64_add_imm_regs(struct bpf_test *self)
1312 {
1313         return __bpf_fill_alu_imm_regs(self, BPF_ADD, false);
1314 }
1315
1316 static int bpf_fill_alu64_sub_imm_regs(struct bpf_test *self)
1317 {
1318         return __bpf_fill_alu_imm_regs(self, BPF_SUB, false);
1319 }
1320
1321 static int bpf_fill_alu64_mul_imm_regs(struct bpf_test *self)
1322 {
1323         return __bpf_fill_alu_imm_regs(self, BPF_MUL, false);
1324 }
1325
1326 static int bpf_fill_alu64_div_imm_regs(struct bpf_test *self)
1327 {
1328         return __bpf_fill_alu_imm_regs(self, BPF_DIV, false);
1329 }
1330
1331 static int bpf_fill_alu64_mod_imm_regs(struct bpf_test *self)
1332 {
1333         return __bpf_fill_alu_imm_regs(self, BPF_MOD, false);
1334 }
1335
1336 /* ALU32 K registers */
1337 static int bpf_fill_alu32_mov_imm_regs(struct bpf_test *self)
1338 {
1339         return __bpf_fill_alu_imm_regs(self, BPF_MOV, true);
1340 }
1341
1342 static int bpf_fill_alu32_and_imm_regs(struct bpf_test *self)
1343 {
1344         return __bpf_fill_alu_imm_regs(self, BPF_AND, true);
1345 }
1346
1347 static int bpf_fill_alu32_or_imm_regs(struct bpf_test *self)
1348 {
1349         return __bpf_fill_alu_imm_regs(self, BPF_OR, true);
1350 }
1351
1352 static int bpf_fill_alu32_xor_imm_regs(struct bpf_test *self)
1353 {
1354         return __bpf_fill_alu_imm_regs(self, BPF_XOR, true);
1355 }
1356
1357 static int bpf_fill_alu32_lsh_imm_regs(struct bpf_test *self)
1358 {
1359         return __bpf_fill_alu_imm_regs(self, BPF_LSH, true);
1360 }
1361
1362 static int bpf_fill_alu32_rsh_imm_regs(struct bpf_test *self)
1363 {
1364         return __bpf_fill_alu_imm_regs(self, BPF_RSH, true);
1365 }
1366
1367 static int bpf_fill_alu32_arsh_imm_regs(struct bpf_test *self)
1368 {
1369         return __bpf_fill_alu_imm_regs(self, BPF_ARSH, true);
1370 }
1371
1372 static int bpf_fill_alu32_add_imm_regs(struct bpf_test *self)
1373 {
1374         return __bpf_fill_alu_imm_regs(self, BPF_ADD, true);
1375 }
1376
1377 static int bpf_fill_alu32_sub_imm_regs(struct bpf_test *self)
1378 {
1379         return __bpf_fill_alu_imm_regs(self, BPF_SUB, true);
1380 }
1381
1382 static int bpf_fill_alu32_mul_imm_regs(struct bpf_test *self)
1383 {
1384         return __bpf_fill_alu_imm_regs(self, BPF_MUL, true);
1385 }
1386
1387 static int bpf_fill_alu32_div_imm_regs(struct bpf_test *self)
1388 {
1389         return __bpf_fill_alu_imm_regs(self, BPF_DIV, true);
1390 }
1391
1392 static int bpf_fill_alu32_mod_imm_regs(struct bpf_test *self)
1393 {
1394         return __bpf_fill_alu_imm_regs(self, BPF_MOD, true);
1395 }
1396
1397 /*
1398  * Test JITs that implement complex ALU operations as function
1399  * calls, and must re-arrange operands for argument passing.
1400  */
1401 static int __bpf_fill_alu_reg_pairs(struct bpf_test *self, u8 op, bool alu32)
1402 {
1403         int len = 2 + 10 * 10 * 12;
1404         u64 dst, src, res, same;
1405         struct bpf_insn *insns;
1406         int rd, rs;
1407         int i = 0;
1408
1409         insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL);
1410         if (!insns)
1411                 return -ENOMEM;
1412
1413         /* Operand and result values according to operation */
1414         if (alu32) {
1415                 dst = 0x76543210U;
1416                 src = 0x01234567U;
1417         } else {
1418                 dst = 0x7edcba9876543210ULL;
1419                 src = 0x0123456789abcdefULL;
1420         }
1421
1422         if (op == BPF_LSH || op == BPF_RSH || op == BPF_ARSH)
1423                 src &= 31;
1424
1425         __bpf_alu_result(&res, dst, src, op);
1426         __bpf_alu_result(&same, src, src, op);
1427
1428         if (alu32) {
1429                 res = (u32)res;
1430                 same = (u32)same;
1431         }
1432
1433         /* Check all combinations of operand registers */
1434         for (rd = R0; rd <= R9; rd++) {
1435                 for (rs = R0; rs <= R9; rs++) {
1436                         u64 val = rd == rs ? same : res;
1437
1438                         i += __bpf_ld_imm64(&insns[i], rd, dst);
1439                         i += __bpf_ld_imm64(&insns[i], rs, src);
1440
1441                         if (alu32)
1442                                 insns[i++] = BPF_ALU32_REG(op, rd, rs);
1443                         else
1444                                 insns[i++] = BPF_ALU64_REG(op, rd, rs);
1445
1446                         insns[i++] = BPF_JMP32_IMM(BPF_JEQ, rd, val, 2);
1447                         insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1448                         insns[i++] = BPF_EXIT_INSN();
1449
1450                         insns[i++] = BPF_ALU64_IMM(BPF_RSH, rd, 32);
1451                         insns[i++] = BPF_JMP32_IMM(BPF_JEQ, rd, val >> 32, 2);
1452                         insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1453                         insns[i++] = BPF_EXIT_INSN();
1454                 }
1455         }
1456
1457         insns[i++] = BPF_MOV64_IMM(R0, 1);
1458         insns[i++] = BPF_EXIT_INSN();
1459
1460         self->u.ptr.insns = insns;
1461         self->u.ptr.len = len;
1462         BUG_ON(i != len);
1463
1464         return 0;
1465 }
1466
1467 /* ALU64 X register combinations */
1468 static int bpf_fill_alu64_mov_reg_pairs(struct bpf_test *self)
1469 {
1470         return __bpf_fill_alu_reg_pairs(self, BPF_MOV, false);
1471 }
1472
1473 static int bpf_fill_alu64_and_reg_pairs(struct bpf_test *self)
1474 {
1475         return __bpf_fill_alu_reg_pairs(self, BPF_AND, false);
1476 }
1477
1478 static int bpf_fill_alu64_or_reg_pairs(struct bpf_test *self)
1479 {
1480         return __bpf_fill_alu_reg_pairs(self, BPF_OR, false);
1481 }
1482
1483 static int bpf_fill_alu64_xor_reg_pairs(struct bpf_test *self)
1484 {
1485         return __bpf_fill_alu_reg_pairs(self, BPF_XOR, false);
1486 }
1487
1488 static int bpf_fill_alu64_lsh_reg_pairs(struct bpf_test *self)
1489 {
1490         return __bpf_fill_alu_reg_pairs(self, BPF_LSH, false);
1491 }
1492
1493 static int bpf_fill_alu64_rsh_reg_pairs(struct bpf_test *self)
1494 {
1495         return __bpf_fill_alu_reg_pairs(self, BPF_RSH, false);
1496 }
1497
1498 static int bpf_fill_alu64_arsh_reg_pairs(struct bpf_test *self)
1499 {
1500         return __bpf_fill_alu_reg_pairs(self, BPF_ARSH, false);
1501 }
1502
1503 static int bpf_fill_alu64_add_reg_pairs(struct bpf_test *self)
1504 {
1505         return __bpf_fill_alu_reg_pairs(self, BPF_ADD, false);
1506 }
1507
1508 static int bpf_fill_alu64_sub_reg_pairs(struct bpf_test *self)
1509 {
1510         return __bpf_fill_alu_reg_pairs(self, BPF_SUB, false);
1511 }
1512
1513 static int bpf_fill_alu64_mul_reg_pairs(struct bpf_test *self)
1514 {
1515         return __bpf_fill_alu_reg_pairs(self, BPF_MUL, false);
1516 }
1517
1518 static int bpf_fill_alu64_div_reg_pairs(struct bpf_test *self)
1519 {
1520         return __bpf_fill_alu_reg_pairs(self, BPF_DIV, false);
1521 }
1522
1523 static int bpf_fill_alu64_mod_reg_pairs(struct bpf_test *self)
1524 {
1525         return __bpf_fill_alu_reg_pairs(self, BPF_MOD, false);
1526 }
1527
1528 /* ALU32 X register combinations */
1529 static int bpf_fill_alu32_mov_reg_pairs(struct bpf_test *self)
1530 {
1531         return __bpf_fill_alu_reg_pairs(self, BPF_MOV, true);
1532 }
1533
1534 static int bpf_fill_alu32_and_reg_pairs(struct bpf_test *self)
1535 {
1536         return __bpf_fill_alu_reg_pairs(self, BPF_AND, true);
1537 }
1538
1539 static int bpf_fill_alu32_or_reg_pairs(struct bpf_test *self)
1540 {
1541         return __bpf_fill_alu_reg_pairs(self, BPF_OR, true);
1542 }
1543
1544 static int bpf_fill_alu32_xor_reg_pairs(struct bpf_test *self)
1545 {
1546         return __bpf_fill_alu_reg_pairs(self, BPF_XOR, true);
1547 }
1548
1549 static int bpf_fill_alu32_lsh_reg_pairs(struct bpf_test *self)
1550 {
1551         return __bpf_fill_alu_reg_pairs(self, BPF_LSH, true);
1552 }
1553
1554 static int bpf_fill_alu32_rsh_reg_pairs(struct bpf_test *self)
1555 {
1556         return __bpf_fill_alu_reg_pairs(self, BPF_RSH, true);
1557 }
1558
1559 static int bpf_fill_alu32_arsh_reg_pairs(struct bpf_test *self)
1560 {
1561         return __bpf_fill_alu_reg_pairs(self, BPF_ARSH, true);
1562 }
1563
1564 static int bpf_fill_alu32_add_reg_pairs(struct bpf_test *self)
1565 {
1566         return __bpf_fill_alu_reg_pairs(self, BPF_ADD, true);
1567 }
1568
1569 static int bpf_fill_alu32_sub_reg_pairs(struct bpf_test *self)
1570 {
1571         return __bpf_fill_alu_reg_pairs(self, BPF_SUB, true);
1572 }
1573
1574 static int bpf_fill_alu32_mul_reg_pairs(struct bpf_test *self)
1575 {
1576         return __bpf_fill_alu_reg_pairs(self, BPF_MUL, true);
1577 }
1578
1579 static int bpf_fill_alu32_div_reg_pairs(struct bpf_test *self)
1580 {
1581         return __bpf_fill_alu_reg_pairs(self, BPF_DIV, true);
1582 }
1583
1584 static int bpf_fill_alu32_mod_reg_pairs(struct bpf_test *self)
1585 {
1586         return __bpf_fill_alu_reg_pairs(self, BPF_MOD, true);
1587 }
1588
1589 /*
1590  * Exhaustive tests of atomic operations for all power-of-two operand
1591  * magnitudes, both for positive and negative values.
1592  */
1593
1594 static int __bpf_emit_atomic64(struct bpf_test *self, void *arg,
1595                                struct bpf_insn *insns, s64 dst, s64 src)
1596 {
1597         int op = *(int *)arg;
1598         u64 keep, fetch, res;
1599         int i = 0;
1600
1601         if (!insns)
1602                 return 21;
1603
1604         switch (op) {
1605         case BPF_XCHG:
1606                 res = src;
1607                 break;
1608         default:
1609                 __bpf_alu_result(&res, dst, src, BPF_OP(op));
1610         }
1611
1612         keep = 0x0123456789abcdefULL;
1613         if (op & BPF_FETCH)
1614                 fetch = dst;
1615         else
1616                 fetch = src;
1617
1618         i += __bpf_ld_imm64(&insns[i], R0, keep);
1619         i += __bpf_ld_imm64(&insns[i], R1, dst);
1620         i += __bpf_ld_imm64(&insns[i], R2, src);
1621         i += __bpf_ld_imm64(&insns[i], R3, res);
1622         i += __bpf_ld_imm64(&insns[i], R4, fetch);
1623         i += __bpf_ld_imm64(&insns[i], R5, keep);
1624
1625         insns[i++] = BPF_STX_MEM(BPF_DW, R10, R1, -8);
1626         insns[i++] = BPF_ATOMIC_OP(BPF_DW, op, R10, R2, -8);
1627         insns[i++] = BPF_LDX_MEM(BPF_DW, R1, R10, -8);
1628
1629         insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
1630         insns[i++] = BPF_EXIT_INSN();
1631
1632         insns[i++] = BPF_JMP_REG(BPF_JEQ, R2, R4, 1);
1633         insns[i++] = BPF_EXIT_INSN();
1634
1635         insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R5, 1);
1636         insns[i++] = BPF_EXIT_INSN();
1637
1638         return i;
1639 }
1640
1641 static int __bpf_emit_atomic32(struct bpf_test *self, void *arg,
1642                                struct bpf_insn *insns, s64 dst, s64 src)
1643 {
1644         int op = *(int *)arg;
1645         u64 keep, fetch, res;
1646         int i = 0;
1647
1648         if (!insns)
1649                 return 21;
1650
1651         switch (op) {
1652         case BPF_XCHG:
1653                 res = src;
1654                 break;
1655         default:
1656                 __bpf_alu_result(&res, (u32)dst, (u32)src, BPF_OP(op));
1657         }
1658
1659         keep = 0x0123456789abcdefULL;
1660         if (op & BPF_FETCH)
1661                 fetch = (u32)dst;
1662         else
1663                 fetch = src;
1664
1665         i += __bpf_ld_imm64(&insns[i], R0, keep);
1666         i += __bpf_ld_imm64(&insns[i], R1, (u32)dst);
1667         i += __bpf_ld_imm64(&insns[i], R2, src);
1668         i += __bpf_ld_imm64(&insns[i], R3, (u32)res);
1669         i += __bpf_ld_imm64(&insns[i], R4, fetch);
1670         i += __bpf_ld_imm64(&insns[i], R5, keep);
1671
1672         insns[i++] = BPF_STX_MEM(BPF_W, R10, R1, -4);
1673         insns[i++] = BPF_ATOMIC_OP(BPF_W, op, R10, R2, -4);
1674         insns[i++] = BPF_LDX_MEM(BPF_W, R1, R10, -4);
1675
1676         insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
1677         insns[i++] = BPF_EXIT_INSN();
1678
1679         insns[i++] = BPF_JMP_REG(BPF_JEQ, R2, R4, 1);
1680         insns[i++] = BPF_EXIT_INSN();
1681
1682         insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R5, 1);
1683         insns[i++] = BPF_EXIT_INSN();
1684
1685         return i;
1686 }
1687
1688 static int __bpf_emit_cmpxchg64(struct bpf_test *self, void *arg,
1689                                 struct bpf_insn *insns, s64 dst, s64 src)
1690 {
1691         int i = 0;
1692
1693         if (!insns)
1694                 return 23;
1695
1696         i += __bpf_ld_imm64(&insns[i], R0, ~dst);
1697         i += __bpf_ld_imm64(&insns[i], R1, dst);
1698         i += __bpf_ld_imm64(&insns[i], R2, src);
1699
1700         /* Result unsuccessful */
1701         insns[i++] = BPF_STX_MEM(BPF_DW, R10, R1, -8);
1702         insns[i++] = BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -8);
1703         insns[i++] = BPF_LDX_MEM(BPF_DW, R3, R10, -8);
1704
1705         insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 2);
1706         insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1707         insns[i++] = BPF_EXIT_INSN();
1708
1709         insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R3, 2);
1710         insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1711         insns[i++] = BPF_EXIT_INSN();
1712
1713         /* Result successful */
1714         insns[i++] = BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -8);
1715         insns[i++] = BPF_LDX_MEM(BPF_DW, R3, R10, -8);
1716
1717         insns[i++] = BPF_JMP_REG(BPF_JEQ, R2, R3, 2);
1718         insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1719         insns[i++] = BPF_EXIT_INSN();
1720
1721         insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R1, 2);
1722         insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1723         insns[i++] = BPF_EXIT_INSN();
1724
1725         return i;
1726 }
1727
1728 static int __bpf_emit_cmpxchg32(struct bpf_test *self, void *arg,
1729                                 struct bpf_insn *insns, s64 dst, s64 src)
1730 {
1731         int i = 0;
1732
1733         if (!insns)
1734                 return 27;
1735
1736         i += __bpf_ld_imm64(&insns[i], R0, ~dst);
1737         i += __bpf_ld_imm64(&insns[i], R1, (u32)dst);
1738         i += __bpf_ld_imm64(&insns[i], R2, src);
1739
1740         /* Result unsuccessful */
1741         insns[i++] = BPF_STX_MEM(BPF_W, R10, R1, -4);
1742         insns[i++] = BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R2, -4);
1743         insns[i++] = BPF_ZEXT_REG(R0), /* Zext always inserted by verifier */
1744         insns[i++] = BPF_LDX_MEM(BPF_W, R3, R10, -4);
1745
1746         insns[i++] = BPF_JMP32_REG(BPF_JEQ, R1, R3, 2);
1747         insns[i++] = BPF_MOV32_IMM(R0, __LINE__);
1748         insns[i++] = BPF_EXIT_INSN();
1749
1750         insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R3, 2);
1751         insns[i++] = BPF_MOV32_IMM(R0, __LINE__);
1752         insns[i++] = BPF_EXIT_INSN();
1753
1754         /* Result successful */
1755         i += __bpf_ld_imm64(&insns[i], R0, dst);
1756         insns[i++] = BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R2, -4);
1757         insns[i++] = BPF_ZEXT_REG(R0), /* Zext always inserted by verifier */
1758         insns[i++] = BPF_LDX_MEM(BPF_W, R3, R10, -4);
1759
1760         insns[i++] = BPF_JMP32_REG(BPF_JEQ, R2, R3, 2);
1761         insns[i++] = BPF_MOV32_IMM(R0, __LINE__);
1762         insns[i++] = BPF_EXIT_INSN();
1763
1764         insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R1, 2);
1765         insns[i++] = BPF_MOV32_IMM(R0, __LINE__);
1766         insns[i++] = BPF_EXIT_INSN();
1767
1768         return i;
1769 }
1770
1771 static int __bpf_fill_atomic64(struct bpf_test *self, int op)
1772 {
1773         return __bpf_fill_pattern(self, &op, 64, 64,
1774                                   0, PATTERN_BLOCK2,
1775                                   &__bpf_emit_atomic64);
1776 }
1777
1778 static int __bpf_fill_atomic32(struct bpf_test *self, int op)
1779 {
1780         return __bpf_fill_pattern(self, &op, 64, 64,
1781                                   0, PATTERN_BLOCK2,
1782                                   &__bpf_emit_atomic32);
1783 }
1784
1785 /* 64-bit atomic operations */
1786 static int bpf_fill_atomic64_add(struct bpf_test *self)
1787 {
1788         return __bpf_fill_atomic64(self, BPF_ADD);
1789 }
1790
1791 static int bpf_fill_atomic64_and(struct bpf_test *self)
1792 {
1793         return __bpf_fill_atomic64(self, BPF_AND);
1794 }
1795
1796 static int bpf_fill_atomic64_or(struct bpf_test *self)
1797 {
1798         return __bpf_fill_atomic64(self, BPF_OR);
1799 }
1800
1801 static int bpf_fill_atomic64_xor(struct bpf_test *self)
1802 {
1803         return __bpf_fill_atomic64(self, BPF_XOR);
1804 }
1805
1806 static int bpf_fill_atomic64_add_fetch(struct bpf_test *self)
1807 {
1808         return __bpf_fill_atomic64(self, BPF_ADD | BPF_FETCH);
1809 }
1810
1811 static int bpf_fill_atomic64_and_fetch(struct bpf_test *self)
1812 {
1813         return __bpf_fill_atomic64(self, BPF_AND | BPF_FETCH);
1814 }
1815
1816 static int bpf_fill_atomic64_or_fetch(struct bpf_test *self)
1817 {
1818         return __bpf_fill_atomic64(self, BPF_OR | BPF_FETCH);
1819 }
1820
1821 static int bpf_fill_atomic64_xor_fetch(struct bpf_test *self)
1822 {
1823         return __bpf_fill_atomic64(self, BPF_XOR | BPF_FETCH);
1824 }
1825
1826 static int bpf_fill_atomic64_xchg(struct bpf_test *self)
1827 {
1828         return __bpf_fill_atomic64(self, BPF_XCHG);
1829 }
1830
1831 static int bpf_fill_cmpxchg64(struct bpf_test *self)
1832 {
1833         return __bpf_fill_pattern(self, NULL, 64, 64, 0, PATTERN_BLOCK2,
1834                                   &__bpf_emit_cmpxchg64);
1835 }
1836
1837 /* 32-bit atomic operations */
1838 static int bpf_fill_atomic32_add(struct bpf_test *self)
1839 {
1840         return __bpf_fill_atomic32(self, BPF_ADD);
1841 }
1842
1843 static int bpf_fill_atomic32_and(struct bpf_test *self)
1844 {
1845         return __bpf_fill_atomic32(self, BPF_AND);
1846 }
1847
1848 static int bpf_fill_atomic32_or(struct bpf_test *self)
1849 {
1850         return __bpf_fill_atomic32(self, BPF_OR);
1851 }
1852
1853 static int bpf_fill_atomic32_xor(struct bpf_test *self)
1854 {
1855         return __bpf_fill_atomic32(self, BPF_XOR);
1856 }
1857
1858 static int bpf_fill_atomic32_add_fetch(struct bpf_test *self)
1859 {
1860         return __bpf_fill_atomic32(self, BPF_ADD | BPF_FETCH);
1861 }
1862
1863 static int bpf_fill_atomic32_and_fetch(struct bpf_test *self)
1864 {
1865         return __bpf_fill_atomic32(self, BPF_AND | BPF_FETCH);
1866 }
1867
1868 static int bpf_fill_atomic32_or_fetch(struct bpf_test *self)
1869 {
1870         return __bpf_fill_atomic32(self, BPF_OR | BPF_FETCH);
1871 }
1872
1873 static int bpf_fill_atomic32_xor_fetch(struct bpf_test *self)
1874 {
1875         return __bpf_fill_atomic32(self, BPF_XOR | BPF_FETCH);
1876 }
1877
1878 static int bpf_fill_atomic32_xchg(struct bpf_test *self)
1879 {
1880         return __bpf_fill_atomic32(self, BPF_XCHG);
1881 }
1882
1883 static int bpf_fill_cmpxchg32(struct bpf_test *self)
1884 {
1885         return __bpf_fill_pattern(self, NULL, 64, 64, 0, PATTERN_BLOCK2,
1886                                   &__bpf_emit_cmpxchg32);
1887 }
1888
1889 /*
1890  * Test JITs that implement ATOMIC operations as function calls or
1891  * other primitives, and must re-arrange operands for argument passing.
1892  */
1893 static int __bpf_fill_atomic_reg_pairs(struct bpf_test *self, u8 width, u8 op)
1894 {
1895         struct bpf_insn *insn;
1896         int len = 2 + 34 * 10 * 10;
1897         u64 mem, upd, res;
1898         int rd, rs, i = 0;
1899
1900         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
1901         if (!insn)
1902                 return -ENOMEM;
1903
1904         /* Operand and memory values */
1905         if (width == BPF_DW) {
1906                 mem = 0x0123456789abcdefULL;
1907                 upd = 0xfedcba9876543210ULL;
1908         } else { /* BPF_W */
1909                 mem = 0x01234567U;
1910                 upd = 0x76543210U;
1911         }
1912
1913         /* Memory updated according to operation */
1914         switch (op) {
1915         case BPF_XCHG:
1916                 res = upd;
1917                 break;
1918         case BPF_CMPXCHG:
1919                 res = mem;
1920                 break;
1921         default:
1922                 __bpf_alu_result(&res, mem, upd, BPF_OP(op));
1923         }
1924
1925         /* Test all operand registers */
1926         for (rd = R0; rd <= R9; rd++) {
1927                 for (rs = R0; rs <= R9; rs++) {
1928                         u64 cmp, src;
1929
1930                         /* Initialize value in memory */
1931                         i += __bpf_ld_imm64(&insn[i], R0, mem);
1932                         insn[i++] = BPF_STX_MEM(width, R10, R0, -8);
1933
1934                         /* Initialize registers in order */
1935                         i += __bpf_ld_imm64(&insn[i], R0, ~mem);
1936                         i += __bpf_ld_imm64(&insn[i], rs, upd);
1937                         insn[i++] = BPF_MOV64_REG(rd, R10);
1938
1939                         /* Perform atomic operation */
1940                         insn[i++] = BPF_ATOMIC_OP(width, op, rd, rs, -8);
1941                         if (op == BPF_CMPXCHG && width == BPF_W)
1942                                 insn[i++] = BPF_ZEXT_REG(R0);
1943
1944                         /* Check R0 register value */
1945                         if (op == BPF_CMPXCHG)
1946                                 cmp = mem;  /* Expect value from memory */
1947                         else if (R0 == rd || R0 == rs)
1948                                 cmp = 0;    /* Aliased, checked below */
1949                         else
1950                                 cmp = ~mem; /* Expect value to be preserved */
1951                         if (cmp) {
1952                                 insn[i++] = BPF_JMP32_IMM(BPF_JEQ, R0,
1953                                                            (u32)cmp, 2);
1954                                 insn[i++] = BPF_MOV32_IMM(R0, __LINE__);
1955                                 insn[i++] = BPF_EXIT_INSN();
1956                                 insn[i++] = BPF_ALU64_IMM(BPF_RSH, R0, 32);
1957                                 insn[i++] = BPF_JMP32_IMM(BPF_JEQ, R0,
1958                                                            cmp >> 32, 2);
1959                                 insn[i++] = BPF_MOV32_IMM(R0, __LINE__);
1960                                 insn[i++] = BPF_EXIT_INSN();
1961                         }
1962
1963                         /* Check source register value */
1964                         if (rs == R0 && op == BPF_CMPXCHG)
1965                                 src = 0;   /* Aliased with R0, checked above */
1966                         else if (rs == rd && (op == BPF_CMPXCHG ||
1967                                               !(op & BPF_FETCH)))
1968                                 src = 0;   /* Aliased with rd, checked below */
1969                         else if (op == BPF_CMPXCHG)
1970                                 src = upd; /* Expect value to be preserved */
1971                         else if (op & BPF_FETCH)
1972                                 src = mem; /* Expect fetched value from mem */
1973                         else /* no fetch */
1974                                 src = upd; /* Expect value to be preserved */
1975                         if (src) {
1976                                 insn[i++] = BPF_JMP32_IMM(BPF_JEQ, rs,
1977                                                            (u32)src, 2);
1978                                 insn[i++] = BPF_MOV32_IMM(R0, __LINE__);
1979                                 insn[i++] = BPF_EXIT_INSN();
1980                                 insn[i++] = BPF_ALU64_IMM(BPF_RSH, rs, 32);
1981                                 insn[i++] = BPF_JMP32_IMM(BPF_JEQ, rs,
1982                                                            src >> 32, 2);
1983                                 insn[i++] = BPF_MOV32_IMM(R0, __LINE__);
1984                                 insn[i++] = BPF_EXIT_INSN();
1985                         }
1986
1987                         /* Check destination register value */
1988                         if (!(rd == R0 && op == BPF_CMPXCHG) &&
1989                             !(rd == rs && (op & BPF_FETCH))) {
1990                                 insn[i++] = BPF_JMP_REG(BPF_JEQ, rd, R10, 2);
1991                                 insn[i++] = BPF_MOV32_IMM(R0, __LINE__);
1992                                 insn[i++] = BPF_EXIT_INSN();
1993                         }
1994
1995                         /* Check value in memory */
1996                         if (rs != rd) {                  /* No aliasing */
1997                                 i += __bpf_ld_imm64(&insn[i], R1, res);
1998                         } else if (op == BPF_XCHG) {     /* Aliased, XCHG */
1999                                 insn[i++] = BPF_MOV64_REG(R1, R10);
2000                         } else if (op == BPF_CMPXCHG) {  /* Aliased, CMPXCHG */
2001                                 i += __bpf_ld_imm64(&insn[i], R1, mem);
2002                         } else {                        /* Aliased, ALU oper */
2003                                 i += __bpf_ld_imm64(&insn[i], R1, mem);
2004                                 insn[i++] = BPF_ALU64_REG(BPF_OP(op), R1, R10);
2005                         }
2006
2007                         insn[i++] = BPF_LDX_MEM(width, R0, R10, -8);
2008                         if (width == BPF_DW)
2009                                 insn[i++] = BPF_JMP_REG(BPF_JEQ, R0, R1, 2);
2010                         else /* width == BPF_W */
2011                                 insn[i++] = BPF_JMP32_REG(BPF_JEQ, R0, R1, 2);
2012                         insn[i++] = BPF_MOV32_IMM(R0, __LINE__);
2013                         insn[i++] = BPF_EXIT_INSN();
2014                 }
2015         }
2016
2017         insn[i++] = BPF_MOV64_IMM(R0, 1);
2018         insn[i++] = BPF_EXIT_INSN();
2019
2020         self->u.ptr.insns = insn;
2021         self->u.ptr.len = i;
2022         BUG_ON(i > len);
2023
2024         return 0;
2025 }
2026
2027 /* 64-bit atomic register tests */
2028 static int bpf_fill_atomic64_add_reg_pairs(struct bpf_test *self)
2029 {
2030         return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_ADD);
2031 }
2032
2033 static int bpf_fill_atomic64_and_reg_pairs(struct bpf_test *self)
2034 {
2035         return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_AND);
2036 }
2037
2038 static int bpf_fill_atomic64_or_reg_pairs(struct bpf_test *self)
2039 {
2040         return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_OR);
2041 }
2042
2043 static int bpf_fill_atomic64_xor_reg_pairs(struct bpf_test *self)
2044 {
2045         return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_XOR);
2046 }
2047
2048 static int bpf_fill_atomic64_add_fetch_reg_pairs(struct bpf_test *self)
2049 {
2050         return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_ADD | BPF_FETCH);
2051 }
2052
2053 static int bpf_fill_atomic64_and_fetch_reg_pairs(struct bpf_test *self)
2054 {
2055         return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_AND | BPF_FETCH);
2056 }
2057
2058 static int bpf_fill_atomic64_or_fetch_reg_pairs(struct bpf_test *self)
2059 {
2060         return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_OR | BPF_FETCH);
2061 }
2062
2063 static int bpf_fill_atomic64_xor_fetch_reg_pairs(struct bpf_test *self)
2064 {
2065         return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_XOR | BPF_FETCH);
2066 }
2067
2068 static int bpf_fill_atomic64_xchg_reg_pairs(struct bpf_test *self)
2069 {
2070         return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_XCHG);
2071 }
2072
2073 static int bpf_fill_atomic64_cmpxchg_reg_pairs(struct bpf_test *self)
2074 {
2075         return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_CMPXCHG);
2076 }
2077
2078 /* 32-bit atomic register tests */
2079 static int bpf_fill_atomic32_add_reg_pairs(struct bpf_test *self)
2080 {
2081         return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_ADD);
2082 }
2083
2084 static int bpf_fill_atomic32_and_reg_pairs(struct bpf_test *self)
2085 {
2086         return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_AND);
2087 }
2088
2089 static int bpf_fill_atomic32_or_reg_pairs(struct bpf_test *self)
2090 {
2091         return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_OR);
2092 }
2093
2094 static int bpf_fill_atomic32_xor_reg_pairs(struct bpf_test *self)
2095 {
2096         return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_XOR);
2097 }
2098
2099 static int bpf_fill_atomic32_add_fetch_reg_pairs(struct bpf_test *self)
2100 {
2101         return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_ADD | BPF_FETCH);
2102 }
2103
2104 static int bpf_fill_atomic32_and_fetch_reg_pairs(struct bpf_test *self)
2105 {
2106         return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_AND | BPF_FETCH);
2107 }
2108
2109 static int bpf_fill_atomic32_or_fetch_reg_pairs(struct bpf_test *self)
2110 {
2111         return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_OR | BPF_FETCH);
2112 }
2113
2114 static int bpf_fill_atomic32_xor_fetch_reg_pairs(struct bpf_test *self)
2115 {
2116         return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_XOR | BPF_FETCH);
2117 }
2118
2119 static int bpf_fill_atomic32_xchg_reg_pairs(struct bpf_test *self)
2120 {
2121         return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_XCHG);
2122 }
2123
2124 static int bpf_fill_atomic32_cmpxchg_reg_pairs(struct bpf_test *self)
2125 {
2126         return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_CMPXCHG);
2127 }
2128
2129 /*
2130  * Test the two-instruction 64-bit immediate load operation for all
2131  * power-of-two magnitudes of the immediate operand. For each MSB, a block
2132  * of immediate values centered around the power-of-two MSB are tested,
2133  * both for positive and negative values. The test is designed to verify
2134  * the operation for JITs that emit different code depending on the magnitude
2135  * of the immediate value. This is often the case if the native instruction
2136  * immediate field width is narrower than 32 bits.
2137  */
2138 static int bpf_fill_ld_imm64_magn(struct bpf_test *self)
2139 {
2140         int block = 64; /* Increase for more tests per MSB position */
2141         int len = 3 + 8 * 63 * block * 2;
2142         struct bpf_insn *insn;
2143         int bit, adj, sign;
2144         int i = 0;
2145
2146         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
2147         if (!insn)
2148                 return -ENOMEM;
2149
2150         insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
2151
2152         for (bit = 0; bit <= 62; bit++) {
2153                 for (adj = -block / 2; adj < block / 2; adj++) {
2154                         for (sign = -1; sign <= 1; sign += 2) {
2155                                 s64 imm = sign * ((1LL << bit) + adj);
2156
2157                                 /* Perform operation */
2158                                 i += __bpf_ld_imm64(&insn[i], R1, imm);
2159
2160                                 /* Load reference */
2161                                 insn[i++] = BPF_ALU32_IMM(BPF_MOV, R2, imm);
2162                                 insn[i++] = BPF_ALU32_IMM(BPF_MOV, R3,
2163                                                           (u32)(imm >> 32));
2164                                 insn[i++] = BPF_ALU64_IMM(BPF_LSH, R3, 32);
2165                                 insn[i++] = BPF_ALU64_REG(BPF_OR, R2, R3);
2166
2167                                 /* Check result */
2168                                 insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R2, 1);
2169                                 insn[i++] = BPF_EXIT_INSN();
2170                         }
2171                 }
2172         }
2173
2174         insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
2175         insn[i++] = BPF_EXIT_INSN();
2176
2177         self->u.ptr.insns = insn;
2178         self->u.ptr.len = len;
2179         BUG_ON(i != len);
2180
2181         return 0;
2182 }
2183
2184 /*
2185  * Test the two-instruction 64-bit immediate load operation for different
2186  * combinations of bytes. Each byte in the 64-bit word is constructed as
2187  * (base & mask) | (rand() & ~mask), where rand() is a deterministic LCG.
2188  * All patterns (base1, mask1) and (base2, mask2) bytes are tested.
2189  */
2190 static int __bpf_fill_ld_imm64_bytes(struct bpf_test *self,
2191                                      u8 base1, u8 mask1,
2192                                      u8 base2, u8 mask2)
2193 {
2194         struct bpf_insn *insn;
2195         int len = 3 + 8 * BIT(8);
2196         int pattern, index;
2197         u32 rand = 1;
2198         int i = 0;
2199
2200         insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
2201         if (!insn)
2202                 return -ENOMEM;
2203
2204         insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
2205
2206         for (pattern = 0; pattern < BIT(8); pattern++) {
2207                 u64 imm = 0;
2208
2209                 for (index = 0; index < 8; index++) {
2210                         int byte;
2211
2212                         if (pattern & BIT(index))
2213                                 byte = (base1 & mask1) | (rand & ~mask1);
2214                         else
2215                                 byte = (base2 & mask2) | (rand & ~mask2);
2216                         imm = (imm << 8) | byte;
2217                 }
2218
2219                 /* Update our LCG */
2220                 rand = rand * 1664525 + 1013904223;
2221
2222                 /* Perform operation */
2223                 i += __bpf_ld_imm64(&insn[i], R1, imm);
2224
2225                 /* Load reference */
2226                 insn[i++] = BPF_ALU32_IMM(BPF_MOV, R2, imm);
2227                 insn[i++] = BPF_ALU32_IMM(BPF_MOV, R3, (u32)(imm >> 32));
2228                 insn[i++] = BPF_ALU64_IMM(BPF_LSH, R3, 32);
2229                 insn[i++] = BPF_ALU64_REG(BPF_OR, R2, R3);
2230
2231                 /* Check result */
2232                 insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R2, 1);
2233                 insn[i++] = BPF_EXIT_INSN();
2234         }
2235
2236         insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
2237         insn[i++] = BPF_EXIT_INSN();
2238
2239         self->u.ptr.insns = insn;
2240         self->u.ptr.len = len;
2241         BUG_ON(i != len);
2242
2243         return 0;
2244 }
2245
2246 static int bpf_fill_ld_imm64_checker(struct bpf_test *self)
2247 {
2248         return __bpf_fill_ld_imm64_bytes(self, 0, 0xff, 0xff, 0xff);
2249 }
2250
2251 static int bpf_fill_ld_imm64_pos_neg(struct bpf_test *self)
2252 {
2253         return __bpf_fill_ld_imm64_bytes(self, 1, 0x81, 0x80, 0x80);
2254 }
2255
2256 static int bpf_fill_ld_imm64_pos_zero(struct bpf_test *self)
2257 {
2258         return __bpf_fill_ld_imm64_bytes(self, 1, 0x81, 0, 0xff);
2259 }
2260
2261 static int bpf_fill_ld_imm64_neg_zero(struct bpf_test *self)
2262 {
2263         return __bpf_fill_ld_imm64_bytes(self, 0x80, 0x80, 0, 0xff);
2264 }
2265
2266 /*
2267  * Exhaustive tests of JMP operations for all combinations of power-of-two
2268  * magnitudes of the operands, both for positive and negative values. The
2269  * test is designed to verify e.g. the JMP and JMP32 operations for JITs that
2270  * emit different code depending on the magnitude of the immediate value.
2271  */
2272
2273 static bool __bpf_match_jmp_cond(s64 v1, s64 v2, u8 op)
2274 {
2275         switch (op) {
2276         case BPF_JSET:
2277                 return !!(v1 & v2);
2278         case BPF_JEQ:
2279                 return v1 == v2;
2280         case BPF_JNE:
2281                 return v1 != v2;
2282         case BPF_JGT:
2283                 return (u64)v1 > (u64)v2;
2284         case BPF_JGE:
2285                 return (u64)v1 >= (u64)v2;
2286         case BPF_JLT:
2287                 return (u64)v1 < (u64)v2;
2288         case BPF_JLE:
2289                 return (u64)v1 <= (u64)v2;
2290         case BPF_JSGT:
2291                 return v1 > v2;
2292         case BPF_JSGE:
2293                 return v1 >= v2;
2294         case BPF_JSLT:
2295                 return v1 < v2;
2296         case BPF_JSLE:
2297                 return v1 <= v2;
2298         }
2299         return false;
2300 }
2301
2302 static int __bpf_emit_jmp_imm(struct bpf_test *self, void *arg,
2303                               struct bpf_insn *insns, s64 dst, s64 imm)
2304 {
2305         int op = *(int *)arg;
2306
2307         if (insns) {
2308                 bool match = __bpf_match_jmp_cond(dst, (s32)imm, op);
2309                 int i = 0;
2310
2311                 insns[i++] = BPF_ALU32_IMM(BPF_MOV, R0, match);
2312
2313                 i += __bpf_ld_imm64(&insns[i], R1, dst);
2314                 insns[i++] = BPF_JMP_IMM(op, R1, imm, 1);
2315                 if (!match)
2316                         insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
2317                 insns[i++] = BPF_EXIT_INSN();
2318
2319                 return i;
2320         }
2321
2322         return 5 + 1;
2323 }
2324
2325 static int __bpf_emit_jmp32_imm(struct bpf_test *self, void *arg,
2326                                 struct bpf_insn *insns, s64 dst, s64 imm)
2327 {
2328         int op = *(int *)arg;
2329
2330         if (insns) {
2331                 bool match = __bpf_match_jmp_cond((s32)dst, (s32)imm, op);
2332                 int i = 0;
2333
2334                 i += __bpf_ld_imm64(&insns[i], R1, dst);
2335                 insns[i++] = BPF_JMP32_IMM(op, R1, imm, 1);
2336                 if (!match)
2337                         insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
2338                 insns[i++] = BPF_EXIT_INSN();
2339
2340                 return i;
2341         }
2342
2343         return 5;
2344 }
2345
2346 static int __bpf_emit_jmp_reg(struct bpf_test *self, void *arg,
2347                               struct bpf_insn *insns, s64 dst, s64 src)
2348 {
2349         int op = *(int *)arg;
2350
2351         if (insns) {
2352                 bool match = __bpf_match_jmp_cond(dst, src, op);
2353                 int i = 0;
2354
2355                 i += __bpf_ld_imm64(&insns[i], R1, dst);
2356                 i += __bpf_ld_imm64(&insns[i], R2, src);
2357                 insns[i++] = BPF_JMP_REG(op, R1, R2, 1);
2358                 if (!match)
2359                         insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
2360                 insns[i++] = BPF_EXIT_INSN();
2361
2362                 return i;
2363         }
2364
2365         return 7;
2366 }
2367
2368 static int __bpf_emit_jmp32_reg(struct bpf_test *self, void *arg,
2369                                 struct bpf_insn *insns, s64 dst, s64 src)
2370 {
2371         int op = *(int *)arg;
2372
2373         if (insns) {
2374                 bool match = __bpf_match_jmp_cond((s32)dst, (s32)src, op);
2375                 int i = 0;
2376
2377                 i += __bpf_ld_imm64(&insns[i], R1, dst);
2378                 i += __bpf_ld_imm64(&insns[i], R2, src);
2379                 insns[i++] = BPF_JMP32_REG(op, R1, R2, 1);
2380                 if (!match)
2381                         insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
2382                 insns[i++] = BPF_EXIT_INSN();
2383
2384                 return i;
2385         }
2386
2387         return 7;
2388 }
2389
2390 static int __bpf_fill_jmp_imm(struct bpf_test *self, int op)
2391 {
2392         return __bpf_fill_pattern(self, &op, 64, 32,
2393                                   PATTERN_BLOCK1, PATTERN_BLOCK2,
2394                                   &__bpf_emit_jmp_imm);
2395 }
2396
2397 static int __bpf_fill_jmp32_imm(struct bpf_test *self, int op)
2398 {
2399         return __bpf_fill_pattern(self, &op, 64, 32,
2400                                   PATTERN_BLOCK1, PATTERN_BLOCK2,
2401                                   &__bpf_emit_jmp32_imm);
2402 }
2403
2404 static int __bpf_fill_jmp_reg(struct bpf_test *self, int op)
2405 {
2406         return __bpf_fill_pattern(self, &op, 64, 64,
2407                                   PATTERN_BLOCK1, PATTERN_BLOCK2,
2408                                   &__bpf_emit_jmp_reg);
2409 }
2410
2411 static int __bpf_fill_jmp32_reg(struct bpf_test *self, int op)
2412 {
2413         return __bpf_fill_pattern(self, &op, 64, 64,
2414                                   PATTERN_BLOCK1, PATTERN_BLOCK2,
2415                                   &__bpf_emit_jmp32_reg);
2416 }
2417
2418 /* JMP immediate tests */
2419 static int bpf_fill_jmp_jset_imm(struct bpf_test *self)
2420 {
2421         return __bpf_fill_jmp_imm(self, BPF_JSET);
2422 }
2423
2424 static int bpf_fill_jmp_jeq_imm(struct bpf_test *self)
2425 {
2426         return __bpf_fill_jmp_imm(self, BPF_JEQ);
2427 }
2428
2429 static int bpf_fill_jmp_jne_imm(struct bpf_test *self)
2430 {
2431         return __bpf_fill_jmp_imm(self, BPF_JNE);
2432 }
2433
2434 static int bpf_fill_jmp_jgt_imm(struct bpf_test *self)
2435 {
2436         return __bpf_fill_jmp_imm(self, BPF_JGT);
2437 }
2438
2439 static int bpf_fill_jmp_jge_imm(struct bpf_test *self)
2440 {
2441         return __bpf_fill_jmp_imm(self, BPF_JGE);
2442 }
2443
2444 static int bpf_fill_jmp_jlt_imm(struct bpf_test *self)
2445 {
2446         return __bpf_fill_jmp_imm(self, BPF_JLT);
2447 }
2448
2449 static int bpf_fill_jmp_jle_imm(struct bpf_test *self)
2450 {
2451         return __bpf_fill_jmp_imm(self, BPF_JLE);
2452 }
2453
2454 static int bpf_fill_jmp_jsgt_imm(struct bpf_test *self)
2455 {
2456         return __bpf_fill_jmp_imm(self, BPF_JSGT);
2457 }
2458
2459 static int bpf_fill_jmp_jsge_imm(struct bpf_test *self)
2460 {
2461         return __bpf_fill_jmp_imm(self, BPF_JSGE);
2462 }
2463
2464 static int bpf_fill_jmp_jslt_imm(struct bpf_test *self)
2465 {
2466         return __bpf_fill_jmp_imm(self, BPF_JSLT);
2467 }
2468
2469 static int bpf_fill_jmp_jsle_imm(struct bpf_test *self)
2470 {
2471         return __bpf_fill_jmp_imm(self, BPF_JSLE);
2472 }
2473
2474 /* JMP32 immediate tests */
2475 static int bpf_fill_jmp32_jset_imm(struct bpf_test *self)
2476 {
2477         return __bpf_fill_jmp32_imm(self, BPF_JSET);
2478 }
2479
2480 static int bpf_fill_jmp32_jeq_imm(struct bpf_test *self)
2481 {
2482         return __bpf_fill_jmp32_imm(self, BPF_JEQ);
2483 }
2484
2485 static int bpf_fill_jmp32_jne_imm(struct bpf_test *self)
2486 {
2487         return __bpf_fill_jmp32_imm(self, BPF_JNE);
2488 }
2489
2490 static int bpf_fill_jmp32_jgt_imm(struct bpf_test *self)
2491 {
2492         return __bpf_fill_jmp32_imm(self, BPF_JGT);
2493 }
2494
2495 static int bpf_fill_jmp32_jge_imm(struct bpf_test *self)
2496 {
2497         return __bpf_fill_jmp32_imm(self, BPF_JGE);
2498 }
2499
2500 static int bpf_fill_jmp32_jlt_imm(struct bpf_test *self)
2501 {
2502         return __bpf_fill_jmp32_imm(self, BPF_JLT);
2503 }
2504
2505 static int bpf_fill_jmp32_jle_imm(struct bpf_test *self)
2506 {
2507         return __bpf_fill_jmp32_imm(self, BPF_JLE);
2508 }
2509
2510 static int bpf_fill_jmp32_jsgt_imm(struct bpf_test *self)
2511 {
2512         return __bpf_fill_jmp32_imm(self, BPF_JSGT);
2513 }
2514
2515 static int bpf_fill_jmp32_jsge_imm(struct bpf_test *self)
2516 {
2517         return __bpf_fill_jmp32_imm(self, BPF_JSGE);
2518 }
2519
2520 static int bpf_fill_jmp32_jslt_imm(struct bpf_test *self)
2521 {
2522         return __bpf_fill_jmp32_imm(self, BPF_JSLT);
2523 }
2524
2525 static int bpf_fill_jmp32_jsle_imm(struct bpf_test *self)
2526 {
2527         return __bpf_fill_jmp32_imm(self, BPF_JSLE);
2528 }
2529
2530 /* JMP register tests */
2531 static int bpf_fill_jmp_jset_reg(struct bpf_test *self)
2532 {
2533         return __bpf_fill_jmp_reg(self, BPF_JSET);
2534 }
2535
2536 static int bpf_fill_jmp_jeq_reg(struct bpf_test *self)
2537 {
2538         return __bpf_fill_jmp_reg(self, BPF_JEQ);
2539 }
2540
2541 static int bpf_fill_jmp_jne_reg(struct bpf_test *self)
2542 {
2543         return __bpf_fill_jmp_reg(self, BPF_JNE);
2544 }
2545
2546 static int bpf_fill_jmp_jgt_reg(struct bpf_test *self)
2547 {
2548         return __bpf_fill_jmp_reg(self, BPF_JGT);
2549 }
2550
2551 static int bpf_fill_jmp_jge_reg(struct bpf_test *self)
2552 {
2553         return __bpf_fill_jmp_reg(self, BPF_JGE);
2554 }
2555
2556 static int bpf_fill_jmp_jlt_reg(struct bpf_test *self)
2557 {
2558         return __bpf_fill_jmp_reg(self, BPF_JLT);
2559 }
2560
2561 static int bpf_fill_jmp_jle_reg(struct bpf_test *self)
2562 {
2563         return __bpf_fill_jmp_reg(self, BPF_JLE);
2564 }
2565
2566 static int bpf_fill_jmp_jsgt_reg(struct bpf_test *self)
2567 {
2568         return __bpf_fill_jmp_reg(self, BPF_JSGT);
2569 }
2570
2571 static int bpf_fill_jmp_jsge_reg(struct bpf_test *self)
2572 {
2573         return __bpf_fill_jmp_reg(self, BPF_JSGE);
2574 }
2575
2576 static int bpf_fill_jmp_jslt_reg(struct bpf_test *self)
2577 {
2578         return __bpf_fill_jmp_reg(self, BPF_JSLT);
2579 }
2580
2581 static int bpf_fill_jmp_jsle_reg(struct bpf_test *self)
2582 {
2583         return __bpf_fill_jmp_reg(self, BPF_JSLE);
2584 }
2585
2586 /* JMP32 register tests */
2587 static int bpf_fill_jmp32_jset_reg(struct bpf_test *self)
2588 {
2589         return __bpf_fill_jmp32_reg(self, BPF_JSET);
2590 }
2591
2592 static int bpf_fill_jmp32_jeq_reg(struct bpf_test *self)
2593 {
2594         return __bpf_fill_jmp32_reg(self, BPF_JEQ);
2595 }
2596
2597 static int bpf_fill_jmp32_jne_reg(struct bpf_test *self)
2598 {
2599         return __bpf_fill_jmp32_reg(self, BPF_JNE);
2600 }
2601
2602 static int bpf_fill_jmp32_jgt_reg(struct bpf_test *self)
2603 {
2604         return __bpf_fill_jmp32_reg(self, BPF_JGT);
2605 }
2606
2607 static int bpf_fill_jmp32_jge_reg(struct bpf_test *self)
2608 {
2609         return __bpf_fill_jmp32_reg(self, BPF_JGE);
2610 }
2611
2612 static int bpf_fill_jmp32_jlt_reg(struct bpf_test *self)
2613 {
2614         return __bpf_fill_jmp32_reg(self, BPF_JLT);
2615 }
2616
2617 static int bpf_fill_jmp32_jle_reg(struct bpf_test *self)
2618 {
2619         return __bpf_fill_jmp32_reg(self, BPF_JLE);
2620 }
2621
2622 static int bpf_fill_jmp32_jsgt_reg(struct bpf_test *self)
2623 {
2624         return __bpf_fill_jmp32_reg(self, BPF_JSGT);
2625 }
2626
2627 static int bpf_fill_jmp32_jsge_reg(struct bpf_test *self)
2628 {
2629         return __bpf_fill_jmp32_reg(self, BPF_JSGE);
2630 }
2631
2632 static int bpf_fill_jmp32_jslt_reg(struct bpf_test *self)
2633 {
2634         return __bpf_fill_jmp32_reg(self, BPF_JSLT);
2635 }
2636
2637 static int bpf_fill_jmp32_jsle_reg(struct bpf_test *self)
2638 {
2639         return __bpf_fill_jmp32_reg(self, BPF_JSLE);
2640 }
2641
2642 /*
2643  * Set up a sequence of staggered jumps, forwards and backwards with
2644  * increasing offset. This tests the conversion of relative jumps to
2645  * JITed native jumps. On some architectures, for example MIPS, a large
2646  * PC-relative jump offset may overflow the immediate field of the native
2647  * conditional branch instruction, triggering a conversion to use an
2648  * absolute jump instead. Since this changes the jump offsets, another
2649  * offset computation pass is necessary, and that may in turn trigger
2650  * another branch conversion. This jump sequence is particularly nasty
2651  * in that regard.
2652  *
2653  * The sequence generation is parameterized by size and jump type.
2654  * The size must be even, and the expected result is always size + 1.
2655  * Below is an example with size=8 and result=9.
2656  *
2657  *                     ________________________Start
2658  *                     R0 = 0
2659  *                     R1 = r1
2660  *                     R2 = r2
2661  *            ,------- JMP +4 * 3______________Preamble: 4 insns
2662  * ,----------|-ind 0- if R0 != 7 JMP 8 * 3 + 1 <--------------------.
2663  * |          |        R0 = 8                                        |
2664  * |          |        JMP +7 * 3               ------------------------.
2665  * | ,--------|-----1- if R0 != 5 JMP 7 * 3 + 1 <--------------.     |  |
2666  * | |        |        R0 = 6                                  |     |  |
2667  * | |        |        JMP +5 * 3               ------------------.  |  |
2668  * | | ,------|-----2- if R0 != 3 JMP 6 * 3 + 1 <--------.     |  |  |  |
2669  * | | |      |        R0 = 4                            |     |  |  |  |
2670  * | | |      |        JMP +3 * 3               ------------.  |  |  |  |
2671  * | | | ,----|-----3- if R0 != 1 JMP 5 * 3 + 1 <--.     |  |  |  |  |  |
2672  * | | | |    |        R0 = 2                      |     |  |  |  |  |  |
2673  * | | | |    |        JMP +1 * 3               ------.  |  |  |  |  |  |
2674  * | | | | ,--t=====4> if R0 != 0 JMP 4 * 3 + 1    1  2  3  4  5  6  7  8 loc
2675  * | | | | |           R0 = 1                     -1 +2 -3 +4 -5 +6 -7 +8 off
2676  * | | | | |           JMP -2 * 3               ---'  |  |  |  |  |  |  |
2677  * | | | | | ,------5- if R0 != 2 JMP 3 * 3 + 1 <-----'  |  |  |  |  |  |
2678  * | | | | | |         R0 = 3                            |  |  |  |  |  |
2679  * | | | | | |         JMP -4 * 3               ---------'  |  |  |  |  |
2680  * | | | | | | ,----6- if R0 != 4 JMP 2 * 3 + 1 <-----------'  |  |  |  |
2681  * | | | | | | |       R0 = 5                                  |  |  |  |
2682  * | | | | | | |       JMP -6 * 3               ---------------'  |  |  |
2683  * | | | | | | | ,--7- if R0 != 6 JMP 1 * 3 + 1 <-----------------'  |  |
2684  * | | | | | | | |     R0 = 7                                        |  |
2685  * | | Error | | |     JMP -8 * 3               ---------------------'  |
2686  * | | paths | | | ,8- if R0 != 8 JMP 0 * 3 + 1 <-----------------------'
2687  * | | | | | | | | |   R0 = 9__________________Sequence: 3 * size - 1 insns
2688  * `-+-+-+-+-+-+-+-+-> EXIT____________________Return: 1 insn
2689  *
2690  */
2691
2692 /* The maximum size parameter */
2693 #define MAX_STAGGERED_JMP_SIZE ((0x7fff / 3) & ~1)
2694
2695 /* We use a reduced number of iterations to get a reasonable execution time */
2696 #define NR_STAGGERED_JMP_RUNS 10
2697
2698 static int __bpf_fill_staggered_jumps(struct bpf_test *self,
2699                                       const struct bpf_insn *jmp,
2700                                       u64 r1, u64 r2)
2701 {
2702         int size = self->test[0].result - 1;
2703         int len = 4 + 3 * (size + 1);
2704         struct bpf_insn *insns;
2705         int off, ind;
2706
2707         insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL);
2708         if (!insns)
2709                 return -ENOMEM;
2710
2711         /* Preamble */
2712         insns[0] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
2713         insns[1] = BPF_ALU64_IMM(BPF_MOV, R1, r1);
2714         insns[2] = BPF_ALU64_IMM(BPF_MOV, R2, r2);
2715         insns[3] = BPF_JMP_IMM(BPF_JA, 0, 0, 3 * size / 2);
2716
2717         /* Sequence */
2718         for (ind = 0, off = size; ind <= size; ind++, off -= 2) {
2719                 struct bpf_insn *ins = &insns[4 + 3 * ind];
2720                 int loc;
2721
2722                 if (off == 0)
2723                         off--;
2724
2725                 loc = abs(off);
2726                 ins[0] = BPF_JMP_IMM(BPF_JNE, R0, loc - 1,
2727                                      3 * (size - ind) + 1);
2728                 ins[1] = BPF_ALU64_IMM(BPF_MOV, R0, loc);
2729                 ins[2] = *jmp;
2730                 ins[2].off = 3 * (off - 1);
2731         }
2732
2733         /* Return */
2734         insns[len - 1] = BPF_EXIT_INSN();
2735
2736         self->u.ptr.insns = insns;
2737         self->u.ptr.len = len;
2738
2739         return 0;
2740 }
2741
2742 /* 64-bit unconditional jump */
2743 static int bpf_fill_staggered_ja(struct bpf_test *self)
2744 {
2745         struct bpf_insn jmp = BPF_JMP_IMM(BPF_JA, 0, 0, 0);
2746
2747         return __bpf_fill_staggered_jumps(self, &jmp, 0, 0);
2748 }
2749
2750 /* 64-bit immediate jumps */
2751 static int bpf_fill_staggered_jeq_imm(struct bpf_test *self)
2752 {
2753         struct bpf_insn jmp = BPF_JMP_IMM(BPF_JEQ, R1, 1234, 0);
2754
2755         return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2756 }
2757
2758 static int bpf_fill_staggered_jne_imm(struct bpf_test *self)
2759 {
2760         struct bpf_insn jmp = BPF_JMP_IMM(BPF_JNE, R1, 1234, 0);
2761
2762         return __bpf_fill_staggered_jumps(self, &jmp, 4321, 0);
2763 }
2764
2765 static int bpf_fill_staggered_jset_imm(struct bpf_test *self)
2766 {
2767         struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSET, R1, 0x82, 0);
2768
2769         return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0);
2770 }
2771
2772 static int bpf_fill_staggered_jgt_imm(struct bpf_test *self)
2773 {
2774         struct bpf_insn jmp = BPF_JMP_IMM(BPF_JGT, R1, 1234, 0);
2775
2776         return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 0);
2777 }
2778
2779 static int bpf_fill_staggered_jge_imm(struct bpf_test *self)
2780 {
2781         struct bpf_insn jmp = BPF_JMP_IMM(BPF_JGE, R1, 1234, 0);
2782
2783         return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2784 }
2785
2786 static int bpf_fill_staggered_jlt_imm(struct bpf_test *self)
2787 {
2788         struct bpf_insn jmp = BPF_JMP_IMM(BPF_JLT, R1, 0x80000000, 0);
2789
2790         return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2791 }
2792
2793 static int bpf_fill_staggered_jle_imm(struct bpf_test *self)
2794 {
2795         struct bpf_insn jmp = BPF_JMP_IMM(BPF_JLE, R1, 1234, 0);
2796
2797         return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2798 }
2799
2800 static int bpf_fill_staggered_jsgt_imm(struct bpf_test *self)
2801 {
2802         struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSGT, R1, -2, 0);
2803
2804         return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
2805 }
2806
2807 static int bpf_fill_staggered_jsge_imm(struct bpf_test *self)
2808 {
2809         struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSGE, R1, -2, 0);
2810
2811         return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
2812 }
2813
2814 static int bpf_fill_staggered_jslt_imm(struct bpf_test *self)
2815 {
2816         struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSLT, R1, -1, 0);
2817
2818         return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
2819 }
2820
2821 static int bpf_fill_staggered_jsle_imm(struct bpf_test *self)
2822 {
2823         struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSLE, R1, -1, 0);
2824
2825         return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
2826 }
2827
2828 /* 64-bit register jumps */
2829 static int bpf_fill_staggered_jeq_reg(struct bpf_test *self)
2830 {
2831         struct bpf_insn jmp = BPF_JMP_REG(BPF_JEQ, R1, R2, 0);
2832
2833         return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
2834 }
2835
2836 static int bpf_fill_staggered_jne_reg(struct bpf_test *self)
2837 {
2838         struct bpf_insn jmp = BPF_JMP_REG(BPF_JNE, R1, R2, 0);
2839
2840         return __bpf_fill_staggered_jumps(self, &jmp, 4321, 1234);
2841 }
2842
2843 static int bpf_fill_staggered_jset_reg(struct bpf_test *self)
2844 {
2845         struct bpf_insn jmp = BPF_JMP_REG(BPF_JSET, R1, R2, 0);
2846
2847         return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0x82);
2848 }
2849
2850 static int bpf_fill_staggered_jgt_reg(struct bpf_test *self)
2851 {
2852         struct bpf_insn jmp = BPF_JMP_REG(BPF_JGT, R1, R2, 0);
2853
2854         return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 1234);
2855 }
2856
2857 static int bpf_fill_staggered_jge_reg(struct bpf_test *self)
2858 {
2859         struct bpf_insn jmp = BPF_JMP_REG(BPF_JGE, R1, R2, 0);
2860
2861         return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
2862 }
2863
2864 static int bpf_fill_staggered_jlt_reg(struct bpf_test *self)
2865 {
2866         struct bpf_insn jmp = BPF_JMP_REG(BPF_JLT, R1, R2, 0);
2867
2868         return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0x80000000);
2869 }
2870
2871 static int bpf_fill_staggered_jle_reg(struct bpf_test *self)
2872 {
2873         struct bpf_insn jmp = BPF_JMP_REG(BPF_JLE, R1, R2, 0);
2874
2875         return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
2876 }
2877
2878 static int bpf_fill_staggered_jsgt_reg(struct bpf_test *self)
2879 {
2880         struct bpf_insn jmp = BPF_JMP_REG(BPF_JSGT, R1, R2, 0);
2881
2882         return __bpf_fill_staggered_jumps(self, &jmp, -1, -2);
2883 }
2884
2885 static int bpf_fill_staggered_jsge_reg(struct bpf_test *self)
2886 {
2887         struct bpf_insn jmp = BPF_JMP_REG(BPF_JSGE, R1, R2, 0);
2888
2889         return __bpf_fill_staggered_jumps(self, &jmp, -2, -2);
2890 }
2891
2892 static int bpf_fill_staggered_jslt_reg(struct bpf_test *self)
2893 {
2894         struct bpf_insn jmp = BPF_JMP_REG(BPF_JSLT, R1, R2, 0);
2895
2896         return __bpf_fill_staggered_jumps(self, &jmp, -2, -1);
2897 }
2898
2899 static int bpf_fill_staggered_jsle_reg(struct bpf_test *self)
2900 {
2901         struct bpf_insn jmp = BPF_JMP_REG(BPF_JSLE, R1, R2, 0);
2902
2903         return __bpf_fill_staggered_jumps(self, &jmp, -1, -1);
2904 }
2905
2906 /* 32-bit immediate jumps */
2907 static int bpf_fill_staggered_jeq32_imm(struct bpf_test *self)
2908 {
2909         struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JEQ, R1, 1234, 0);
2910
2911         return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2912 }
2913
2914 static int bpf_fill_staggered_jne32_imm(struct bpf_test *self)
2915 {
2916         struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JNE, R1, 1234, 0);
2917
2918         return __bpf_fill_staggered_jumps(self, &jmp, 4321, 0);
2919 }
2920
2921 static int bpf_fill_staggered_jset32_imm(struct bpf_test *self)
2922 {
2923         struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSET, R1, 0x82, 0);
2924
2925         return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0);
2926 }
2927
2928 static int bpf_fill_staggered_jgt32_imm(struct bpf_test *self)
2929 {
2930         struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JGT, R1, 1234, 0);
2931
2932         return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 0);
2933 }
2934
2935 static int bpf_fill_staggered_jge32_imm(struct bpf_test *self)
2936 {
2937         struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JGE, R1, 1234, 0);
2938
2939         return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2940 }
2941
2942 static int bpf_fill_staggered_jlt32_imm(struct bpf_test *self)
2943 {
2944         struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JLT, R1, 0x80000000, 0);
2945
2946         return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2947 }
2948
2949 static int bpf_fill_staggered_jle32_imm(struct bpf_test *self)
2950 {
2951         struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JLE, R1, 1234, 0);
2952
2953         return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2954 }
2955
2956 static int bpf_fill_staggered_jsgt32_imm(struct bpf_test *self)
2957 {
2958         struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSGT, R1, -2, 0);
2959
2960         return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
2961 }
2962
2963 static int bpf_fill_staggered_jsge32_imm(struct bpf_test *self)
2964 {
2965         struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSGE, R1, -2, 0);
2966
2967         return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
2968 }
2969
2970 static int bpf_fill_staggered_jslt32_imm(struct bpf_test *self)
2971 {
2972         struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSLT, R1, -1, 0);
2973
2974         return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
2975 }
2976
2977 static int bpf_fill_staggered_jsle32_imm(struct bpf_test *self)
2978 {
2979         struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSLE, R1, -1, 0);
2980
2981         return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
2982 }
2983
2984 /* 32-bit register jumps */
2985 static int bpf_fill_staggered_jeq32_reg(struct bpf_test *self)
2986 {
2987         struct bpf_insn jmp = BPF_JMP32_REG(BPF_JEQ, R1, R2, 0);
2988
2989         return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
2990 }
2991
2992 static int bpf_fill_staggered_jne32_reg(struct bpf_test *self)
2993 {
2994         struct bpf_insn jmp = BPF_JMP32_REG(BPF_JNE, R1, R2, 0);
2995
2996         return __bpf_fill_staggered_jumps(self, &jmp, 4321, 1234);
2997 }
2998
2999 static int bpf_fill_staggered_jset32_reg(struct bpf_test *self)
3000 {
3001         struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSET, R1, R2, 0);
3002
3003         return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0x82);
3004 }
3005
3006 static int bpf_fill_staggered_jgt32_reg(struct bpf_test *self)
3007 {
3008         struct bpf_insn jmp = BPF_JMP32_REG(BPF_JGT, R1, R2, 0);
3009
3010         return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 1234);
3011 }
3012
3013 static int bpf_fill_staggered_jge32_reg(struct bpf_test *self)
3014 {
3015         struct bpf_insn jmp = BPF_JMP32_REG(BPF_JGE, R1, R2, 0);
3016
3017         return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
3018 }
3019
3020 static int bpf_fill_staggered_jlt32_reg(struct bpf_test *self)
3021 {
3022         struct bpf_insn jmp = BPF_JMP32_REG(BPF_JLT, R1, R2, 0);
3023
3024         return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0x80000000);
3025 }
3026
3027 static int bpf_fill_staggered_jle32_reg(struct bpf_test *self)
3028 {
3029         struct bpf_insn jmp = BPF_JMP32_REG(BPF_JLE, R1, R2, 0);
3030
3031         return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
3032 }
3033
3034 static int bpf_fill_staggered_jsgt32_reg(struct bpf_test *self)
3035 {
3036         struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSGT, R1, R2, 0);
3037
3038         return __bpf_fill_staggered_jumps(self, &jmp, -1, -2);
3039 }
3040
3041 static int bpf_fill_staggered_jsge32_reg(struct bpf_test *self)
3042 {
3043         struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSGE, R1, R2, 0);
3044
3045         return __bpf_fill_staggered_jumps(self, &jmp, -2, -2);
3046 }
3047
3048 static int bpf_fill_staggered_jslt32_reg(struct bpf_test *self)
3049 {
3050         struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSLT, R1, R2, 0);
3051
3052         return __bpf_fill_staggered_jumps(self, &jmp, -2, -1);
3053 }
3054
3055 static int bpf_fill_staggered_jsle32_reg(struct bpf_test *self)
3056 {
3057         struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSLE, R1, R2, 0);
3058
3059         return __bpf_fill_staggered_jumps(self, &jmp, -1, -1);
3060 }
3061
3062
3063 static struct bpf_test tests[] = {
3064         {
3065                 "TAX",
3066                 .u.insns = {
3067                         BPF_STMT(BPF_LD | BPF_IMM, 1),
3068                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
3069                         BPF_STMT(BPF_LD | BPF_IMM, 2),
3070                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3071                         BPF_STMT(BPF_ALU | BPF_NEG, 0), /* A == -3 */
3072                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
3073                         BPF_STMT(BPF_LD | BPF_LEN, 0),
3074                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3075                         BPF_STMT(BPF_MISC | BPF_TAX, 0), /* X == len - 3 */
3076                         BPF_STMT(BPF_LD | BPF_B | BPF_IND, 1),
3077                         BPF_STMT(BPF_RET | BPF_A, 0)
3078                 },
3079                 CLASSIC,
3080                 { 10, 20, 30, 40, 50 },
3081                 { { 2, 10 }, { 3, 20 }, { 4, 30 } },
3082         },
3083         {
3084                 "TXA",
3085                 .u.insns = {
3086                         BPF_STMT(BPF_LDX | BPF_LEN, 0),
3087                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
3088                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3089                         BPF_STMT(BPF_RET | BPF_A, 0) /* A == len * 2 */
3090                 },
3091                 CLASSIC,
3092                 { 10, 20, 30, 40, 50 },
3093                 { { 1, 2 }, { 3, 6 }, { 4, 8 } },
3094         },
3095         {
3096                 "ADD_SUB_MUL_K",
3097                 .u.insns = {
3098                         BPF_STMT(BPF_LD | BPF_IMM, 1),
3099                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 2),
3100                         BPF_STMT(BPF_LDX | BPF_IMM, 3),
3101                         BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
3102                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0xffffffff),
3103                         BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 3),
3104                         BPF_STMT(BPF_RET | BPF_A, 0)
3105                 },
3106                 CLASSIC | FLAG_NO_DATA,
3107                 { },
3108                 { { 0, 0xfffffffd } }
3109         },
3110         {
3111                 "DIV_MOD_KX",
3112                 .u.insns = {
3113                         BPF_STMT(BPF_LD | BPF_IMM, 8),
3114                         BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 2),
3115                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
3116                         BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
3117                         BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
3118                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
3119                         BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
3120                         BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x70000000),
3121                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
3122                         BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
3123                         BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
3124                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
3125                         BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
3126                         BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x70000000),
3127                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3128                         BPF_STMT(BPF_RET | BPF_A, 0)
3129                 },
3130                 CLASSIC | FLAG_NO_DATA,
3131                 { },
3132                 { { 0, 0x20000000 } }
3133         },
3134         {
3135                 "AND_OR_LSH_K",
3136                 .u.insns = {
3137                         BPF_STMT(BPF_LD | BPF_IMM, 0xff),
3138                         BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
3139                         BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 27),
3140                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
3141                         BPF_STMT(BPF_LD | BPF_IMM, 0xf),
3142                         BPF_STMT(BPF_ALU | BPF_OR | BPF_K, 0xf0),
3143                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3144                         BPF_STMT(BPF_RET | BPF_A, 0)
3145                 },
3146                 CLASSIC | FLAG_NO_DATA,
3147                 { },
3148                 { { 0, 0x800000ff }, { 1, 0x800000ff } },
3149         },
3150         {
3151                 "LD_IMM_0",
3152                 .u.insns = {
3153                         BPF_STMT(BPF_LD | BPF_IMM, 0), /* ld #0 */
3154                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0, 1, 0),
3155                         BPF_STMT(BPF_RET | BPF_K, 0),
3156                         BPF_STMT(BPF_RET | BPF_K, 1),
3157                 },
3158                 CLASSIC,
3159                 { },
3160                 { { 1, 1 } },
3161         },
3162         {
3163                 "LD_IND",
3164                 .u.insns = {
3165                         BPF_STMT(BPF_LDX | BPF_LEN, 0),
3166                         BPF_STMT(BPF_LD | BPF_H | BPF_IND, MAX_K),
3167                         BPF_STMT(BPF_RET | BPF_K, 1)
3168                 },
3169                 CLASSIC,
3170                 { },
3171                 { { 1, 0 }, { 10, 0 }, { 60, 0 } },
3172         },
3173         {
3174                 "LD_ABS",
3175                 .u.insns = {
3176                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1000),
3177                         BPF_STMT(BPF_RET | BPF_K, 1)
3178                 },
3179                 CLASSIC,
3180                 { },
3181                 { { 1, 0 }, { 10, 0 }, { 60, 0 } },
3182         },
3183         {
3184                 "LD_ABS_LL",
3185                 .u.insns = {
3186                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF),
3187                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
3188                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF + 1),
3189                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3190                         BPF_STMT(BPF_RET | BPF_A, 0)
3191                 },
3192                 CLASSIC,
3193                 { 1, 2, 3 },
3194                 { { 1, 0 }, { 2, 3 } },
3195         },
3196         {
3197                 "LD_IND_LL",
3198                 .u.insns = {
3199                         BPF_STMT(BPF_LD | BPF_IMM, SKF_LL_OFF - 1),
3200                         BPF_STMT(BPF_LDX | BPF_LEN, 0),
3201                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3202                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
3203                         BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
3204                         BPF_STMT(BPF_RET | BPF_A, 0)
3205                 },
3206                 CLASSIC,
3207                 { 1, 2, 3, 0xff },
3208                 { { 1, 1 }, { 3, 3 }, { 4, 0xff } },
3209         },
3210         {
3211                 "LD_ABS_NET",
3212                 .u.insns = {
3213                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF),
3214                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
3215                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF + 1),
3216                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3217                         BPF_STMT(BPF_RET | BPF_A, 0)
3218                 },
3219                 CLASSIC,
3220                 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
3221                 { { 15, 0 }, { 16, 3 } },
3222         },
3223         {
3224                 "LD_IND_NET",
3225                 .u.insns = {
3226                         BPF_STMT(BPF_LD | BPF_IMM, SKF_NET_OFF - 15),
3227                         BPF_STMT(BPF_LDX | BPF_LEN, 0),
3228                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3229                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
3230                         BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
3231                         BPF_STMT(BPF_RET | BPF_A, 0)
3232                 },
3233                 CLASSIC,
3234                 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
3235                 { { 14, 0 }, { 15, 1 }, { 17, 3 } },
3236         },
3237         {
3238                 "LD_PKTTYPE",
3239                 .u.insns = {
3240                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3241                                  SKF_AD_OFF + SKF_AD_PKTTYPE),
3242                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
3243                         BPF_STMT(BPF_RET | BPF_K, 1),
3244                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3245                                  SKF_AD_OFF + SKF_AD_PKTTYPE),
3246                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
3247                         BPF_STMT(BPF_RET | BPF_K, 1),
3248                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3249                                  SKF_AD_OFF + SKF_AD_PKTTYPE),
3250                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
3251                         BPF_STMT(BPF_RET | BPF_K, 1),
3252                         BPF_STMT(BPF_RET | BPF_A, 0)
3253                 },
3254                 CLASSIC,
3255                 { },
3256                 { { 1, 3 }, { 10, 3 } },
3257         },
3258         {
3259                 "LD_MARK",
3260                 .u.insns = {
3261                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3262                                  SKF_AD_OFF + SKF_AD_MARK),
3263                         BPF_STMT(BPF_RET | BPF_A, 0)
3264                 },
3265                 CLASSIC,
3266                 { },
3267                 { { 1, SKB_MARK}, { 10, SKB_MARK} },
3268         },
3269         {
3270                 "LD_RXHASH",
3271                 .u.insns = {
3272                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3273                                  SKF_AD_OFF + SKF_AD_RXHASH),
3274                         BPF_STMT(BPF_RET | BPF_A, 0)
3275                 },
3276                 CLASSIC,
3277                 { },
3278                 { { 1, SKB_HASH}, { 10, SKB_HASH} },
3279         },
3280         {
3281                 "LD_QUEUE",
3282                 .u.insns = {
3283                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3284                                  SKF_AD_OFF + SKF_AD_QUEUE),
3285                         BPF_STMT(BPF_RET | BPF_A, 0)
3286                 },
3287                 CLASSIC,
3288                 { },
3289                 { { 1, SKB_QUEUE_MAP }, { 10, SKB_QUEUE_MAP } },
3290         },
3291         {
3292                 "LD_PROTOCOL",
3293                 .u.insns = {
3294                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 1),
3295                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 20, 1, 0),
3296                         BPF_STMT(BPF_RET | BPF_K, 0),
3297                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3298                                  SKF_AD_OFF + SKF_AD_PROTOCOL),
3299                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
3300                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
3301                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 30, 1, 0),
3302                         BPF_STMT(BPF_RET | BPF_K, 0),
3303                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
3304                         BPF_STMT(BPF_RET | BPF_A, 0)
3305                 },
3306                 CLASSIC,
3307                 { 10, 20, 30 },
3308                 { { 10, ETH_P_IP }, { 100, ETH_P_IP } },
3309         },
3310         {
3311                 "LD_VLAN_TAG",
3312                 .u.insns = {
3313                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3314                                  SKF_AD_OFF + SKF_AD_VLAN_TAG),
3315                         BPF_STMT(BPF_RET | BPF_A, 0)
3316                 },
3317                 CLASSIC,
3318                 { },
3319                 {
3320                         { 1, SKB_VLAN_TCI },
3321                         { 10, SKB_VLAN_TCI }
3322                 },
3323         },
3324         {
3325                 "LD_VLAN_TAG_PRESENT",
3326                 .u.insns = {
3327                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3328                                  SKF_AD_OFF + SKF_AD_VLAN_TAG_PRESENT),
3329                         BPF_STMT(BPF_RET | BPF_A, 0)
3330                 },
3331                 CLASSIC,
3332                 { },
3333                 {
3334                         { 1, SKB_VLAN_PRESENT },
3335                         { 10, SKB_VLAN_PRESENT }
3336                 },
3337         },
3338         {
3339                 "LD_IFINDEX",
3340                 .u.insns = {
3341                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3342                                  SKF_AD_OFF + SKF_AD_IFINDEX),
3343                         BPF_STMT(BPF_RET | BPF_A, 0)
3344                 },
3345                 CLASSIC,
3346                 { },
3347                 { { 1, SKB_DEV_IFINDEX }, { 10, SKB_DEV_IFINDEX } },
3348         },
3349         {
3350                 "LD_HATYPE",
3351                 .u.insns = {
3352                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3353                                  SKF_AD_OFF + SKF_AD_HATYPE),
3354                         BPF_STMT(BPF_RET | BPF_A, 0)
3355                 },
3356                 CLASSIC,
3357                 { },
3358                 { { 1, SKB_DEV_TYPE }, { 10, SKB_DEV_TYPE } },
3359         },
3360         {
3361                 "LD_CPU",
3362                 .u.insns = {
3363                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3364                                  SKF_AD_OFF + SKF_AD_CPU),
3365                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
3366                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3367                                  SKF_AD_OFF + SKF_AD_CPU),
3368                         BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
3369                         BPF_STMT(BPF_RET | BPF_A, 0)
3370                 },
3371                 CLASSIC,
3372                 { },
3373                 { { 1, 0 }, { 10, 0 } },
3374         },
3375         {
3376                 "LD_NLATTR",
3377                 .u.insns = {
3378                         BPF_STMT(BPF_LDX | BPF_IMM, 2),
3379                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
3380                         BPF_STMT(BPF_LDX | BPF_IMM, 3),
3381                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3382                                  SKF_AD_OFF + SKF_AD_NLATTR),
3383                         BPF_STMT(BPF_RET | BPF_A, 0)
3384                 },
3385                 CLASSIC,
3386 #ifdef __BIG_ENDIAN
3387                 { 0xff, 0xff, 0, 4, 0, 2, 0, 4, 0, 3 },
3388 #else
3389                 { 0xff, 0xff, 4, 0, 2, 0, 4, 0, 3, 0 },
3390 #endif
3391                 { { 4, 0 }, { 20, 6 } },
3392         },
3393         {
3394                 "LD_NLATTR_NEST",
3395                 .u.insns = {
3396                         BPF_STMT(BPF_LD | BPF_IMM, 2),
3397                         BPF_STMT(BPF_LDX | BPF_IMM, 3),
3398                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3399                                  SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3400                         BPF_STMT(BPF_LD | BPF_IMM, 2),
3401                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3402                                  SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3403                         BPF_STMT(BPF_LD | BPF_IMM, 2),
3404                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3405                                  SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3406                         BPF_STMT(BPF_LD | BPF_IMM, 2),
3407                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3408                                  SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3409                         BPF_STMT(BPF_LD | BPF_IMM, 2),
3410                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3411                                  SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3412                         BPF_STMT(BPF_LD | BPF_IMM, 2),
3413                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3414                                  SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3415                         BPF_STMT(BPF_LD | BPF_IMM, 2),
3416                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3417                                  SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3418                         BPF_STMT(BPF_LD | BPF_IMM, 2),
3419                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3420                                  SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3421                         BPF_STMT(BPF_RET | BPF_A, 0)
3422                 },
3423                 CLASSIC,
3424 #ifdef __BIG_ENDIAN
3425                 { 0xff, 0xff, 0, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3 },
3426 #else
3427                 { 0xff, 0xff, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3, 0 },
3428 #endif
3429                 { { 4, 0 }, { 20, 10 } },
3430         },
3431         {
3432                 "LD_PAYLOAD_OFF",
3433                 .u.insns = {
3434                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3435                                  SKF_AD_OFF + SKF_AD_PAY_OFFSET),
3436                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3437                                  SKF_AD_OFF + SKF_AD_PAY_OFFSET),
3438                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3439                                  SKF_AD_OFF + SKF_AD_PAY_OFFSET),
3440                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3441                                  SKF_AD_OFF + SKF_AD_PAY_OFFSET),
3442                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3443                                  SKF_AD_OFF + SKF_AD_PAY_OFFSET),
3444                         BPF_STMT(BPF_RET | BPF_A, 0)
3445                 },
3446                 CLASSIC,
3447                 /* 00:00:00:00:00:00 > 00:00:00:00:00:00, ethtype IPv4 (0x0800),
3448                  * length 98: 127.0.0.1 > 127.0.0.1: ICMP echo request,
3449                  * id 9737, seq 1, length 64
3450                  */
3451                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3452                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3453                   0x08, 0x00,
3454                   0x45, 0x00, 0x00, 0x54, 0xac, 0x8b, 0x40, 0x00, 0x40,
3455                   0x01, 0x90, 0x1b, 0x7f, 0x00, 0x00, 0x01 },
3456                 { { 30, 0 }, { 100, 42 } },
3457         },
3458         {
3459                 "LD_ANC_XOR",
3460                 .u.insns = {
3461                         BPF_STMT(BPF_LD | BPF_IMM, 10),
3462                         BPF_STMT(BPF_LDX | BPF_IMM, 300),
3463                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3464                                  SKF_AD_OFF + SKF_AD_ALU_XOR_X),
3465                         BPF_STMT(BPF_RET | BPF_A, 0)
3466                 },
3467                 CLASSIC,
3468                 { },
3469                 { { 4, 0xA ^ 300 }, { 20, 0xA ^ 300 } },
3470         },
3471         {
3472                 "SPILL_FILL",
3473                 .u.insns = {
3474                         BPF_STMT(BPF_LDX | BPF_LEN, 0),
3475                         BPF_STMT(BPF_LD | BPF_IMM, 2),
3476                         BPF_STMT(BPF_ALU | BPF_RSH, 1),
3477                         BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
3478                         BPF_STMT(BPF_ST, 1), /* M1 = 1 ^ len */
3479                         BPF_STMT(BPF_ALU | BPF_XOR | BPF_K, 0x80000000),
3480                         BPF_STMT(BPF_ST, 2), /* M2 = 1 ^ len ^ 0x80000000 */
3481                         BPF_STMT(BPF_STX, 15), /* M3 = len */
3482                         BPF_STMT(BPF_LDX | BPF_MEM, 1),
3483                         BPF_STMT(BPF_LD | BPF_MEM, 2),
3484                         BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
3485                         BPF_STMT(BPF_LDX | BPF_MEM, 15),
3486                         BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
3487                         BPF_STMT(BPF_RET | BPF_A, 0)
3488                 },
3489                 CLASSIC,
3490                 { },
3491                 { { 1, 0x80000001 }, { 2, 0x80000002 }, { 60, 0x80000000 ^ 60 } }
3492         },
3493         {
3494                 "JEQ",
3495                 .u.insns = {
3496                         BPF_STMT(BPF_LDX | BPF_LEN, 0),
3497                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
3498                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 0, 1),
3499                         BPF_STMT(BPF_RET | BPF_K, 1),
3500                         BPF_STMT(BPF_RET | BPF_K, MAX_K)
3501                 },
3502                 CLASSIC,
3503                 { 3, 3, 3, 3, 3 },
3504                 { { 1, 0 }, { 3, 1 }, { 4, MAX_K } },
3505         },
3506         {
3507                 "JGT",
3508                 .u.insns = {
3509                         BPF_STMT(BPF_LDX | BPF_LEN, 0),
3510                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
3511                         BPF_JUMP(BPF_JMP | BPF_JGT | BPF_X, 0, 0, 1),
3512                         BPF_STMT(BPF_RET | BPF_K, 1),
3513                         BPF_STMT(BPF_RET | BPF_K, MAX_K)
3514                 },
3515                 CLASSIC,
3516                 { 4, 4, 4, 3, 3 },
3517                 { { 2, 0 }, { 3, 1 }, { 4, MAX_K } },
3518         },
3519         {
3520                 "JGE (jt 0), test 1",
3521                 .u.insns = {
3522                         BPF_STMT(BPF_LDX | BPF_LEN, 0),
3523                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
3524                         BPF_JUMP(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 1),
3525                         BPF_STMT(BPF_RET | BPF_K, 1),
3526                         BPF_STMT(BPF_RET | BPF_K, MAX_K)
3527                 },
3528                 CLASSIC,
3529                 { 4, 4, 4, 3, 3 },
3530                 { { 2, 0 }, { 3, 1 }, { 4, 1 } },
3531         },
3532         {
3533                 "JGE (jt 0), test 2",
3534                 .u.insns = {
3535                         BPF_STMT(BPF_LDX | BPF_LEN, 0),
3536                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
3537                         BPF_JUMP(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 1),
3538                         BPF_STMT(BPF_RET | BPF_K, 1),
3539                         BPF_STMT(BPF_RET | BPF_K, MAX_K)
3540                 },
3541                 CLASSIC,
3542                 { 4, 4, 5, 3, 3 },
3543                 { { 4, 1 }, { 5, 1 }, { 6, MAX_K } },
3544         },
3545         {
3546                 "JGE",
3547                 .u.insns = {
3548                         BPF_STMT(BPF_LDX | BPF_LEN, 0),
3549                         BPF_STMT(BPF_LD | BPF_B | BPF_IND, MAX_K),
3550                         BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 1, 1, 0),
3551                         BPF_STMT(BPF_RET | BPF_K, 10),
3552                         BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 2, 1, 0),
3553                         BPF_STMT(BPF_RET | BPF_K, 20),
3554                         BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 3, 1, 0),
3555                         BPF_STMT(BPF_RET | BPF_K, 30),
3556                         BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 4, 1, 0),
3557                         BPF_STMT(BPF_RET | BPF_K, 40),
3558                         BPF_STMT(BPF_RET | BPF_K, MAX_K)
3559                 },
3560                 CLASSIC,
3561                 { 1, 2, 3, 4, 5 },
3562                 { { 1, 20 }, { 3, 40 }, { 5, MAX_K } },
3563         },
3564         {
3565                 "JSET",
3566                 .u.insns = {
3567                         BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
3568                         BPF_JUMP(BPF_JMP | BPF_JA, 1, 1, 1),
3569                         BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
3570                         BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
3571                         BPF_STMT(BPF_LDX | BPF_LEN, 0),
3572                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
3573                         BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, 4),
3574                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
3575                         BPF_STMT(BPF_LD | BPF_W | BPF_IND, 0),
3576                         BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 1, 0, 1),
3577                         BPF_STMT(BPF_RET | BPF_K, 10),
3578                         BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x80000000, 0, 1),
3579                         BPF_STMT(BPF_RET | BPF_K, 20),
3580                         BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
3581                         BPF_STMT(BPF_RET | BPF_K, 30),
3582                         BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
3583                         BPF_STMT(BPF_RET | BPF_K, 30),
3584                         BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
3585                         BPF_STMT(BPF_RET | BPF_K, 30),
3586                         BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
3587                         BPF_STMT(BPF_RET | BPF_K, 30),
3588                         BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
3589                         BPF_STMT(BPF_RET | BPF_K, 30),
3590                         BPF_STMT(BPF_RET | BPF_K, MAX_K)
3591                 },
3592                 CLASSIC,
3593                 { 0, 0xAA, 0x55, 1 },
3594                 { { 4, 10 }, { 5, 20 }, { 6, MAX_K } },
3595         },
3596         {
3597                 "tcpdump port 22",
3598                 .u.insns = {
3599                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
3600                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 0, 8), /* IPv6 */
3601                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 20),
3602                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
3603                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
3604                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 17),
3605                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 54),
3606                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 14, 0),
3607                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 56),
3608                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 12, 13),
3609                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0800, 0, 12), /* IPv4 */
3610                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
3611                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
3612                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
3613                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 8),
3614                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
3615                         BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 6, 0),
3616                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
3617                         BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
3618                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
3619                         BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
3620                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 1),
3621                         BPF_STMT(BPF_RET | BPF_K, 0xffff),
3622                         BPF_STMT(BPF_RET | BPF_K, 0),
3623                 },
3624                 CLASSIC,
3625                 /* 3c:07:54:43:e5:76 > 10:bf:48:d6:43:d6, ethertype IPv4(0x0800)
3626                  * length 114: 10.1.1.149.49700 > 10.1.2.10.22: Flags [P.],
3627                  * seq 1305692979:1305693027, ack 3650467037, win 65535,
3628                  * options [nop,nop,TS val 2502645400 ecr 3971138], length 48
3629                  */
3630                 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
3631                   0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
3632                   0x08, 0x00,
3633                   0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
3634                   0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
3635                   0x0a, 0x01, 0x01, 0x95, /* ip src */
3636                   0x0a, 0x01, 0x02, 0x0a, /* ip dst */
3637                   0xc2, 0x24,
3638                   0x00, 0x16 /* dst port */ },
3639                 { { 10, 0 }, { 30, 0 }, { 100, 65535 } },
3640         },
3641         {
3642                 "tcpdump complex",
3643                 .u.insns = {
3644                         /* tcpdump -nei eth0 'tcp port 22 and (((ip[2:2] -
3645                          * ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0) and
3646                          * (len > 115 or len < 30000000000)' -d
3647                          */
3648                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
3649                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 30, 0),
3650                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x800, 0, 29),
3651                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
3652                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 0, 27),
3653                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
3654                         BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 25, 0),
3655                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
3656                         BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
3657                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
3658                         BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
3659                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 20),
3660                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 16),
3661                         BPF_STMT(BPF_ST, 1),
3662                         BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 14),
3663                         BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf),
3664                         BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 2),
3665                         BPF_STMT(BPF_MISC | BPF_TAX, 0x5), /* libpcap emits K on TAX */
3666                         BPF_STMT(BPF_LD | BPF_MEM, 1),
3667                         BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
3668                         BPF_STMT(BPF_ST, 5),
3669                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
3670                         BPF_STMT(BPF_LD | BPF_B | BPF_IND, 26),
3671                         BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
3672                         BPF_STMT(BPF_ALU | BPF_RSH | BPF_K, 2),
3673                         BPF_STMT(BPF_MISC | BPF_TAX, 0x9), /* libpcap emits K on TAX */
3674                         BPF_STMT(BPF_LD | BPF_MEM, 5),
3675                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 4, 0),
3676                         BPF_STMT(BPF_LD | BPF_LEN, 0),
3677                         BPF_JUMP(BPF_JMP | BPF_JGT | BPF_K, 0x73, 1, 0),
3678                         BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 0xfc23ac00, 1, 0),
3679                         BPF_STMT(BPF_RET | BPF_K, 0xffff),
3680                         BPF_STMT(BPF_RET | BPF_K, 0),
3681                 },
3682                 CLASSIC,
3683                 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
3684                   0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
3685                   0x08, 0x00,
3686                   0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
3687                   0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
3688                   0x0a, 0x01, 0x01, 0x95, /* ip src */
3689                   0x0a, 0x01, 0x02, 0x0a, /* ip dst */
3690                   0xc2, 0x24,
3691                   0x00, 0x16 /* dst port */ },
3692                 { { 10, 0 }, { 30, 0 }, { 100, 65535 } },
3693         },
3694         {
3695                 "RET_A",
3696                 .u.insns = {
3697                         /* check that uninitialized X and A contain zeros */
3698                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
3699                         BPF_STMT(BPF_RET | BPF_A, 0)
3700                 },
3701                 CLASSIC,
3702                 { },
3703                 { {1, 0}, {2, 0} },
3704         },
3705         {
3706                 "INT: ADD trivial",
3707                 .u.insns_int = {
3708                         BPF_ALU64_IMM(BPF_MOV, R1, 1),
3709                         BPF_ALU64_IMM(BPF_ADD, R1, 2),
3710                         BPF_ALU64_IMM(BPF_MOV, R2, 3),
3711                         BPF_ALU64_REG(BPF_SUB, R1, R2),
3712                         BPF_ALU64_IMM(BPF_ADD, R1, -1),
3713                         BPF_ALU64_IMM(BPF_MUL, R1, 3),
3714                         BPF_ALU64_REG(BPF_MOV, R0, R1),
3715                         BPF_EXIT_INSN(),
3716                 },
3717                 INTERNAL,
3718                 { },
3719                 { { 0, 0xfffffffd } }
3720         },
3721         {
3722                 "INT: MUL_X",
3723                 .u.insns_int = {
3724                         BPF_ALU64_IMM(BPF_MOV, R0, -1),
3725                         BPF_ALU64_IMM(BPF_MOV, R1, -1),
3726                         BPF_ALU64_IMM(BPF_MOV, R2, 3),
3727                         BPF_ALU64_REG(BPF_MUL, R1, R2),
3728                         BPF_JMP_IMM(BPF_JEQ, R1, 0xfffffffd, 1),
3729                         BPF_EXIT_INSN(),
3730                         BPF_ALU64_IMM(BPF_MOV, R0, 1),
3731                         BPF_EXIT_INSN(),
3732                 },
3733                 INTERNAL,
3734                 { },
3735                 { { 0, 1 } }
3736         },
3737         {
3738                 "INT: MUL_X2",
3739                 .u.insns_int = {
3740                         BPF_ALU32_IMM(BPF_MOV, R0, -1),
3741                         BPF_ALU32_IMM(BPF_MOV, R1, -1),
3742                         BPF_ALU32_IMM(BPF_MOV, R2, 3),
3743                         BPF_ALU64_REG(BPF_MUL, R1, R2),
3744                         BPF_ALU64_IMM(BPF_RSH, R1, 8),
3745                         BPF_JMP_IMM(BPF_JEQ, R1, 0x2ffffff, 1),
3746                         BPF_EXIT_INSN(),
3747                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
3748                         BPF_EXIT_INSN(),
3749                 },
3750                 INTERNAL,
3751                 { },
3752                 { { 0, 1 } }
3753         },
3754         {
3755                 "INT: MUL32_X",
3756                 .u.insns_int = {
3757                         BPF_ALU32_IMM(BPF_MOV, R0, -1),
3758                         BPF_ALU64_IMM(BPF_MOV, R1, -1),
3759                         BPF_ALU32_IMM(BPF_MOV, R2, 3),
3760                         BPF_ALU32_REG(BPF_MUL, R1, R2),
3761                         BPF_ALU64_IMM(BPF_RSH, R1, 8),
3762                         BPF_JMP_IMM(BPF_JEQ, R1, 0xffffff, 1),
3763                         BPF_EXIT_INSN(),
3764                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
3765                         BPF_EXIT_INSN(),
3766                 },
3767                 INTERNAL,
3768                 { },
3769                 { { 0, 1 } }
3770         },
3771         {
3772                 /* Have to test all register combinations, since
3773                  * JITing of different registers will produce
3774                  * different asm code.
3775                  */
3776                 "INT: ADD 64-bit",
3777                 .u.insns_int = {
3778                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
3779                         BPF_ALU64_IMM(BPF_MOV, R1, 1),
3780                         BPF_ALU64_IMM(BPF_MOV, R2, 2),
3781                         BPF_ALU64_IMM(BPF_MOV, R3, 3),
3782                         BPF_ALU64_IMM(BPF_MOV, R4, 4),
3783                         BPF_ALU64_IMM(BPF_MOV, R5, 5),
3784                         BPF_ALU64_IMM(BPF_MOV, R6, 6),
3785                         BPF_ALU64_IMM(BPF_MOV, R7, 7),
3786                         BPF_ALU64_IMM(BPF_MOV, R8, 8),
3787                         BPF_ALU64_IMM(BPF_MOV, R9, 9),
3788                         BPF_ALU64_IMM(BPF_ADD, R0, 20),
3789                         BPF_ALU64_IMM(BPF_ADD, R1, 20),
3790                         BPF_ALU64_IMM(BPF_ADD, R2, 20),
3791                         BPF_ALU64_IMM(BPF_ADD, R3, 20),
3792                         BPF_ALU64_IMM(BPF_ADD, R4, 20),
3793                         BPF_ALU64_IMM(BPF_ADD, R5, 20),
3794                         BPF_ALU64_IMM(BPF_ADD, R6, 20),
3795                         BPF_ALU64_IMM(BPF_ADD, R7, 20),
3796                         BPF_ALU64_IMM(BPF_ADD, R8, 20),
3797                         BPF_ALU64_IMM(BPF_ADD, R9, 20),
3798                         BPF_ALU64_IMM(BPF_SUB, R0, 10),
3799                         BPF_ALU64_IMM(BPF_SUB, R1, 10),
3800                         BPF_ALU64_IMM(BPF_SUB, R2, 10),
3801                         BPF_ALU64_IMM(BPF_SUB, R3, 10),
3802                         BPF_ALU64_IMM(BPF_SUB, R4, 10),
3803                         BPF_ALU64_IMM(BPF_SUB, R5, 10),
3804                         BPF_ALU64_IMM(BPF_SUB, R6, 10),
3805                         BPF_ALU64_IMM(BPF_SUB, R7, 10),
3806                         BPF_ALU64_IMM(BPF_SUB, R8, 10),
3807                         BPF_ALU64_IMM(BPF_SUB, R9, 10),
3808                         BPF_ALU64_REG(BPF_ADD, R0, R0),
3809                         BPF_ALU64_REG(BPF_ADD, R0, R1),
3810                         BPF_ALU64_REG(BPF_ADD, R0, R2),
3811                         BPF_ALU64_REG(BPF_ADD, R0, R3),
3812                         BPF_ALU64_REG(BPF_ADD, R0, R4),
3813                         BPF_ALU64_REG(BPF_ADD, R0, R5),
3814                         BPF_ALU64_REG(BPF_ADD, R0, R6),
3815                         BPF_ALU64_REG(BPF_ADD, R0, R7),
3816                         BPF_ALU64_REG(BPF_ADD, R0, R8),
3817                         BPF_ALU64_REG(BPF_ADD, R0, R9), /* R0 == 155 */
3818                         BPF_JMP_IMM(BPF_JEQ, R0, 155, 1),
3819                         BPF_EXIT_INSN(),
3820                         BPF_ALU64_REG(BPF_ADD, R1, R0),
3821                         BPF_ALU64_REG(BPF_ADD, R1, R1),
3822                         BPF_ALU64_REG(BPF_ADD, R1, R2),
3823                         BPF_ALU64_REG(BPF_ADD, R1, R3),
3824                         BPF_ALU64_REG(BPF_ADD, R1, R4),
3825                         BPF_ALU64_REG(BPF_ADD, R1, R5),
3826                         BPF_ALU64_REG(BPF_ADD, R1, R6),
3827                         BPF_ALU64_REG(BPF_ADD, R1, R7),
3828                         BPF_ALU64_REG(BPF_ADD, R1, R8),
3829                         BPF_ALU64_REG(BPF_ADD, R1, R9), /* R1 == 456 */
3830                         BPF_JMP_IMM(BPF_JEQ, R1, 456, 1),
3831                         BPF_EXIT_INSN(),
3832                         BPF_ALU64_REG(BPF_ADD, R2, R0),
3833                         BPF_ALU64_REG(BPF_ADD, R2, R1),
3834                         BPF_ALU64_REG(BPF_ADD, R2, R2),
3835                         BPF_ALU64_REG(BPF_ADD, R2, R3),
3836                         BPF_ALU64_REG(BPF_ADD, R2, R4),
3837                         BPF_ALU64_REG(BPF_ADD, R2, R5),
3838                         BPF_ALU64_REG(BPF_ADD, R2, R6),
3839                         BPF_ALU64_REG(BPF_ADD, R2, R7),
3840                         BPF_ALU64_REG(BPF_ADD, R2, R8),
3841                         BPF_ALU64_REG(BPF_ADD, R2, R9), /* R2 == 1358 */
3842                         BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1),
3843                         BPF_EXIT_INSN(),
3844                         BPF_ALU64_REG(BPF_ADD, R3, R0),
3845                         BPF_ALU64_REG(BPF_ADD, R3, R1),
3846                         BPF_ALU64_REG(BPF_ADD, R3, R2),
3847                         BPF_ALU64_REG(BPF_ADD, R3, R3),
3848                         BPF_ALU64_REG(BPF_ADD, R3, R4),
3849                         BPF_ALU64_REG(BPF_ADD, R3, R5),
3850                         BPF_ALU64_REG(BPF_ADD, R3, R6),
3851                         BPF_ALU64_REG(BPF_ADD, R3, R7),
3852                         BPF_ALU64_REG(BPF_ADD, R3, R8),
3853                         BPF_ALU64_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
3854                         BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
3855                         BPF_EXIT_INSN(),
3856                         BPF_ALU64_REG(BPF_ADD, R4, R0),
3857                         BPF_ALU64_REG(BPF_ADD, R4, R1),
3858                         BPF_ALU64_REG(BPF_ADD, R4, R2),
3859                         BPF_ALU64_REG(BPF_ADD, R4, R3),
3860                         BPF_ALU64_REG(BPF_ADD, R4, R4),
3861                         BPF_ALU64_REG(BPF_ADD, R4, R5),
3862                         BPF_ALU64_REG(BPF_ADD, R4, R6),
3863                         BPF_ALU64_REG(BPF_ADD, R4, R7),
3864                         BPF_ALU64_REG(BPF_ADD, R4, R8),
3865                         BPF_ALU64_REG(BPF_ADD, R4, R9), /* R4 == 12177 */
3866                         BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1),
3867                         BPF_EXIT_INSN(),
3868                         BPF_ALU64_REG(BPF_ADD, R5, R0),
3869                         BPF_ALU64_REG(BPF_ADD, R5, R1),
3870                         BPF_ALU64_REG(BPF_ADD, R5, R2),
3871                         BPF_ALU64_REG(BPF_ADD, R5, R3),
3872                         BPF_ALU64_REG(BPF_ADD, R5, R4),
3873                         BPF_ALU64_REG(BPF_ADD, R5, R5),
3874                         BPF_ALU64_REG(BPF_ADD, R5, R6),
3875                         BPF_ALU64_REG(BPF_ADD, R5, R7),
3876                         BPF_ALU64_REG(BPF_ADD, R5, R8),
3877                         BPF_ALU64_REG(BPF_ADD, R5, R9), /* R5 == 36518 */
3878                         BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1),
3879                         BPF_EXIT_INSN(),
3880                         BPF_ALU64_REG(BPF_ADD, R6, R0),
3881                         BPF_ALU64_REG(BPF_ADD, R6, R1),
3882                         BPF_ALU64_REG(BPF_ADD, R6, R2),
3883                         BPF_ALU64_REG(BPF_ADD, R6, R3),
3884                         BPF_ALU64_REG(BPF_ADD, R6, R4),
3885                         BPF_ALU64_REG(BPF_ADD, R6, R5),
3886                         BPF_ALU64_REG(BPF_ADD, R6, R6),
3887                         BPF_ALU64_REG(BPF_ADD, R6, R7),
3888                         BPF_ALU64_REG(BPF_ADD, R6, R8),
3889                         BPF_ALU64_REG(BPF_ADD, R6, R9), /* R6 == 109540 */
3890                         BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1),
3891                         BPF_EXIT_INSN(),
3892                         BPF_ALU64_REG(BPF_ADD, R7, R0),
3893                         BPF_ALU64_REG(BPF_ADD, R7, R1),
3894                         BPF_ALU64_REG(BPF_ADD, R7, R2),
3895                         BPF_ALU64_REG(BPF_ADD, R7, R3),
3896                         BPF_ALU64_REG(BPF_ADD, R7, R4),
3897                         BPF_ALU64_REG(BPF_ADD, R7, R5),
3898                         BPF_ALU64_REG(BPF_ADD, R7, R6),
3899                         BPF_ALU64_REG(BPF_ADD, R7, R7),
3900                         BPF_ALU64_REG(BPF_ADD, R7, R8),
3901                         BPF_ALU64_REG(BPF_ADD, R7, R9), /* R7 == 328605 */
3902                         BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1),
3903                         BPF_EXIT_INSN(),
3904                         BPF_ALU64_REG(BPF_ADD, R8, R0),
3905                         BPF_ALU64_REG(BPF_ADD, R8, R1),
3906                         BPF_ALU64_REG(BPF_ADD, R8, R2),
3907                         BPF_ALU64_REG(BPF_ADD, R8, R3),
3908                         BPF_ALU64_REG(BPF_ADD, R8, R4),
3909                         BPF_ALU64_REG(BPF_ADD, R8, R5),
3910                         BPF_ALU64_REG(BPF_ADD, R8, R6),
3911                         BPF_ALU64_REG(BPF_ADD, R8, R7),
3912                         BPF_ALU64_REG(BPF_ADD, R8, R8),
3913                         BPF_ALU64_REG(BPF_ADD, R8, R9), /* R8 == 985799 */
3914                         BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1),
3915                         BPF_EXIT_INSN(),
3916                         BPF_ALU64_REG(BPF_ADD, R9, R0),
3917                         BPF_ALU64_REG(BPF_ADD, R9, R1),
3918                         BPF_ALU64_REG(BPF_ADD, R9, R2),
3919                         BPF_ALU64_REG(BPF_ADD, R9, R3),
3920                         BPF_ALU64_REG(BPF_ADD, R9, R4),
3921                         BPF_ALU64_REG(BPF_ADD, R9, R5),
3922                         BPF_ALU64_REG(BPF_ADD, R9, R6),
3923                         BPF_ALU64_REG(BPF_ADD, R9, R7),
3924                         BPF_ALU64_REG(BPF_ADD, R9, R8),
3925                         BPF_ALU64_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */
3926                         BPF_ALU64_REG(BPF_MOV, R0, R9),
3927                         BPF_EXIT_INSN(),
3928                 },
3929                 INTERNAL,
3930                 { },
3931                 { { 0, 2957380 } }
3932         },
3933         {
3934                 "INT: ADD 32-bit",
3935                 .u.insns_int = {
3936                         BPF_ALU32_IMM(BPF_MOV, R0, 20),
3937                         BPF_ALU32_IMM(BPF_MOV, R1, 1),
3938                         BPF_ALU32_IMM(BPF_MOV, R2, 2),
3939                         BPF_ALU32_IMM(BPF_MOV, R3, 3),
3940                         BPF_ALU32_IMM(BPF_MOV, R4, 4),
3941                         BPF_ALU32_IMM(BPF_MOV, R5, 5),
3942                         BPF_ALU32_IMM(BPF_MOV, R6, 6),
3943                         BPF_ALU32_IMM(BPF_MOV, R7, 7),
3944                         BPF_ALU32_IMM(BPF_MOV, R8, 8),
3945                         BPF_ALU32_IMM(BPF_MOV, R9, 9),
3946                         BPF_ALU64_IMM(BPF_ADD, R1, 10),
3947                         BPF_ALU64_IMM(BPF_ADD, R2, 10),
3948                         BPF_ALU64_IMM(BPF_ADD, R3, 10),
3949                         BPF_ALU64_IMM(BPF_ADD, R4, 10),
3950                         BPF_ALU64_IMM(BPF_ADD, R5, 10),
3951                         BPF_ALU64_IMM(BPF_ADD, R6, 10),
3952                         BPF_ALU64_IMM(BPF_ADD, R7, 10),
3953                         BPF_ALU64_IMM(BPF_ADD, R8, 10),
3954                         BPF_ALU64_IMM(BPF_ADD, R9, 10),
3955                         BPF_ALU32_REG(BPF_ADD, R0, R1),
3956                         BPF_ALU32_REG(BPF_ADD, R0, R2),
3957                         BPF_ALU32_REG(BPF_ADD, R0, R3),
3958                         BPF_ALU32_REG(BPF_ADD, R0, R4),
3959                         BPF_ALU32_REG(BPF_ADD, R0, R5),
3960                         BPF_ALU32_REG(BPF_ADD, R0, R6),
3961                         BPF_ALU32_REG(BPF_ADD, R0, R7),
3962                         BPF_ALU32_REG(BPF_ADD, R0, R8),
3963                         BPF_ALU32_REG(BPF_ADD, R0, R9), /* R0 == 155 */
3964                         BPF_JMP_IMM(BPF_JEQ, R0, 155, 1),
3965                         BPF_EXIT_INSN(),
3966                         BPF_ALU32_REG(BPF_ADD, R1, R0),
3967                         BPF_ALU32_REG(BPF_ADD, R1, R1),
3968                         BPF_ALU32_REG(BPF_ADD, R1, R2),
3969                         BPF_ALU32_REG(BPF_ADD, R1, R3),
3970                         BPF_ALU32_REG(BPF_ADD, R1, R4),
3971                         BPF_ALU32_REG(BPF_ADD, R1, R5),
3972                         BPF_ALU32_REG(BPF_ADD, R1, R6),
3973                         BPF_ALU32_REG(BPF_ADD, R1, R7),
3974                         BPF_ALU32_REG(BPF_ADD, R1, R8),
3975                         BPF_ALU32_REG(BPF_ADD, R1, R9), /* R1 == 456 */
3976                         BPF_JMP_IMM(BPF_JEQ, R1, 456, 1),
3977                         BPF_EXIT_INSN(),
3978                         BPF_ALU32_REG(BPF_ADD, R2, R0),
3979                         BPF_ALU32_REG(BPF_ADD, R2, R1),
3980                         BPF_ALU32_REG(BPF_ADD, R2, R2),
3981                         BPF_ALU32_REG(BPF_ADD, R2, R3),
3982                         BPF_ALU32_REG(BPF_ADD, R2, R4),
3983                         BPF_ALU32_REG(BPF_ADD, R2, R5),
3984                         BPF_ALU32_REG(BPF_ADD, R2, R6),
3985                         BPF_ALU32_REG(BPF_ADD, R2, R7),
3986                         BPF_ALU32_REG(BPF_ADD, R2, R8),
3987                         BPF_ALU32_REG(BPF_ADD, R2, R9), /* R2 == 1358 */
3988                         BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1),
3989                         BPF_EXIT_INSN(),
3990                         BPF_ALU32_REG(BPF_ADD, R3, R0),
3991                         BPF_ALU32_REG(BPF_ADD, R3, R1),
3992                         BPF_ALU32_REG(BPF_ADD, R3, R2),
3993                         BPF_ALU32_REG(BPF_ADD, R3, R3),
3994                         BPF_ALU32_REG(BPF_ADD, R3, R4),
3995                         BPF_ALU32_REG(BPF_ADD, R3, R5),
3996                         BPF_ALU32_REG(BPF_ADD, R3, R6),
3997                         BPF_ALU32_REG(BPF_ADD, R3, R7),
3998                         BPF_ALU32_REG(BPF_ADD, R3, R8),
3999                         BPF_ALU32_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
4000                         BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
4001                         BPF_EXIT_INSN(),
4002                         BPF_ALU32_REG(BPF_ADD, R4, R0),
4003                         BPF_ALU32_REG(BPF_ADD, R4, R1),
4004                         BPF_ALU32_REG(BPF_ADD, R4, R2),
4005                         BPF_ALU32_REG(BPF_ADD, R4, R3),
4006                         BPF_ALU32_REG(BPF_ADD, R4, R4),
4007                         BPF_ALU32_REG(BPF_ADD, R4, R5),
4008                         BPF_ALU32_REG(BPF_ADD, R4, R6),
4009                         BPF_ALU32_REG(BPF_ADD, R4, R7),
4010                         BPF_ALU32_REG(BPF_ADD, R4, R8),
4011                         BPF_ALU32_REG(BPF_ADD, R4, R9), /* R4 == 12177 */
4012                         BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1),
4013                         BPF_EXIT_INSN(),
4014                         BPF_ALU32_REG(BPF_ADD, R5, R0),
4015                         BPF_ALU32_REG(BPF_ADD, R5, R1),
4016                         BPF_ALU32_REG(BPF_ADD, R5, R2),
4017                         BPF_ALU32_REG(BPF_ADD, R5, R3),
4018                         BPF_ALU32_REG(BPF_ADD, R5, R4),
4019                         BPF_ALU32_REG(BPF_ADD, R5, R5),
4020                         BPF_ALU32_REG(BPF_ADD, R5, R6),
4021                         BPF_ALU32_REG(BPF_ADD, R5, R7),
4022                         BPF_ALU32_REG(BPF_ADD, R5, R8),
4023                         BPF_ALU32_REG(BPF_ADD, R5, R9), /* R5 == 36518 */
4024                         BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1),
4025                         BPF_EXIT_INSN(),
4026                         BPF_ALU32_REG(BPF_ADD, R6, R0),
4027                         BPF_ALU32_REG(BPF_ADD, R6, R1),
4028                         BPF_ALU32_REG(BPF_ADD, R6, R2),
4029                         BPF_ALU32_REG(BPF_ADD, R6, R3),
4030                         BPF_ALU32_REG(BPF_ADD, R6, R4),
4031                         BPF_ALU32_REG(BPF_ADD, R6, R5),
4032                         BPF_ALU32_REG(BPF_ADD, R6, R6),
4033                         BPF_ALU32_REG(BPF_ADD, R6, R7),
4034                         BPF_ALU32_REG(BPF_ADD, R6, R8),
4035                         BPF_ALU32_REG(BPF_ADD, R6, R9), /* R6 == 109540 */
4036                         BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1),
4037                         BPF_EXIT_INSN(),
4038                         BPF_ALU32_REG(BPF_ADD, R7, R0),
4039                         BPF_ALU32_REG(BPF_ADD, R7, R1),
4040                         BPF_ALU32_REG(BPF_ADD, R7, R2),
4041                         BPF_ALU32_REG(BPF_ADD, R7, R3),
4042                         BPF_ALU32_REG(BPF_ADD, R7, R4),
4043                         BPF_ALU32_REG(BPF_ADD, R7, R5),
4044                         BPF_ALU32_REG(BPF_ADD, R7, R6),
4045                         BPF_ALU32_REG(BPF_ADD, R7, R7),
4046                         BPF_ALU32_REG(BPF_ADD, R7, R8),
4047                         BPF_ALU32_REG(BPF_ADD, R7, R9), /* R7 == 328605 */
4048                         BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1),
4049                         BPF_EXIT_INSN(),
4050                         BPF_ALU32_REG(BPF_ADD, R8, R0),
4051                         BPF_ALU32_REG(BPF_ADD, R8, R1),
4052                         BPF_ALU32_REG(BPF_ADD, R8, R2),
4053                         BPF_ALU32_REG(BPF_ADD, R8, R3),
4054                         BPF_ALU32_REG(BPF_ADD, R8, R4),
4055                         BPF_ALU32_REG(BPF_ADD, R8, R5),
4056                         BPF_ALU32_REG(BPF_ADD, R8, R6),
4057                         BPF_ALU32_REG(BPF_ADD, R8, R7),
4058                         BPF_ALU32_REG(BPF_ADD, R8, R8),
4059                         BPF_ALU32_REG(BPF_ADD, R8, R9), /* R8 == 985799 */
4060                         BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1),
4061                         BPF_EXIT_INSN(),
4062                         BPF_ALU32_REG(BPF_ADD, R9, R0),
4063                         BPF_ALU32_REG(BPF_ADD, R9, R1),
4064                         BPF_ALU32_REG(BPF_ADD, R9, R2),
4065                         BPF_ALU32_REG(BPF_ADD, R9, R3),
4066                         BPF_ALU32_REG(BPF_ADD, R9, R4),
4067                         BPF_ALU32_REG(BPF_ADD, R9, R5),
4068                         BPF_ALU32_REG(BPF_ADD, R9, R6),
4069                         BPF_ALU32_REG(BPF_ADD, R9, R7),
4070                         BPF_ALU32_REG(BPF_ADD, R9, R8),
4071                         BPF_ALU32_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */
4072                         BPF_ALU32_REG(BPF_MOV, R0, R9),
4073                         BPF_EXIT_INSN(),
4074                 },
4075                 INTERNAL,
4076                 { },
4077                 { { 0, 2957380 } }
4078         },
4079         {       /* Mainly checking JIT here. */
4080                 "INT: SUB",
4081                 .u.insns_int = {
4082                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
4083                         BPF_ALU64_IMM(BPF_MOV, R1, 1),
4084                         BPF_ALU64_IMM(BPF_MOV, R2, 2),
4085                         BPF_ALU64_IMM(BPF_MOV, R3, 3),
4086                         BPF_ALU64_IMM(BPF_MOV, R4, 4),
4087                         BPF_ALU64_IMM(BPF_MOV, R5, 5),
4088                         BPF_ALU64_IMM(BPF_MOV, R6, 6),
4089                         BPF_ALU64_IMM(BPF_MOV, R7, 7),
4090                         BPF_ALU64_IMM(BPF_MOV, R8, 8),
4091                         BPF_ALU64_IMM(BPF_MOV, R9, 9),
4092                         BPF_ALU64_REG(BPF_SUB, R0, R0),
4093                         BPF_ALU64_REG(BPF_SUB, R0, R1),
4094                         BPF_ALU64_REG(BPF_SUB, R0, R2),
4095                         BPF_ALU64_REG(BPF_SUB, R0, R3),
4096                         BPF_ALU64_REG(BPF_SUB, R0, R4),
4097                         BPF_ALU64_REG(BPF_SUB, R0, R5),
4098                         BPF_ALU64_REG(BPF_SUB, R0, R6),
4099                         BPF_ALU64_REG(BPF_SUB, R0, R7),
4100                         BPF_ALU64_REG(BPF_SUB, R0, R8),
4101                         BPF_ALU64_REG(BPF_SUB, R0, R9),
4102                         BPF_ALU64_IMM(BPF_SUB, R0, 10),
4103                         BPF_JMP_IMM(BPF_JEQ, R0, -55, 1),
4104                         BPF_EXIT_INSN(),
4105                         BPF_ALU64_REG(BPF_SUB, R1, R0),
4106                         BPF_ALU64_REG(BPF_SUB, R1, R2),
4107                         BPF_ALU64_REG(BPF_SUB, R1, R3),
4108                         BPF_ALU64_REG(BPF_SUB, R1, R4),
4109                         BPF_ALU64_REG(BPF_SUB, R1, R5),
4110                         BPF_ALU64_REG(BPF_SUB, R1, R6),
4111                         BPF_ALU64_REG(BPF_SUB, R1, R7),
4112                         BPF_ALU64_REG(BPF_SUB, R1, R8),
4113                         BPF_ALU64_REG(BPF_SUB, R1, R9),
4114                         BPF_ALU64_IMM(BPF_SUB, R1, 10),
4115                         BPF_ALU64_REG(BPF_SUB, R2, R0),
4116                         BPF_ALU64_REG(BPF_SUB, R2, R1),
4117                         BPF_ALU64_REG(BPF_SUB, R2, R3),
4118                         BPF_ALU64_REG(BPF_SUB, R2, R4),
4119                         BPF_ALU64_REG(BPF_SUB, R2, R5),
4120                         BPF_ALU64_REG(BPF_SUB, R2, R6),
4121                         BPF_ALU64_REG(BPF_SUB, R2, R7),
4122                         BPF_ALU64_REG(BPF_SUB, R2, R8),
4123                         BPF_ALU64_REG(BPF_SUB, R2, R9),
4124                         BPF_ALU64_IMM(BPF_SUB, R2, 10),
4125                         BPF_ALU64_REG(BPF_SUB, R3, R0),
4126                         BPF_ALU64_REG(BPF_SUB, R3, R1),
4127                         BPF_ALU64_REG(BPF_SUB, R3, R2),
4128                         BPF_ALU64_REG(BPF_SUB, R3, R4),
4129                         BPF_ALU64_REG(BPF_SUB, R3, R5),
4130                         BPF_ALU64_REG(BPF_SUB, R3, R6),
4131                         BPF_ALU64_REG(BPF_SUB, R3, R7),
4132                         BPF_ALU64_REG(BPF_SUB, R3, R8),
4133                         BPF_ALU64_REG(BPF_SUB, R3, R9),
4134                         BPF_ALU64_IMM(BPF_SUB, R3, 10),
4135                         BPF_ALU64_REG(BPF_SUB, R4, R0),
4136                         BPF_ALU64_REG(BPF_SUB, R4, R1),
4137                         BPF_ALU64_REG(BPF_SUB, R4, R2),
4138                         BPF_ALU64_REG(BPF_SUB, R4, R3),
4139                         BPF_ALU64_REG(BPF_SUB, R4, R5),
4140                         BPF_ALU64_REG(BPF_SUB, R4, R6),
4141                         BPF_ALU64_REG(BPF_SUB, R4, R7),
4142                         BPF_ALU64_REG(BPF_SUB, R4, R8),
4143                         BPF_ALU64_REG(BPF_SUB, R4, R9),
4144                         BPF_ALU64_IMM(BPF_SUB, R4, 10),
4145                         BPF_ALU64_REG(BPF_SUB, R5, R0),
4146                         BPF_ALU64_REG(BPF_SUB, R5, R1),
4147                         BPF_ALU64_REG(BPF_SUB, R5, R2),
4148                         BPF_ALU64_REG(BPF_SUB, R5, R3),
4149                         BPF_ALU64_REG(BPF_SUB, R5, R4),
4150                         BPF_ALU64_REG(BPF_SUB, R5, R6),
4151                         BPF_ALU64_REG(BPF_SUB, R5, R7),
4152                         BPF_ALU64_REG(BPF_SUB, R5, R8),
4153                         BPF_ALU64_REG(BPF_SUB, R5, R9),
4154                         BPF_ALU64_IMM(BPF_SUB, R5, 10),
4155                         BPF_ALU64_REG(BPF_SUB, R6, R0),
4156                         BPF_ALU64_REG(BPF_SUB, R6, R1),
4157                         BPF_ALU64_REG(BPF_SUB, R6, R2),
4158                         BPF_ALU64_REG(BPF_SUB, R6, R3),
4159                         BPF_ALU64_REG(BPF_SUB, R6, R4),
4160                         BPF_ALU64_REG(BPF_SUB, R6, R5),
4161                         BPF_ALU64_REG(BPF_SUB, R6, R7),
4162                         BPF_ALU64_REG(BPF_SUB, R6, R8),
4163                         BPF_ALU64_REG(BPF_SUB, R6, R9),
4164                         BPF_ALU64_IMM(BPF_SUB, R6, 10),
4165                         BPF_ALU64_REG(BPF_SUB, R7, R0),
4166                         BPF_ALU64_REG(BPF_SUB, R7, R1),
4167                         BPF_ALU64_REG(BPF_SUB, R7, R2),
4168                         BPF_ALU64_REG(BPF_SUB, R7, R3),
4169                         BPF_ALU64_REG(BPF_SUB, R7, R4),
4170                         BPF_ALU64_REG(BPF_SUB, R7, R5),
4171                         BPF_ALU64_REG(BPF_SUB, R7, R6),
4172                         BPF_ALU64_REG(BPF_SUB, R7, R8),
4173                         BPF_ALU64_REG(BPF_SUB, R7, R9),
4174                         BPF_ALU64_IMM(BPF_SUB, R7, 10),
4175                         BPF_ALU64_REG(BPF_SUB, R8, R0),
4176                         BPF_ALU64_REG(BPF_SUB, R8, R1),
4177                         BPF_ALU64_REG(BPF_SUB, R8, R2),
4178                         BPF_ALU64_REG(BPF_SUB, R8, R3),
4179                         BPF_ALU64_REG(BPF_SUB, R8, R4),
4180                         BPF_ALU64_REG(BPF_SUB, R8, R5),
4181                         BPF_ALU64_REG(BPF_SUB, R8, R6),
4182                         BPF_ALU64_REG(BPF_SUB, R8, R7),
4183                         BPF_ALU64_REG(BPF_SUB, R8, R9),
4184                         BPF_ALU64_IMM(BPF_SUB, R8, 10),
4185                         BPF_ALU64_REG(BPF_SUB, R9, R0),
4186                         BPF_ALU64_REG(BPF_SUB, R9, R1),
4187                         BPF_ALU64_REG(BPF_SUB, R9, R2),
4188                         BPF_ALU64_REG(BPF_SUB, R9, R3),
4189                         BPF_ALU64_REG(BPF_SUB, R9, R4),
4190                         BPF_ALU64_REG(BPF_SUB, R9, R5),
4191                         BPF_ALU64_REG(BPF_SUB, R9, R6),
4192                         BPF_ALU64_REG(BPF_SUB, R9, R7),
4193                         BPF_ALU64_REG(BPF_SUB, R9, R8),
4194                         BPF_ALU64_IMM(BPF_SUB, R9, 10),
4195                         BPF_ALU64_IMM(BPF_SUB, R0, 10),
4196                         BPF_ALU64_IMM(BPF_NEG, R0, 0),
4197                         BPF_ALU64_REG(BPF_SUB, R0, R1),
4198                         BPF_ALU64_REG(BPF_SUB, R0, R2),
4199                         BPF_ALU64_REG(BPF_SUB, R0, R3),
4200                         BPF_ALU64_REG(BPF_SUB, R0, R4),
4201                         BPF_ALU64_REG(BPF_SUB, R0, R5),
4202                         BPF_ALU64_REG(BPF_SUB, R0, R6),
4203                         BPF_ALU64_REG(BPF_SUB, R0, R7),
4204                         BPF_ALU64_REG(BPF_SUB, R0, R8),
4205                         BPF_ALU64_REG(BPF_SUB, R0, R9),
4206                         BPF_EXIT_INSN(),
4207                 },
4208                 INTERNAL,
4209                 { },
4210                 { { 0, 11 } }
4211         },
4212         {       /* Mainly checking JIT here. */
4213                 "INT: XOR",
4214                 .u.insns_int = {
4215                         BPF_ALU64_REG(BPF_SUB, R0, R0),
4216                         BPF_ALU64_REG(BPF_XOR, R1, R1),
4217                         BPF_JMP_REG(BPF_JEQ, R0, R1, 1),
4218                         BPF_EXIT_INSN(),
4219                         BPF_ALU64_IMM(BPF_MOV, R0, 10),
4220                         BPF_ALU64_IMM(BPF_MOV, R1, -1),
4221                         BPF_ALU64_REG(BPF_SUB, R1, R1),
4222                         BPF_ALU64_REG(BPF_XOR, R2, R2),
4223                         BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
4224                         BPF_EXIT_INSN(),
4225                         BPF_ALU64_REG(BPF_SUB, R2, R2),
4226                         BPF_ALU64_REG(BPF_XOR, R3, R3),
4227                         BPF_ALU64_IMM(BPF_MOV, R0, 10),
4228                         BPF_ALU64_IMM(BPF_MOV, R1, -1),
4229                         BPF_JMP_REG(BPF_JEQ, R2, R3, 1),
4230                         BPF_EXIT_INSN(),
4231                         BPF_ALU64_REG(BPF_SUB, R3, R3),
4232                         BPF_ALU64_REG(BPF_XOR, R4, R4),
4233                         BPF_ALU64_IMM(BPF_MOV, R2, 1),
4234                         BPF_ALU64_IMM(BPF_MOV, R5, -1),
4235                         BPF_JMP_REG(BPF_JEQ, R3, R4, 1),
4236                         BPF_EXIT_INSN(),
4237                         BPF_ALU64_REG(BPF_SUB, R4, R4),
4238                         BPF_ALU64_REG(BPF_XOR, R5, R5),
4239                         BPF_ALU64_IMM(BPF_MOV, R3, 1),
4240                         BPF_ALU64_IMM(BPF_MOV, R7, -1),
4241                         BPF_JMP_REG(BPF_JEQ, R5, R4, 1),
4242                         BPF_EXIT_INSN(),
4243                         BPF_ALU64_IMM(BPF_MOV, R5, 1),
4244                         BPF_ALU64_REG(BPF_SUB, R5, R5),
4245                         BPF_ALU64_REG(BPF_XOR, R6, R6),
4246                         BPF_ALU64_IMM(BPF_MOV, R1, 1),
4247                         BPF_ALU64_IMM(BPF_MOV, R8, -1),
4248                         BPF_JMP_REG(BPF_JEQ, R5, R6, 1),
4249                         BPF_EXIT_INSN(),
4250                         BPF_ALU64_REG(BPF_SUB, R6, R6),
4251                         BPF_ALU64_REG(BPF_XOR, R7, R7),
4252                         BPF_JMP_REG(BPF_JEQ, R7, R6, 1),
4253                         BPF_EXIT_INSN(),
4254                         BPF_ALU64_REG(BPF_SUB, R7, R7),
4255                         BPF_ALU64_REG(BPF_XOR, R8, R8),
4256                         BPF_JMP_REG(BPF_JEQ, R7, R8, 1),
4257                         BPF_EXIT_INSN(),
4258                         BPF_ALU64_REG(BPF_SUB, R8, R8),
4259                         BPF_ALU64_REG(BPF_XOR, R9, R9),
4260                         BPF_JMP_REG(BPF_JEQ, R9, R8, 1),
4261                         BPF_EXIT_INSN(),
4262                         BPF_ALU64_REG(BPF_SUB, R9, R9),
4263                         BPF_ALU64_REG(BPF_XOR, R0, R0),
4264                         BPF_JMP_REG(BPF_JEQ, R9, R0, 1),
4265                         BPF_EXIT_INSN(),
4266                         BPF_ALU64_REG(BPF_SUB, R1, R1),
4267                         BPF_ALU64_REG(BPF_XOR, R0, R0),
4268                         BPF_JMP_REG(BPF_JEQ, R9, R0, 2),
4269                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
4270                         BPF_EXIT_INSN(),
4271                         BPF_ALU64_IMM(BPF_MOV, R0, 1),
4272                         BPF_EXIT_INSN(),
4273                 },
4274                 INTERNAL,
4275                 { },
4276                 { { 0, 1 } }
4277         },
4278         {       /* Mainly checking JIT here. */
4279                 "INT: MUL",
4280                 .u.insns_int = {
4281                         BPF_ALU64_IMM(BPF_MOV, R0, 11),
4282                         BPF_ALU64_IMM(BPF_MOV, R1, 1),
4283                         BPF_ALU64_IMM(BPF_MOV, R2, 2),
4284                         BPF_ALU64_IMM(BPF_MOV, R3, 3),
4285                         BPF_ALU64_IMM(BPF_MOV, R4, 4),
4286                         BPF_ALU64_IMM(BPF_MOV, R5, 5),
4287                         BPF_ALU64_IMM(BPF_MOV, R6, 6),
4288                         BPF_ALU64_IMM(BPF_MOV, R7, 7),
4289                         BPF_ALU64_IMM(BPF_MOV, R8, 8),
4290                         BPF_ALU64_IMM(BPF_MOV, R9, 9),
4291                         BPF_ALU64_REG(BPF_MUL, R0, R0),
4292                         BPF_ALU64_REG(BPF_MUL, R0, R1),
4293                         BPF_ALU64_REG(BPF_MUL, R0, R2),
4294                         BPF_ALU64_REG(BPF_MUL, R0, R3),
4295                         BPF_ALU64_REG(BPF_MUL, R0, R4),
4296                         BPF_ALU64_REG(BPF_MUL, R0, R5),
4297                         BPF_ALU64_REG(BPF_MUL, R0, R6),
4298                         BPF_ALU64_REG(BPF_MUL, R0, R7),
4299                         BPF_ALU64_REG(BPF_MUL, R0, R8),
4300                         BPF_ALU64_REG(BPF_MUL, R0, R9),
4301                         BPF_ALU64_IMM(BPF_MUL, R0, 10),
4302                         BPF_JMP_IMM(BPF_JEQ, R0, 439084800, 1),
4303                         BPF_EXIT_INSN(),
4304                         BPF_ALU64_REG(BPF_MUL, R1, R0),
4305                         BPF_ALU64_REG(BPF_MUL, R1, R2),
4306                         BPF_ALU64_REG(BPF_MUL, R1, R3),
4307                         BPF_ALU64_REG(BPF_MUL, R1, R4),
4308                         BPF_ALU64_REG(BPF_MUL, R1, R5),
4309                         BPF_ALU64_REG(BPF_MUL, R1, R6),
4310                         BPF_ALU64_REG(BPF_MUL, R1, R7),
4311                         BPF_ALU64_REG(BPF_MUL, R1, R8),
4312                         BPF_ALU64_REG(BPF_MUL, R1, R9),
4313                         BPF_ALU64_IMM(BPF_MUL, R1, 10),
4314                         BPF_ALU64_REG(BPF_MOV, R2, R1),
4315                         BPF_ALU64_IMM(BPF_RSH, R2, 32),
4316                         BPF_JMP_IMM(BPF_JEQ, R2, 0x5a924, 1),
4317                         BPF_EXIT_INSN(),
4318                         BPF_ALU64_IMM(BPF_LSH, R1, 32),
4319                         BPF_ALU64_IMM(BPF_ARSH, R1, 32),
4320                         BPF_JMP_IMM(BPF_JEQ, R1, 0xebb90000, 1),
4321                         BPF_EXIT_INSN(),
4322                         BPF_ALU64_REG(BPF_MUL, R2, R0),
4323                         BPF_ALU64_REG(BPF_MUL, R2, R1),
4324                         BPF_ALU64_REG(BPF_MUL, R2, R3),
4325                         BPF_ALU64_REG(BPF_MUL, R2, R4),
4326                         BPF_ALU64_REG(BPF_MUL, R2, R5),
4327                         BPF_ALU64_REG(BPF_MUL, R2, R6),
4328                         BPF_ALU64_REG(BPF_MUL, R2, R7),
4329                         BPF_ALU64_REG(BPF_MUL, R2, R8),
4330                         BPF_ALU64_REG(BPF_MUL, R2, R9),
4331                         BPF_ALU64_IMM(BPF_MUL, R2, 10),
4332                         BPF_ALU64_IMM(BPF_RSH, R2, 32),
4333                         BPF_ALU64_REG(BPF_MOV, R0, R2),
4334                         BPF_EXIT_INSN(),
4335                 },
4336                 INTERNAL,
4337                 { },
4338                 { { 0, 0x35d97ef2 } }
4339         },
4340         {       /* Mainly checking JIT here. */
4341                 "MOV REG64",
4342                 .u.insns_int = {
4343                         BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
4344                         BPF_MOV64_REG(R1, R0),
4345                         BPF_MOV64_REG(R2, R1),
4346                         BPF_MOV64_REG(R3, R2),
4347                         BPF_MOV64_REG(R4, R3),
4348                         BPF_MOV64_REG(R5, R4),
4349                         BPF_MOV64_REG(R6, R5),
4350                         BPF_MOV64_REG(R7, R6),
4351                         BPF_MOV64_REG(R8, R7),
4352                         BPF_MOV64_REG(R9, R8),
4353                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
4354                         BPF_ALU64_IMM(BPF_MOV, R1, 0),
4355                         BPF_ALU64_IMM(BPF_MOV, R2, 0),
4356                         BPF_ALU64_IMM(BPF_MOV, R3, 0),
4357                         BPF_ALU64_IMM(BPF_MOV, R4, 0),
4358                         BPF_ALU64_IMM(BPF_MOV, R5, 0),
4359                         BPF_ALU64_IMM(BPF_MOV, R6, 0),
4360                         BPF_ALU64_IMM(BPF_MOV, R7, 0),
4361                         BPF_ALU64_IMM(BPF_MOV, R8, 0),
4362                         BPF_ALU64_IMM(BPF_MOV, R9, 0),
4363                         BPF_ALU64_REG(BPF_ADD, R0, R0),
4364                         BPF_ALU64_REG(BPF_ADD, R0, R1),
4365                         BPF_ALU64_REG(BPF_ADD, R0, R2),
4366                         BPF_ALU64_REG(BPF_ADD, R0, R3),
4367                         BPF_ALU64_REG(BPF_ADD, R0, R4),
4368                         BPF_ALU64_REG(BPF_ADD, R0, R5),
4369                         BPF_ALU64_REG(BPF_ADD, R0, R6),
4370                         BPF_ALU64_REG(BPF_ADD, R0, R7),
4371                         BPF_ALU64_REG(BPF_ADD, R0, R8),
4372                         BPF_ALU64_REG(BPF_ADD, R0, R9),
4373                         BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
4374                         BPF_EXIT_INSN(),
4375                 },
4376                 INTERNAL,
4377                 { },
4378                 { { 0, 0xfefe } }
4379         },
4380         {       /* Mainly checking JIT here. */
4381                 "MOV REG32",
4382                 .u.insns_int = {
4383                         BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
4384                         BPF_MOV64_REG(R1, R0),
4385                         BPF_MOV64_REG(R2, R1),
4386                         BPF_MOV64_REG(R3, R2),
4387                         BPF_MOV64_REG(R4, R3),
4388                         BPF_MOV64_REG(R5, R4),
4389                         BPF_MOV64_REG(R6, R5),
4390                         BPF_MOV64_REG(R7, R6),
4391                         BPF_MOV64_REG(R8, R7),
4392                         BPF_MOV64_REG(R9, R8),
4393                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
4394                         BPF_ALU32_IMM(BPF_MOV, R1, 0),
4395                         BPF_ALU32_IMM(BPF_MOV, R2, 0),
4396                         BPF_ALU32_IMM(BPF_MOV, R3, 0),
4397                         BPF_ALU32_IMM(BPF_MOV, R4, 0),
4398                         BPF_ALU32_IMM(BPF_MOV, R5, 0),
4399                         BPF_ALU32_IMM(BPF_MOV, R6, 0),
4400                         BPF_ALU32_IMM(BPF_MOV, R7, 0),
4401                         BPF_ALU32_IMM(BPF_MOV, R8, 0),
4402                         BPF_ALU32_IMM(BPF_MOV, R9, 0),
4403                         BPF_ALU64_REG(BPF_ADD, R0, R0),
4404                         BPF_ALU64_REG(BPF_ADD, R0, R1),
4405                         BPF_ALU64_REG(BPF_ADD, R0, R2),
4406                         BPF_ALU64_REG(BPF_ADD, R0, R3),
4407                         BPF_ALU64_REG(BPF_ADD, R0, R4),
4408                         BPF_ALU64_REG(BPF_ADD, R0, R5),
4409                         BPF_ALU64_REG(BPF_ADD, R0, R6),
4410                         BPF_ALU64_REG(BPF_ADD, R0, R7),
4411                         BPF_ALU64_REG(BPF_ADD, R0, R8),
4412                         BPF_ALU64_REG(BPF_ADD, R0, R9),
4413                         BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
4414                         BPF_EXIT_INSN(),
4415                 },
4416                 INTERNAL,
4417                 { },
4418                 { { 0, 0xfefe } }
4419         },
4420         {       /* Mainly checking JIT here. */
4421                 "LD IMM64",
4422                 .u.insns_int = {
4423                         BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
4424                         BPF_MOV64_REG(R1, R0),
4425                         BPF_MOV64_REG(R2, R1),
4426                         BPF_MOV64_REG(R3, R2),
4427                         BPF_MOV64_REG(R4, R3),
4428                         BPF_MOV64_REG(R5, R4),
4429                         BPF_MOV64_REG(R6, R5),
4430                         BPF_MOV64_REG(R7, R6),
4431                         BPF_MOV64_REG(R8, R7),
4432                         BPF_MOV64_REG(R9, R8),
4433                         BPF_LD_IMM64(R0, 0x0LL),
4434                         BPF_LD_IMM64(R1, 0x0LL),
4435                         BPF_LD_IMM64(R2, 0x0LL),
4436                         BPF_LD_IMM64(R3, 0x0LL),
4437                         BPF_LD_IMM64(R4, 0x0LL),
4438                         BPF_LD_IMM64(R5, 0x0LL),
4439                         BPF_LD_IMM64(R6, 0x0LL),
4440                         BPF_LD_IMM64(R7, 0x0LL),
4441                         BPF_LD_IMM64(R8, 0x0LL),
4442                         BPF_LD_IMM64(R9, 0x0LL),
4443                         BPF_ALU64_REG(BPF_ADD, R0, R0),
4444                         BPF_ALU64_REG(BPF_ADD, R0, R1),
4445                         BPF_ALU64_REG(BPF_ADD, R0, R2),
4446                         BPF_ALU64_REG(BPF_ADD, R0, R3),
4447                         BPF_ALU64_REG(BPF_ADD, R0, R4),
4448                         BPF_ALU64_REG(BPF_ADD, R0, R5),
4449                         BPF_ALU64_REG(BPF_ADD, R0, R6),
4450                         BPF_ALU64_REG(BPF_ADD, R0, R7),
4451                         BPF_ALU64_REG(BPF_ADD, R0, R8),
4452                         BPF_ALU64_REG(BPF_ADD, R0, R9),
4453                         BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
4454                         BPF_EXIT_INSN(),
4455                 },
4456                 INTERNAL,
4457                 { },
4458                 { { 0, 0xfefe } }
4459         },
4460         {
4461                 "INT: ALU MIX",
4462                 .u.insns_int = {
4463                         BPF_ALU64_IMM(BPF_MOV, R0, 11),
4464                         BPF_ALU64_IMM(BPF_ADD, R0, -1),
4465                         BPF_ALU64_IMM(BPF_MOV, R2, 2),
4466                         BPF_ALU64_IMM(BPF_XOR, R2, 3),
4467                         BPF_ALU64_REG(BPF_DIV, R0, R2),
4468                         BPF_JMP_IMM(BPF_JEQ, R0, 10, 1),
4469                         BPF_EXIT_INSN(),
4470                         BPF_ALU64_IMM(BPF_MOD, R0, 3),
4471                         BPF_JMP_IMM(BPF_JEQ, R0, 1, 1),
4472                         BPF_EXIT_INSN(),
4473                         BPF_ALU64_IMM(BPF_MOV, R0, -1),
4474                         BPF_EXIT_INSN(),
4475                 },
4476                 INTERNAL,
4477                 { },
4478                 { { 0, -1 } }
4479         },
4480         {
4481                 "INT: shifts by register",
4482                 .u.insns_int = {
4483                         BPF_MOV64_IMM(R0, -1234),
4484                         BPF_MOV64_IMM(R1, 1),
4485                         BPF_ALU32_REG(BPF_RSH, R0, R1),
4486                         BPF_JMP_IMM(BPF_JEQ, R0, 0x7ffffd97, 1),
4487                         BPF_EXIT_INSN(),
4488                         BPF_MOV64_IMM(R2, 1),
4489                         BPF_ALU64_REG(BPF_LSH, R0, R2),
4490                         BPF_MOV32_IMM(R4, -1234),
4491                         BPF_JMP_REG(BPF_JEQ, R0, R4, 1),
4492                         BPF_EXIT_INSN(),
4493                         BPF_ALU64_IMM(BPF_AND, R4, 63),
4494                         BPF_ALU64_REG(BPF_LSH, R0, R4), /* R0 <= 46 */
4495                         BPF_MOV64_IMM(R3, 47),
4496                         BPF_ALU64_REG(BPF_ARSH, R0, R3),
4497                         BPF_JMP_IMM(BPF_JEQ, R0, -617, 1),
4498                         BPF_EXIT_INSN(),
4499                         BPF_MOV64_IMM(R2, 1),
4500                         BPF_ALU64_REG(BPF_LSH, R4, R2), /* R4 = 46 << 1 */
4501                         BPF_JMP_IMM(BPF_JEQ, R4, 92, 1),
4502                         BPF_EXIT_INSN(),
4503                         BPF_MOV64_IMM(R4, 4),
4504                         BPF_ALU64_REG(BPF_LSH, R4, R4), /* R4 = 4 << 4 */
4505                         BPF_JMP_IMM(BPF_JEQ, R4, 64, 1),
4506                         BPF_EXIT_INSN(),
4507                         BPF_MOV64_IMM(R4, 5),
4508                         BPF_ALU32_REG(BPF_LSH, R4, R4), /* R4 = 5 << 5 */
4509                         BPF_JMP_IMM(BPF_JEQ, R4, 160, 1),
4510                         BPF_EXIT_INSN(),
4511                         BPF_MOV64_IMM(R0, -1),
4512                         BPF_EXIT_INSN(),
4513                 },
4514                 INTERNAL,
4515                 { },
4516                 { { 0, -1 } }
4517         },
4518 #ifdef CONFIG_32BIT
4519         {
4520                 "INT: 32-bit context pointer word order and zero-extension",
4521                 .u.insns_int = {
4522                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
4523                         BPF_JMP32_IMM(BPF_JEQ, R1, 0, 3),
4524                         BPF_ALU64_IMM(BPF_RSH, R1, 32),
4525                         BPF_JMP32_IMM(BPF_JNE, R1, 0, 1),
4526                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
4527                         BPF_EXIT_INSN(),
4528                 },
4529                 INTERNAL,
4530                 { },
4531                 { { 0, 1 } }
4532         },
4533 #endif
4534         {
4535                 "check: missing ret",
4536                 .u.insns = {
4537                         BPF_STMT(BPF_LD | BPF_IMM, 1),
4538                 },
4539                 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4540                 { },
4541                 { },
4542                 .fill_helper = NULL,
4543                 .expected_errcode = -EINVAL,
4544         },
4545         {
4546                 "check: div_k_0",
4547                 .u.insns = {
4548                         BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0),
4549                         BPF_STMT(BPF_RET | BPF_K, 0)
4550                 },
4551                 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4552                 { },
4553                 { },
4554                 .fill_helper = NULL,
4555                 .expected_errcode = -EINVAL,
4556         },
4557         {
4558                 "check: unknown insn",
4559                 .u.insns = {
4560                         /* seccomp insn, rejected in socket filter */
4561                         BPF_STMT(BPF_LDX | BPF_W | BPF_ABS, 0),
4562                         BPF_STMT(BPF_RET | BPF_K, 0)
4563                 },
4564                 CLASSIC | FLAG_EXPECTED_FAIL,
4565                 { },
4566                 { },
4567                 .fill_helper = NULL,
4568                 .expected_errcode = -EINVAL,
4569         },
4570         {
4571                 "check: out of range spill/fill",
4572                 .u.insns = {
4573                         BPF_STMT(BPF_STX, 16),
4574                         BPF_STMT(BPF_RET | BPF_K, 0)
4575                 },
4576                 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4577                 { },
4578                 { },
4579                 .fill_helper = NULL,
4580                 .expected_errcode = -EINVAL,
4581         },
4582         {
4583                 "JUMPS + HOLES",
4584                 .u.insns = {
4585                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4586                         BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 15),
4587                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4588                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4589                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4590                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4591                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4592                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4593                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4594                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4595                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4596                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4597                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4598                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4599                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4600                         BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 3, 4),
4601                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4602                         BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 1, 2),
4603                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4604                         BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
4605                         BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
4606                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4607                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4608                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4609                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4610                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4611                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4612                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4613                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4614                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4615                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4616                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4617                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4618                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4619                         BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 2, 3),
4620                         BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 1, 2),
4621                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4622                         BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
4623                         BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
4624                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4625                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4626                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4627                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4628                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4629                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4630                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4631                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4632                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4633                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4634                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4635                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4636                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4637                         BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 2, 3),
4638                         BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 1, 2),
4639                         BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4640                         BPF_STMT(BPF_RET | BPF_A, 0),
4641                         BPF_STMT(BPF_RET | BPF_A, 0),
4642                 },
4643                 CLASSIC,
4644                 { 0x00, 0x1b, 0x21, 0x3c, 0x9d, 0xf8,
4645                   0x90, 0xe2, 0xba, 0x0a, 0x56, 0xb4,
4646                   0x08, 0x00,
4647                   0x45, 0x00, 0x00, 0x28, 0x00, 0x00,
4648                   0x20, 0x00, 0x40, 0x11, 0x00, 0x00, /* IP header */
4649                   0xc0, 0xa8, 0x33, 0x01,
4650                   0xc0, 0xa8, 0x33, 0x02,
4651                   0xbb, 0xb6,
4652                   0xa9, 0xfa,
4653                   0x00, 0x14, 0x00, 0x00,
4654                   0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4655                   0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4656                   0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4657                   0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4658                   0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4659                   0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4660                   0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4661                   0xcc, 0xcc, 0xcc, 0xcc },
4662                 { { 88, 0x001b } }
4663         },
4664         {
4665                 "check: RET X",
4666                 .u.insns = {
4667                         BPF_STMT(BPF_RET | BPF_X, 0),
4668                 },
4669                 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4670                 { },
4671                 { },
4672                 .fill_helper = NULL,
4673                 .expected_errcode = -EINVAL,
4674         },
4675         {
4676                 "check: LDX + RET X",
4677                 .u.insns = {
4678                         BPF_STMT(BPF_LDX | BPF_IMM, 42),
4679                         BPF_STMT(BPF_RET | BPF_X, 0),
4680                 },
4681                 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4682                 { },
4683                 { },
4684                 .fill_helper = NULL,
4685                 .expected_errcode = -EINVAL,
4686         },
4687         {       /* Mainly checking JIT here. */
4688                 "M[]: alt STX + LDX",
4689                 .u.insns = {
4690                         BPF_STMT(BPF_LDX | BPF_IMM, 100),
4691                         BPF_STMT(BPF_STX, 0),
4692                         BPF_STMT(BPF_LDX | BPF_MEM, 0),
4693                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
4694                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4695                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
4696                         BPF_STMT(BPF_STX, 1),
4697                         BPF_STMT(BPF_LDX | BPF_MEM, 1),
4698                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
4699                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4700                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
4701                         BPF_STMT(BPF_STX, 2),
4702                         BPF_STMT(BPF_LDX | BPF_MEM, 2),
4703                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
4704                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4705                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
4706                         BPF_STMT(BPF_STX, 3),
4707                         BPF_STMT(BPF_LDX | BPF_MEM, 3),
4708                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
4709                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4710                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
4711                         BPF_STMT(BPF_STX, 4),
4712                         BPF_STMT(BPF_LDX | BPF_MEM, 4),
4713                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
4714                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4715                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
4716                         BPF_STMT(BPF_STX, 5),
4717                         BPF_STMT(BPF_LDX | BPF_MEM, 5),
4718                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
4719                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4720                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
4721                         BPF_STMT(BPF_STX, 6),
4722                         BPF_STMT(BPF_LDX | BPF_MEM, 6),
4723                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
4724                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4725                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
4726                         BPF_STMT(BPF_STX, 7),
4727                         BPF_STMT(BPF_LDX | BPF_MEM, 7),
4728                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
4729                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4730                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
4731                         BPF_STMT(BPF_STX, 8),
4732                         BPF_STMT(BPF_LDX | BPF_MEM, 8),
4733                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
4734                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4735                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
4736                         BPF_STMT(BPF_STX, 9),
4737                         BPF_STMT(BPF_LDX | BPF_MEM, 9),
4738                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
4739                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4740                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
4741                         BPF_STMT(BPF_STX, 10),
4742                         BPF_STMT(BPF_LDX | BPF_MEM, 10),
4743                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
4744                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4745                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
4746                         BPF_STMT(BPF_STX, 11),
4747                         BPF_STMT(BPF_LDX | BPF_MEM, 11),
4748                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
4749                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4750                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
4751                         BPF_STMT(BPF_STX, 12),
4752                         BPF_STMT(BPF_LDX | BPF_MEM, 12),
4753                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
4754                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4755                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
4756                         BPF_STMT(BPF_STX, 13),
4757                         BPF_STMT(BPF_LDX | BPF_MEM, 13),
4758                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
4759                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4760                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
4761                         BPF_STMT(BPF_STX, 14),
4762                         BPF_STMT(BPF_LDX | BPF_MEM, 14),
4763                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
4764                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4765                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
4766                         BPF_STMT(BPF_STX, 15),
4767                         BPF_STMT(BPF_LDX | BPF_MEM, 15),
4768                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
4769                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4770                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
4771                         BPF_STMT(BPF_RET | BPF_A, 0),
4772                 },
4773                 CLASSIC | FLAG_NO_DATA,
4774                 { },
4775                 { { 0, 116 } },
4776         },
4777         {       /* Mainly checking JIT here. */
4778                 "M[]: full STX + full LDX",
4779                 .u.insns = {
4780                         BPF_STMT(BPF_LDX | BPF_IMM, 0xbadfeedb),
4781                         BPF_STMT(BPF_STX, 0),
4782                         BPF_STMT(BPF_LDX | BPF_IMM, 0xecabedae),
4783                         BPF_STMT(BPF_STX, 1),
4784                         BPF_STMT(BPF_LDX | BPF_IMM, 0xafccfeaf),
4785                         BPF_STMT(BPF_STX, 2),
4786                         BPF_STMT(BPF_LDX | BPF_IMM, 0xbffdcedc),
4787                         BPF_STMT(BPF_STX, 3),
4788                         BPF_STMT(BPF_LDX | BPF_IMM, 0xfbbbdccb),
4789                         BPF_STMT(BPF_STX, 4),
4790                         BPF_STMT(BPF_LDX | BPF_IMM, 0xfbabcbda),
4791                         BPF_STMT(BPF_STX, 5),
4792                         BPF_STMT(BPF_LDX | BPF_IMM, 0xaedecbdb),
4793                         BPF_STMT(BPF_STX, 6),
4794                         BPF_STMT(BPF_LDX | BPF_IMM, 0xadebbade),
4795                         BPF_STMT(BPF_STX, 7),
4796                         BPF_STMT(BPF_LDX | BPF_IMM, 0xfcfcfaec),
4797                         BPF_STMT(BPF_STX, 8),
4798                         BPF_STMT(BPF_LDX | BPF_IMM, 0xbcdddbdc),
4799                         BPF_STMT(BPF_STX, 9),
4800                         BPF_STMT(BPF_LDX | BPF_IMM, 0xfeefdfac),
4801                         BPF_STMT(BPF_STX, 10),
4802                         BPF_STMT(BPF_LDX | BPF_IMM, 0xcddcdeea),
4803                         BPF_STMT(BPF_STX, 11),
4804                         BPF_STMT(BPF_LDX | BPF_IMM, 0xaccfaebb),
4805                         BPF_STMT(BPF_STX, 12),
4806                         BPF_STMT(BPF_LDX | BPF_IMM, 0xbdcccdcf),
4807                         BPF_STMT(BPF_STX, 13),
4808                         BPF_STMT(BPF_LDX | BPF_IMM, 0xaaedecde),
4809                         BPF_STMT(BPF_STX, 14),
4810                         BPF_STMT(BPF_LDX | BPF_IMM, 0xfaeacdad),
4811                         BPF_STMT(BPF_STX, 15),
4812                         BPF_STMT(BPF_LDX | BPF_MEM, 0),
4813                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
4814                         BPF_STMT(BPF_LDX | BPF_MEM, 1),
4815                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4816                         BPF_STMT(BPF_LDX | BPF_MEM, 2),
4817                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4818                         BPF_STMT(BPF_LDX | BPF_MEM, 3),
4819                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4820                         BPF_STMT(BPF_LDX | BPF_MEM, 4),
4821                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4822                         BPF_STMT(BPF_LDX | BPF_MEM, 5),
4823                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4824                         BPF_STMT(BPF_LDX | BPF_MEM, 6),
4825                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4826                         BPF_STMT(BPF_LDX | BPF_MEM, 7),
4827                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4828                         BPF_STMT(BPF_LDX | BPF_MEM, 8),
4829                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4830                         BPF_STMT(BPF_LDX | BPF_MEM, 9),
4831                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4832                         BPF_STMT(BPF_LDX | BPF_MEM, 10),
4833                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4834                         BPF_STMT(BPF_LDX | BPF_MEM, 11),
4835                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4836                         BPF_STMT(BPF_LDX | BPF_MEM, 12),
4837                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4838                         BPF_STMT(BPF_LDX | BPF_MEM, 13),
4839                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4840                         BPF_STMT(BPF_LDX | BPF_MEM, 14),
4841                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4842                         BPF_STMT(BPF_LDX | BPF_MEM, 15),
4843                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4844                         BPF_STMT(BPF_RET | BPF_A, 0),
4845                 },
4846                 CLASSIC | FLAG_NO_DATA,
4847                 { },
4848                 { { 0, 0x2a5a5e5 } },
4849         },
4850         {
4851                 "check: SKF_AD_MAX",
4852                 .u.insns = {
4853                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
4854                                  SKF_AD_OFF + SKF_AD_MAX),
4855                         BPF_STMT(BPF_RET | BPF_A, 0),
4856                 },
4857                 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4858                 { },
4859                 { },
4860                 .fill_helper = NULL,
4861                 .expected_errcode = -EINVAL,
4862         },
4863         {       /* Passes checker but fails during runtime. */
4864                 "LD [SKF_AD_OFF-1]",
4865                 .u.insns = {
4866                         BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
4867                                  SKF_AD_OFF - 1),
4868                         BPF_STMT(BPF_RET | BPF_K, 1),
4869                 },
4870                 CLASSIC,
4871                 { },
4872                 { { 1, 0 } },
4873         },
4874         {
4875                 "load 64-bit immediate",
4876                 .u.insns_int = {
4877                         BPF_LD_IMM64(R1, 0x567800001234LL),
4878                         BPF_MOV64_REG(R2, R1),
4879                         BPF_MOV64_REG(R3, R2),
4880                         BPF_ALU64_IMM(BPF_RSH, R2, 32),
4881                         BPF_ALU64_IMM(BPF_LSH, R3, 32),
4882                         BPF_ALU64_IMM(BPF_RSH, R3, 32),
4883                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
4884                         BPF_JMP_IMM(BPF_JEQ, R2, 0x5678, 1),
4885                         BPF_EXIT_INSN(),
4886                         BPF_JMP_IMM(BPF_JEQ, R3, 0x1234, 1),
4887                         BPF_EXIT_INSN(),
4888                         BPF_LD_IMM64(R0, 0x1ffffffffLL),
4889                         BPF_ALU64_IMM(BPF_RSH, R0, 32), /* R0 = 1 */
4890                         BPF_EXIT_INSN(),
4891                 },
4892                 INTERNAL,
4893                 { },
4894                 { { 0, 1 } }
4895         },
4896         /* BPF_ALU | BPF_MOV | BPF_X */
4897         {
4898                 "ALU_MOV_X: dst = 2",
4899                 .u.insns_int = {
4900                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
4901                         BPF_ALU32_REG(BPF_MOV, R0, R1),
4902                         BPF_EXIT_INSN(),
4903                 },
4904                 INTERNAL,
4905                 { },
4906                 { { 0, 2 } },
4907         },
4908         {
4909                 "ALU_MOV_X: dst = 4294967295",
4910                 .u.insns_int = {
4911                         BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
4912                         BPF_ALU32_REG(BPF_MOV, R0, R1),
4913                         BPF_EXIT_INSN(),
4914                 },
4915                 INTERNAL,
4916                 { },
4917                 { { 0, 4294967295U } },
4918         },
4919         {
4920                 "ALU64_MOV_X: dst = 2",
4921                 .u.insns_int = {
4922                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
4923                         BPF_ALU64_REG(BPF_MOV, R0, R1),
4924                         BPF_EXIT_INSN(),
4925                 },
4926                 INTERNAL,
4927                 { },
4928                 { { 0, 2 } },
4929         },
4930         {
4931                 "ALU64_MOV_X: dst = 4294967295",
4932                 .u.insns_int = {
4933                         BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
4934                         BPF_ALU64_REG(BPF_MOV, R0, R1),
4935                         BPF_EXIT_INSN(),
4936                 },
4937                 INTERNAL,
4938                 { },
4939                 { { 0, 4294967295U } },
4940         },
4941         /* BPF_ALU | BPF_MOV | BPF_K */
4942         {
4943                 "ALU_MOV_K: dst = 2",
4944                 .u.insns_int = {
4945                         BPF_ALU32_IMM(BPF_MOV, R0, 2),
4946                         BPF_EXIT_INSN(),
4947                 },
4948                 INTERNAL,
4949                 { },
4950                 { { 0, 2 } },
4951         },
4952         {
4953                 "ALU_MOV_K: dst = 4294967295",
4954                 .u.insns_int = {
4955                         BPF_ALU32_IMM(BPF_MOV, R0, 4294967295U),
4956                         BPF_EXIT_INSN(),
4957                 },
4958                 INTERNAL,
4959                 { },
4960                 { { 0, 4294967295U } },
4961         },
4962         {
4963                 "ALU_MOV_K: 0x0000ffffffff0000 = 0x00000000ffffffff",
4964                 .u.insns_int = {
4965                         BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
4966                         BPF_LD_IMM64(R3, 0x00000000ffffffffLL),
4967                         BPF_ALU32_IMM(BPF_MOV, R2, 0xffffffff),
4968                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4969                         BPF_MOV32_IMM(R0, 2),
4970                         BPF_EXIT_INSN(),
4971                         BPF_MOV32_IMM(R0, 1),
4972                         BPF_EXIT_INSN(),
4973                 },
4974                 INTERNAL,
4975                 { },
4976                 { { 0, 0x1 } },
4977         },
4978         {
4979                 "ALU_MOV_K: small negative",
4980                 .u.insns_int = {
4981                         BPF_ALU32_IMM(BPF_MOV, R0, -123),
4982                         BPF_EXIT_INSN(),
4983                 },
4984                 INTERNAL,
4985                 { },
4986                 { { 0, -123 } }
4987         },
4988         {
4989                 "ALU_MOV_K: small negative zero extension",
4990                 .u.insns_int = {
4991                         BPF_ALU32_IMM(BPF_MOV, R0, -123),
4992                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
4993                         BPF_EXIT_INSN(),
4994                 },
4995                 INTERNAL,
4996                 { },
4997                 { { 0, 0 } }
4998         },
4999         {
5000                 "ALU_MOV_K: large negative",
5001                 .u.insns_int = {
5002                         BPF_ALU32_IMM(BPF_MOV, R0, -123456789),
5003                         BPF_EXIT_INSN(),
5004                 },
5005                 INTERNAL,
5006                 { },
5007                 { { 0, -123456789 } }
5008         },
5009         {
5010                 "ALU_MOV_K: large negative zero extension",
5011                 .u.insns_int = {
5012                         BPF_ALU32_IMM(BPF_MOV, R0, -123456789),
5013                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
5014                         BPF_EXIT_INSN(),
5015                 },
5016                 INTERNAL,
5017                 { },
5018                 { { 0, 0 } }
5019         },
5020         {
5021                 "ALU64_MOV_K: dst = 2",
5022                 .u.insns_int = {
5023                         BPF_ALU64_IMM(BPF_MOV, R0, 2),
5024                         BPF_EXIT_INSN(),
5025                 },
5026                 INTERNAL,
5027                 { },
5028                 { { 0, 2 } },
5029         },
5030         {
5031                 "ALU64_MOV_K: dst = 2147483647",
5032                 .u.insns_int = {
5033                         BPF_ALU64_IMM(BPF_MOV, R0, 2147483647),
5034                         BPF_EXIT_INSN(),
5035                 },
5036                 INTERNAL,
5037                 { },
5038                 { { 0, 2147483647 } },
5039         },
5040         {
5041                 "ALU64_OR_K: dst = 0x0",
5042                 .u.insns_int = {
5043                         BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
5044                         BPF_LD_IMM64(R3, 0x0),
5045                         BPF_ALU64_IMM(BPF_MOV, R2, 0x0),
5046                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5047                         BPF_MOV32_IMM(R0, 2),
5048                         BPF_EXIT_INSN(),
5049                         BPF_MOV32_IMM(R0, 1),
5050                         BPF_EXIT_INSN(),
5051                 },
5052                 INTERNAL,
5053                 { },
5054                 { { 0, 0x1 } },
5055         },
5056         {
5057                 "ALU64_MOV_K: dst = -1",
5058                 .u.insns_int = {
5059                         BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
5060                         BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
5061                         BPF_ALU64_IMM(BPF_MOV, R2, 0xffffffff),
5062                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5063                         BPF_MOV32_IMM(R0, 2),
5064                         BPF_EXIT_INSN(),
5065                         BPF_MOV32_IMM(R0, 1),
5066                         BPF_EXIT_INSN(),
5067                 },
5068                 INTERNAL,
5069                 { },
5070                 { { 0, 0x1 } },
5071         },
5072         {
5073                 "ALU64_MOV_K: small negative",
5074                 .u.insns_int = {
5075                         BPF_ALU64_IMM(BPF_MOV, R0, -123),
5076                         BPF_EXIT_INSN(),
5077                 },
5078                 INTERNAL,
5079                 { },
5080                 { { 0, -123 } }
5081         },
5082         {
5083                 "ALU64_MOV_K: small negative sign extension",
5084                 .u.insns_int = {
5085                         BPF_ALU64_IMM(BPF_MOV, R0, -123),
5086                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
5087                         BPF_EXIT_INSN(),
5088                 },
5089                 INTERNAL,
5090                 { },
5091                 { { 0, 0xffffffff } }
5092         },
5093         {
5094                 "ALU64_MOV_K: large negative",
5095                 .u.insns_int = {
5096                         BPF_ALU64_IMM(BPF_MOV, R0, -123456789),
5097                         BPF_EXIT_INSN(),
5098                 },
5099                 INTERNAL,
5100                 { },
5101                 { { 0, -123456789 } }
5102         },
5103         {
5104                 "ALU64_MOV_K: large negative sign extension",
5105                 .u.insns_int = {
5106                         BPF_ALU64_IMM(BPF_MOV, R0, -123456789),
5107                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
5108                         BPF_EXIT_INSN(),
5109                 },
5110                 INTERNAL,
5111                 { },
5112                 { { 0, 0xffffffff } }
5113         },
5114         /* MOVSX32 */
5115         {
5116                 "ALU_MOVSX | BPF_B",
5117                 .u.insns_int = {
5118                         BPF_LD_IMM64(R2, 0x00000000ffffffefLL),
5119                         BPF_LD_IMM64(R3, 0xdeadbeefdeadbeefLL),
5120                         BPF_MOVSX32_REG(R1, R3, 8),
5121                         BPF_JMP_REG(BPF_JEQ, R2, R1, 2),
5122                         BPF_MOV32_IMM(R0, 2),
5123                         BPF_EXIT_INSN(),
5124                         BPF_MOV32_IMM(R0, 1),
5125                         BPF_EXIT_INSN(),
5126                 },
5127                 INTERNAL,
5128                 { },
5129                 { { 0, 0x1 } },
5130         },
5131         {
5132                 "ALU_MOVSX | BPF_H",
5133                 .u.insns_int = {
5134                         BPF_LD_IMM64(R2, 0x00000000ffffbeefLL),
5135                         BPF_LD_IMM64(R3, 0xdeadbeefdeadbeefLL),
5136                         BPF_MOVSX32_REG(R1, R3, 16),
5137                         BPF_JMP_REG(BPF_JEQ, R2, R1, 2),
5138                         BPF_MOV32_IMM(R0, 2),
5139                         BPF_EXIT_INSN(),
5140                         BPF_MOV32_IMM(R0, 1),
5141                         BPF_EXIT_INSN(),
5142                 },
5143                 INTERNAL,
5144                 { },
5145                 { { 0, 0x1 } },
5146         },
5147         /* MOVSX64 REG */
5148         {
5149                 "ALU64_MOVSX | BPF_B",
5150                 .u.insns_int = {
5151                         BPF_LD_IMM64(R2, 0xffffffffffffffefLL),
5152                         BPF_LD_IMM64(R3, 0xdeadbeefdeadbeefLL),
5153                         BPF_MOVSX64_REG(R1, R3, 8),
5154                         BPF_JMP_REG(BPF_JEQ, R2, R1, 2),
5155                         BPF_MOV32_IMM(R0, 2),
5156                         BPF_EXIT_INSN(),
5157                         BPF_MOV32_IMM(R0, 1),
5158                         BPF_EXIT_INSN(),
5159                 },
5160                 INTERNAL,
5161                 { },
5162                 { { 0, 0x1 } },
5163         },
5164         {
5165                 "ALU64_MOVSX | BPF_H",
5166                 .u.insns_int = {
5167                         BPF_LD_IMM64(R2, 0xffffffffffffbeefLL),
5168                         BPF_LD_IMM64(R3, 0xdeadbeefdeadbeefLL),
5169                         BPF_MOVSX64_REG(R1, R3, 16),
5170                         BPF_JMP_REG(BPF_JEQ, R2, R1, 2),
5171                         BPF_MOV32_IMM(R0, 2),
5172                         BPF_EXIT_INSN(),
5173                         BPF_MOV32_IMM(R0, 1),
5174                         BPF_EXIT_INSN(),
5175                 },
5176                 INTERNAL,
5177                 { },
5178                 { { 0, 0x1 } },
5179         },
5180         {
5181                 "ALU64_MOVSX | BPF_W",
5182                 .u.insns_int = {
5183                         BPF_LD_IMM64(R2, 0xffffffffdeadbeefLL),
5184                         BPF_LD_IMM64(R3, 0xdeadbeefdeadbeefLL),
5185                         BPF_MOVSX64_REG(R1, R3, 32),
5186                         BPF_JMP_REG(BPF_JEQ, R2, R1, 2),
5187                         BPF_MOV32_IMM(R0, 2),
5188                         BPF_EXIT_INSN(),
5189                         BPF_MOV32_IMM(R0, 1),
5190                         BPF_EXIT_INSN(),
5191                 },
5192                 INTERNAL,
5193                 { },
5194                 { { 0, 0x1 } },
5195         },
5196         /* BPF_ALU | BPF_ADD | BPF_X */
5197         {
5198                 "ALU_ADD_X: 1 + 2 = 3",
5199                 .u.insns_int = {
5200                         BPF_LD_IMM64(R0, 1),
5201                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
5202                         BPF_ALU32_REG(BPF_ADD, R0, R1),
5203                         BPF_EXIT_INSN(),
5204                 },
5205                 INTERNAL,
5206                 { },
5207                 { { 0, 3 } },
5208         },
5209         {
5210                 "ALU_ADD_X: 1 + 4294967294 = 4294967295",
5211                 .u.insns_int = {
5212                         BPF_LD_IMM64(R0, 1),
5213                         BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
5214                         BPF_ALU32_REG(BPF_ADD, R0, R1),
5215                         BPF_EXIT_INSN(),
5216                 },
5217                 INTERNAL,
5218                 { },
5219                 { { 0, 4294967295U } },
5220         },
5221         {
5222                 "ALU_ADD_X: 2 + 4294967294 = 0",
5223                 .u.insns_int = {
5224                         BPF_LD_IMM64(R0, 2),
5225                         BPF_LD_IMM64(R1, 4294967294U),
5226                         BPF_ALU32_REG(BPF_ADD, R0, R1),
5227                         BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
5228                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5229                         BPF_EXIT_INSN(),
5230                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
5231                         BPF_EXIT_INSN(),
5232                 },
5233                 INTERNAL,
5234                 { },
5235                 { { 0, 1 } },
5236         },
5237         {
5238                 "ALU64_ADD_X: 1 + 2 = 3",
5239                 .u.insns_int = {
5240                         BPF_LD_IMM64(R0, 1),
5241                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
5242                         BPF_ALU64_REG(BPF_ADD, R0, R1),
5243                         BPF_EXIT_INSN(),
5244                 },
5245                 INTERNAL,
5246                 { },
5247                 { { 0, 3 } },
5248         },
5249         {
5250                 "ALU64_ADD_X: 1 + 4294967294 = 4294967295",
5251                 .u.insns_int = {
5252                         BPF_LD_IMM64(R0, 1),
5253                         BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
5254                         BPF_ALU64_REG(BPF_ADD, R0, R1),
5255                         BPF_EXIT_INSN(),
5256                 },
5257                 INTERNAL,
5258                 { },
5259                 { { 0, 4294967295U } },
5260         },
5261         {
5262                 "ALU64_ADD_X: 2 + 4294967294 = 4294967296",
5263                 .u.insns_int = {
5264                         BPF_LD_IMM64(R0, 2),
5265                         BPF_LD_IMM64(R1, 4294967294U),
5266                         BPF_LD_IMM64(R2, 4294967296ULL),
5267                         BPF_ALU64_REG(BPF_ADD, R0, R1),
5268                         BPF_JMP_REG(BPF_JEQ, R0, R2, 2),
5269                         BPF_MOV32_IMM(R0, 0),
5270                         BPF_EXIT_INSN(),
5271                         BPF_MOV32_IMM(R0, 1),
5272                         BPF_EXIT_INSN(),
5273                 },
5274                 INTERNAL,
5275                 { },
5276                 { { 0, 1 } },
5277         },
5278         /* BPF_ALU | BPF_ADD | BPF_K */
5279         {
5280                 "ALU_ADD_K: 1 + 2 = 3",
5281                 .u.insns_int = {
5282                         BPF_LD_IMM64(R0, 1),
5283                         BPF_ALU32_IMM(BPF_ADD, R0, 2),
5284                         BPF_EXIT_INSN(),
5285                 },
5286                 INTERNAL,
5287                 { },
5288                 { { 0, 3 } },
5289         },
5290         {
5291                 "ALU_ADD_K: 3 + 0 = 3",
5292                 .u.insns_int = {
5293                         BPF_LD_IMM64(R0, 3),
5294                         BPF_ALU32_IMM(BPF_ADD, R0, 0),
5295                         BPF_EXIT_INSN(),
5296                 },
5297                 INTERNAL,
5298                 { },
5299                 { { 0, 3 } },
5300         },
5301         {
5302                 "ALU_ADD_K: 1 + 4294967294 = 4294967295",
5303                 .u.insns_int = {
5304                         BPF_LD_IMM64(R0, 1),
5305                         BPF_ALU32_IMM(BPF_ADD, R0, 4294967294U),
5306                         BPF_EXIT_INSN(),
5307                 },
5308                 INTERNAL,
5309                 { },
5310                 { { 0, 4294967295U } },
5311         },
5312         {
5313                 "ALU_ADD_K: 4294967294 + 2 = 0",
5314                 .u.insns_int = {
5315                         BPF_LD_IMM64(R0, 4294967294U),
5316                         BPF_ALU32_IMM(BPF_ADD, R0, 2),
5317                         BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
5318                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5319                         BPF_EXIT_INSN(),
5320                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
5321                         BPF_EXIT_INSN(),
5322                 },
5323                 INTERNAL,
5324                 { },
5325                 { { 0, 1 } },
5326         },
5327         {
5328                 "ALU_ADD_K: 0 + (-1) = 0x00000000ffffffff",
5329                 .u.insns_int = {
5330                         BPF_LD_IMM64(R2, 0x0),
5331                         BPF_LD_IMM64(R3, 0x00000000ffffffff),
5332                         BPF_ALU32_IMM(BPF_ADD, R2, 0xffffffff),
5333                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5334                         BPF_MOV32_IMM(R0, 2),
5335                         BPF_EXIT_INSN(),
5336                         BPF_MOV32_IMM(R0, 1),
5337                         BPF_EXIT_INSN(),
5338                 },
5339                 INTERNAL,
5340                 { },
5341                 { { 0, 0x1 } },
5342         },
5343         {
5344                 "ALU_ADD_K: 0 + 0xffff = 0xffff",
5345                 .u.insns_int = {
5346                         BPF_LD_IMM64(R2, 0x0),
5347                         BPF_LD_IMM64(R3, 0xffff),
5348                         BPF_ALU32_IMM(BPF_ADD, R2, 0xffff),
5349                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5350                         BPF_MOV32_IMM(R0, 2),
5351                         BPF_EXIT_INSN(),
5352                         BPF_MOV32_IMM(R0, 1),
5353                         BPF_EXIT_INSN(),
5354                 },
5355                 INTERNAL,
5356                 { },
5357                 { { 0, 0x1 } },
5358         },
5359         {
5360                 "ALU_ADD_K: 0 + 0x7fffffff = 0x7fffffff",
5361                 .u.insns_int = {
5362                         BPF_LD_IMM64(R2, 0x0),
5363                         BPF_LD_IMM64(R3, 0x7fffffff),
5364                         BPF_ALU32_IMM(BPF_ADD, R2, 0x7fffffff),
5365                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5366                         BPF_MOV32_IMM(R0, 2),
5367                         BPF_EXIT_INSN(),
5368                         BPF_MOV32_IMM(R0, 1),
5369                         BPF_EXIT_INSN(),
5370                 },
5371                 INTERNAL,
5372                 { },
5373                 { { 0, 0x1 } },
5374         },
5375         {
5376                 "ALU_ADD_K: 0 + 0x80000000 = 0x80000000",
5377                 .u.insns_int = {
5378                         BPF_LD_IMM64(R2, 0x0),
5379                         BPF_LD_IMM64(R3, 0x80000000),
5380                         BPF_ALU32_IMM(BPF_ADD, R2, 0x80000000),
5381                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5382                         BPF_MOV32_IMM(R0, 2),
5383                         BPF_EXIT_INSN(),
5384                         BPF_MOV32_IMM(R0, 1),
5385                         BPF_EXIT_INSN(),
5386                 },
5387                 INTERNAL,
5388                 { },
5389                 { { 0, 0x1 } },
5390         },
5391         {
5392                 "ALU_ADD_K: 0 + 0x80008000 = 0x80008000",
5393                 .u.insns_int = {
5394                         BPF_LD_IMM64(R2, 0x0),
5395                         BPF_LD_IMM64(R3, 0x80008000),
5396                         BPF_ALU32_IMM(BPF_ADD, R2, 0x80008000),
5397                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5398                         BPF_MOV32_IMM(R0, 2),
5399                         BPF_EXIT_INSN(),
5400                         BPF_MOV32_IMM(R0, 1),
5401                         BPF_EXIT_INSN(),
5402                 },
5403                 INTERNAL,
5404                 { },
5405                 { { 0, 0x1 } },
5406         },
5407         {
5408                 "ALU64_ADD_K: 1 + 2 = 3",
5409                 .u.insns_int = {
5410                         BPF_LD_IMM64(R0, 1),
5411                         BPF_ALU64_IMM(BPF_ADD, R0, 2),
5412                         BPF_EXIT_INSN(),
5413                 },
5414                 INTERNAL,
5415                 { },
5416                 { { 0, 3 } },
5417         },
5418         {
5419                 "ALU64_ADD_K: 3 + 0 = 3",
5420                 .u.insns_int = {
5421                         BPF_LD_IMM64(R0, 3),
5422                         BPF_ALU64_IMM(BPF_ADD, R0, 0),
5423                         BPF_EXIT_INSN(),
5424                 },
5425                 INTERNAL,
5426                 { },
5427                 { { 0, 3 } },
5428         },
5429         {
5430                 "ALU64_ADD_K: 1 + 2147483646 = 2147483647",
5431                 .u.insns_int = {
5432                         BPF_LD_IMM64(R0, 1),
5433                         BPF_ALU64_IMM(BPF_ADD, R0, 2147483646),
5434                         BPF_EXIT_INSN(),
5435                 },
5436                 INTERNAL,
5437                 { },
5438                 { { 0, 2147483647 } },
5439         },
5440         {
5441                 "ALU64_ADD_K: 4294967294 + 2 = 4294967296",
5442                 .u.insns_int = {
5443                         BPF_LD_IMM64(R0, 4294967294U),
5444                         BPF_LD_IMM64(R1, 4294967296ULL),
5445                         BPF_ALU64_IMM(BPF_ADD, R0, 2),
5446                         BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
5447                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
5448                         BPF_EXIT_INSN(),
5449                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
5450                         BPF_EXIT_INSN(),
5451                 },
5452                 INTERNAL,
5453                 { },
5454                 { { 0, 1 } },
5455         },
5456         {
5457                 "ALU64_ADD_K: 2147483646 + -2147483647 = -1",
5458                 .u.insns_int = {
5459                         BPF_LD_IMM64(R0, 2147483646),
5460                         BPF_ALU64_IMM(BPF_ADD, R0, -2147483647),
5461                         BPF_EXIT_INSN(),
5462                 },
5463                 INTERNAL,
5464                 { },
5465                 { { 0, -1 } },
5466         },
5467         {
5468                 "ALU64_ADD_K: 1 + 0 = 1",
5469                 .u.insns_int = {
5470                         BPF_LD_IMM64(R2, 0x1),
5471                         BPF_LD_IMM64(R3, 0x1),
5472                         BPF_ALU64_IMM(BPF_ADD, R2, 0x0),
5473                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5474                         BPF_MOV32_IMM(R0, 2),
5475                         BPF_EXIT_INSN(),
5476                         BPF_MOV32_IMM(R0, 1),
5477                         BPF_EXIT_INSN(),
5478                 },
5479                 INTERNAL,
5480                 { },
5481                 { { 0, 0x1 } },
5482         },
5483         {
5484                 "ALU64_ADD_K: 0 + (-1) = 0xffffffffffffffff",
5485                 .u.insns_int = {
5486                         BPF_LD_IMM64(R2, 0x0),
5487                         BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
5488                         BPF_ALU64_IMM(BPF_ADD, R2, 0xffffffff),
5489                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5490                         BPF_MOV32_IMM(R0, 2),
5491                         BPF_EXIT_INSN(),
5492                         BPF_MOV32_IMM(R0, 1),
5493                         BPF_EXIT_INSN(),
5494                 },
5495                 INTERNAL,
5496                 { },
5497                 { { 0, 0x1 } },
5498         },
5499         {
5500                 "ALU64_ADD_K: 0 + 0xffff = 0xffff",
5501                 .u.insns_int = {
5502                         BPF_LD_IMM64(R2, 0x0),
5503                         BPF_LD_IMM64(R3, 0xffff),
5504                         BPF_ALU64_IMM(BPF_ADD, R2, 0xffff),
5505                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5506                         BPF_MOV32_IMM(R0, 2),
5507                         BPF_EXIT_INSN(),
5508                         BPF_MOV32_IMM(R0, 1),
5509                         BPF_EXIT_INSN(),
5510                 },
5511                 INTERNAL,
5512                 { },
5513                 { { 0, 0x1 } },
5514         },
5515         {
5516                 "ALU64_ADD_K: 0 + 0x7fffffff = 0x7fffffff",
5517                 .u.insns_int = {
5518                         BPF_LD_IMM64(R2, 0x0),
5519                         BPF_LD_IMM64(R3, 0x7fffffff),
5520                         BPF_ALU64_IMM(BPF_ADD, R2, 0x7fffffff),
5521                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5522                         BPF_MOV32_IMM(R0, 2),
5523                         BPF_EXIT_INSN(),
5524                         BPF_MOV32_IMM(R0, 1),
5525                         BPF_EXIT_INSN(),
5526                 },
5527                 INTERNAL,
5528                 { },
5529                 { { 0, 0x1 } },
5530         },
5531         {
5532                 "ALU64_ADD_K: 0 + 0x80000000 = 0xffffffff80000000",
5533                 .u.insns_int = {
5534                         BPF_LD_IMM64(R2, 0x0),
5535                         BPF_LD_IMM64(R3, 0xffffffff80000000LL),
5536                         BPF_ALU64_IMM(BPF_ADD, R2, 0x80000000),
5537                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5538                         BPF_MOV32_IMM(R0, 2),
5539                         BPF_EXIT_INSN(),
5540                         BPF_MOV32_IMM(R0, 1),
5541                         BPF_EXIT_INSN(),
5542                 },
5543                 INTERNAL,
5544                 { },
5545                 { { 0, 0x1 } },
5546         },
5547         {
5548                 "ALU_ADD_K: 0 + 0x80008000 = 0xffffffff80008000",
5549                 .u.insns_int = {
5550                         BPF_LD_IMM64(R2, 0x0),
5551                         BPF_LD_IMM64(R3, 0xffffffff80008000LL),
5552                         BPF_ALU64_IMM(BPF_ADD, R2, 0x80008000),
5553                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5554                         BPF_MOV32_IMM(R0, 2),
5555                         BPF_EXIT_INSN(),
5556                         BPF_MOV32_IMM(R0, 1),
5557                         BPF_EXIT_INSN(),
5558                 },
5559                 INTERNAL,
5560                 { },
5561                 { { 0, 0x1 } },
5562         },
5563         /* BPF_ALU | BPF_SUB | BPF_X */
5564         {
5565                 "ALU_SUB_X: 3 - 1 = 2",
5566                 .u.insns_int = {
5567                         BPF_LD_IMM64(R0, 3),
5568                         BPF_ALU32_IMM(BPF_MOV, R1, 1),
5569                         BPF_ALU32_REG(BPF_SUB, R0, R1),
5570                         BPF_EXIT_INSN(),
5571                 },
5572                 INTERNAL,
5573                 { },
5574                 { { 0, 2 } },
5575         },
5576         {
5577                 "ALU_SUB_X: 4294967295 - 4294967294 = 1",
5578                 .u.insns_int = {
5579                         BPF_LD_IMM64(R0, 4294967295U),
5580                         BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
5581                         BPF_ALU32_REG(BPF_SUB, R0, R1),
5582                         BPF_EXIT_INSN(),
5583                 },
5584                 INTERNAL,
5585                 { },
5586                 { { 0, 1 } },
5587         },
5588         {
5589                 "ALU64_SUB_X: 3 - 1 = 2",
5590                 .u.insns_int = {
5591                         BPF_LD_IMM64(R0, 3),
5592                         BPF_ALU32_IMM(BPF_MOV, R1, 1),
5593                         BPF_ALU64_REG(BPF_SUB, R0, R1),
5594                         BPF_EXIT_INSN(),
5595                 },
5596                 INTERNAL,
5597                 { },
5598                 { { 0, 2 } },
5599         },
5600         {
5601                 "ALU64_SUB_X: 4294967295 - 4294967294 = 1",
5602                 .u.insns_int = {
5603                         BPF_LD_IMM64(R0, 4294967295U),
5604                         BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
5605                         BPF_ALU64_REG(BPF_SUB, R0, R1),
5606                         BPF_EXIT_INSN(),
5607                 },
5608                 INTERNAL,
5609                 { },
5610                 { { 0, 1 } },
5611         },
5612         /* BPF_ALU | BPF_SUB | BPF_K */
5613         {
5614                 "ALU_SUB_K: 3 - 1 = 2",
5615                 .u.insns_int = {
5616                         BPF_LD_IMM64(R0, 3),
5617                         BPF_ALU32_IMM(BPF_SUB, R0, 1),
5618                         BPF_EXIT_INSN(),
5619                 },
5620                 INTERNAL,
5621                 { },
5622                 { { 0, 2 } },
5623         },
5624         {
5625                 "ALU_SUB_K: 3 - 0 = 3",
5626                 .u.insns_int = {
5627                         BPF_LD_IMM64(R0, 3),
5628                         BPF_ALU32_IMM(BPF_SUB, R0, 0),
5629                         BPF_EXIT_INSN(),
5630                 },
5631                 INTERNAL,
5632                 { },
5633                 { { 0, 3 } },
5634         },
5635         {
5636                 "ALU_SUB_K: 4294967295 - 4294967294 = 1",
5637                 .u.insns_int = {
5638                         BPF_LD_IMM64(R0, 4294967295U),
5639                         BPF_ALU32_IMM(BPF_SUB, R0, 4294967294U),
5640                         BPF_EXIT_INSN(),
5641                 },
5642                 INTERNAL,
5643                 { },
5644                 { { 0, 1 } },
5645         },
5646         {
5647                 "ALU64_SUB_K: 3 - 1 = 2",
5648                 .u.insns_int = {
5649                         BPF_LD_IMM64(R0, 3),
5650                         BPF_ALU64_IMM(BPF_SUB, R0, 1),
5651                         BPF_EXIT_INSN(),
5652                 },
5653                 INTERNAL,
5654                 { },
5655                 { { 0, 2 } },
5656         },
5657         {
5658                 "ALU64_SUB_K: 3 - 0 = 3",
5659                 .u.insns_int = {
5660                         BPF_LD_IMM64(R0, 3),
5661                         BPF_ALU64_IMM(BPF_SUB, R0, 0),
5662                         BPF_EXIT_INSN(),
5663                 },
5664                 INTERNAL,
5665                 { },
5666                 { { 0, 3 } },
5667         },
5668         {
5669                 "ALU64_SUB_K: 4294967294 - 4294967295 = -1",
5670                 .u.insns_int = {
5671                         BPF_LD_IMM64(R0, 4294967294U),
5672                         BPF_ALU64_IMM(BPF_SUB, R0, 4294967295U),
5673                         BPF_EXIT_INSN(),
5674                 },
5675                 INTERNAL,
5676                 { },
5677                 { { 0, -1 } },
5678         },
5679         {
5680                 "ALU64_ADD_K: 2147483646 - 2147483647 = -1",
5681                 .u.insns_int = {
5682                         BPF_LD_IMM64(R0, 2147483646),
5683                         BPF_ALU64_IMM(BPF_SUB, R0, 2147483647),
5684                         BPF_EXIT_INSN(),
5685                 },
5686                 INTERNAL,
5687                 { },
5688                 { { 0, -1 } },
5689         },
5690         /* BPF_ALU | BPF_MUL | BPF_X */
5691         {
5692                 "ALU_MUL_X: 2 * 3 = 6",
5693                 .u.insns_int = {
5694                         BPF_LD_IMM64(R0, 2),
5695                         BPF_ALU32_IMM(BPF_MOV, R1, 3),
5696                         BPF_ALU32_REG(BPF_MUL, R0, R1),
5697                         BPF_EXIT_INSN(),
5698                 },
5699                 INTERNAL,
5700                 { },
5701                 { { 0, 6 } },
5702         },
5703         {
5704                 "ALU_MUL_X: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
5705                 .u.insns_int = {
5706                         BPF_LD_IMM64(R0, 2),
5707                         BPF_ALU32_IMM(BPF_MOV, R1, 0x7FFFFFF8),
5708                         BPF_ALU32_REG(BPF_MUL, R0, R1),
5709                         BPF_EXIT_INSN(),
5710                 },
5711                 INTERNAL,
5712                 { },
5713                 { { 0, 0xFFFFFFF0 } },
5714         },
5715         {
5716                 "ALU_MUL_X: -1 * -1 = 1",
5717                 .u.insns_int = {
5718                         BPF_LD_IMM64(R0, -1),
5719                         BPF_ALU32_IMM(BPF_MOV, R1, -1),
5720                         BPF_ALU32_REG(BPF_MUL, R0, R1),
5721                         BPF_EXIT_INSN(),
5722                 },
5723                 INTERNAL,
5724                 { },
5725                 { { 0, 1 } },
5726         },
5727         {
5728                 "ALU64_MUL_X: 2 * 3 = 6",
5729                 .u.insns_int = {
5730                         BPF_LD_IMM64(R0, 2),
5731                         BPF_ALU32_IMM(BPF_MOV, R1, 3),
5732                         BPF_ALU64_REG(BPF_MUL, R0, R1),
5733                         BPF_EXIT_INSN(),
5734                 },
5735                 INTERNAL,
5736                 { },
5737                 { { 0, 6 } },
5738         },
5739         {
5740                 "ALU64_MUL_X: 1 * 2147483647 = 2147483647",
5741                 .u.insns_int = {
5742                         BPF_LD_IMM64(R0, 1),
5743                         BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
5744                         BPF_ALU64_REG(BPF_MUL, R0, R1),
5745                         BPF_EXIT_INSN(),
5746                 },
5747                 INTERNAL,
5748                 { },
5749                 { { 0, 2147483647 } },
5750         },
5751         {
5752                 "ALU64_MUL_X: 64x64 multiply, low word",
5753                 .u.insns_int = {
5754                         BPF_LD_IMM64(R0, 0x0fedcba987654321LL),
5755                         BPF_LD_IMM64(R1, 0x123456789abcdef0LL),
5756                         BPF_ALU64_REG(BPF_MUL, R0, R1),
5757                         BPF_EXIT_INSN(),
5758                 },
5759                 INTERNAL,
5760                 { },
5761                 { { 0, 0xe5618cf0 } }
5762         },
5763         {
5764                 "ALU64_MUL_X: 64x64 multiply, high word",
5765                 .u.insns_int = {
5766                         BPF_LD_IMM64(R0, 0x0fedcba987654321LL),
5767                         BPF_LD_IMM64(R1, 0x123456789abcdef0LL),
5768                         BPF_ALU64_REG(BPF_MUL, R0, R1),
5769                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
5770                         BPF_EXIT_INSN(),
5771                 },
5772                 INTERNAL,
5773                 { },
5774                 { { 0, 0x2236d88f } }
5775         },
5776         /* BPF_ALU | BPF_MUL | BPF_K */
5777         {
5778                 "ALU_MUL_K: 2 * 3 = 6",
5779                 .u.insns_int = {
5780                         BPF_LD_IMM64(R0, 2),
5781                         BPF_ALU32_IMM(BPF_MUL, R0, 3),
5782                         BPF_EXIT_INSN(),
5783                 },
5784                 INTERNAL,
5785                 { },
5786                 { { 0, 6 } },
5787         },
5788         {
5789                 "ALU_MUL_K: 3 * 1 = 3",
5790                 .u.insns_int = {
5791                         BPF_LD_IMM64(R0, 3),
5792                         BPF_ALU32_IMM(BPF_MUL, R0, 1),
5793                         BPF_EXIT_INSN(),
5794                 },
5795                 INTERNAL,
5796                 { },
5797                 { { 0, 3 } },
5798         },
5799         {
5800                 "ALU_MUL_K: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
5801                 .u.insns_int = {
5802                         BPF_LD_IMM64(R0, 2),
5803                         BPF_ALU32_IMM(BPF_MUL, R0, 0x7FFFFFF8),
5804                         BPF_EXIT_INSN(),
5805                 },
5806                 INTERNAL,
5807                 { },
5808                 { { 0, 0xFFFFFFF0 } },
5809         },
5810         {
5811                 "ALU_MUL_K: 1 * (-1) = 0x00000000ffffffff",
5812                 .u.insns_int = {
5813                         BPF_LD_IMM64(R2, 0x1),
5814                         BPF_LD_IMM64(R3, 0x00000000ffffffff),
5815                         BPF_ALU32_IMM(BPF_MUL, R2, 0xffffffff),
5816                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5817                         BPF_MOV32_IMM(R0, 2),
5818                         BPF_EXIT_INSN(),
5819                         BPF_MOV32_IMM(R0, 1),
5820                         BPF_EXIT_INSN(),
5821                 },
5822                 INTERNAL,
5823                 { },
5824                 { { 0, 0x1 } },
5825         },
5826         {
5827                 "ALU64_MUL_K: 2 * 3 = 6",
5828                 .u.insns_int = {
5829                         BPF_LD_IMM64(R0, 2),
5830                         BPF_ALU64_IMM(BPF_MUL, R0, 3),
5831                         BPF_EXIT_INSN(),
5832                 },
5833                 INTERNAL,
5834                 { },
5835                 { { 0, 6 } },
5836         },
5837         {
5838                 "ALU64_MUL_K: 3 * 1 = 3",
5839                 .u.insns_int = {
5840                         BPF_LD_IMM64(R0, 3),
5841                         BPF_ALU64_IMM(BPF_MUL, R0, 1),
5842                         BPF_EXIT_INSN(),
5843                 },
5844                 INTERNAL,
5845                 { },
5846                 { { 0, 3 } },
5847         },
5848         {
5849                 "ALU64_MUL_K: 1 * 2147483647 = 2147483647",
5850                 .u.insns_int = {
5851                         BPF_LD_IMM64(R0, 1),
5852                         BPF_ALU64_IMM(BPF_MUL, R0, 2147483647),
5853                         BPF_EXIT_INSN(),
5854                 },
5855                 INTERNAL,
5856                 { },
5857                 { { 0, 2147483647 } },
5858         },
5859         {
5860                 "ALU64_MUL_K: 1 * -2147483647 = -2147483647",
5861                 .u.insns_int = {
5862                         BPF_LD_IMM64(R0, 1),
5863                         BPF_ALU64_IMM(BPF_MUL, R0, -2147483647),
5864                         BPF_EXIT_INSN(),
5865                 },
5866                 INTERNAL,
5867                 { },
5868                 { { 0, -2147483647 } },
5869         },
5870         {
5871                 "ALU64_MUL_K: 1 * (-1) = 0xffffffffffffffff",
5872                 .u.insns_int = {
5873                         BPF_LD_IMM64(R2, 0x1),
5874                         BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
5875                         BPF_ALU64_IMM(BPF_MUL, R2, 0xffffffff),
5876                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5877                         BPF_MOV32_IMM(R0, 2),
5878                         BPF_EXIT_INSN(),
5879                         BPF_MOV32_IMM(R0, 1),
5880                         BPF_EXIT_INSN(),
5881                 },
5882                 INTERNAL,
5883                 { },
5884                 { { 0, 0x1 } },
5885         },
5886         {
5887                 "ALU64_MUL_K: 64x32 multiply, low word",
5888                 .u.insns_int = {
5889                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5890                         BPF_ALU64_IMM(BPF_MUL, R0, 0x12345678),
5891                         BPF_EXIT_INSN(),
5892                 },
5893                 INTERNAL,
5894                 { },
5895                 { { 0, 0xe242d208 } }
5896         },
5897         {
5898                 "ALU64_MUL_K: 64x32 multiply, high word",
5899                 .u.insns_int = {
5900                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5901                         BPF_ALU64_IMM(BPF_MUL, R0, 0x12345678),
5902                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
5903                         BPF_EXIT_INSN(),
5904                 },
5905                 INTERNAL,
5906                 { },
5907                 { { 0, 0xc28f5c28 } }
5908         },
5909         /* BPF_ALU | BPF_DIV | BPF_X */
5910         {
5911                 "ALU_DIV_X: 6 / 2 = 3",
5912                 .u.insns_int = {
5913                         BPF_LD_IMM64(R0, 6),
5914                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
5915                         BPF_ALU32_REG(BPF_DIV, R0, R1),
5916                         BPF_EXIT_INSN(),
5917                 },
5918                 INTERNAL,
5919                 { },
5920                 { { 0, 3 } },
5921         },
5922         {
5923                 "ALU_DIV_X: 4294967295 / 4294967295 = 1",
5924                 .u.insns_int = {
5925                         BPF_LD_IMM64(R0, 4294967295U),
5926                         BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
5927                         BPF_ALU32_REG(BPF_DIV, R0, R1),
5928                         BPF_EXIT_INSN(),
5929                 },
5930                 INTERNAL,
5931                 { },
5932                 { { 0, 1 } },
5933         },
5934         {
5935                 "ALU64_DIV_X: 6 / 2 = 3",
5936                 .u.insns_int = {
5937                         BPF_LD_IMM64(R0, 6),
5938                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
5939                         BPF_ALU64_REG(BPF_DIV, R0, R1),
5940                         BPF_EXIT_INSN(),
5941                 },
5942                 INTERNAL,
5943                 { },
5944                 { { 0, 3 } },
5945         },
5946         {
5947                 "ALU64_DIV_X: 2147483647 / 2147483647 = 1",
5948                 .u.insns_int = {
5949                         BPF_LD_IMM64(R0, 2147483647),
5950                         BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
5951                         BPF_ALU64_REG(BPF_DIV, R0, R1),
5952                         BPF_EXIT_INSN(),
5953                 },
5954                 INTERNAL,
5955                 { },
5956                 { { 0, 1 } },
5957         },
5958         {
5959                 "ALU64_DIV_X: 0xffffffffffffffff / (-1) = 0x0000000000000001",
5960                 .u.insns_int = {
5961                         BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
5962                         BPF_LD_IMM64(R4, 0xffffffffffffffffLL),
5963                         BPF_LD_IMM64(R3, 0x0000000000000001LL),
5964                         BPF_ALU64_REG(BPF_DIV, R2, R4),
5965                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5966                         BPF_MOV32_IMM(R0, 2),
5967                         BPF_EXIT_INSN(),
5968                         BPF_MOV32_IMM(R0, 1),
5969                         BPF_EXIT_INSN(),
5970                 },
5971                 INTERNAL,
5972                 { },
5973                 { { 0, 0x1 } },
5974         },
5975         /* BPF_ALU | BPF_DIV | BPF_K */
5976         {
5977                 "ALU_DIV_K: 6 / 2 = 3",
5978                 .u.insns_int = {
5979                         BPF_LD_IMM64(R0, 6),
5980                         BPF_ALU32_IMM(BPF_DIV, R0, 2),
5981                         BPF_EXIT_INSN(),
5982                 },
5983                 INTERNAL,
5984                 { },
5985                 { { 0, 3 } },
5986         },
5987         {
5988                 "ALU_DIV_K: 3 / 1 = 3",
5989                 .u.insns_int = {
5990                         BPF_LD_IMM64(R0, 3),
5991                         BPF_ALU32_IMM(BPF_DIV, R0, 1),
5992                         BPF_EXIT_INSN(),
5993                 },
5994                 INTERNAL,
5995                 { },
5996                 { { 0, 3 } },
5997         },
5998         {
5999                 "ALU_DIV_K: 4294967295 / 4294967295 = 1",
6000                 .u.insns_int = {
6001                         BPF_LD_IMM64(R0, 4294967295U),
6002                         BPF_ALU32_IMM(BPF_DIV, R0, 4294967295U),
6003                         BPF_EXIT_INSN(),
6004                 },
6005                 INTERNAL,
6006                 { },
6007                 { { 0, 1 } },
6008         },
6009         {
6010                 "ALU_DIV_K: 0xffffffffffffffff / (-1) = 0x1",
6011                 .u.insns_int = {
6012                         BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
6013                         BPF_LD_IMM64(R3, 0x1UL),
6014                         BPF_ALU32_IMM(BPF_DIV, R2, 0xffffffff),
6015                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6016                         BPF_MOV32_IMM(R0, 2),
6017                         BPF_EXIT_INSN(),
6018                         BPF_MOV32_IMM(R0, 1),
6019                         BPF_EXIT_INSN(),
6020                 },
6021                 INTERNAL,
6022                 { },
6023                 { { 0, 0x1 } },
6024         },
6025         {
6026                 "ALU64_DIV_K: 6 / 2 = 3",
6027                 .u.insns_int = {
6028                         BPF_LD_IMM64(R0, 6),
6029                         BPF_ALU64_IMM(BPF_DIV, R0, 2),
6030                         BPF_EXIT_INSN(),
6031                 },
6032                 INTERNAL,
6033                 { },
6034                 { { 0, 3 } },
6035         },
6036         {
6037                 "ALU64_DIV_K: 3 / 1 = 3",
6038                 .u.insns_int = {
6039                         BPF_LD_IMM64(R0, 3),
6040                         BPF_ALU64_IMM(BPF_DIV, R0, 1),
6041                         BPF_EXIT_INSN(),
6042                 },
6043                 INTERNAL,
6044                 { },
6045                 { { 0, 3 } },
6046         },
6047         {
6048                 "ALU64_DIV_K: 2147483647 / 2147483647 = 1",
6049                 .u.insns_int = {
6050                         BPF_LD_IMM64(R0, 2147483647),
6051                         BPF_ALU64_IMM(BPF_DIV, R0, 2147483647),
6052                         BPF_EXIT_INSN(),
6053                 },
6054                 INTERNAL,
6055                 { },
6056                 { { 0, 1 } },
6057         },
6058         {
6059                 "ALU64_DIV_K: 0xffffffffffffffff / (-1) = 0x0000000000000001",
6060                 .u.insns_int = {
6061                         BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
6062                         BPF_LD_IMM64(R3, 0x0000000000000001LL),
6063                         BPF_ALU64_IMM(BPF_DIV, R2, 0xffffffff),
6064                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6065                         BPF_MOV32_IMM(R0, 2),
6066                         BPF_EXIT_INSN(),
6067                         BPF_MOV32_IMM(R0, 1),
6068                         BPF_EXIT_INSN(),
6069                 },
6070                 INTERNAL,
6071                 { },
6072                 { { 0, 0x1 } },
6073         },
6074         /* BPF_ALU | BPF_MOD | BPF_X */
6075         {
6076                 "ALU_MOD_X: 3 % 2 = 1",
6077                 .u.insns_int = {
6078                         BPF_LD_IMM64(R0, 3),
6079                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
6080                         BPF_ALU32_REG(BPF_MOD, R0, R1),
6081                         BPF_EXIT_INSN(),
6082                 },
6083                 INTERNAL,
6084                 { },
6085                 { { 0, 1 } },
6086         },
6087         {
6088                 "ALU_MOD_X: 4294967295 % 4294967293 = 2",
6089                 .u.insns_int = {
6090                         BPF_LD_IMM64(R0, 4294967295U),
6091                         BPF_ALU32_IMM(BPF_MOV, R1, 4294967293U),
6092                         BPF_ALU32_REG(BPF_MOD, R0, R1),
6093                         BPF_EXIT_INSN(),
6094                 },
6095                 INTERNAL,
6096                 { },
6097                 { { 0, 2 } },
6098         },
6099         {
6100                 "ALU64_MOD_X: 3 % 2 = 1",
6101                 .u.insns_int = {
6102                         BPF_LD_IMM64(R0, 3),
6103                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
6104                         BPF_ALU64_REG(BPF_MOD, R0, R1),
6105                         BPF_EXIT_INSN(),
6106                 },
6107                 INTERNAL,
6108                 { },
6109                 { { 0, 1 } },
6110         },
6111         {
6112                 "ALU64_MOD_X: 2147483647 % 2147483645 = 2",
6113                 .u.insns_int = {
6114                         BPF_LD_IMM64(R0, 2147483647),
6115                         BPF_ALU32_IMM(BPF_MOV, R1, 2147483645),
6116                         BPF_ALU64_REG(BPF_MOD, R0, R1),
6117                         BPF_EXIT_INSN(),
6118                 },
6119                 INTERNAL,
6120                 { },
6121                 { { 0, 2 } },
6122         },
6123         /* BPF_ALU | BPF_MOD | BPF_K */
6124         {
6125                 "ALU_MOD_K: 3 % 2 = 1",
6126                 .u.insns_int = {
6127                         BPF_LD_IMM64(R0, 3),
6128                         BPF_ALU32_IMM(BPF_MOD, R0, 2),
6129                         BPF_EXIT_INSN(),
6130                 },
6131                 INTERNAL,
6132                 { },
6133                 { { 0, 1 } },
6134         },
6135         {
6136                 "ALU_MOD_K: 3 % 1 = 0",
6137                 .u.insns_int = {
6138                         BPF_LD_IMM64(R0, 3),
6139                         BPF_ALU32_IMM(BPF_MOD, R0, 1),
6140                         BPF_EXIT_INSN(),
6141                 },
6142                 INTERNAL,
6143                 { },
6144                 { { 0, 0 } },
6145         },
6146         {
6147                 "ALU_MOD_K: 4294967295 % 4294967293 = 2",
6148                 .u.insns_int = {
6149                         BPF_LD_IMM64(R0, 4294967295U),
6150                         BPF_ALU32_IMM(BPF_MOD, R0, 4294967293U),
6151                         BPF_EXIT_INSN(),
6152                 },
6153                 INTERNAL,
6154                 { },
6155                 { { 0, 2 } },
6156         },
6157         {
6158                 "ALU64_MOD_K: 3 % 2 = 1",
6159                 .u.insns_int = {
6160                         BPF_LD_IMM64(R0, 3),
6161                         BPF_ALU64_IMM(BPF_MOD, R0, 2),
6162                         BPF_EXIT_INSN(),
6163                 },
6164                 INTERNAL,
6165                 { },
6166                 { { 0, 1 } },
6167         },
6168         {
6169                 "ALU64_MOD_K: 3 % 1 = 0",
6170                 .u.insns_int = {
6171                         BPF_LD_IMM64(R0, 3),
6172                         BPF_ALU64_IMM(BPF_MOD, R0, 1),
6173                         BPF_EXIT_INSN(),
6174                 },
6175                 INTERNAL,
6176                 { },
6177                 { { 0, 0 } },
6178         },
6179         {
6180                 "ALU64_MOD_K: 2147483647 % 2147483645 = 2",
6181                 .u.insns_int = {
6182                         BPF_LD_IMM64(R0, 2147483647),
6183                         BPF_ALU64_IMM(BPF_MOD, R0, 2147483645),
6184                         BPF_EXIT_INSN(),
6185                 },
6186                 INTERNAL,
6187                 { },
6188                 { { 0, 2 } },
6189         },
6190         /* BPF_ALU | BPF_DIV | BPF_X off=1 (SDIV) */
6191         {
6192                 "ALU_SDIV_X: -6 / 2 = -3",
6193                 .u.insns_int = {
6194                         BPF_LD_IMM64(R0, -6),
6195                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
6196                         BPF_ALU32_REG_OFF(BPF_DIV, R0, R1, 1),
6197                         BPF_EXIT_INSN(),
6198                 },
6199                 INTERNAL,
6200                 { },
6201                 { { 0, -3 } },
6202         },
6203         /* BPF_ALU | BPF_DIV | BPF_K off=1 (SDIV) */
6204         {
6205                 "ALU_SDIV_K: -6 / 2 = -3",
6206                 .u.insns_int = {
6207                         BPF_LD_IMM64(R0, -6),
6208                         BPF_ALU32_IMM_OFF(BPF_DIV, R0, 2, 1),
6209                         BPF_EXIT_INSN(),
6210                 },
6211                 INTERNAL,
6212                 { },
6213                 { { 0, -3 } },
6214         },
6215         /* BPF_ALU64 | BPF_DIV | BPF_X off=1 (SDIV64) */
6216         {
6217                 "ALU64_SDIV_X: -6 / 2 = -3",
6218                 .u.insns_int = {
6219                         BPF_LD_IMM64(R0, -6),
6220                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
6221                         BPF_ALU64_REG_OFF(BPF_DIV, R0, R1, 1),
6222                         BPF_EXIT_INSN(),
6223                 },
6224                 INTERNAL,
6225                 { },
6226                 { { 0, -3 } },
6227         },
6228         /* BPF_ALU64 | BPF_DIV | BPF_K off=1 (SDIV64) */
6229         {
6230                 "ALU64_SDIV_K: -6 / 2 = -3",
6231                 .u.insns_int = {
6232                         BPF_LD_IMM64(R0, -6),
6233                         BPF_ALU64_IMM_OFF(BPF_DIV, R0, 2, 1),
6234                         BPF_EXIT_INSN(),
6235                 },
6236                 INTERNAL,
6237                 { },
6238                 { { 0, -3 } },
6239         },
6240         /* BPF_ALU | BPF_MOD | BPF_X off=1 (SMOD) */
6241         {
6242                 "ALU_SMOD_X: -7 % 2 = -1",
6243                 .u.insns_int = {
6244                         BPF_LD_IMM64(R0, -7),
6245                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
6246                         BPF_ALU32_REG_OFF(BPF_MOD, R0, R1, 1),
6247                         BPF_EXIT_INSN(),
6248                 },
6249                 INTERNAL,
6250                 { },
6251                 { { 0, -1 } },
6252         },
6253         /* BPF_ALU | BPF_MOD | BPF_K off=1 (SMOD) */
6254         {
6255                 "ALU_SMOD_K: -7 % 2 = -1",
6256                 .u.insns_int = {
6257                         BPF_LD_IMM64(R0, -7),
6258                         BPF_ALU32_IMM_OFF(BPF_MOD, R0, 2, 1),
6259                         BPF_EXIT_INSN(),
6260                 },
6261                 INTERNAL,
6262                 { },
6263                 { { 0, -1 } },
6264         },
6265         /* BPF_ALU64 | BPF_MOD | BPF_X off=1 (SMOD64) */
6266         {
6267                 "ALU64_SMOD_X: -7 % 2 = -1",
6268                 .u.insns_int = {
6269                         BPF_LD_IMM64(R0, -7),
6270                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
6271                         BPF_ALU64_REG_OFF(BPF_MOD, R0, R1, 1),
6272                         BPF_EXIT_INSN(),
6273                 },
6274                 INTERNAL,
6275                 { },
6276                 { { 0, -1 } },
6277         },
6278         /* BPF_ALU64 | BPF_MOD | BPF_K off=1 (SMOD64) */
6279         {
6280                 "ALU64_SMOD_K: -7 % 2 = -1",
6281                 .u.insns_int = {
6282                         BPF_LD_IMM64(R0, -7),
6283                         BPF_ALU64_IMM_OFF(BPF_MOD, R0, 2, 1),
6284                         BPF_EXIT_INSN(),
6285                 },
6286                 INTERNAL,
6287                 { },
6288                 { { 0, -1 } },
6289         },
6290         /* BPF_ALU | BPF_AND | BPF_X */
6291         {
6292                 "ALU_AND_X: 3 & 2 = 2",
6293                 .u.insns_int = {
6294                         BPF_LD_IMM64(R0, 3),
6295                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
6296                         BPF_ALU32_REG(BPF_AND, R0, R1),
6297                         BPF_EXIT_INSN(),
6298                 },
6299                 INTERNAL,
6300                 { },
6301                 { { 0, 2 } },
6302         },
6303         {
6304                 "ALU_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
6305                 .u.insns_int = {
6306                         BPF_LD_IMM64(R0, 0xffffffff),
6307                         BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6308                         BPF_ALU32_REG(BPF_AND, R0, R1),
6309                         BPF_EXIT_INSN(),
6310                 },
6311                 INTERNAL,
6312                 { },
6313                 { { 0, 0xffffffff } },
6314         },
6315         {
6316                 "ALU64_AND_X: 3 & 2 = 2",
6317                 .u.insns_int = {
6318                         BPF_LD_IMM64(R0, 3),
6319                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
6320                         BPF_ALU64_REG(BPF_AND, R0, R1),
6321                         BPF_EXIT_INSN(),
6322                 },
6323                 INTERNAL,
6324                 { },
6325                 { { 0, 2 } },
6326         },
6327         {
6328                 "ALU64_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
6329                 .u.insns_int = {
6330                         BPF_LD_IMM64(R0, 0xffffffff),
6331                         BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6332                         BPF_ALU64_REG(BPF_AND, R0, R1),
6333                         BPF_EXIT_INSN(),
6334                 },
6335                 INTERNAL,
6336                 { },
6337                 { { 0, 0xffffffff } },
6338         },
6339         /* BPF_ALU | BPF_AND | BPF_K */
6340         {
6341                 "ALU_AND_K: 3 & 2 = 2",
6342                 .u.insns_int = {
6343                         BPF_LD_IMM64(R0, 3),
6344                         BPF_ALU32_IMM(BPF_AND, R0, 2),
6345                         BPF_EXIT_INSN(),
6346                 },
6347                 INTERNAL,
6348                 { },
6349                 { { 0, 2 } },
6350         },
6351         {
6352                 "ALU_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
6353                 .u.insns_int = {
6354                         BPF_LD_IMM64(R0, 0xffffffff),
6355                         BPF_ALU32_IMM(BPF_AND, R0, 0xffffffff),
6356                         BPF_EXIT_INSN(),
6357                 },
6358                 INTERNAL,
6359                 { },
6360                 { { 0, 0xffffffff } },
6361         },
6362         {
6363                 "ALU_AND_K: Small immediate",
6364                 .u.insns_int = {
6365                         BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
6366                         BPF_ALU32_IMM(BPF_AND, R0, 15),
6367                         BPF_EXIT_INSN(),
6368                 },
6369                 INTERNAL,
6370                 { },
6371                 { { 0, 4 } }
6372         },
6373         {
6374                 "ALU_AND_K: Large immediate",
6375                 .u.insns_int = {
6376                         BPF_ALU32_IMM(BPF_MOV, R0, 0xf1f2f3f4),
6377                         BPF_ALU32_IMM(BPF_AND, R0, 0xafbfcfdf),
6378                         BPF_EXIT_INSN(),
6379                 },
6380                 INTERNAL,
6381                 { },
6382                 { { 0, 0xa1b2c3d4 } }
6383         },
6384         {
6385                 "ALU_AND_K: Zero extension",
6386                 .u.insns_int = {
6387                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6388                         BPF_LD_IMM64(R1, 0x0000000080a0c0e0LL),
6389                         BPF_ALU32_IMM(BPF_AND, R0, 0xf0f0f0f0),
6390                         BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6391                         BPF_MOV32_IMM(R0, 2),
6392                         BPF_EXIT_INSN(),
6393                         BPF_MOV32_IMM(R0, 1),
6394                         BPF_EXIT_INSN(),
6395                 },
6396                 INTERNAL,
6397                 { },
6398                 { { 0, 1 } }
6399         },
6400         {
6401                 "ALU64_AND_K: 3 & 2 = 2",
6402                 .u.insns_int = {
6403                         BPF_LD_IMM64(R0, 3),
6404                         BPF_ALU64_IMM(BPF_AND, R0, 2),
6405                         BPF_EXIT_INSN(),
6406                 },
6407                 INTERNAL,
6408                 { },
6409                 { { 0, 2 } },
6410         },
6411         {
6412                 "ALU64_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
6413                 .u.insns_int = {
6414                         BPF_LD_IMM64(R0, 0xffffffff),
6415                         BPF_ALU64_IMM(BPF_AND, R0, 0xffffffff),
6416                         BPF_EXIT_INSN(),
6417                 },
6418                 INTERNAL,
6419                 { },
6420                 { { 0, 0xffffffff } },
6421         },
6422         {
6423                 "ALU64_AND_K: 0x0000ffffffff0000 & 0x0 = 0x0000000000000000",
6424                 .u.insns_int = {
6425                         BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6426                         BPF_LD_IMM64(R3, 0x0000000000000000LL),
6427                         BPF_ALU64_IMM(BPF_AND, R2, 0x0),
6428                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6429                         BPF_MOV32_IMM(R0, 2),
6430                         BPF_EXIT_INSN(),
6431                         BPF_MOV32_IMM(R0, 1),
6432                         BPF_EXIT_INSN(),
6433                 },
6434                 INTERNAL,
6435                 { },
6436                 { { 0, 0x1 } },
6437         },
6438         {
6439                 "ALU64_AND_K: 0x0000ffffffff0000 & -1 = 0x0000ffffffff0000",
6440                 .u.insns_int = {
6441                         BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6442                         BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
6443                         BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
6444                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6445                         BPF_MOV32_IMM(R0, 2),
6446                         BPF_EXIT_INSN(),
6447                         BPF_MOV32_IMM(R0, 1),
6448                         BPF_EXIT_INSN(),
6449                 },
6450                 INTERNAL,
6451                 { },
6452                 { { 0, 0x1 } },
6453         },
6454         {
6455                 "ALU64_AND_K: 0xffffffffffffffff & -1 = 0xffffffffffffffff",
6456                 .u.insns_int = {
6457                         BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
6458                         BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
6459                         BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
6460                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6461                         BPF_MOV32_IMM(R0, 2),
6462                         BPF_EXIT_INSN(),
6463                         BPF_MOV32_IMM(R0, 1),
6464                         BPF_EXIT_INSN(),
6465                 },
6466                 INTERNAL,
6467                 { },
6468                 { { 0, 0x1 } },
6469         },
6470         {
6471                 "ALU64_AND_K: Sign extension 1",
6472                 .u.insns_int = {
6473                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6474                         BPF_LD_IMM64(R1, 0x00000000090b0d0fLL),
6475                         BPF_ALU64_IMM(BPF_AND, R0, 0x0f0f0f0f),
6476                         BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6477                         BPF_MOV32_IMM(R0, 2),
6478                         BPF_EXIT_INSN(),
6479                         BPF_MOV32_IMM(R0, 1),
6480                         BPF_EXIT_INSN(),
6481                 },
6482                 INTERNAL,
6483                 { },
6484                 { { 0, 1 } }
6485         },
6486         {
6487                 "ALU64_AND_K: Sign extension 2",
6488                 .u.insns_int = {
6489                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6490                         BPF_LD_IMM64(R1, 0x0123456780a0c0e0LL),
6491                         BPF_ALU64_IMM(BPF_AND, R0, 0xf0f0f0f0),
6492                         BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6493                         BPF_MOV32_IMM(R0, 2),
6494                         BPF_EXIT_INSN(),
6495                         BPF_MOV32_IMM(R0, 1),
6496                         BPF_EXIT_INSN(),
6497                 },
6498                 INTERNAL,
6499                 { },
6500                 { { 0, 1 } }
6501         },
6502         /* BPF_ALU | BPF_OR | BPF_X */
6503         {
6504                 "ALU_OR_X: 1 | 2 = 3",
6505                 .u.insns_int = {
6506                         BPF_LD_IMM64(R0, 1),
6507                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
6508                         BPF_ALU32_REG(BPF_OR, R0, R1),
6509                         BPF_EXIT_INSN(),
6510                 },
6511                 INTERNAL,
6512                 { },
6513                 { { 0, 3 } },
6514         },
6515         {
6516                 "ALU_OR_X: 0x0 | 0xffffffff = 0xffffffff",
6517                 .u.insns_int = {
6518                         BPF_LD_IMM64(R0, 0),
6519                         BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6520                         BPF_ALU32_REG(BPF_OR, R0, R1),
6521                         BPF_EXIT_INSN(),
6522                 },
6523                 INTERNAL,
6524                 { },
6525                 { { 0, 0xffffffff } },
6526         },
6527         {
6528                 "ALU64_OR_X: 1 | 2 = 3",
6529                 .u.insns_int = {
6530                         BPF_LD_IMM64(R0, 1),
6531                         BPF_ALU32_IMM(BPF_MOV, R1, 2),
6532                         BPF_ALU64_REG(BPF_OR, R0, R1),
6533                         BPF_EXIT_INSN(),
6534                 },
6535                 INTERNAL,
6536                 { },
6537                 { { 0, 3 } },
6538         },
6539         {
6540                 "ALU64_OR_X: 0 | 0xffffffff = 0xffffffff",
6541                 .u.insns_int = {
6542                         BPF_LD_IMM64(R0, 0),
6543                         BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6544                         BPF_ALU64_REG(BPF_OR, R0, R1),
6545                         BPF_EXIT_INSN(),
6546                 },
6547                 INTERNAL,
6548                 { },
6549                 { { 0, 0xffffffff } },
6550         },
6551         /* BPF_ALU | BPF_OR | BPF_K */
6552         {
6553                 "ALU_OR_K: 1 | 2 = 3",
6554                 .u.insns_int = {
6555                         BPF_LD_IMM64(R0, 1),
6556                         BPF_ALU32_IMM(BPF_OR, R0, 2),
6557                         BPF_EXIT_INSN(),
6558                 },
6559                 INTERNAL,
6560                 { },
6561                 { { 0, 3 } },
6562         },
6563         {
6564                 "ALU_OR_K: 0 & 0xffffffff = 0xffffffff",
6565                 .u.insns_int = {
6566                         BPF_LD_IMM64(R0, 0),
6567                         BPF_ALU32_IMM(BPF_OR, R0, 0xffffffff),
6568                         BPF_EXIT_INSN(),
6569                 },
6570                 INTERNAL,
6571                 { },
6572                 { { 0, 0xffffffff } },
6573         },
6574         {
6575                 "ALU_OR_K: Small immediate",
6576                 .u.insns_int = {
6577                         BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
6578                         BPF_ALU32_IMM(BPF_OR, R0, 1),
6579                         BPF_EXIT_INSN(),
6580                 },
6581                 INTERNAL,
6582                 { },
6583                 { { 0, 0x01020305 } }
6584         },
6585         {
6586                 "ALU_OR_K: Large immediate",
6587                 .u.insns_int = {
6588                         BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
6589                         BPF_ALU32_IMM(BPF_OR, R0, 0xa0b0c0d0),
6590                         BPF_EXIT_INSN(),
6591                 },
6592                 INTERNAL,
6593                 { },
6594                 { { 0, 0xa1b2c3d4 } }
6595         },
6596         {
6597                 "ALU_OR_K: Zero extension",
6598                 .u.insns_int = {
6599                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6600                         BPF_LD_IMM64(R1, 0x00000000f9fbfdffLL),
6601                         BPF_ALU32_IMM(BPF_OR, R0, 0xf0f0f0f0),
6602                         BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6603                         BPF_MOV32_IMM(R0, 2),
6604                         BPF_EXIT_INSN(),
6605                         BPF_MOV32_IMM(R0, 1),
6606                         BPF_EXIT_INSN(),
6607                 },
6608                 INTERNAL,
6609                 { },
6610                 { { 0, 1 } }
6611         },
6612         {
6613                 "ALU64_OR_K: 1 | 2 = 3",
6614                 .u.insns_int = {
6615                         BPF_LD_IMM64(R0, 1),
6616                         BPF_ALU64_IMM(BPF_OR, R0, 2),
6617                         BPF_EXIT_INSN(),
6618                 },
6619                 INTERNAL,
6620                 { },
6621                 { { 0, 3 } },
6622         },
6623         {
6624                 "ALU64_OR_K: 0 & 0xffffffff = 0xffffffff",
6625                 .u.insns_int = {
6626                         BPF_LD_IMM64(R0, 0),
6627                         BPF_ALU64_IMM(BPF_OR, R0, 0xffffffff),
6628                         BPF_EXIT_INSN(),
6629                 },
6630                 INTERNAL,
6631                 { },
6632                 { { 0, 0xffffffff } },
6633         },
6634         {
6635                 "ALU64_OR_K: 0x0000ffffffff0000 | 0x0 = 0x0000ffffffff0000",
6636                 .u.insns_int = {
6637                         BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6638                         BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
6639                         BPF_ALU64_IMM(BPF_OR, R2, 0x0),
6640                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6641                         BPF_MOV32_IMM(R0, 2),
6642                         BPF_EXIT_INSN(),
6643                         BPF_MOV32_IMM(R0, 1),
6644                         BPF_EXIT_INSN(),
6645                 },
6646                 INTERNAL,
6647                 { },
6648                 { { 0, 0x1 } },
6649         },
6650         {
6651                 "ALU64_OR_K: 0x0000ffffffff0000 | -1 = 0xffffffffffffffff",
6652                 .u.insns_int = {
6653                         BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6654                         BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
6655                         BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
6656                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6657                         BPF_MOV32_IMM(R0, 2),
6658                         BPF_EXIT_INSN(),
6659                         BPF_MOV32_IMM(R0, 1),
6660                         BPF_EXIT_INSN(),
6661                 },
6662                 INTERNAL,
6663                 { },
6664                 { { 0, 0x1 } },
6665         },
6666         {
6667                 "ALU64_OR_K: 0x000000000000000 | -1 = 0xffffffffffffffff",
6668                 .u.insns_int = {
6669                         BPF_LD_IMM64(R2, 0x0000000000000000LL),
6670                         BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
6671                         BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
6672                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6673                         BPF_MOV32_IMM(R0, 2),
6674                         BPF_EXIT_INSN(),
6675                         BPF_MOV32_IMM(R0, 1),
6676                         BPF_EXIT_INSN(),
6677                 },
6678                 INTERNAL,
6679                 { },
6680                 { { 0, 0x1 } },
6681         },
6682         {
6683                 "ALU64_OR_K: Sign extension 1",
6684                 .u.insns_int = {
6685                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6686                         BPF_LD_IMM64(R1, 0x012345678fafcfefLL),
6687                         BPF_ALU64_IMM(BPF_OR, R0, 0x0f0f0f0f),
6688                         BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6689                         BPF_MOV32_IMM(R0, 2),
6690                         BPF_EXIT_INSN(),
6691                         BPF_MOV32_IMM(R0, 1),
6692                         BPF_EXIT_INSN(),
6693                 },
6694                 INTERNAL,
6695                 { },
6696                 { { 0, 1 } }
6697         },
6698         {
6699                 "ALU64_OR_K: Sign extension 2",
6700                 .u.insns_int = {
6701                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6702                         BPF_LD_IMM64(R1, 0xfffffffff9fbfdffLL),
6703                         BPF_ALU64_IMM(BPF_OR, R0, 0xf0f0f0f0),
6704                         BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6705                         BPF_MOV32_IMM(R0, 2),
6706                         BPF_EXIT_INSN(),
6707                         BPF_MOV32_IMM(R0, 1),
6708                         BPF_EXIT_INSN(),
6709                 },
6710                 INTERNAL,
6711                 { },
6712                 { { 0, 1 } }
6713         },
6714         /* BPF_ALU | BPF_XOR | BPF_X */
6715         {
6716                 "ALU_XOR_X: 5 ^ 6 = 3",
6717                 .u.insns_int = {
6718                         BPF_LD_IMM64(R0, 5),
6719                         BPF_ALU32_IMM(BPF_MOV, R1, 6),
6720                         BPF_ALU32_REG(BPF_XOR, R0, R1),
6721                         BPF_EXIT_INSN(),
6722                 },
6723                 INTERNAL,
6724                 { },
6725                 { { 0, 3 } },
6726         },
6727         {
6728                 "ALU_XOR_X: 0x1 ^ 0xffffffff = 0xfffffffe",
6729                 .u.insns_int = {
6730                         BPF_LD_IMM64(R0, 1),
6731                         BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6732                         BPF_ALU32_REG(BPF_XOR, R0, R1),
6733                         BPF_EXIT_INSN(),
6734                 },
6735                 INTERNAL,
6736                 { },
6737                 { { 0, 0xfffffffe } },
6738         },
6739         {
6740                 "ALU64_XOR_X: 5 ^ 6 = 3",
6741                 .u.insns_int = {
6742                         BPF_LD_IMM64(R0, 5),
6743                         BPF_ALU32_IMM(BPF_MOV, R1, 6),
6744                         BPF_ALU64_REG(BPF_XOR, R0, R1),
6745                         BPF_EXIT_INSN(),
6746                 },
6747                 INTERNAL,
6748                 { },
6749                 { { 0, 3 } },
6750         },
6751         {
6752                 "ALU64_XOR_X: 1 ^ 0xffffffff = 0xfffffffe",
6753                 .u.insns_int = {
6754                         BPF_LD_IMM64(R0, 1),
6755                         BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6756                         BPF_ALU64_REG(BPF_XOR, R0, R1),
6757                         BPF_EXIT_INSN(),
6758                 },
6759                 INTERNAL,
6760                 { },
6761                 { { 0, 0xfffffffe } },
6762         },
6763         /* BPF_ALU | BPF_XOR | BPF_K */
6764         {
6765                 "ALU_XOR_K: 5 ^ 6 = 3",
6766                 .u.insns_int = {
6767                         BPF_LD_IMM64(R0, 5),
6768                         BPF_ALU32_IMM(BPF_XOR, R0, 6),
6769                         BPF_EXIT_INSN(),
6770                 },
6771                 INTERNAL,
6772                 { },
6773                 { { 0, 3 } },
6774         },
6775         {
6776                 "ALU_XOR_K: 1 ^ 0xffffffff = 0xfffffffe",
6777                 .u.insns_int = {
6778                         BPF_LD_IMM64(R0, 1),
6779                         BPF_ALU32_IMM(BPF_XOR, R0, 0xffffffff),
6780                         BPF_EXIT_INSN(),
6781                 },
6782                 INTERNAL,
6783                 { },
6784                 { { 0, 0xfffffffe } },
6785         },
6786         {
6787                 "ALU_XOR_K: Small immediate",
6788                 .u.insns_int = {
6789                         BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
6790                         BPF_ALU32_IMM(BPF_XOR, R0, 15),
6791                         BPF_EXIT_INSN(),
6792                 },
6793                 INTERNAL,
6794                 { },
6795                 { { 0, 0x0102030b } }
6796         },
6797         {
6798                 "ALU_XOR_K: Large immediate",
6799                 .u.insns_int = {
6800                         BPF_ALU32_IMM(BPF_MOV, R0, 0xf1f2f3f4),
6801                         BPF_ALU32_IMM(BPF_XOR, R0, 0xafbfcfdf),
6802                         BPF_EXIT_INSN(),
6803                 },
6804                 INTERNAL,
6805                 { },
6806                 { { 0, 0x5e4d3c2b } }
6807         },
6808         {
6809                 "ALU_XOR_K: Zero extension",
6810                 .u.insns_int = {
6811                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6812                         BPF_LD_IMM64(R1, 0x00000000795b3d1fLL),
6813                         BPF_ALU32_IMM(BPF_XOR, R0, 0xf0f0f0f0),
6814                         BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6815                         BPF_MOV32_IMM(R0, 2),
6816                         BPF_EXIT_INSN(),
6817                         BPF_MOV32_IMM(R0, 1),
6818                         BPF_EXIT_INSN(),
6819                 },
6820                 INTERNAL,
6821                 { },
6822                 { { 0, 1 } }
6823         },
6824         {
6825                 "ALU64_XOR_K: 5 ^ 6 = 3",
6826                 .u.insns_int = {
6827                         BPF_LD_IMM64(R0, 5),
6828                         BPF_ALU64_IMM(BPF_XOR, R0, 6),
6829                         BPF_EXIT_INSN(),
6830                 },
6831                 INTERNAL,
6832                 { },
6833                 { { 0, 3 } },
6834         },
6835         {
6836                 "ALU64_XOR_K: 1 ^ 0xffffffff = 0xfffffffe",
6837                 .u.insns_int = {
6838                         BPF_LD_IMM64(R0, 1),
6839                         BPF_ALU64_IMM(BPF_XOR, R0, 0xffffffff),
6840                         BPF_EXIT_INSN(),
6841                 },
6842                 INTERNAL,
6843                 { },
6844                 { { 0, 0xfffffffe } },
6845         },
6846         {
6847                 "ALU64_XOR_K: 0x0000ffffffff0000 ^ 0x0 = 0x0000ffffffff0000",
6848                 .u.insns_int = {
6849                         BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6850                         BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
6851                         BPF_ALU64_IMM(BPF_XOR, R2, 0x0),
6852                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6853                         BPF_MOV32_IMM(R0, 2),
6854                         BPF_EXIT_INSN(),
6855                         BPF_MOV32_IMM(R0, 1),
6856                         BPF_EXIT_INSN(),
6857                 },
6858                 INTERNAL,
6859                 { },
6860                 { { 0, 0x1 } },
6861         },
6862         {
6863                 "ALU64_XOR_K: 0x0000ffffffff0000 ^ -1 = 0xffff00000000ffff",
6864                 .u.insns_int = {
6865                         BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6866                         BPF_LD_IMM64(R3, 0xffff00000000ffffLL),
6867                         BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
6868                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6869                         BPF_MOV32_IMM(R0, 2),
6870                         BPF_EXIT_INSN(),
6871                         BPF_MOV32_IMM(R0, 1),
6872                         BPF_EXIT_INSN(),
6873                 },
6874                 INTERNAL,
6875                 { },
6876                 { { 0, 0x1 } },
6877         },
6878         {
6879                 "ALU64_XOR_K: 0x000000000000000 ^ -1 = 0xffffffffffffffff",
6880                 .u.insns_int = {
6881                         BPF_LD_IMM64(R2, 0x0000000000000000LL),
6882                         BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
6883                         BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
6884                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6885                         BPF_MOV32_IMM(R0, 2),
6886                         BPF_EXIT_INSN(),
6887                         BPF_MOV32_IMM(R0, 1),
6888                         BPF_EXIT_INSN(),
6889                 },
6890                 INTERNAL,
6891                 { },
6892                 { { 0, 0x1 } },
6893         },
6894         {
6895                 "ALU64_XOR_K: Sign extension 1",
6896                 .u.insns_int = {
6897                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6898                         BPF_LD_IMM64(R1, 0x0123456786a4c2e0LL),
6899                         BPF_ALU64_IMM(BPF_XOR, R0, 0x0f0f0f0f),
6900                         BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6901                         BPF_MOV32_IMM(R0, 2),
6902                         BPF_EXIT_INSN(),
6903                         BPF_MOV32_IMM(R0, 1),
6904                         BPF_EXIT_INSN(),
6905                 },
6906                 INTERNAL,
6907                 { },
6908                 { { 0, 1 } }
6909         },
6910         {
6911                 "ALU64_XOR_K: Sign extension 2",
6912                 .u.insns_int = {
6913                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6914                         BPF_LD_IMM64(R1, 0xfedcba98795b3d1fLL),
6915                         BPF_ALU64_IMM(BPF_XOR, R0, 0xf0f0f0f0),
6916                         BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6917                         BPF_MOV32_IMM(R0, 2),
6918                         BPF_EXIT_INSN(),
6919                         BPF_MOV32_IMM(R0, 1),
6920                         BPF_EXIT_INSN(),
6921                 },
6922                 INTERNAL,
6923                 { },
6924                 { { 0, 1 } }
6925         },
6926         /* BPF_ALU | BPF_LSH | BPF_X */
6927         {
6928                 "ALU_LSH_X: 1 << 1 = 2",
6929                 .u.insns_int = {
6930                         BPF_LD_IMM64(R0, 1),
6931                         BPF_ALU32_IMM(BPF_MOV, R1, 1),
6932                         BPF_ALU32_REG(BPF_LSH, R0, R1),
6933                         BPF_EXIT_INSN(),
6934                 },
6935                 INTERNAL,
6936                 { },
6937                 { { 0, 2 } },
6938         },
6939         {
6940                 "ALU_LSH_X: 1 << 31 = 0x80000000",
6941                 .u.insns_int = {
6942                         BPF_LD_IMM64(R0, 1),
6943                         BPF_ALU32_IMM(BPF_MOV, R1, 31),
6944                         BPF_ALU32_REG(BPF_LSH, R0, R1),
6945                         BPF_EXIT_INSN(),
6946                 },
6947                 INTERNAL,
6948                 { },
6949                 { { 0, 0x80000000 } },
6950         },
6951         {
6952                 "ALU_LSH_X: 0x12345678 << 12 = 0x45678000",
6953                 .u.insns_int = {
6954                         BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
6955                         BPF_ALU32_IMM(BPF_MOV, R1, 12),
6956                         BPF_ALU32_REG(BPF_LSH, R0, R1),
6957                         BPF_EXIT_INSN(),
6958                 },
6959                 INTERNAL,
6960                 { },
6961                 { { 0, 0x45678000 } }
6962         },
6963         {
6964                 "ALU64_LSH_X: 1 << 1 = 2",
6965                 .u.insns_int = {
6966                         BPF_LD_IMM64(R0, 1),
6967                         BPF_ALU32_IMM(BPF_MOV, R1, 1),
6968                         BPF_ALU64_REG(BPF_LSH, R0, R1),
6969                         BPF_EXIT_INSN(),
6970                 },
6971                 INTERNAL,
6972                 { },
6973                 { { 0, 2 } },
6974         },
6975         {
6976                 "ALU64_LSH_X: 1 << 31 = 0x80000000",
6977                 .u.insns_int = {
6978                         BPF_LD_IMM64(R0, 1),
6979                         BPF_ALU32_IMM(BPF_MOV, R1, 31),
6980                         BPF_ALU64_REG(BPF_LSH, R0, R1),
6981                         BPF_EXIT_INSN(),
6982                 },
6983                 INTERNAL,
6984                 { },
6985                 { { 0, 0x80000000 } },
6986         },
6987         {
6988                 "ALU64_LSH_X: Shift < 32, low word",
6989                 .u.insns_int = {
6990                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6991                         BPF_ALU32_IMM(BPF_MOV, R1, 12),
6992                         BPF_ALU64_REG(BPF_LSH, R0, R1),
6993                         BPF_EXIT_INSN(),
6994                 },
6995                 INTERNAL,
6996                 { },
6997                 { { 0, 0xbcdef000 } }
6998         },
6999         {
7000                 "ALU64_LSH_X: Shift < 32, high word",
7001                 .u.insns_int = {
7002                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7003                         BPF_ALU32_IMM(BPF_MOV, R1, 12),
7004                         BPF_ALU64_REG(BPF_LSH, R0, R1),
7005                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
7006                         BPF_EXIT_INSN(),
7007                 },
7008                 INTERNAL,
7009                 { },
7010                 { { 0, 0x3456789a } }
7011         },
7012         {
7013                 "ALU64_LSH_X: Shift > 32, low word",
7014                 .u.insns_int = {
7015                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7016                         BPF_ALU32_IMM(BPF_MOV, R1, 36),
7017                         BPF_ALU64_REG(BPF_LSH, R0, R1),
7018                         BPF_EXIT_INSN(),
7019                 },
7020                 INTERNAL,
7021                 { },
7022                 { { 0, 0 } }
7023         },
7024         {
7025                 "ALU64_LSH_X: Shift > 32, high word",
7026                 .u.insns_int = {
7027                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7028                         BPF_ALU32_IMM(BPF_MOV, R1, 36),
7029                         BPF_ALU64_REG(BPF_LSH, R0, R1),
7030                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
7031                         BPF_EXIT_INSN(),
7032                 },
7033                 INTERNAL,
7034                 { },
7035                 { { 0, 0x9abcdef0 } }
7036         },
7037         {
7038                 "ALU64_LSH_X: Shift == 32, low word",
7039                 .u.insns_int = {
7040                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7041                         BPF_ALU32_IMM(BPF_MOV, R1, 32),
7042                         BPF_ALU64_REG(BPF_LSH, R0, R1),
7043                         BPF_EXIT_INSN(),
7044                 },
7045                 INTERNAL,
7046                 { },
7047                 { { 0, 0 } }
7048         },
7049         {
7050                 "ALU64_LSH_X: Shift == 32, high word",
7051                 .u.insns_int = {
7052                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7053                         BPF_ALU32_IMM(BPF_MOV, R1, 32),
7054                         BPF_ALU64_REG(BPF_LSH, R0, R1),
7055                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
7056                         BPF_EXIT_INSN(),
7057                 },
7058                 INTERNAL,
7059                 { },
7060                 { { 0, 0x89abcdef } }
7061         },
7062         {
7063                 "ALU64_LSH_X: Zero shift, low word",
7064                 .u.insns_int = {
7065                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7066                         BPF_ALU32_IMM(BPF_MOV, R1, 0),
7067                         BPF_ALU64_REG(BPF_LSH, R0, R1),
7068                         BPF_EXIT_INSN(),
7069                 },
7070                 INTERNAL,
7071                 { },
7072                 { { 0, 0x89abcdef } }
7073         },
7074         {
7075                 "ALU64_LSH_X: Zero shift, high word",
7076                 .u.insns_int = {
7077                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7078                         BPF_ALU32_IMM(BPF_MOV, R1, 0),
7079                         BPF_ALU64_REG(BPF_LSH, R0, R1),
7080                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
7081                         BPF_EXIT_INSN(),
7082                 },
7083                 INTERNAL,
7084                 { },
7085                 { { 0, 0x01234567 } }
7086         },
7087         /* BPF_ALU | BPF_LSH | BPF_K */
7088         {
7089                 "ALU_LSH_K: 1 << 1 = 2",
7090                 .u.insns_int = {
7091                         BPF_LD_IMM64(R0, 1),
7092                         BPF_ALU32_IMM(BPF_LSH, R0, 1),
7093                         BPF_EXIT_INSN(),
7094                 },
7095                 INTERNAL,
7096                 { },
7097                 { { 0, 2 } },
7098         },
7099         {
7100                 "ALU_LSH_K: 1 << 31 = 0x80000000",
7101                 .u.insns_int = {
7102                         BPF_LD_IMM64(R0, 1),
7103                         BPF_ALU32_IMM(BPF_LSH, R0, 31),
7104                         BPF_EXIT_INSN(),
7105                 },
7106                 INTERNAL,
7107                 { },
7108                 { { 0, 0x80000000 } },
7109         },
7110         {
7111                 "ALU_LSH_K: 0x12345678 << 12 = 0x45678000",
7112                 .u.insns_int = {
7113                         BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
7114                         BPF_ALU32_IMM(BPF_LSH, R0, 12),
7115                         BPF_EXIT_INSN(),
7116                 },
7117                 INTERNAL,
7118                 { },
7119                 { { 0, 0x45678000 } }
7120         },
7121         {
7122                 "ALU_LSH_K: 0x12345678 << 0 = 0x12345678",
7123                 .u.insns_int = {
7124                         BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
7125                         BPF_ALU32_IMM(BPF_LSH, R0, 0),
7126                         BPF_EXIT_INSN(),
7127                 },
7128                 INTERNAL,
7129                 { },
7130                 { { 0, 0x12345678 } }
7131         },
7132         {
7133                 "ALU64_LSH_K: 1 << 1 = 2",
7134                 .u.insns_int = {
7135                         BPF_LD_IMM64(R0, 1),
7136                         BPF_ALU64_IMM(BPF_LSH, R0, 1),
7137                         BPF_EXIT_INSN(),
7138                 },
7139                 INTERNAL,
7140                 { },
7141                 { { 0, 2 } },
7142         },
7143         {
7144                 "ALU64_LSH_K: 1 << 31 = 0x80000000",
7145                 .u.insns_int = {
7146                         BPF_LD_IMM64(R0, 1),
7147                         BPF_ALU64_IMM(BPF_LSH, R0, 31),
7148                         BPF_EXIT_INSN(),
7149                 },
7150                 INTERNAL,
7151                 { },
7152                 { { 0, 0x80000000 } },
7153         },
7154         {
7155                 "ALU64_LSH_K: Shift < 32, low word",
7156                 .u.insns_int = {
7157                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7158                         BPF_ALU64_IMM(BPF_LSH, R0, 12),
7159                         BPF_EXIT_INSN(),
7160                 },
7161                 INTERNAL,
7162                 { },
7163                 { { 0, 0xbcdef000 } }
7164         },
7165         {
7166                 "ALU64_LSH_K: Shift < 32, high word",
7167                 .u.insns_int = {
7168                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7169                         BPF_ALU64_IMM(BPF_LSH, R0, 12),
7170                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
7171                         BPF_EXIT_INSN(),
7172                 },
7173                 INTERNAL,
7174                 { },
7175                 { { 0, 0x3456789a } }
7176         },
7177         {
7178                 "ALU64_LSH_K: Shift > 32, low word",
7179                 .u.insns_int = {
7180                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7181                         BPF_ALU64_IMM(BPF_LSH, R0, 36),
7182                         BPF_EXIT_INSN(),
7183                 },
7184                 INTERNAL,
7185                 { },
7186                 { { 0, 0 } }
7187         },
7188         {
7189                 "ALU64_LSH_K: Shift > 32, high word",
7190                 .u.insns_int = {
7191                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7192                         BPF_ALU64_IMM(BPF_LSH, R0, 36),
7193                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
7194                         BPF_EXIT_INSN(),
7195                 },
7196                 INTERNAL,
7197                 { },
7198                 { { 0, 0x9abcdef0 } }
7199         },
7200         {
7201                 "ALU64_LSH_K: Shift == 32, low word",
7202                 .u.insns_int = {
7203                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7204                         BPF_ALU64_IMM(BPF_LSH, R0, 32),
7205                         BPF_EXIT_INSN(),
7206                 },
7207                 INTERNAL,
7208                 { },
7209                 { { 0, 0 } }
7210         },
7211         {
7212                 "ALU64_LSH_K: Shift == 32, high word",
7213                 .u.insns_int = {
7214                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7215                         BPF_ALU64_IMM(BPF_LSH, R0, 32),
7216                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
7217                         BPF_EXIT_INSN(),
7218                 },
7219                 INTERNAL,
7220                 { },
7221                 { { 0, 0x89abcdef } }
7222         },
7223         {
7224                 "ALU64_LSH_K: Zero shift",
7225                 .u.insns_int = {
7226                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7227                         BPF_ALU64_IMM(BPF_LSH, R0, 0),
7228                         BPF_EXIT_INSN(),
7229                 },
7230                 INTERNAL,
7231                 { },
7232                 { { 0, 0x89abcdef } }
7233         },
7234         /* BPF_ALU | BPF_RSH | BPF_X */
7235         {
7236                 "ALU_RSH_X: 2 >> 1 = 1",
7237                 .u.insns_int = {
7238                         BPF_LD_IMM64(R0, 2),
7239                         BPF_ALU32_IMM(BPF_MOV, R1, 1),
7240                         BPF_ALU32_REG(BPF_RSH, R0, R1),
7241                         BPF_EXIT_INSN(),
7242                 },
7243                 INTERNAL,
7244                 { },
7245                 { { 0, 1 } },
7246         },
7247         {
7248                 "ALU_RSH_X: 0x80000000 >> 31 = 1",
7249                 .u.insns_int = {
7250                         BPF_LD_IMM64(R0, 0x80000000),
7251                         BPF_ALU32_IMM(BPF_MOV, R1, 31),
7252                         BPF_ALU32_REG(BPF_RSH, R0, R1),
7253                         BPF_EXIT_INSN(),
7254                 },
7255                 INTERNAL,
7256                 { },
7257                 { { 0, 1 } },
7258         },
7259         {
7260                 "ALU_RSH_X: 0x12345678 >> 20 = 0x123",
7261                 .u.insns_int = {
7262                         BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
7263                         BPF_ALU32_IMM(BPF_MOV, R1, 20),
7264                         BPF_ALU32_REG(BPF_RSH, R0, R1),
7265                         BPF_EXIT_INSN(),
7266                 },
7267                 INTERNAL,
7268                 { },
7269                 { { 0, 0x123 } }
7270         },
7271         {
7272                 "ALU64_RSH_X: 2 >> 1 = 1",
7273                 .u.insns_int = {
7274                         BPF_LD_IMM64(R0, 2),
7275                         BPF_ALU32_IMM(BPF_MOV, R1, 1),
7276                         BPF_ALU64_REG(BPF_RSH, R0, R1),
7277                         BPF_EXIT_INSN(),
7278                 },
7279                 INTERNAL,
7280                 { },
7281                 { { 0, 1 } },
7282         },
7283         {
7284                 "ALU64_RSH_X: 0x80000000 >> 31 = 1",
7285                 .u.insns_int = {
7286                         BPF_LD_IMM64(R0, 0x80000000),
7287                         BPF_ALU32_IMM(BPF_MOV, R1, 31),
7288                         BPF_ALU64_REG(BPF_RSH, R0, R1),
7289                         BPF_EXIT_INSN(),
7290                 },
7291                 INTERNAL,
7292                 { },
7293                 { { 0, 1 } },
7294         },
7295         {
7296                 "ALU64_RSH_X: Shift < 32, low word",
7297                 .u.insns_int = {
7298                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7299                         BPF_ALU32_IMM(BPF_MOV, R1, 12),
7300                         BPF_ALU64_REG(BPF_RSH, R0, R1),
7301                         BPF_EXIT_INSN(),
7302                 },
7303                 INTERNAL,
7304                 { },
7305                 { { 0, 0x56789abc } }
7306         },
7307         {
7308                 "ALU64_RSH_X: Shift < 32, high word",
7309                 .u.insns_int = {
7310                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7311                         BPF_ALU32_IMM(BPF_MOV, R1, 12),
7312                         BPF_ALU64_REG(BPF_RSH, R0, R1),
7313                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
7314                         BPF_EXIT_INSN(),
7315                 },
7316                 INTERNAL,
7317                 { },
7318                 { { 0, 0x00081234 } }
7319         },
7320         {
7321                 "ALU64_RSH_X: Shift > 32, low word",
7322                 .u.insns_int = {
7323                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7324                         BPF_ALU32_IMM(BPF_MOV, R1, 36),
7325                         BPF_ALU64_REG(BPF_RSH, R0, R1),
7326                         BPF_EXIT_INSN(),
7327                 },
7328                 INTERNAL,
7329                 { },
7330                 { { 0, 0x08123456 } }
7331         },
7332         {
7333                 "ALU64_RSH_X: Shift > 32, high word",
7334                 .u.insns_int = {
7335                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7336                         BPF_ALU32_IMM(BPF_MOV, R1, 36),
7337                         BPF_ALU64_REG(BPF_RSH, R0, R1),
7338                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
7339                         BPF_EXIT_INSN(),
7340                 },
7341                 INTERNAL,
7342                 { },
7343                 { { 0, 0 } }
7344         },
7345         {
7346                 "ALU64_RSH_X: Shift == 32, low word",
7347                 .u.insns_int = {
7348                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7349                         BPF_ALU32_IMM(BPF_MOV, R1, 32),
7350                         BPF_ALU64_REG(BPF_RSH, R0, R1),
7351                         BPF_EXIT_INSN(),
7352                 },
7353                 INTERNAL,
7354                 { },
7355                 { { 0, 0x81234567 } }
7356         },
7357         {
7358                 "ALU64_RSH_X: Shift == 32, high word",
7359                 .u.insns_int = {
7360                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7361                         BPF_ALU32_IMM(BPF_MOV, R1, 32),
7362                         BPF_ALU64_REG(BPF_RSH, R0, R1),
7363                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
7364                         BPF_EXIT_INSN(),
7365                 },
7366                 INTERNAL,
7367                 { },
7368                 { { 0, 0 } }
7369         },
7370         {
7371                 "ALU64_RSH_X: Zero shift, low word",
7372                 .u.insns_int = {
7373                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7374                         BPF_ALU32_IMM(BPF_MOV, R1, 0),
7375                         BPF_ALU64_REG(BPF_RSH, R0, R1),
7376                         BPF_EXIT_INSN(),
7377                 },
7378                 INTERNAL,
7379                 { },
7380                 { { 0, 0x89abcdef } }
7381         },
7382         {
7383                 "ALU64_RSH_X: Zero shift, high word",
7384                 .u.insns_int = {
7385                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7386                         BPF_ALU32_IMM(BPF_MOV, R1, 0),
7387                         BPF_ALU64_REG(BPF_RSH, R0, R1),
7388                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
7389                         BPF_EXIT_INSN(),
7390                 },
7391                 INTERNAL,
7392                 { },
7393                 { { 0, 0x81234567 } }
7394         },
7395         /* BPF_ALU | BPF_RSH | BPF_K */
7396         {
7397                 "ALU_RSH_K: 2 >> 1 = 1",
7398                 .u.insns_int = {
7399                         BPF_LD_IMM64(R0, 2),
7400                         BPF_ALU32_IMM(BPF_RSH, R0, 1),
7401                         BPF_EXIT_INSN(),
7402                 },
7403                 INTERNAL,
7404                 { },
7405                 { { 0, 1 } },
7406         },
7407         {
7408                 "ALU_RSH_K: 0x80000000 >> 31 = 1",
7409                 .u.insns_int = {
7410                         BPF_LD_IMM64(R0, 0x80000000),
7411                         BPF_ALU32_IMM(BPF_RSH, R0, 31),
7412                         BPF_EXIT_INSN(),
7413                 },
7414                 INTERNAL,
7415                 { },
7416                 { { 0, 1 } },
7417         },
7418         {
7419                 "ALU_RSH_K: 0x12345678 >> 20 = 0x123",
7420                 .u.insns_int = {
7421                         BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
7422                         BPF_ALU32_IMM(BPF_RSH, R0, 20),
7423                         BPF_EXIT_INSN(),
7424                 },
7425                 INTERNAL,
7426                 { },
7427                 { { 0, 0x123 } }
7428         },
7429         {
7430                 "ALU_RSH_K: 0x12345678 >> 0 = 0x12345678",
7431                 .u.insns_int = {
7432                         BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
7433                         BPF_ALU32_IMM(BPF_RSH, R0, 0),
7434                         BPF_EXIT_INSN(),
7435                 },
7436                 INTERNAL,
7437                 { },
7438                 { { 0, 0x12345678 } }
7439         },
7440         {
7441                 "ALU64_RSH_K: 2 >> 1 = 1",
7442                 .u.insns_int = {
7443                         BPF_LD_IMM64(R0, 2),
7444                         BPF_ALU64_IMM(BPF_RSH, R0, 1),
7445                         BPF_EXIT_INSN(),
7446                 },
7447                 INTERNAL,
7448                 { },
7449                 { { 0, 1 } },
7450         },
7451         {
7452                 "ALU64_RSH_K: 0x80000000 >> 31 = 1",
7453                 .u.insns_int = {
7454                         BPF_LD_IMM64(R0, 0x80000000),
7455                         BPF_ALU64_IMM(BPF_RSH, R0, 31),
7456                         BPF_EXIT_INSN(),
7457                 },
7458                 INTERNAL,
7459                 { },
7460                 { { 0, 1 } },
7461         },
7462         {
7463                 "ALU64_RSH_K: Shift < 32, low word",
7464                 .u.insns_int = {
7465                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7466                         BPF_ALU64_IMM(BPF_RSH, R0, 12),
7467                         BPF_EXIT_INSN(),
7468                 },
7469                 INTERNAL,
7470                 { },
7471                 { { 0, 0x56789abc } }
7472         },
7473         {
7474                 "ALU64_RSH_K: Shift < 32, high word",
7475                 .u.insns_int = {
7476                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7477                         BPF_ALU64_IMM(BPF_RSH, R0, 12),
7478                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
7479                         BPF_EXIT_INSN(),
7480                 },
7481                 INTERNAL,
7482                 { },
7483                 { { 0, 0x00081234 } }
7484         },
7485         {
7486                 "ALU64_RSH_K: Shift > 32, low word",
7487                 .u.insns_int = {
7488                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7489                         BPF_ALU64_IMM(BPF_RSH, R0, 36),
7490                         BPF_EXIT_INSN(),
7491                 },
7492                 INTERNAL,
7493                 { },
7494                 { { 0, 0x08123456 } }
7495         },
7496         {
7497                 "ALU64_RSH_K: Shift > 32, high word",
7498                 .u.insns_int = {
7499                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7500                         BPF_ALU64_IMM(BPF_RSH, R0, 36),
7501                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
7502                         BPF_EXIT_INSN(),
7503                 },
7504                 INTERNAL,
7505                 { },
7506                 { { 0, 0 } }
7507         },
7508         {
7509                 "ALU64_RSH_K: Shift == 32, low word",
7510                 .u.insns_int = {
7511                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7512                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
7513                         BPF_EXIT_INSN(),
7514                 },
7515                 INTERNAL,
7516                 { },
7517                 { { 0, 0x81234567 } }
7518         },
7519         {
7520                 "ALU64_RSH_K: Shift == 32, high word",
7521                 .u.insns_int = {
7522                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7523                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
7524                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
7525                         BPF_EXIT_INSN(),
7526                 },
7527                 INTERNAL,
7528                 { },
7529                 { { 0, 0 } }
7530         },
7531         {
7532                 "ALU64_RSH_K: Zero shift",
7533                 .u.insns_int = {
7534                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7535                         BPF_ALU64_IMM(BPF_RSH, R0, 0),
7536                         BPF_EXIT_INSN(),
7537                 },
7538                 INTERNAL,
7539                 { },
7540                 { { 0, 0x89abcdef } }
7541         },
7542         /* BPF_ALU | BPF_ARSH | BPF_X */
7543         {
7544                 "ALU32_ARSH_X: -1234 >> 7 = -10",
7545                 .u.insns_int = {
7546                         BPF_ALU32_IMM(BPF_MOV, R0, -1234),
7547                         BPF_ALU32_IMM(BPF_MOV, R1, 7),
7548                         BPF_ALU32_REG(BPF_ARSH, R0, R1),
7549                         BPF_EXIT_INSN(),
7550                 },
7551                 INTERNAL,
7552                 { },
7553                 { { 0, -10 } }
7554         },
7555         {
7556                 "ALU64_ARSH_X: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
7557                 .u.insns_int = {
7558                         BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
7559                         BPF_ALU32_IMM(BPF_MOV, R1, 40),
7560                         BPF_ALU64_REG(BPF_ARSH, R0, R1),
7561                         BPF_EXIT_INSN(),
7562                 },
7563                 INTERNAL,
7564                 { },
7565                 { { 0, 0xffff00ff } },
7566         },
7567         {
7568                 "ALU64_ARSH_X: Shift < 32, low word",
7569                 .u.insns_int = {
7570                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7571                         BPF_ALU32_IMM(BPF_MOV, R1, 12),
7572                         BPF_ALU64_REG(BPF_ARSH, R0, R1),
7573                         BPF_EXIT_INSN(),
7574                 },
7575                 INTERNAL,
7576                 { },
7577                 { { 0, 0x56789abc } }
7578         },
7579         {
7580                 "ALU64_ARSH_X: Shift < 32, high word",
7581                 .u.insns_int = {
7582                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7583                         BPF_ALU32_IMM(BPF_MOV, R1, 12),
7584                         BPF_ALU64_REG(BPF_ARSH, R0, R1),
7585                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
7586                         BPF_EXIT_INSN(),
7587                 },
7588                 INTERNAL,
7589                 { },
7590                 { { 0, 0xfff81234 } }
7591         },
7592         {
7593                 "ALU64_ARSH_X: Shift > 32, low word",
7594                 .u.insns_int = {
7595                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7596                         BPF_ALU32_IMM(BPF_MOV, R1, 36),
7597                         BPF_ALU64_REG(BPF_ARSH, R0, R1),
7598                         BPF_EXIT_INSN(),
7599                 },
7600                 INTERNAL,
7601                 { },
7602                 { { 0, 0xf8123456 } }
7603         },
7604         {
7605                 "ALU64_ARSH_X: Shift > 32, high word",
7606                 .u.insns_int = {
7607                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7608                         BPF_ALU32_IMM(BPF_MOV, R1, 36),
7609                         BPF_ALU64_REG(BPF_ARSH, R0, R1),
7610                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
7611                         BPF_EXIT_INSN(),
7612                 },
7613                 INTERNAL,
7614                 { },
7615                 { { 0, -1 } }
7616         },
7617         {
7618                 "ALU64_ARSH_X: Shift == 32, low word",
7619                 .u.insns_int = {
7620                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7621                         BPF_ALU32_IMM(BPF_MOV, R1, 32),
7622                         BPF_ALU64_REG(BPF_ARSH, R0, R1),
7623                         BPF_EXIT_INSN(),
7624                 },
7625                 INTERNAL,
7626                 { },
7627                 { { 0, 0x81234567 } }
7628         },
7629         {
7630                 "ALU64_ARSH_X: Shift == 32, high word",
7631                 .u.insns_int = {
7632                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7633                         BPF_ALU32_IMM(BPF_MOV, R1, 32),
7634                         BPF_ALU64_REG(BPF_ARSH, R0, R1),
7635                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
7636                         BPF_EXIT_INSN(),
7637                 },
7638                 INTERNAL,
7639                 { },
7640                 { { 0, -1 } }
7641         },
7642         {
7643                 "ALU64_ARSH_X: Zero shift, low word",
7644                 .u.insns_int = {
7645                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7646                         BPF_ALU32_IMM(BPF_MOV, R1, 0),
7647                         BPF_ALU64_REG(BPF_ARSH, R0, R1),
7648                         BPF_EXIT_INSN(),
7649                 },
7650                 INTERNAL,
7651                 { },
7652                 { { 0, 0x89abcdef } }
7653         },
7654         {
7655                 "ALU64_ARSH_X: Zero shift, high word",
7656                 .u.insns_int = {
7657                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7658                         BPF_ALU32_IMM(BPF_MOV, R1, 0),
7659                         BPF_ALU64_REG(BPF_ARSH, R0, R1),
7660                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
7661                         BPF_EXIT_INSN(),
7662                 },
7663                 INTERNAL,
7664                 { },
7665                 { { 0, 0x81234567 } }
7666         },
7667         /* BPF_ALU | BPF_ARSH | BPF_K */
7668         {
7669                 "ALU32_ARSH_K: -1234 >> 7 = -10",
7670                 .u.insns_int = {
7671                         BPF_ALU32_IMM(BPF_MOV, R0, -1234),
7672                         BPF_ALU32_IMM(BPF_ARSH, R0, 7),
7673                         BPF_EXIT_INSN(),
7674                 },
7675                 INTERNAL,
7676                 { },
7677                 { { 0, -10 } }
7678         },
7679         {
7680                 "ALU32_ARSH_K: -1234 >> 0 = -1234",
7681                 .u.insns_int = {
7682                         BPF_ALU32_IMM(BPF_MOV, R0, -1234),
7683                         BPF_ALU32_IMM(BPF_ARSH, R0, 0),
7684                         BPF_EXIT_INSN(),
7685                 },
7686                 INTERNAL,
7687                 { },
7688                 { { 0, -1234 } }
7689         },
7690         {
7691                 "ALU64_ARSH_K: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
7692                 .u.insns_int = {
7693                         BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
7694                         BPF_ALU64_IMM(BPF_ARSH, R0, 40),
7695                         BPF_EXIT_INSN(),
7696                 },
7697                 INTERNAL,
7698                 { },
7699                 { { 0, 0xffff00ff } },
7700         },
7701         {
7702                 "ALU64_ARSH_K: Shift < 32, low word",
7703                 .u.insns_int = {
7704                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7705                         BPF_ALU64_IMM(BPF_RSH, R0, 12),
7706                         BPF_EXIT_INSN(),
7707                 },
7708                 INTERNAL,
7709                 { },
7710                 { { 0, 0x56789abc } }
7711         },
7712         {
7713                 "ALU64_ARSH_K: Shift < 32, high word",
7714                 .u.insns_int = {
7715                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7716                         BPF_ALU64_IMM(BPF_ARSH, R0, 12),
7717                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
7718                         BPF_EXIT_INSN(),
7719                 },
7720                 INTERNAL,
7721                 { },
7722                 { { 0, 0xfff81234 } }
7723         },
7724         {
7725                 "ALU64_ARSH_K: Shift > 32, low word",
7726                 .u.insns_int = {
7727                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7728                         BPF_ALU64_IMM(BPF_ARSH, R0, 36),
7729                         BPF_EXIT_INSN(),
7730                 },
7731                 INTERNAL,
7732                 { },
7733                 { { 0, 0xf8123456 } }
7734         },
7735         {
7736                 "ALU64_ARSH_K: Shift > 32, high word",
7737                 .u.insns_int = {
7738                         BPF_LD_IMM64(R0, 0xf123456789abcdefLL),
7739                         BPF_ALU64_IMM(BPF_ARSH, R0, 36),
7740                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
7741                         BPF_EXIT_INSN(),
7742                 },
7743                 INTERNAL,
7744                 { },
7745                 { { 0, -1 } }
7746         },
7747         {
7748                 "ALU64_ARSH_K: Shift == 32, low word",
7749                 .u.insns_int = {
7750                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7751                         BPF_ALU64_IMM(BPF_ARSH, R0, 32),
7752                         BPF_EXIT_INSN(),
7753                 },
7754                 INTERNAL,
7755                 { },
7756                 { { 0, 0x81234567 } }
7757         },
7758         {
7759                 "ALU64_ARSH_K: Shift == 32, high word",
7760                 .u.insns_int = {
7761                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7762                         BPF_ALU64_IMM(BPF_ARSH, R0, 32),
7763                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
7764                         BPF_EXIT_INSN(),
7765                 },
7766                 INTERNAL,
7767                 { },
7768                 { { 0, -1 } }
7769         },
7770         {
7771                 "ALU64_ARSH_K: Zero shift",
7772                 .u.insns_int = {
7773                         BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7774                         BPF_ALU64_IMM(BPF_ARSH, R0, 0),
7775                         BPF_EXIT_INSN(),
7776                 },
7777                 INTERNAL,
7778                 { },
7779                 { { 0, 0x89abcdef } }
7780         },
7781         /* BPF_ALU | BPF_NEG */
7782         {
7783                 "ALU_NEG: -(3) = -3",
7784                 .u.insns_int = {
7785                         BPF_ALU32_IMM(BPF_MOV, R0, 3),
7786                         BPF_ALU32_IMM(BPF_NEG, R0, 0),
7787                         BPF_EXIT_INSN(),
7788                 },
7789                 INTERNAL,
7790                 { },
7791                 { { 0, -3 } },
7792         },
7793         {
7794                 "ALU_NEG: -(-3) = 3",
7795                 .u.insns_int = {
7796                         BPF_ALU32_IMM(BPF_MOV, R0, -3),
7797                         BPF_ALU32_IMM(BPF_NEG, R0, 0),
7798                         BPF_EXIT_INSN(),
7799                 },
7800                 INTERNAL,
7801                 { },
7802                 { { 0, 3 } },
7803         },
7804         {
7805                 "ALU64_NEG: -(3) = -3",
7806                 .u.insns_int = {
7807                         BPF_LD_IMM64(R0, 3),
7808                         BPF_ALU64_IMM(BPF_NEG, R0, 0),
7809                         BPF_EXIT_INSN(),
7810                 },
7811                 INTERNAL,
7812                 { },
7813                 { { 0, -3 } },
7814         },
7815         {
7816                 "ALU64_NEG: -(-3) = 3",
7817                 .u.insns_int = {
7818                         BPF_LD_IMM64(R0, -3),
7819                         BPF_ALU64_IMM(BPF_NEG, R0, 0),
7820                         BPF_EXIT_INSN(),
7821                 },
7822                 INTERNAL,
7823                 { },
7824                 { { 0, 3 } },
7825         },
7826         /* BPF_ALU | BPF_END | BPF_FROM_BE */
7827         {
7828                 "ALU_END_FROM_BE 16: 0x0123456789abcdef -> 0xcdef",
7829                 .u.insns_int = {
7830                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7831                         BPF_ENDIAN(BPF_FROM_BE, R0, 16),
7832                         BPF_EXIT_INSN(),
7833                 },
7834                 INTERNAL,
7835                 { },
7836                 { { 0,  cpu_to_be16(0xcdef) } },
7837         },
7838         {
7839                 "ALU_END_FROM_BE 32: 0x0123456789abcdef -> 0x89abcdef",
7840                 .u.insns_int = {
7841                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7842                         BPF_ENDIAN(BPF_FROM_BE, R0, 32),
7843                         BPF_ALU64_REG(BPF_MOV, R1, R0),
7844                         BPF_ALU64_IMM(BPF_RSH, R1, 32),
7845                         BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
7846                         BPF_EXIT_INSN(),
7847                 },
7848                 INTERNAL,
7849                 { },
7850                 { { 0, cpu_to_be32(0x89abcdef) } },
7851         },
7852         {
7853                 "ALU_END_FROM_BE 64: 0x0123456789abcdef -> 0x89abcdef",
7854                 .u.insns_int = {
7855                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7856                         BPF_ENDIAN(BPF_FROM_BE, R0, 64),
7857                         BPF_EXIT_INSN(),
7858                 },
7859                 INTERNAL,
7860                 { },
7861                 { { 0, (u32) cpu_to_be64(0x0123456789abcdefLL) } },
7862         },
7863         {
7864                 "ALU_END_FROM_BE 64: 0x0123456789abcdef >> 32 -> 0x01234567",
7865                 .u.insns_int = {
7866                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7867                         BPF_ENDIAN(BPF_FROM_BE, R0, 64),
7868                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
7869                         BPF_EXIT_INSN(),
7870                 },
7871                 INTERNAL,
7872                 { },
7873                 { { 0, (u32) (cpu_to_be64(0x0123456789abcdefLL) >> 32) } },
7874         },
7875         /* BPF_ALU | BPF_END | BPF_FROM_BE, reversed */
7876         {
7877                 "ALU_END_FROM_BE 16: 0xfedcba9876543210 -> 0x3210",
7878                 .u.insns_int = {
7879                         BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7880                         BPF_ENDIAN(BPF_FROM_BE, R0, 16),
7881                         BPF_EXIT_INSN(),
7882                 },
7883                 INTERNAL,
7884                 { },
7885                 { { 0,  cpu_to_be16(0x3210) } },
7886         },
7887         {
7888                 "ALU_END_FROM_BE 32: 0xfedcba9876543210 -> 0x76543210",
7889                 .u.insns_int = {
7890                         BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7891                         BPF_ENDIAN(BPF_FROM_BE, R0, 32),
7892                         BPF_ALU64_REG(BPF_MOV, R1, R0),
7893                         BPF_ALU64_IMM(BPF_RSH, R1, 32),
7894                         BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
7895                         BPF_EXIT_INSN(),
7896                 },
7897                 INTERNAL,
7898                 { },
7899                 { { 0, cpu_to_be32(0x76543210) } },
7900         },
7901         {
7902                 "ALU_END_FROM_BE 64: 0xfedcba9876543210 -> 0x76543210",
7903                 .u.insns_int = {
7904                         BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7905                         BPF_ENDIAN(BPF_FROM_BE, R0, 64),
7906                         BPF_EXIT_INSN(),
7907                 },
7908                 INTERNAL,
7909                 { },
7910                 { { 0, (u32) cpu_to_be64(0xfedcba9876543210ULL) } },
7911         },
7912         {
7913                 "ALU_END_FROM_BE 64: 0xfedcba9876543210 >> 32 -> 0xfedcba98",
7914                 .u.insns_int = {
7915                         BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7916                         BPF_ENDIAN(BPF_FROM_BE, R0, 64),
7917                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
7918                         BPF_EXIT_INSN(),
7919                 },
7920                 INTERNAL,
7921                 { },
7922                 { { 0, (u32) (cpu_to_be64(0xfedcba9876543210ULL) >> 32) } },
7923         },
7924         /* BPF_ALU | BPF_END | BPF_FROM_LE */
7925         {
7926                 "ALU_END_FROM_LE 16: 0x0123456789abcdef -> 0xefcd",
7927                 .u.insns_int = {
7928                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7929                         BPF_ENDIAN(BPF_FROM_LE, R0, 16),
7930                         BPF_EXIT_INSN(),
7931                 },
7932                 INTERNAL,
7933                 { },
7934                 { { 0, cpu_to_le16(0xcdef) } },
7935         },
7936         {
7937                 "ALU_END_FROM_LE 32: 0x0123456789abcdef -> 0xefcdab89",
7938                 .u.insns_int = {
7939                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7940                         BPF_ENDIAN(BPF_FROM_LE, R0, 32),
7941                         BPF_ALU64_REG(BPF_MOV, R1, R0),
7942                         BPF_ALU64_IMM(BPF_RSH, R1, 32),
7943                         BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
7944                         BPF_EXIT_INSN(),
7945                 },
7946                 INTERNAL,
7947                 { },
7948                 { { 0, cpu_to_le32(0x89abcdef) } },
7949         },
7950         {
7951                 "ALU_END_FROM_LE 64: 0x0123456789abcdef -> 0x67452301",
7952                 .u.insns_int = {
7953                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7954                         BPF_ENDIAN(BPF_FROM_LE, R0, 64),
7955                         BPF_EXIT_INSN(),
7956                 },
7957                 INTERNAL,
7958                 { },
7959                 { { 0, (u32) cpu_to_le64(0x0123456789abcdefLL) } },
7960         },
7961         {
7962                 "ALU_END_FROM_LE 64: 0x0123456789abcdef >> 32 -> 0xefcdab89",
7963                 .u.insns_int = {
7964                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7965                         BPF_ENDIAN(BPF_FROM_LE, R0, 64),
7966                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
7967                         BPF_EXIT_INSN(),
7968                 },
7969                 INTERNAL,
7970                 { },
7971                 { { 0, (u32) (cpu_to_le64(0x0123456789abcdefLL) >> 32) } },
7972         },
7973         /* BPF_ALU | BPF_END | BPF_FROM_LE, reversed */
7974         {
7975                 "ALU_END_FROM_LE 16: 0xfedcba9876543210 -> 0x1032",
7976                 .u.insns_int = {
7977                         BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7978                         BPF_ENDIAN(BPF_FROM_LE, R0, 16),
7979                         BPF_EXIT_INSN(),
7980                 },
7981                 INTERNAL,
7982                 { },
7983                 { { 0,  cpu_to_le16(0x3210) } },
7984         },
7985         {
7986                 "ALU_END_FROM_LE 32: 0xfedcba9876543210 -> 0x10325476",
7987                 .u.insns_int = {
7988                         BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7989                         BPF_ENDIAN(BPF_FROM_LE, R0, 32),
7990                         BPF_ALU64_REG(BPF_MOV, R1, R0),
7991                         BPF_ALU64_IMM(BPF_RSH, R1, 32),
7992                         BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
7993                         BPF_EXIT_INSN(),
7994                 },
7995                 INTERNAL,
7996                 { },
7997                 { { 0, cpu_to_le32(0x76543210) } },
7998         },
7999         {
8000                 "ALU_END_FROM_LE 64: 0xfedcba9876543210 -> 0x10325476",
8001                 .u.insns_int = {
8002                         BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
8003                         BPF_ENDIAN(BPF_FROM_LE, R0, 64),
8004                         BPF_EXIT_INSN(),
8005                 },
8006                 INTERNAL,
8007                 { },
8008                 { { 0, (u32) cpu_to_le64(0xfedcba9876543210ULL) } },
8009         },
8010         {
8011                 "ALU_END_FROM_LE 64: 0xfedcba9876543210 >> 32 -> 0x98badcfe",
8012                 .u.insns_int = {
8013                         BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
8014                         BPF_ENDIAN(BPF_FROM_LE, R0, 64),
8015                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
8016                         BPF_EXIT_INSN(),
8017                 },
8018                 INTERNAL,
8019                 { },
8020                 { { 0, (u32) (cpu_to_le64(0xfedcba9876543210ULL) >> 32) } },
8021         },
8022         /* BSWAP */
8023         {
8024                 "BSWAP 16: 0x0123456789abcdef -> 0xefcd",
8025                 .u.insns_int = {
8026                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
8027                         BPF_BSWAP(R0, 16),
8028                         BPF_EXIT_INSN(),
8029                 },
8030                 INTERNAL,
8031                 { },
8032                 { { 0, 0xefcd } },
8033         },
8034         {
8035                 "BSWAP 32: 0x0123456789abcdef -> 0xefcdab89",
8036                 .u.insns_int = {
8037                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
8038                         BPF_BSWAP(R0, 32),
8039                         BPF_ALU64_REG(BPF_MOV, R1, R0),
8040                         BPF_ALU64_IMM(BPF_RSH, R1, 32),
8041                         BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
8042                         BPF_EXIT_INSN(),
8043                 },
8044                 INTERNAL,
8045                 { },
8046                 { { 0, 0xefcdab89 } },
8047         },
8048         {
8049                 "BSWAP 64: 0x0123456789abcdef -> 0x67452301",
8050                 .u.insns_int = {
8051                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
8052                         BPF_BSWAP(R0, 64),
8053                         BPF_EXIT_INSN(),
8054                 },
8055                 INTERNAL,
8056                 { },
8057                 { { 0, 0x67452301 } },
8058         },
8059         {
8060                 "BSWAP 64: 0x0123456789abcdef >> 32 -> 0xefcdab89",
8061                 .u.insns_int = {
8062                         BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
8063                         BPF_BSWAP(R0, 64),
8064                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
8065                         BPF_EXIT_INSN(),
8066                 },
8067                 INTERNAL,
8068                 { },
8069                 { { 0, 0xefcdab89 } },
8070         },
8071         /* BSWAP, reversed */
8072         {
8073                 "BSWAP 16: 0xfedcba9876543210 -> 0x1032",
8074                 .u.insns_int = {
8075                         BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
8076                         BPF_BSWAP(R0, 16),
8077                         BPF_EXIT_INSN(),
8078                 },
8079                 INTERNAL,
8080                 { },
8081                 { { 0, 0x1032 } },
8082         },
8083         {
8084                 "BSWAP 32: 0xfedcba9876543210 -> 0x10325476",
8085                 .u.insns_int = {
8086                         BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
8087                         BPF_BSWAP(R0, 32),
8088                         BPF_ALU64_REG(BPF_MOV, R1, R0),
8089                         BPF_ALU64_IMM(BPF_RSH, R1, 32),
8090                         BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
8091                         BPF_EXIT_INSN(),
8092                 },
8093                 INTERNAL,
8094                 { },
8095                 { { 0, 0x10325476 } },
8096         },
8097         {
8098                 "BSWAP 64: 0xfedcba9876543210 -> 0x98badcfe",
8099                 .u.insns_int = {
8100                         BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
8101                         BPF_BSWAP(R0, 64),
8102                         BPF_EXIT_INSN(),
8103                 },
8104                 INTERNAL,
8105                 { },
8106                 { { 0, 0x98badcfe } },
8107         },
8108         {
8109                 "BSWAP 64: 0xfedcba9876543210 >> 32 -> 0x10325476",
8110                 .u.insns_int = {
8111                         BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
8112                         BPF_BSWAP(R0, 64),
8113                         BPF_ALU64_IMM(BPF_RSH, R0, 32),
8114                         BPF_EXIT_INSN(),
8115                 },
8116                 INTERNAL,
8117                 { },
8118                 { { 0, 0x10325476 } },
8119         },
8120         /* BPF_LDX_MEM B/H/W/DW */
8121         {
8122                 "BPF_LDX_MEM | BPF_B, base",
8123                 .u.insns_int = {
8124                         BPF_LD_IMM64(R1, 0x0102030405060708ULL),
8125                         BPF_LD_IMM64(R2, 0x0000000000000008ULL),
8126                         BPF_STX_MEM(BPF_DW, R10, R1, -8),
8127 #ifdef __BIG_ENDIAN
8128                         BPF_LDX_MEM(BPF_B, R0, R10, -1),
8129 #else
8130                         BPF_LDX_MEM(BPF_B, R0, R10, -8),
8131 #endif
8132                         BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8133                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
8134                         BPF_EXIT_INSN(),
8135                 },
8136                 INTERNAL,
8137                 { },
8138                 { { 0, 0 } },
8139                 .stack_depth = 8,
8140         },
8141         {
8142                 "BPF_LDX_MEM | BPF_B, MSB set",
8143                 .u.insns_int = {
8144                         BPF_LD_IMM64(R1, 0x8182838485868788ULL),
8145                         BPF_LD_IMM64(R2, 0x0000000000000088ULL),
8146                         BPF_STX_MEM(BPF_DW, R10, R1, -8),
8147 #ifdef __BIG_ENDIAN
8148                         BPF_LDX_MEM(BPF_B, R0, R10, -1),
8149 #else
8150                         BPF_LDX_MEM(BPF_B, R0, R10, -8),
8151 #endif
8152                         BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8153                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
8154                         BPF_EXIT_INSN(),
8155                 },
8156                 INTERNAL,
8157                 { },
8158                 { { 0, 0 } },
8159                 .stack_depth = 8,
8160         },
8161         {
8162                 "BPF_LDX_MEM | BPF_B, negative offset",
8163                 .u.insns_int = {
8164                         BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8165                         BPF_LD_IMM64(R3, 0x0000000000000088ULL),
8166                         BPF_ALU64_IMM(BPF_ADD, R1, 512),
8167                         BPF_STX_MEM(BPF_B, R1, R2, -256),
8168                         BPF_LDX_MEM(BPF_B, R0, R1, -256),
8169                         BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8170                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
8171                         BPF_EXIT_INSN(),
8172                 },
8173                 INTERNAL | FLAG_LARGE_MEM,
8174                 { },
8175                 { { 512, 0 } },
8176                 .stack_depth = 0,
8177         },
8178         {
8179                 "BPF_LDX_MEM | BPF_B, small positive offset",
8180                 .u.insns_int = {
8181                         BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8182                         BPF_LD_IMM64(R3, 0x0000000000000088ULL),
8183                         BPF_STX_MEM(BPF_B, R1, R2, 256),
8184                         BPF_LDX_MEM(BPF_B, R0, R1, 256),
8185                         BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8186                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
8187                         BPF_EXIT_INSN(),
8188                 },
8189                 INTERNAL | FLAG_LARGE_MEM,
8190                 { },
8191                 { { 512, 0 } },
8192                 .stack_depth = 0,
8193         },
8194         {
8195                 "BPF_LDX_MEM | BPF_B, large positive offset",
8196                 .u.insns_int = {
8197                         BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8198                         BPF_LD_IMM64(R3, 0x0000000000000088ULL),
8199                         BPF_STX_MEM(BPF_B, R1, R2, 4096),
8200                         BPF_LDX_MEM(BPF_B, R0, R1, 4096),
8201                         BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8202                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
8203                         BPF_EXIT_INSN(),
8204                 },
8205                 INTERNAL | FLAG_LARGE_MEM,
8206                 { },
8207                 { { 4096 + 16, 0 } },
8208                 .stack_depth = 0,
8209         },
8210         {
8211                 "BPF_LDX_MEM | BPF_H, base",
8212                 .u.insns_int = {
8213                         BPF_LD_IMM64(R1, 0x0102030405060708ULL),
8214                         BPF_LD_IMM64(R2, 0x0000000000000708ULL),
8215                         BPF_STX_MEM(BPF_DW, R10, R1, -8),
8216 #ifdef __BIG_ENDIAN
8217                         BPF_LDX_MEM(BPF_H, R0, R10, -2),
8218 #else
8219                         BPF_LDX_MEM(BPF_H, R0, R10, -8),
8220 #endif
8221                         BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8222                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
8223                         BPF_EXIT_INSN(),
8224                 },
8225                 INTERNAL,
8226                 { },
8227                 { { 0, 0 } },
8228                 .stack_depth = 8,
8229         },
8230         {
8231                 "BPF_LDX_MEM | BPF_H, MSB set",
8232                 .u.insns_int = {
8233                         BPF_LD_IMM64(R1, 0x8182838485868788ULL),
8234                         BPF_LD_IMM64(R2, 0x0000000000008788ULL),
8235                         BPF_STX_MEM(BPF_DW, R10, R1, -8),
8236 #ifdef __BIG_ENDIAN
8237                         BPF_LDX_MEM(BPF_H, R0, R10, -2),
8238 #else
8239                         BPF_LDX_MEM(BPF_H, R0, R10, -8),
8240 #endif
8241                         BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8242                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
8243                         BPF_EXIT_INSN(),
8244                 },
8245                 INTERNAL,
8246                 { },
8247                 { { 0, 0 } },
8248                 .stack_depth = 8,
8249         },
8250         {
8251                 "BPF_LDX_MEM | BPF_H, negative offset",
8252                 .u.insns_int = {
8253                         BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8254                         BPF_LD_IMM64(R3, 0x0000000000008788ULL),
8255                         BPF_ALU64_IMM(BPF_ADD, R1, 512),
8256                         BPF_STX_MEM(BPF_H, R1, R2, -256),
8257                         BPF_LDX_MEM(BPF_H, R0, R1, -256),
8258                         BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8259                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
8260                         BPF_EXIT_INSN(),
8261                 },
8262                 INTERNAL | FLAG_LARGE_MEM,
8263                 { },
8264                 { { 512, 0 } },
8265                 .stack_depth = 0,
8266         },
8267         {
8268                 "BPF_LDX_MEM | BPF_H, small positive offset",
8269                 .u.insns_int = {
8270                         BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8271                         BPF_LD_IMM64(R3, 0x0000000000008788ULL),
8272                         BPF_STX_MEM(BPF_H, R1, R2, 256),
8273                         BPF_LDX_MEM(BPF_H, R0, R1, 256),
8274                         BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8275                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
8276                         BPF_EXIT_INSN(),
8277                 },
8278                 INTERNAL | FLAG_LARGE_MEM,
8279                 { },
8280                 { { 512, 0 } },
8281                 .stack_depth = 0,
8282         },
8283         {
8284                 "BPF_LDX_MEM | BPF_H, large positive offset",
8285                 .u.insns_int = {
8286                         BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8287                         BPF_LD_IMM64(R3, 0x0000000000008788ULL),
8288                         BPF_STX_MEM(BPF_H, R1, R2, 8192),
8289                         BPF_LDX_MEM(BPF_H, R0, R1, 8192),
8290                         BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8291                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
8292                         BPF_EXIT_INSN(),
8293                 },
8294                 INTERNAL | FLAG_LARGE_MEM,
8295                 { },
8296                 { { 8192 + 16, 0 } },
8297                 .stack_depth = 0,
8298         },
8299         {
8300                 "BPF_LDX_MEM | BPF_H, unaligned positive offset",
8301                 .u.insns_int = {
8302                         BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8303                         BPF_LD_IMM64(R3, 0x0000000000008788ULL),
8304                         BPF_STX_MEM(BPF_H, R1, R2, 13),
8305                         BPF_LDX_MEM(BPF_H, R0, R1, 13),
8306                         BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8307                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
8308                         BPF_EXIT_INSN(),
8309                 },
8310                 INTERNAL | FLAG_LARGE_MEM,
8311                 { },
8312                 { { 32, 0 } },
8313                 .stack_depth = 0,
8314         },
8315         {
8316                 "BPF_LDX_MEM | BPF_W, base",
8317                 .u.insns_int = {
8318                         BPF_LD_IMM64(R1, 0x0102030405060708ULL),
8319                         BPF_LD_IMM64(R2, 0x0000000005060708ULL),
8320                         BPF_STX_MEM(BPF_DW, R10, R1, -8),
8321 #ifdef __BIG_ENDIAN
8322                         BPF_LDX_MEM(BPF_W, R0, R10, -4),
8323 #else
8324                         BPF_LDX_MEM(BPF_W, R0, R10, -8),
8325 #endif
8326                         BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8327                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
8328                         BPF_EXIT_INSN(),
8329                 },
8330                 INTERNAL,
8331                 { },
8332                 { { 0, 0 } },
8333                 .stack_depth = 8,
8334         },
8335         {
8336                 "BPF_LDX_MEM | BPF_W, MSB set",
8337                 .u.insns_int = {
8338                         BPF_LD_IMM64(R1, 0x8182838485868788ULL),
8339                         BPF_LD_IMM64(R2, 0x0000000085868788ULL),
8340                         BPF_STX_MEM(BPF_DW, R10, R1, -8),
8341 #ifdef __BIG_ENDIAN
8342                         BPF_LDX_MEM(BPF_W, R0, R10, -4),
8343 #else
8344                         BPF_LDX_MEM(BPF_W, R0, R10, -8),
8345 #endif
8346                         BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8347                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
8348                         BPF_EXIT_INSN(),
8349                 },
8350                 INTERNAL,
8351                 { },
8352                 { { 0, 0 } },
8353                 .stack_depth = 8,
8354         },
8355         {
8356                 "BPF_LDX_MEM | BPF_W, negative offset",
8357                 .u.insns_int = {
8358                         BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8359                         BPF_LD_IMM64(R3, 0x0000000085868788ULL),
8360                         BPF_ALU64_IMM(BPF_ADD, R1, 512),
8361                         BPF_STX_MEM(BPF_W, R1, R2, -256),
8362                         BPF_LDX_MEM(BPF_W, R0, R1, -256),
8363                         BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8364                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
8365                         BPF_EXIT_INSN(),
8366                 },
8367                 INTERNAL | FLAG_LARGE_MEM,
8368                 { },
8369                 { { 512, 0 } },
8370                 .stack_depth = 0,
8371         },
8372         {
8373                 "BPF_LDX_MEM | BPF_W, small positive offset",
8374                 .u.insns_int = {
8375                         BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8376                         BPF_LD_IMM64(R3, 0x0000000085868788ULL),
8377                         BPF_STX_MEM(BPF_W, R1, R2, 256),
8378                         BPF_LDX_MEM(BPF_W, R0, R1, 256),
8379                         BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8380                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
8381                         BPF_EXIT_INSN(),
8382                 },
8383                 INTERNAL | FLAG_LARGE_MEM,
8384                 { },
8385                 { { 512, 0 } },
8386                 .stack_depth = 0,
8387         },
8388         {
8389                 "BPF_LDX_MEM | BPF_W, large positive offset",
8390                 .u.insns_int = {
8391                         BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8392                         BPF_LD_IMM64(R3, 0x0000000085868788ULL),
8393                         BPF_STX_MEM(BPF_W, R1, R2, 16384),
8394                         BPF_LDX_MEM(BPF_W, R0, R1, 16384),
8395                         BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8396                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
8397                         BPF_EXIT_INSN(),
8398                 },
8399                 INTERNAL | FLAG_LARGE_MEM,
8400                 { },
8401                 { { 16384 + 16, 0 } },
8402                 .stack_depth = 0,
8403         },
8404         {
8405                 "BPF_LDX_MEM | BPF_W, unaligned positive offset",
8406                 .u.insns_int = {
8407                         BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8408                         BPF_LD_IMM64(R3, 0x0000000085868788ULL),
8409                         BPF_STX_MEM(BPF_W, R1, R2, 13),
8410                         BPF_LDX_MEM(BPF_W, R0, R1, 13),
8411                         BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8412                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
8413                         BPF_EXIT_INSN(),
8414                 },
8415                 INTERNAL | FLAG_LARGE_MEM,
8416                 { },
8417                 { { 32, 0 } },
8418                 .stack_depth = 0,
8419         },
8420         {
8421                 "BPF_LDX_MEM | BPF_DW, base",
8422                 .u.insns_int = {
8423                         BPF_LD_IMM64(R1, 0x0102030405060708ULL),
8424                         BPF_STX_MEM(BPF_DW, R10, R1, -8),
8425                         BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8426                         BPF_JMP_REG(BPF_JNE, R0, R1, 1),
8427                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
8428                         BPF_EXIT_INSN(),
8429                 },
8430                 INTERNAL,
8431                 { },
8432                 { { 0, 0 } },
8433                 .stack_depth = 8,
8434         },
8435         {
8436                 "BPF_LDX_MEM | BPF_DW, MSB set",
8437                 .u.insns_int = {
8438                         BPF_LD_IMM64(R1, 0x8182838485868788ULL),
8439                         BPF_STX_MEM(BPF_DW, R10, R1, -8),
8440                         BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8441                         BPF_JMP_REG(BPF_JNE, R0, R1, 1),
8442                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
8443                         BPF_EXIT_INSN(),
8444                 },
8445                 INTERNAL,
8446                 { },
8447                 { { 0, 0 } },
8448                 .stack_depth = 8,
8449         },
8450         {
8451                 "BPF_LDX_MEM | BPF_DW, negative offset",
8452                 .u.insns_int = {
8453                         BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8454                         BPF_ALU64_IMM(BPF_ADD, R1, 512),
8455                         BPF_STX_MEM(BPF_DW, R1, R2, -256),
8456                         BPF_LDX_MEM(BPF_DW, R0, R1, -256),
8457                         BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8458                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
8459                         BPF_EXIT_INSN(),
8460                 },
8461                 INTERNAL | FLAG_LARGE_MEM,
8462                 { },
8463                 { { 512, 0 } },
8464                 .stack_depth = 0,
8465         },
8466         {
8467                 "BPF_LDX_MEM | BPF_DW, small positive offset",
8468                 .u.insns_int = {
8469                         BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8470                         BPF_STX_MEM(BPF_DW, R1, R2, 256),
8471                         BPF_LDX_MEM(BPF_DW, R0, R1, 256),
8472                         BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8473                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
8474                         BPF_EXIT_INSN(),
8475                 },
8476                 INTERNAL | FLAG_LARGE_MEM,
8477                 { },
8478                 { { 512, 0 } },
8479                 .stack_depth = 8,
8480         },
8481         {
8482                 "BPF_LDX_MEM | BPF_DW, large positive offset",
8483                 .u.insns_int = {
8484                         BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8485                         BPF_STX_MEM(BPF_DW, R1, R2, 32760),
8486                         BPF_LDX_MEM(BPF_DW, R0, R1, 32760),
8487                         BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8488                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
8489                         BPF_EXIT_INSN(),
8490                 },
8491                 INTERNAL | FLAG_LARGE_MEM,
8492                 { },
8493                 { { 32768, 0 } },
8494                 .stack_depth = 0,
8495         },
8496         {
8497                 "BPF_LDX_MEM | BPF_DW, unaligned positive offset",
8498                 .u.insns_int = {
8499                         BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8500                         BPF_STX_MEM(BPF_DW, R1, R2, 13),
8501                         BPF_LDX_MEM(BPF_DW, R0, R1, 13),
8502                         BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8503                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
8504                         BPF_EXIT_INSN(),
8505                 },
8506                 INTERNAL | FLAG_LARGE_MEM,
8507                 { },
8508                 { { 32, 0 } },
8509                 .stack_depth = 0,
8510         },
8511         /* BPF_LDX_MEMSX B/H/W */
8512         {
8513                 "BPF_LDX_MEMSX | BPF_B",
8514                 .u.insns_int = {
8515                         BPF_LD_IMM64(R1, 0xdead0000000000f0ULL),
8516                         BPF_LD_IMM64(R2, 0xfffffffffffffff0ULL),
8517                         BPF_STX_MEM(BPF_DW, R10, R1, -8),
8518 #ifdef __BIG_ENDIAN
8519                         BPF_LDX_MEMSX(BPF_B, R0, R10, -1),
8520 #else
8521                         BPF_LDX_MEMSX(BPF_B, R0, R10, -8),
8522 #endif
8523                         BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8524                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
8525                         BPF_EXIT_INSN(),
8526                 },
8527                 INTERNAL,
8528                 { },
8529                 { { 0, 0 } },
8530                 .stack_depth = 8,
8531         },
8532         {
8533                 "BPF_LDX_MEMSX | BPF_H",
8534                 .u.insns_int = {
8535                         BPF_LD_IMM64(R1, 0xdead00000000f123ULL),
8536                         BPF_LD_IMM64(R2, 0xfffffffffffff123ULL),
8537                         BPF_STX_MEM(BPF_DW, R10, R1, -8),
8538 #ifdef __BIG_ENDIAN
8539                         BPF_LDX_MEMSX(BPF_H, R0, R10, -2),
8540 #else
8541                         BPF_LDX_MEMSX(BPF_H, R0, R10, -8),
8542 #endif
8543                         BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8544                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
8545                         BPF_EXIT_INSN(),
8546                 },
8547                 INTERNAL,
8548                 { },
8549                 { { 0, 0 } },
8550                 .stack_depth = 8,
8551         },
8552         {
8553                 "BPF_LDX_MEMSX | BPF_W",
8554                 .u.insns_int = {
8555                         BPF_LD_IMM64(R1, 0x00000000deadbeefULL),
8556                         BPF_LD_IMM64(R2, 0xffffffffdeadbeefULL),
8557                         BPF_STX_MEM(BPF_DW, R10, R1, -8),
8558 #ifdef __BIG_ENDIAN
8559                         BPF_LDX_MEMSX(BPF_W, R0, R10, -4),
8560 #else
8561                         BPF_LDX_MEMSX(BPF_W, R0, R10, -8),
8562 #endif
8563                         BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8564                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
8565                         BPF_EXIT_INSN(),
8566                 },
8567                 INTERNAL,
8568                 { },
8569                 { { 0, 0 } },
8570                 .stack_depth = 8,
8571         },
8572         /* BPF_STX_MEM B/H/W/DW */
8573         {
8574                 "BPF_STX_MEM | BPF_B",
8575                 .u.insns_int = {
8576                         BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8577                         BPF_LD_IMM64(R2, 0x0102030405060708ULL),
8578                         BPF_LD_IMM64(R3, 0x8090a0b0c0d0e008ULL),
8579                         BPF_STX_MEM(BPF_DW, R10, R1, -8),
8580 #ifdef __BIG_ENDIAN
8581                         BPF_STX_MEM(BPF_B, R10, R2, -1),
8582 #else
8583                         BPF_STX_MEM(BPF_B, R10, R2, -8),
8584 #endif
8585                         BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8586                         BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8587                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
8588                         BPF_EXIT_INSN(),
8589                 },
8590                 INTERNAL,
8591                 { },
8592                 { { 0, 0 } },
8593                 .stack_depth = 8,
8594         },
8595         {
8596                 "BPF_STX_MEM | BPF_B, MSB set",
8597                 .u.insns_int = {
8598                         BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8599                         BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8600                         BPF_LD_IMM64(R3, 0x8090a0b0c0d0e088ULL),
8601                         BPF_STX_MEM(BPF_DW, R10, R1, -8),
8602 #ifdef __BIG_ENDIAN
8603                         BPF_STX_MEM(BPF_B, R10, R2, -1),
8604 #else
8605                         BPF_STX_MEM(BPF_B, R10, R2, -8),
8606 #endif
8607                         BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8608                         BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8609                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
8610                         BPF_EXIT_INSN(),
8611                 },
8612                 INTERNAL,
8613                 { },
8614                 { { 0, 0 } },
8615                 .stack_depth = 8,
8616         },
8617         {
8618                 "BPF_STX_MEM | BPF_H",
8619                 .u.insns_int = {
8620                         BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8621                         BPF_LD_IMM64(R2, 0x0102030405060708ULL),
8622                         BPF_LD_IMM64(R3, 0x8090a0b0c0d00708ULL),
8623                         BPF_STX_MEM(BPF_DW, R10, R1, -8),
8624 #ifdef __BIG_ENDIAN
8625                         BPF_STX_MEM(BPF_H, R10, R2, -2),
8626 #else
8627                         BPF_STX_MEM(BPF_H, R10, R2, -8),
8628 #endif
8629                         BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8630                         BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8631                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
8632                         BPF_EXIT_INSN(),
8633                 },
8634                 INTERNAL,
8635                 { },
8636                 { { 0, 0 } },
8637                 .stack_depth = 8,
8638         },
8639         {
8640                 "BPF_STX_MEM | BPF_H, MSB set",
8641                 .u.insns_int = {
8642                         BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8643                         BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8644                         BPF_LD_IMM64(R3, 0x8090a0b0c0d08788ULL),
8645                         BPF_STX_MEM(BPF_DW, R10, R1, -8),
8646 #ifdef __BIG_ENDIAN
8647                         BPF_STX_MEM(BPF_H, R10, R2, -2),
8648 #else
8649                         BPF_STX_MEM(BPF_H, R10, R2, -8),
8650 #endif
8651                         BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8652                         BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8653                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
8654                         BPF_EXIT_INSN(),
8655                 },
8656                 INTERNAL,
8657                 { },
8658                 { { 0, 0 } },
8659                 .stack_depth = 8,
8660         },
8661         {
8662                 "BPF_STX_MEM | BPF_W",
8663                 .u.insns_int = {
8664                         BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8665                         BPF_LD_IMM64(R2, 0x0102030405060708ULL),
8666                         BPF_LD_IMM64(R3, 0x8090a0b005060708ULL),
8667                         BPF_STX_MEM(BPF_DW, R10, R1, -8),
8668 #ifdef __BIG_ENDIAN
8669                         BPF_STX_MEM(BPF_W, R10, R2, -4),
8670 #else
8671                         BPF_STX_MEM(BPF_W, R10, R2, -8),
8672 #endif
8673                         BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8674                         BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8675                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
8676                         BPF_EXIT_INSN(),
8677                 },
8678                 INTERNAL,
8679                 { },
8680                 { { 0, 0 } },
8681                 .stack_depth = 8,
8682         },
8683         {
8684                 "BPF_STX_MEM | BPF_W, MSB set",
8685                 .u.insns_int = {
8686                         BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8687                         BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8688                         BPF_LD_IMM64(R3, 0x8090a0b085868788ULL),
8689                         BPF_STX_MEM(BPF_DW, R10, R1, -8),
8690 #ifdef __BIG_ENDIAN
8691                         BPF_STX_MEM(BPF_W, R10, R2, -4),
8692 #else
8693                         BPF_STX_MEM(BPF_W, R10, R2, -8),
8694 #endif
8695                         BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8696                         BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8697                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
8698                         BPF_EXIT_INSN(),
8699                 },
8700                 INTERNAL,
8701                 { },
8702                 { { 0, 0 } },
8703                 .stack_depth = 8,
8704         },
8705         /* BPF_ST(X) | BPF_MEM | BPF_B/H/W/DW */
8706         {
8707                 "ST_MEM_B: Store/Load byte: max negative",
8708                 .u.insns_int = {
8709                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
8710                         BPF_ST_MEM(BPF_B, R10, -40, 0xff),
8711                         BPF_LDX_MEM(BPF_B, R0, R10, -40),
8712                         BPF_EXIT_INSN(),
8713                 },
8714                 INTERNAL,
8715                 { },
8716                 { { 0, 0xff } },
8717                 .stack_depth = 40,
8718         },
8719         {
8720                 "ST_MEM_B: Store/Load byte: max positive",
8721                 .u.insns_int = {
8722                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
8723                         BPF_ST_MEM(BPF_H, R10, -40, 0x7f),
8724                         BPF_LDX_MEM(BPF_H, R0, R10, -40),
8725                         BPF_EXIT_INSN(),
8726                 },
8727                 INTERNAL,
8728                 { },
8729                 { { 0, 0x7f } },
8730                 .stack_depth = 40,
8731         },
8732         {
8733                 "STX_MEM_B: Store/Load byte: max negative",
8734                 .u.insns_int = {
8735                         BPF_LD_IMM64(R0, 0),
8736                         BPF_LD_IMM64(R1, 0xffLL),
8737                         BPF_STX_MEM(BPF_B, R10, R1, -40),
8738                         BPF_LDX_MEM(BPF_B, R0, R10, -40),
8739                         BPF_EXIT_INSN(),
8740                 },
8741                 INTERNAL,
8742                 { },
8743                 { { 0, 0xff } },
8744                 .stack_depth = 40,
8745         },
8746         {
8747                 "ST_MEM_H: Store/Load half word: max negative",
8748                 .u.insns_int = {
8749                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
8750                         BPF_ST_MEM(BPF_H, R10, -40, 0xffff),
8751                         BPF_LDX_MEM(BPF_H, R0, R10, -40),
8752                         BPF_EXIT_INSN(),
8753                 },
8754                 INTERNAL,
8755                 { },
8756                 { { 0, 0xffff } },
8757                 .stack_depth = 40,
8758         },
8759         {
8760                 "ST_MEM_H: Store/Load half word: max positive",
8761                 .u.insns_int = {
8762                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
8763                         BPF_ST_MEM(BPF_H, R10, -40, 0x7fff),
8764                         BPF_LDX_MEM(BPF_H, R0, R10, -40),
8765                         BPF_EXIT_INSN(),
8766                 },
8767                 INTERNAL,
8768                 { },
8769                 { { 0, 0x7fff } },
8770                 .stack_depth = 40,
8771         },
8772         {
8773                 "STX_MEM_H: Store/Load half word: max negative",
8774                 .u.insns_int = {
8775                         BPF_LD_IMM64(R0, 0),
8776                         BPF_LD_IMM64(R1, 0xffffLL),
8777                         BPF_STX_MEM(BPF_H, R10, R1, -40),
8778                         BPF_LDX_MEM(BPF_H, R0, R10, -40),
8779                         BPF_EXIT_INSN(),
8780                 },
8781                 INTERNAL,
8782                 { },
8783                 { { 0, 0xffff } },
8784                 .stack_depth = 40,
8785         },
8786         {
8787                 "ST_MEM_W: Store/Load word: max negative",
8788                 .u.insns_int = {
8789                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
8790                         BPF_ST_MEM(BPF_W, R10, -40, 0xffffffff),
8791                         BPF_LDX_MEM(BPF_W, R0, R10, -40),
8792                         BPF_EXIT_INSN(),
8793                 },
8794                 INTERNAL,
8795                 { },
8796                 { { 0, 0xffffffff } },
8797                 .stack_depth = 40,
8798         },
8799         {
8800                 "ST_MEM_W: Store/Load word: max positive",
8801                 .u.insns_int = {
8802                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
8803                         BPF_ST_MEM(BPF_W, R10, -40, 0x7fffffff),
8804                         BPF_LDX_MEM(BPF_W, R0, R10, -40),
8805                         BPF_EXIT_INSN(),
8806                 },
8807                 INTERNAL,
8808                 { },
8809                 { { 0, 0x7fffffff } },
8810                 .stack_depth = 40,
8811         },
8812         {
8813                 "STX_MEM_W: Store/Load word: max negative",
8814                 .u.insns_int = {
8815                         BPF_LD_IMM64(R0, 0),
8816                         BPF_LD_IMM64(R1, 0xffffffffLL),
8817                         BPF_STX_MEM(BPF_W, R10, R1, -40),
8818                         BPF_LDX_MEM(BPF_W, R0, R10, -40),
8819                         BPF_EXIT_INSN(),
8820                 },
8821                 INTERNAL,
8822                 { },
8823                 { { 0, 0xffffffff } },
8824                 .stack_depth = 40,
8825         },
8826         {
8827                 "ST_MEM_DW: Store/Load double word: max negative",
8828                 .u.insns_int = {
8829                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
8830                         BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
8831                         BPF_LDX_MEM(BPF_DW, R0, R10, -40),
8832                         BPF_EXIT_INSN(),
8833                 },
8834                 INTERNAL,
8835                 { },
8836                 { { 0, 0xffffffff } },
8837                 .stack_depth = 40,
8838         },
8839         {
8840                 "ST_MEM_DW: Store/Load double word: max negative 2",
8841                 .u.insns_int = {
8842                         BPF_LD_IMM64(R2, 0xffff00000000ffffLL),
8843                         BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
8844                         BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
8845                         BPF_LDX_MEM(BPF_DW, R2, R10, -40),
8846                         BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
8847                         BPF_MOV32_IMM(R0, 2),
8848                         BPF_EXIT_INSN(),
8849                         BPF_MOV32_IMM(R0, 1),
8850                         BPF_EXIT_INSN(),
8851                 },
8852                 INTERNAL,
8853                 { },
8854                 { { 0, 0x1 } },
8855                 .stack_depth = 40,
8856         },
8857         {
8858                 "ST_MEM_DW: Store/Load double word: max positive",
8859                 .u.insns_int = {
8860                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
8861                         BPF_ST_MEM(BPF_DW, R10, -40, 0x7fffffff),
8862                         BPF_LDX_MEM(BPF_DW, R0, R10, -40),
8863                         BPF_EXIT_INSN(),
8864                 },
8865                 INTERNAL,
8866                 { },
8867                 { { 0, 0x7fffffff } },
8868                 .stack_depth = 40,
8869         },
8870         {
8871                 "STX_MEM_DW: Store/Load double word: max negative",
8872                 .u.insns_int = {
8873                         BPF_LD_IMM64(R0, 0),
8874                         BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
8875                         BPF_STX_MEM(BPF_DW, R10, R1, -40),
8876                         BPF_LDX_MEM(BPF_DW, R0, R10, -40),
8877                         BPF_EXIT_INSN(),
8878                 },
8879                 INTERNAL,
8880                 { },
8881                 { { 0, 0xffffffff } },
8882                 .stack_depth = 40,
8883         },
8884         {
8885                 "STX_MEM_DW: Store double word: first word in memory",
8886                 .u.insns_int = {
8887                         BPF_LD_IMM64(R0, 0),
8888                         BPF_LD_IMM64(R1, 0x0123456789abcdefLL),
8889                         BPF_STX_MEM(BPF_DW, R10, R1, -40),
8890                         BPF_LDX_MEM(BPF_W, R0, R10, -40),
8891                         BPF_EXIT_INSN(),
8892                 },
8893                 INTERNAL,
8894                 { },
8895 #ifdef __BIG_ENDIAN
8896                 { { 0, 0x01234567 } },
8897 #else
8898                 { { 0, 0x89abcdef } },
8899 #endif
8900                 .stack_depth = 40,
8901         },
8902         {
8903                 "STX_MEM_DW: Store double word: second word in memory",
8904                 .u.insns_int = {
8905                         BPF_LD_IMM64(R0, 0),
8906                         BPF_LD_IMM64(R1, 0x0123456789abcdefLL),
8907                         BPF_STX_MEM(BPF_DW, R10, R1, -40),
8908                         BPF_LDX_MEM(BPF_W, R0, R10, -36),
8909                         BPF_EXIT_INSN(),
8910                 },
8911                 INTERNAL,
8912                 { },
8913 #ifdef __BIG_ENDIAN
8914                 { { 0, 0x89abcdef } },
8915 #else
8916                 { { 0, 0x01234567 } },
8917 #endif
8918                 .stack_depth = 40,
8919         },
8920         /* BPF_STX | BPF_ATOMIC | BPF_W/DW */
8921         {
8922                 "STX_XADD_W: X + 1 + 1 + 1 + ...",
8923                 { },
8924                 INTERNAL,
8925                 { },
8926                 { { 0, 4134 } },
8927                 .fill_helper = bpf_fill_stxw,
8928         },
8929         {
8930                 "STX_XADD_DW: X + 1 + 1 + 1 + ...",
8931                 { },
8932                 INTERNAL,
8933                 { },
8934                 { { 0, 4134 } },
8935                 .fill_helper = bpf_fill_stxdw,
8936         },
8937         /*
8938          * Exhaustive tests of atomic operation variants.
8939          * Individual tests are expanded from template macros for all
8940          * combinations of ALU operation, word size and fetching.
8941          */
8942 #define BPF_ATOMIC_POISON(width) ((width) == BPF_W ? (0xbaadf00dULL << 32) : 0)
8943
8944 #define BPF_ATOMIC_OP_TEST1(width, op, logic, old, update, result)      \
8945 {                                                                       \
8946         "BPF_ATOMIC | " #width ", " #op ": Test: "                      \
8947                 #old " " #logic " " #update " = " #result,              \
8948         .u.insns_int = {                                                \
8949                 BPF_LD_IMM64(R5, (update) | BPF_ATOMIC_POISON(width)),  \
8950                 BPF_ST_MEM(width, R10, -40, old),                       \
8951                 BPF_ATOMIC_OP(width, op, R10, R5, -40),                 \
8952                 BPF_LDX_MEM(width, R0, R10, -40),                       \
8953                 BPF_ALU64_REG(BPF_MOV, R1, R0),                         \
8954                 BPF_ALU64_IMM(BPF_RSH, R1, 32),                         \
8955                 BPF_ALU64_REG(BPF_OR, R0, R1),                          \
8956                 BPF_EXIT_INSN(),                                        \
8957         },                                                              \
8958         INTERNAL,                                                       \
8959         { },                                                            \
8960         { { 0, result } },                                              \
8961         .stack_depth = 40,                                              \
8962 }
8963 #define BPF_ATOMIC_OP_TEST2(width, op, logic, old, update, result)      \
8964 {                                                                       \
8965         "BPF_ATOMIC | " #width ", " #op ": Test side effects, r10: "    \
8966                 #old " " #logic " " #update " = " #result,              \
8967         .u.insns_int = {                                                \
8968                 BPF_ALU64_REG(BPF_MOV, R1, R10),                        \
8969                 BPF_LD_IMM64(R0, (update) | BPF_ATOMIC_POISON(width)),  \
8970                 BPF_ST_MEM(BPF_W, R10, -40, old),                       \
8971                 BPF_ATOMIC_OP(width, op, R10, R0, -40),                 \
8972                 BPF_ALU64_REG(BPF_MOV, R0, R10),                        \
8973                 BPF_ALU64_REG(BPF_SUB, R0, R1),                         \
8974                 BPF_ALU64_REG(BPF_MOV, R1, R0),                         \
8975                 BPF_ALU64_IMM(BPF_RSH, R1, 32),                         \
8976                 BPF_ALU64_REG(BPF_OR, R0, R1),                          \
8977                 BPF_EXIT_INSN(),                                        \
8978         },                                                              \
8979         INTERNAL,                                                       \
8980         { },                                                            \
8981         { { 0, 0 } },                                                   \
8982         .stack_depth = 40,                                              \
8983 }
8984 #define BPF_ATOMIC_OP_TEST3(width, op, logic, old, update, result)      \
8985 {                                                                       \
8986         "BPF_ATOMIC | " #width ", " #op ": Test side effects, r0: "     \
8987                 #old " " #logic " " #update " = " #result,              \
8988         .u.insns_int = {                                                \
8989                 BPF_ALU64_REG(BPF_MOV, R0, R10),                        \
8990                 BPF_LD_IMM64(R1, (update) | BPF_ATOMIC_POISON(width)),  \
8991                 BPF_ST_MEM(width, R10, -40, old),                       \
8992                 BPF_ATOMIC_OP(width, op, R10, R1, -40),                 \
8993                 BPF_ALU64_REG(BPF_SUB, R0, R10),                        \
8994                 BPF_ALU64_REG(BPF_MOV, R1, R0),                         \
8995                 BPF_ALU64_IMM(BPF_RSH, R1, 32),                         \
8996                 BPF_ALU64_REG(BPF_OR, R0, R1),                          \
8997                 BPF_EXIT_INSN(),                                        \
8998         },                                                              \
8999         INTERNAL,                                                       \
9000         { },                                                            \
9001         { { 0, 0 } },                                                   \
9002         .stack_depth = 40,                                              \
9003 }
9004 #define BPF_ATOMIC_OP_TEST4(width, op, logic, old, update, result)      \
9005 {                                                                       \
9006         "BPF_ATOMIC | " #width ", " #op ": Test fetch: "                \
9007                 #old " " #logic " " #update " = " #result,              \
9008         .u.insns_int = {                                                \
9009                 BPF_LD_IMM64(R3, (update) | BPF_ATOMIC_POISON(width)),  \
9010                 BPF_ST_MEM(width, R10, -40, old),                       \
9011                 BPF_ATOMIC_OP(width, op, R10, R3, -40),                 \
9012                 BPF_ALU32_REG(BPF_MOV, R0, R3),                         \
9013                 BPF_EXIT_INSN(),                                        \
9014         },                                                              \
9015         INTERNAL,                                                       \
9016         { },                                                            \
9017         { { 0, (op) & BPF_FETCH ? old : update } },                     \
9018         .stack_depth = 40,                                              \
9019 }
9020         /* BPF_ATOMIC | BPF_W: BPF_ADD */
9021         BPF_ATOMIC_OP_TEST1(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
9022         BPF_ATOMIC_OP_TEST2(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
9023         BPF_ATOMIC_OP_TEST3(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
9024         BPF_ATOMIC_OP_TEST4(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
9025         /* BPF_ATOMIC | BPF_W: BPF_ADD | BPF_FETCH */
9026         BPF_ATOMIC_OP_TEST1(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
9027         BPF_ATOMIC_OP_TEST2(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
9028         BPF_ATOMIC_OP_TEST3(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
9029         BPF_ATOMIC_OP_TEST4(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
9030         /* BPF_ATOMIC | BPF_DW: BPF_ADD */
9031         BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
9032         BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
9033         BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
9034         BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
9035         /* BPF_ATOMIC | BPF_DW: BPF_ADD | BPF_FETCH */
9036         BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
9037         BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
9038         BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
9039         BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
9040         /* BPF_ATOMIC | BPF_W: BPF_AND */
9041         BPF_ATOMIC_OP_TEST1(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
9042         BPF_ATOMIC_OP_TEST2(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
9043         BPF_ATOMIC_OP_TEST3(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
9044         BPF_ATOMIC_OP_TEST4(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
9045         /* BPF_ATOMIC | BPF_W: BPF_AND | BPF_FETCH */
9046         BPF_ATOMIC_OP_TEST1(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
9047         BPF_ATOMIC_OP_TEST2(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
9048         BPF_ATOMIC_OP_TEST3(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
9049         BPF_ATOMIC_OP_TEST4(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
9050         /* BPF_ATOMIC | BPF_DW: BPF_AND */
9051         BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
9052         BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
9053         BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
9054         BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
9055         /* BPF_ATOMIC | BPF_DW: BPF_AND | BPF_FETCH */
9056         BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
9057         BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
9058         BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
9059         BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
9060         /* BPF_ATOMIC | BPF_W: BPF_OR */
9061         BPF_ATOMIC_OP_TEST1(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
9062         BPF_ATOMIC_OP_TEST2(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
9063         BPF_ATOMIC_OP_TEST3(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
9064         BPF_ATOMIC_OP_TEST4(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
9065         /* BPF_ATOMIC | BPF_W: BPF_OR | BPF_FETCH */
9066         BPF_ATOMIC_OP_TEST1(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
9067         BPF_ATOMIC_OP_TEST2(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
9068         BPF_ATOMIC_OP_TEST3(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
9069         BPF_ATOMIC_OP_TEST4(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
9070         /* BPF_ATOMIC | BPF_DW: BPF_OR */
9071         BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
9072         BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
9073         BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
9074         BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
9075         /* BPF_ATOMIC | BPF_DW: BPF_OR | BPF_FETCH */
9076         BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
9077         BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
9078         BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
9079         BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
9080         /* BPF_ATOMIC | BPF_W: BPF_XOR */
9081         BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
9082         BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
9083         BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
9084         BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
9085         /* BPF_ATOMIC | BPF_W: BPF_XOR | BPF_FETCH */
9086         BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
9087         BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
9088         BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
9089         BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
9090         /* BPF_ATOMIC | BPF_DW: BPF_XOR */
9091         BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
9092         BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
9093         BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
9094         BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
9095         /* BPF_ATOMIC | BPF_DW: BPF_XOR | BPF_FETCH */
9096         BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
9097         BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
9098         BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
9099         BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
9100         /* BPF_ATOMIC | BPF_W: BPF_XCHG */
9101         BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
9102         BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
9103         BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
9104         BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
9105         /* BPF_ATOMIC | BPF_DW: BPF_XCHG */
9106         BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
9107         BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
9108         BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
9109         BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
9110 #undef BPF_ATOMIC_POISON
9111 #undef BPF_ATOMIC_OP_TEST1
9112 #undef BPF_ATOMIC_OP_TEST2
9113 #undef BPF_ATOMIC_OP_TEST3
9114 #undef BPF_ATOMIC_OP_TEST4
9115         /* BPF_ATOMIC | BPF_W, BPF_CMPXCHG */
9116         {
9117                 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test successful return",
9118                 .u.insns_int = {
9119                         BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
9120                         BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
9121                         BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
9122                         BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
9123                         BPF_EXIT_INSN(),
9124                 },
9125                 INTERNAL,
9126                 { },
9127                 { { 0, 0x01234567 } },
9128                 .stack_depth = 40,
9129         },
9130         {
9131                 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test successful store",
9132                 .u.insns_int = {
9133                         BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
9134                         BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
9135                         BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
9136                         BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
9137                         BPF_LDX_MEM(BPF_W, R0, R10, -40),
9138                         BPF_EXIT_INSN(),
9139                 },
9140                 INTERNAL,
9141                 { },
9142                 { { 0, 0x89abcdef } },
9143                 .stack_depth = 40,
9144         },
9145         {
9146                 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test failure return",
9147                 .u.insns_int = {
9148                         BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
9149                         BPF_ALU32_IMM(BPF_MOV, R0, 0x76543210),
9150                         BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
9151                         BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
9152                         BPF_EXIT_INSN(),
9153                 },
9154                 INTERNAL,
9155                 { },
9156                 { { 0, 0x01234567 } },
9157                 .stack_depth = 40,
9158         },
9159         {
9160                 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test failure store",
9161                 .u.insns_int = {
9162                         BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
9163                         BPF_ALU32_IMM(BPF_MOV, R0, 0x76543210),
9164                         BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
9165                         BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
9166                         BPF_LDX_MEM(BPF_W, R0, R10, -40),
9167                         BPF_EXIT_INSN(),
9168                 },
9169                 INTERNAL,
9170                 { },
9171                 { { 0, 0x01234567 } },
9172                 .stack_depth = 40,
9173         },
9174         {
9175                 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test side effects",
9176                 .u.insns_int = {
9177                         BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
9178                         BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
9179                         BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
9180                         BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
9181                         BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
9182                         BPF_ALU32_REG(BPF_MOV, R0, R3),
9183                         BPF_EXIT_INSN(),
9184                 },
9185                 INTERNAL,
9186                 { },
9187                 { { 0, 0x89abcdef } },
9188                 .stack_depth = 40,
9189         },
9190         /* BPF_ATOMIC | BPF_DW, BPF_CMPXCHG */
9191         {
9192                 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test successful return",
9193                 .u.insns_int = {
9194                         BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
9195                         BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
9196                         BPF_ALU64_REG(BPF_MOV, R0, R1),
9197                         BPF_STX_MEM(BPF_DW, R10, R1, -40),
9198                         BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
9199                         BPF_JMP_REG(BPF_JNE, R0, R1, 1),
9200                         BPF_ALU64_REG(BPF_SUB, R0, R1),
9201                         BPF_EXIT_INSN(),
9202                 },
9203                 INTERNAL,
9204                 { },
9205                 { { 0, 0 } },
9206                 .stack_depth = 40,
9207         },
9208         {
9209                 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test successful store",
9210                 .u.insns_int = {
9211                         BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
9212                         BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
9213                         BPF_ALU64_REG(BPF_MOV, R0, R1),
9214                         BPF_STX_MEM(BPF_DW, R10, R0, -40),
9215                         BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
9216                         BPF_LDX_MEM(BPF_DW, R0, R10, -40),
9217                         BPF_JMP_REG(BPF_JNE, R0, R2, 1),
9218                         BPF_ALU64_REG(BPF_SUB, R0, R2),
9219                         BPF_EXIT_INSN(),
9220                 },
9221                 INTERNAL,
9222                 { },
9223                 { { 0, 0 } },
9224                 .stack_depth = 40,
9225         },
9226         {
9227                 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test failure return",
9228                 .u.insns_int = {
9229                         BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
9230                         BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
9231                         BPF_ALU64_REG(BPF_MOV, R0, R1),
9232                         BPF_ALU64_IMM(BPF_ADD, R0, 1),
9233                         BPF_STX_MEM(BPF_DW, R10, R1, -40),
9234                         BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
9235                         BPF_JMP_REG(BPF_JNE, R0, R1, 1),
9236                         BPF_ALU64_REG(BPF_SUB, R0, R1),
9237                         BPF_EXIT_INSN(),
9238                 },
9239                 INTERNAL,
9240                 { },
9241                 { { 0, 0 } },
9242                 .stack_depth = 40,
9243         },
9244         {
9245                 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test failure store",
9246                 .u.insns_int = {
9247                         BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
9248                         BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
9249                         BPF_ALU64_REG(BPF_MOV, R0, R1),
9250                         BPF_ALU64_IMM(BPF_ADD, R0, 1),
9251                         BPF_STX_MEM(BPF_DW, R10, R1, -40),
9252                         BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
9253                         BPF_LDX_MEM(BPF_DW, R0, R10, -40),
9254                         BPF_JMP_REG(BPF_JNE, R0, R1, 1),
9255                         BPF_ALU64_REG(BPF_SUB, R0, R1),
9256                         BPF_EXIT_INSN(),
9257                 },
9258                 INTERNAL,
9259                 { },
9260                 { { 0, 0 } },
9261                 .stack_depth = 40,
9262         },
9263         {
9264                 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test side effects",
9265                 .u.insns_int = {
9266                         BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
9267                         BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
9268                         BPF_ALU64_REG(BPF_MOV, R0, R1),
9269                         BPF_STX_MEM(BPF_DW, R10, R1, -40),
9270                         BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
9271                         BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
9272                         BPF_JMP_REG(BPF_JNE, R0, R2, 1),
9273                         BPF_ALU64_REG(BPF_SUB, R0, R2),
9274                         BPF_EXIT_INSN(),
9275                 },
9276                 INTERNAL,
9277                 { },
9278                 { { 0, 0 } },
9279                 .stack_depth = 40,
9280         },
9281         /* BPF_JMP32 | BPF_JEQ | BPF_K */
9282         {
9283                 "JMP32_JEQ_K: Small immediate",
9284                 .u.insns_int = {
9285                         BPF_ALU32_IMM(BPF_MOV, R0, 123),
9286                         BPF_JMP32_IMM(BPF_JEQ, R0, 321, 1),
9287                         BPF_JMP32_IMM(BPF_JEQ, R0, 123, 1),
9288                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9289                         BPF_EXIT_INSN(),
9290                 },
9291                 INTERNAL,
9292                 { },
9293                 { { 0, 123 } }
9294         },
9295         {
9296                 "JMP32_JEQ_K: Large immediate",
9297                 .u.insns_int = {
9298                         BPF_ALU32_IMM(BPF_MOV, R0, 12345678),
9299                         BPF_JMP32_IMM(BPF_JEQ, R0, 12345678 & 0xffff, 1),
9300                         BPF_JMP32_IMM(BPF_JEQ, R0, 12345678, 1),
9301                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9302                         BPF_EXIT_INSN(),
9303                 },
9304                 INTERNAL,
9305                 { },
9306                 { { 0, 12345678 } }
9307         },
9308         {
9309                 "JMP32_JEQ_K: negative immediate",
9310                 .u.insns_int = {
9311                         BPF_ALU32_IMM(BPF_MOV, R0, -123),
9312                         BPF_JMP32_IMM(BPF_JEQ, R0,  123, 1),
9313                         BPF_JMP32_IMM(BPF_JEQ, R0, -123, 1),
9314                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9315                         BPF_EXIT_INSN(),
9316                 },
9317                 INTERNAL,
9318                 { },
9319                 { { 0, -123 } }
9320         },
9321         /* BPF_JMP32 | BPF_JEQ | BPF_X */
9322         {
9323                 "JMP32_JEQ_X",
9324                 .u.insns_int = {
9325                         BPF_ALU32_IMM(BPF_MOV, R0, 1234),
9326                         BPF_ALU32_IMM(BPF_MOV, R1, 4321),
9327                         BPF_JMP32_REG(BPF_JEQ, R0, R1, 2),
9328                         BPF_ALU32_IMM(BPF_MOV, R1, 1234),
9329                         BPF_JMP32_REG(BPF_JEQ, R0, R1, 1),
9330                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9331                         BPF_EXIT_INSN(),
9332                 },
9333                 INTERNAL,
9334                 { },
9335                 { { 0, 1234 } }
9336         },
9337         /* BPF_JMP32 | BPF_JNE | BPF_K */
9338         {
9339                 "JMP32_JNE_K: Small immediate",
9340                 .u.insns_int = {
9341                         BPF_ALU32_IMM(BPF_MOV, R0, 123),
9342                         BPF_JMP32_IMM(BPF_JNE, R0, 123, 1),
9343                         BPF_JMP32_IMM(BPF_JNE, R0, 321, 1),
9344                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9345                         BPF_EXIT_INSN(),
9346                 },
9347                 INTERNAL,
9348                 { },
9349                 { { 0, 123 } }
9350         },
9351         {
9352                 "JMP32_JNE_K: Large immediate",
9353                 .u.insns_int = {
9354                         BPF_ALU32_IMM(BPF_MOV, R0, 12345678),
9355                         BPF_JMP32_IMM(BPF_JNE, R0, 12345678, 1),
9356                         BPF_JMP32_IMM(BPF_JNE, R0, 12345678 & 0xffff, 1),
9357                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9358                         BPF_EXIT_INSN(),
9359                 },
9360                 INTERNAL,
9361                 { },
9362                 { { 0, 12345678 } }
9363         },
9364         {
9365                 "JMP32_JNE_K: negative immediate",
9366                 .u.insns_int = {
9367                         BPF_ALU32_IMM(BPF_MOV, R0, -123),
9368                         BPF_JMP32_IMM(BPF_JNE, R0, -123, 1),
9369                         BPF_JMP32_IMM(BPF_JNE, R0,  123, 1),
9370                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9371                         BPF_EXIT_INSN(),
9372                 },
9373                 INTERNAL,
9374                 { },
9375                 { { 0, -123 } }
9376         },
9377         /* BPF_JMP32 | BPF_JNE | BPF_X */
9378         {
9379                 "JMP32_JNE_X",
9380                 .u.insns_int = {
9381                         BPF_ALU32_IMM(BPF_MOV, R0, 1234),
9382                         BPF_ALU32_IMM(BPF_MOV, R1, 1234),
9383                         BPF_JMP32_REG(BPF_JNE, R0, R1, 2),
9384                         BPF_ALU32_IMM(BPF_MOV, R1, 4321),
9385                         BPF_JMP32_REG(BPF_JNE, R0, R1, 1),
9386                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9387                         BPF_EXIT_INSN(),
9388                 },
9389                 INTERNAL,
9390                 { },
9391                 { { 0, 1234 } }
9392         },
9393         /* BPF_JMP32 | BPF_JSET | BPF_K */
9394         {
9395                 "JMP32_JSET_K: Small immediate",
9396                 .u.insns_int = {
9397                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
9398                         BPF_JMP32_IMM(BPF_JSET, R0, 2, 1),
9399                         BPF_JMP32_IMM(BPF_JSET, R0, 3, 1),
9400                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9401                         BPF_EXIT_INSN(),
9402                 },
9403                 INTERNAL,
9404                 { },
9405                 { { 0, 1 } }
9406         },
9407         {
9408                 "JMP32_JSET_K: Large immediate",
9409                 .u.insns_int = {
9410                         BPF_ALU32_IMM(BPF_MOV, R0, 0x40000000),
9411                         BPF_JMP32_IMM(BPF_JSET, R0, 0x3fffffff, 1),
9412                         BPF_JMP32_IMM(BPF_JSET, R0, 0x60000000, 1),
9413                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9414                         BPF_EXIT_INSN(),
9415                 },
9416                 INTERNAL,
9417                 { },
9418                 { { 0, 0x40000000 } }
9419         },
9420         {
9421                 "JMP32_JSET_K: negative immediate",
9422                 .u.insns_int = {
9423                         BPF_ALU32_IMM(BPF_MOV, R0, -123),
9424                         BPF_JMP32_IMM(BPF_JSET, R0, -1, 1),
9425                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9426                         BPF_EXIT_INSN(),
9427                 },
9428                 INTERNAL,
9429                 { },
9430                 { { 0, -123 } }
9431         },
9432         /* BPF_JMP32 | BPF_JSET | BPF_X */
9433         {
9434                 "JMP32_JSET_X",
9435                 .u.insns_int = {
9436                         BPF_ALU32_IMM(BPF_MOV, R0, 8),
9437                         BPF_ALU32_IMM(BPF_MOV, R1, 7),
9438                         BPF_JMP32_REG(BPF_JSET, R0, R1, 2),
9439                         BPF_ALU32_IMM(BPF_MOV, R1, 8 | 2),
9440                         BPF_JMP32_REG(BPF_JNE, R0, R1, 1),
9441                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9442                         BPF_EXIT_INSN(),
9443                 },
9444                 INTERNAL,
9445                 { },
9446                 { { 0, 8 } }
9447         },
9448         /* BPF_JMP32 | BPF_JGT | BPF_K */
9449         {
9450                 "JMP32_JGT_K: Small immediate",
9451                 .u.insns_int = {
9452                         BPF_ALU32_IMM(BPF_MOV, R0, 123),
9453                         BPF_JMP32_IMM(BPF_JGT, R0, 123, 1),
9454                         BPF_JMP32_IMM(BPF_JGT, R0, 122, 1),
9455                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9456                         BPF_EXIT_INSN(),
9457                 },
9458                 INTERNAL,
9459                 { },
9460                 { { 0, 123 } }
9461         },
9462         {
9463                 "JMP32_JGT_K: Large immediate",
9464                 .u.insns_int = {
9465                         BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9466                         BPF_JMP32_IMM(BPF_JGT, R0, 0xffffffff, 1),
9467                         BPF_JMP32_IMM(BPF_JGT, R0, 0xfffffffd, 1),
9468                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9469                         BPF_EXIT_INSN(),
9470                 },
9471                 INTERNAL,
9472                 { },
9473                 { { 0, 0xfffffffe } }
9474         },
9475         /* BPF_JMP32 | BPF_JGT | BPF_X */
9476         {
9477                 "JMP32_JGT_X",
9478                 .u.insns_int = {
9479                         BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9480                         BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
9481                         BPF_JMP32_REG(BPF_JGT, R0, R1, 2),
9482                         BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
9483                         BPF_JMP32_REG(BPF_JGT, R0, R1, 1),
9484                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9485                         BPF_EXIT_INSN(),
9486                 },
9487                 INTERNAL,
9488                 { },
9489                 { { 0, 0xfffffffe } }
9490         },
9491         /* BPF_JMP32 | BPF_JGE | BPF_K */
9492         {
9493                 "JMP32_JGE_K: Small immediate",
9494                 .u.insns_int = {
9495                         BPF_ALU32_IMM(BPF_MOV, R0, 123),
9496                         BPF_JMP32_IMM(BPF_JGE, R0, 124, 1),
9497                         BPF_JMP32_IMM(BPF_JGE, R0, 123, 1),
9498                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9499                         BPF_EXIT_INSN(),
9500                 },
9501                 INTERNAL,
9502                 { },
9503                 { { 0, 123 } }
9504         },
9505         {
9506                 "JMP32_JGE_K: Large immediate",
9507                 .u.insns_int = {
9508                         BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9509                         BPF_JMP32_IMM(BPF_JGE, R0, 0xffffffff, 1),
9510                         BPF_JMP32_IMM(BPF_JGE, R0, 0xfffffffe, 1),
9511                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9512                         BPF_EXIT_INSN(),
9513                 },
9514                 INTERNAL,
9515                 { },
9516                 { { 0, 0xfffffffe } }
9517         },
9518         /* BPF_JMP32 | BPF_JGE | BPF_X */
9519         {
9520                 "JMP32_JGE_X",
9521                 .u.insns_int = {
9522                         BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9523                         BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
9524                         BPF_JMP32_REG(BPF_JGE, R0, R1, 2),
9525                         BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffe),
9526                         BPF_JMP32_REG(BPF_JGE, R0, R1, 1),
9527                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9528                         BPF_EXIT_INSN(),
9529                 },
9530                 INTERNAL,
9531                 { },
9532                 { { 0, 0xfffffffe } }
9533         },
9534         /* BPF_JMP32 | BPF_JLT | BPF_K */
9535         {
9536                 "JMP32_JLT_K: Small immediate",
9537                 .u.insns_int = {
9538                         BPF_ALU32_IMM(BPF_MOV, R0, 123),
9539                         BPF_JMP32_IMM(BPF_JLT, R0, 123, 1),
9540                         BPF_JMP32_IMM(BPF_JLT, R0, 124, 1),
9541                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9542                         BPF_EXIT_INSN(),
9543                 },
9544                 INTERNAL,
9545                 { },
9546                 { { 0, 123 } }
9547         },
9548         {
9549                 "JMP32_JLT_K: Large immediate",
9550                 .u.insns_int = {
9551                         BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9552                         BPF_JMP32_IMM(BPF_JLT, R0, 0xfffffffd, 1),
9553                         BPF_JMP32_IMM(BPF_JLT, R0, 0xffffffff, 1),
9554                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9555                         BPF_EXIT_INSN(),
9556                 },
9557                 INTERNAL,
9558                 { },
9559                 { { 0, 0xfffffffe } }
9560         },
9561         /* BPF_JMP32 | BPF_JLT | BPF_X */
9562         {
9563                 "JMP32_JLT_X",
9564                 .u.insns_int = {
9565                         BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9566                         BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
9567                         BPF_JMP32_REG(BPF_JLT, R0, R1, 2),
9568                         BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
9569                         BPF_JMP32_REG(BPF_JLT, R0, R1, 1),
9570                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9571                         BPF_EXIT_INSN(),
9572                 },
9573                 INTERNAL,
9574                 { },
9575                 { { 0, 0xfffffffe } }
9576         },
9577         /* BPF_JMP32 | BPF_JLE | BPF_K */
9578         {
9579                 "JMP32_JLE_K: Small immediate",
9580                 .u.insns_int = {
9581                         BPF_ALU32_IMM(BPF_MOV, R0, 123),
9582                         BPF_JMP32_IMM(BPF_JLE, R0, 122, 1),
9583                         BPF_JMP32_IMM(BPF_JLE, R0, 123, 1),
9584                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9585                         BPF_EXIT_INSN(),
9586                 },
9587                 INTERNAL,
9588                 { },
9589                 { { 0, 123 } }
9590         },
9591         {
9592                 "JMP32_JLE_K: Large immediate",
9593                 .u.insns_int = {
9594                         BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9595                         BPF_JMP32_IMM(BPF_JLE, R0, 0xfffffffd, 1),
9596                         BPF_JMP32_IMM(BPF_JLE, R0, 0xfffffffe, 1),
9597                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9598                         BPF_EXIT_INSN(),
9599                 },
9600                 INTERNAL,
9601                 { },
9602                 { { 0, 0xfffffffe } }
9603         },
9604         /* BPF_JMP32 | BPF_JLE | BPF_X */
9605         {
9606                 "JMP32_JLE_X",
9607                 .u.insns_int = {
9608                         BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9609                         BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
9610                         BPF_JMP32_REG(BPF_JLE, R0, R1, 2),
9611                         BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffe),
9612                         BPF_JMP32_REG(BPF_JLE, R0, R1, 1),
9613                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9614                         BPF_EXIT_INSN(),
9615                 },
9616                 INTERNAL,
9617                 { },
9618                 { { 0, 0xfffffffe } }
9619         },
9620         /* BPF_JMP32 | BPF_JSGT | BPF_K */
9621         {
9622                 "JMP32_JSGT_K: Small immediate",
9623                 .u.insns_int = {
9624                         BPF_ALU32_IMM(BPF_MOV, R0, -123),
9625                         BPF_JMP32_IMM(BPF_JSGT, R0, -123, 1),
9626                         BPF_JMP32_IMM(BPF_JSGT, R0, -124, 1),
9627                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9628                         BPF_EXIT_INSN(),
9629                 },
9630                 INTERNAL,
9631                 { },
9632                 { { 0, -123 } }
9633         },
9634         {
9635                 "JMP32_JSGT_K: Large immediate",
9636                 .u.insns_int = {
9637                         BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9638                         BPF_JMP32_IMM(BPF_JSGT, R0, -12345678, 1),
9639                         BPF_JMP32_IMM(BPF_JSGT, R0, -12345679, 1),
9640                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9641                         BPF_EXIT_INSN(),
9642                 },
9643                 INTERNAL,
9644                 { },
9645                 { { 0, -12345678 } }
9646         },
9647         /* BPF_JMP32 | BPF_JSGT | BPF_X */
9648         {
9649                 "JMP32_JSGT_X",
9650                 .u.insns_int = {
9651                         BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9652                         BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
9653                         BPF_JMP32_REG(BPF_JSGT, R0, R1, 2),
9654                         BPF_ALU32_IMM(BPF_MOV, R1, -12345679),
9655                         BPF_JMP32_REG(BPF_JSGT, R0, R1, 1),
9656                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9657                         BPF_EXIT_INSN(),
9658                 },
9659                 INTERNAL,
9660                 { },
9661                 { { 0, -12345678 } }
9662         },
9663         /* BPF_JMP32 | BPF_JSGE | BPF_K */
9664         {
9665                 "JMP32_JSGE_K: Small immediate",
9666                 .u.insns_int = {
9667                         BPF_ALU32_IMM(BPF_MOV, R0, -123),
9668                         BPF_JMP32_IMM(BPF_JSGE, R0, -122, 1),
9669                         BPF_JMP32_IMM(BPF_JSGE, R0, -123, 1),
9670                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9671                         BPF_EXIT_INSN(),
9672                 },
9673                 INTERNAL,
9674                 { },
9675                 { { 0, -123 } }
9676         },
9677         {
9678                 "JMP32_JSGE_K: Large immediate",
9679                 .u.insns_int = {
9680                         BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9681                         BPF_JMP32_IMM(BPF_JSGE, R0, -12345677, 1),
9682                         BPF_JMP32_IMM(BPF_JSGE, R0, -12345678, 1),
9683                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9684                         BPF_EXIT_INSN(),
9685                 },
9686                 INTERNAL,
9687                 { },
9688                 { { 0, -12345678 } }
9689         },
9690         /* BPF_JMP32 | BPF_JSGE | BPF_X */
9691         {
9692                 "JMP32_JSGE_X",
9693                 .u.insns_int = {
9694                         BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9695                         BPF_ALU32_IMM(BPF_MOV, R1, -12345677),
9696                         BPF_JMP32_REG(BPF_JSGE, R0, R1, 2),
9697                         BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
9698                         BPF_JMP32_REG(BPF_JSGE, R0, R1, 1),
9699                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9700                         BPF_EXIT_INSN(),
9701                 },
9702                 INTERNAL,
9703                 { },
9704                 { { 0, -12345678 } }
9705         },
9706         /* BPF_JMP32 | BPF_JSLT | BPF_K */
9707         {
9708                 "JMP32_JSLT_K: Small immediate",
9709                 .u.insns_int = {
9710                         BPF_ALU32_IMM(BPF_MOV, R0, -123),
9711                         BPF_JMP32_IMM(BPF_JSLT, R0, -123, 1),
9712                         BPF_JMP32_IMM(BPF_JSLT, R0, -122, 1),
9713                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9714                         BPF_EXIT_INSN(),
9715                 },
9716                 INTERNAL,
9717                 { },
9718                 { { 0, -123 } }
9719         },
9720         {
9721                 "JMP32_JSLT_K: Large immediate",
9722                 .u.insns_int = {
9723                         BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9724                         BPF_JMP32_IMM(BPF_JSLT, R0, -12345678, 1),
9725                         BPF_JMP32_IMM(BPF_JSLT, R0, -12345677, 1),
9726                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9727                         BPF_EXIT_INSN(),
9728                 },
9729                 INTERNAL,
9730                 { },
9731                 { { 0, -12345678 } }
9732         },
9733         /* BPF_JMP32 | BPF_JSLT | BPF_X */
9734         {
9735                 "JMP32_JSLT_X",
9736                 .u.insns_int = {
9737                         BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9738                         BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
9739                         BPF_JMP32_REG(BPF_JSLT, R0, R1, 2),
9740                         BPF_ALU32_IMM(BPF_MOV, R1, -12345677),
9741                         BPF_JMP32_REG(BPF_JSLT, R0, R1, 1),
9742                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9743                         BPF_EXIT_INSN(),
9744                 },
9745                 INTERNAL,
9746                 { },
9747                 { { 0, -12345678 } }
9748         },
9749         /* BPF_JMP32 | BPF_JSLE | BPF_K */
9750         {
9751                 "JMP32_JSLE_K: Small immediate",
9752                 .u.insns_int = {
9753                         BPF_ALU32_IMM(BPF_MOV, R0, -123),
9754                         BPF_JMP32_IMM(BPF_JSLE, R0, -124, 1),
9755                         BPF_JMP32_IMM(BPF_JSLE, R0, -123, 1),
9756                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9757                         BPF_EXIT_INSN(),
9758                 },
9759                 INTERNAL,
9760                 { },
9761                 { { 0, -123 } }
9762         },
9763         {
9764                 "JMP32_JSLE_K: Large immediate",
9765                 .u.insns_int = {
9766                         BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9767                         BPF_JMP32_IMM(BPF_JSLE, R0, -12345679, 1),
9768                         BPF_JMP32_IMM(BPF_JSLE, R0, -12345678, 1),
9769                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9770                         BPF_EXIT_INSN(),
9771                 },
9772                 INTERNAL,
9773                 { },
9774                 { { 0, -12345678 } }
9775         },
9776         /* BPF_JMP32 | BPF_JSLE | BPF_K */
9777         {
9778                 "JMP32_JSLE_X",
9779                 .u.insns_int = {
9780                         BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9781                         BPF_ALU32_IMM(BPF_MOV, R1, -12345679),
9782                         BPF_JMP32_REG(BPF_JSLE, R0, R1, 2),
9783                         BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
9784                         BPF_JMP32_REG(BPF_JSLE, R0, R1, 1),
9785                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9786                         BPF_EXIT_INSN(),
9787                 },
9788                 INTERNAL,
9789                 { },
9790                 { { 0, -12345678 } }
9791         },
9792         /* BPF_JMP | BPF_EXIT */
9793         {
9794                 "JMP_EXIT",
9795                 .u.insns_int = {
9796                         BPF_ALU32_IMM(BPF_MOV, R0, 0x4711),
9797                         BPF_EXIT_INSN(),
9798                         BPF_ALU32_IMM(BPF_MOV, R0, 0x4712),
9799                 },
9800                 INTERNAL,
9801                 { },
9802                 { { 0, 0x4711 } },
9803         },
9804         /* BPF_JMP | BPF_JA */
9805         {
9806                 "JMP_JA: Unconditional jump: if (true) return 1",
9807                 .u.insns_int = {
9808                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9809                         BPF_JMP_IMM(BPF_JA, 0, 0, 1),
9810                         BPF_EXIT_INSN(),
9811                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
9812                         BPF_EXIT_INSN(),
9813                 },
9814                 INTERNAL,
9815                 { },
9816                 { { 0, 1 } },
9817         },
9818         /* BPF_JMP32 | BPF_JA */
9819         {
9820                 "JMP32_JA: Unconditional jump: if (true) return 1",
9821                 .u.insns_int = {
9822                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9823                         BPF_JMP32_IMM(BPF_JA, 0, 1, 0),
9824                         BPF_EXIT_INSN(),
9825                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
9826                         BPF_EXIT_INSN(),
9827                 },
9828                 INTERNAL,
9829                 { },
9830                 { { 0, 1 } },
9831         },
9832         /* BPF_JMP | BPF_JSLT | BPF_K */
9833         {
9834                 "JMP_JSLT_K: Signed jump: if (-2 < -1) return 1",
9835                 .u.insns_int = {
9836                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9837                         BPF_LD_IMM64(R1, 0xfffffffffffffffeLL),
9838                         BPF_JMP_IMM(BPF_JSLT, R1, -1, 1),
9839                         BPF_EXIT_INSN(),
9840                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
9841                         BPF_EXIT_INSN(),
9842                 },
9843                 INTERNAL,
9844                 { },
9845                 { { 0, 1 } },
9846         },
9847         {
9848                 "JMP_JSLT_K: Signed jump: if (-1 < -1) return 0",
9849                 .u.insns_int = {
9850                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
9851                         BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9852                         BPF_JMP_IMM(BPF_JSLT, R1, -1, 1),
9853                         BPF_EXIT_INSN(),
9854                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9855                         BPF_EXIT_INSN(),
9856                 },
9857                 INTERNAL,
9858                 { },
9859                 { { 0, 1 } },
9860         },
9861         /* BPF_JMP | BPF_JSGT | BPF_K */
9862         {
9863                 "JMP_JSGT_K: Signed jump: if (-1 > -2) return 1",
9864                 .u.insns_int = {
9865                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9866                         BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9867                         BPF_JMP_IMM(BPF_JSGT, R1, -2, 1),
9868                         BPF_EXIT_INSN(),
9869                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
9870                         BPF_EXIT_INSN(),
9871                 },
9872                 INTERNAL,
9873                 { },
9874                 { { 0, 1 } },
9875         },
9876         {
9877                 "JMP_JSGT_K: Signed jump: if (-1 > -1) return 0",
9878                 .u.insns_int = {
9879                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
9880                         BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9881                         BPF_JMP_IMM(BPF_JSGT, R1, -1, 1),
9882                         BPF_EXIT_INSN(),
9883                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9884                         BPF_EXIT_INSN(),
9885                 },
9886                 INTERNAL,
9887                 { },
9888                 { { 0, 1 } },
9889         },
9890         /* BPF_JMP | BPF_JSLE | BPF_K */
9891         {
9892                 "JMP_JSLE_K: Signed jump: if (-2 <= -1) return 1",
9893                 .u.insns_int = {
9894                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9895                         BPF_LD_IMM64(R1, 0xfffffffffffffffeLL),
9896                         BPF_JMP_IMM(BPF_JSLE, R1, -1, 1),
9897                         BPF_EXIT_INSN(),
9898                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
9899                         BPF_EXIT_INSN(),
9900                 },
9901                 INTERNAL,
9902                 { },
9903                 { { 0, 1 } },
9904         },
9905         {
9906                 "JMP_JSLE_K: Signed jump: if (-1 <= -1) return 1",
9907                 .u.insns_int = {
9908                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9909                         BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9910                         BPF_JMP_IMM(BPF_JSLE, R1, -1, 1),
9911                         BPF_EXIT_INSN(),
9912                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
9913                         BPF_EXIT_INSN(),
9914                 },
9915                 INTERNAL,
9916                 { },
9917                 { { 0, 1 } },
9918         },
9919         {
9920                 "JMP_JSLE_K: Signed jump: value walk 1",
9921                 .u.insns_int = {
9922                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9923                         BPF_LD_IMM64(R1, 3),
9924                         BPF_JMP_IMM(BPF_JSLE, R1, 0, 6),
9925                         BPF_ALU64_IMM(BPF_SUB, R1, 1),
9926                         BPF_JMP_IMM(BPF_JSLE, R1, 0, 4),
9927                         BPF_ALU64_IMM(BPF_SUB, R1, 1),
9928                         BPF_JMP_IMM(BPF_JSLE, R1, 0, 2),
9929                         BPF_ALU64_IMM(BPF_SUB, R1, 1),
9930                         BPF_JMP_IMM(BPF_JSLE, R1, 0, 1),
9931                         BPF_EXIT_INSN(),                /* bad exit */
9932                         BPF_ALU32_IMM(BPF_MOV, R0, 1),  /* good exit */
9933                         BPF_EXIT_INSN(),
9934                 },
9935                 INTERNAL,
9936                 { },
9937                 { { 0, 1 } },
9938         },
9939         {
9940                 "JMP_JSLE_K: Signed jump: value walk 2",
9941                 .u.insns_int = {
9942                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9943                         BPF_LD_IMM64(R1, 3),
9944                         BPF_JMP_IMM(BPF_JSLE, R1, 0, 4),
9945                         BPF_ALU64_IMM(BPF_SUB, R1, 2),
9946                         BPF_JMP_IMM(BPF_JSLE, R1, 0, 2),
9947                         BPF_ALU64_IMM(BPF_SUB, R1, 2),
9948                         BPF_JMP_IMM(BPF_JSLE, R1, 0, 1),
9949                         BPF_EXIT_INSN(),                /* bad exit */
9950                         BPF_ALU32_IMM(BPF_MOV, R0, 1),  /* good exit */
9951                         BPF_EXIT_INSN(),
9952                 },
9953                 INTERNAL,
9954                 { },
9955                 { { 0, 1 } },
9956         },
9957         /* BPF_JMP | BPF_JSGE | BPF_K */
9958         {
9959                 "JMP_JSGE_K: Signed jump: if (-1 >= -2) return 1",
9960                 .u.insns_int = {
9961                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9962                         BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9963                         BPF_JMP_IMM(BPF_JSGE, R1, -2, 1),
9964                         BPF_EXIT_INSN(),
9965                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
9966                         BPF_EXIT_INSN(),
9967                 },
9968                 INTERNAL,
9969                 { },
9970                 { { 0, 1 } },
9971         },
9972         {
9973                 "JMP_JSGE_K: Signed jump: if (-1 >= -1) return 1",
9974                 .u.insns_int = {
9975                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9976                         BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9977                         BPF_JMP_IMM(BPF_JSGE, R1, -1, 1),
9978                         BPF_EXIT_INSN(),
9979                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
9980                         BPF_EXIT_INSN(),
9981                 },
9982                 INTERNAL,
9983                 { },
9984                 { { 0, 1 } },
9985         },
9986         {
9987                 "JMP_JSGE_K: Signed jump: value walk 1",
9988                 .u.insns_int = {
9989                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
9990                         BPF_LD_IMM64(R1, -3),
9991                         BPF_JMP_IMM(BPF_JSGE, R1, 0, 6),
9992                         BPF_ALU64_IMM(BPF_ADD, R1, 1),
9993                         BPF_JMP_IMM(BPF_JSGE, R1, 0, 4),
9994                         BPF_ALU64_IMM(BPF_ADD, R1, 1),
9995                         BPF_JMP_IMM(BPF_JSGE, R1, 0, 2),
9996                         BPF_ALU64_IMM(BPF_ADD, R1, 1),
9997                         BPF_JMP_IMM(BPF_JSGE, R1, 0, 1),
9998                         BPF_EXIT_INSN(),                /* bad exit */
9999                         BPF_ALU32_IMM(BPF_MOV, R0, 1),  /* good exit */
10000                         BPF_EXIT_INSN(),
10001                 },
10002                 INTERNAL,
10003                 { },
10004                 { { 0, 1 } },
10005         },
10006         {
10007                 "JMP_JSGE_K: Signed jump: value walk 2",
10008                 .u.insns_int = {
10009                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10010                         BPF_LD_IMM64(R1, -3),
10011                         BPF_JMP_IMM(BPF_JSGE, R1, 0, 4),
10012                         BPF_ALU64_IMM(BPF_ADD, R1, 2),
10013                         BPF_JMP_IMM(BPF_JSGE, R1, 0, 2),
10014                         BPF_ALU64_IMM(BPF_ADD, R1, 2),
10015                         BPF_JMP_IMM(BPF_JSGE, R1, 0, 1),
10016                         BPF_EXIT_INSN(),                /* bad exit */
10017                         BPF_ALU32_IMM(BPF_MOV, R0, 1),  /* good exit */
10018                         BPF_EXIT_INSN(),
10019                 },
10020                 INTERNAL,
10021                 { },
10022                 { { 0, 1 } },
10023         },
10024         /* BPF_JMP | BPF_JGT | BPF_K */
10025         {
10026                 "JMP_JGT_K: if (3 > 2) return 1",
10027                 .u.insns_int = {
10028                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10029                         BPF_LD_IMM64(R1, 3),
10030                         BPF_JMP_IMM(BPF_JGT, R1, 2, 1),
10031                         BPF_EXIT_INSN(),
10032                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
10033                         BPF_EXIT_INSN(),
10034                 },
10035                 INTERNAL,
10036                 { },
10037                 { { 0, 1 } },
10038         },
10039         {
10040                 "JMP_JGT_K: Unsigned jump: if (-1 > 1) return 1",
10041                 .u.insns_int = {
10042                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10043                         BPF_LD_IMM64(R1, -1),
10044                         BPF_JMP_IMM(BPF_JGT, R1, 1, 1),
10045                         BPF_EXIT_INSN(),
10046                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
10047                         BPF_EXIT_INSN(),
10048                 },
10049                 INTERNAL,
10050                 { },
10051                 { { 0, 1 } },
10052         },
10053         /* BPF_JMP | BPF_JLT | BPF_K */
10054         {
10055                 "JMP_JLT_K: if (2 < 3) return 1",
10056                 .u.insns_int = {
10057                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10058                         BPF_LD_IMM64(R1, 2),
10059                         BPF_JMP_IMM(BPF_JLT, R1, 3, 1),
10060                         BPF_EXIT_INSN(),
10061                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
10062                         BPF_EXIT_INSN(),
10063                 },
10064                 INTERNAL,
10065                 { },
10066                 { { 0, 1 } },
10067         },
10068         {
10069                 "JMP_JGT_K: Unsigned jump: if (1 < -1) return 1",
10070                 .u.insns_int = {
10071                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10072                         BPF_LD_IMM64(R1, 1),
10073                         BPF_JMP_IMM(BPF_JLT, R1, -1, 1),
10074                         BPF_EXIT_INSN(),
10075                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
10076                         BPF_EXIT_INSN(),
10077                 },
10078                 INTERNAL,
10079                 { },
10080                 { { 0, 1 } },
10081         },
10082         /* BPF_JMP | BPF_JGE | BPF_K */
10083         {
10084                 "JMP_JGE_K: if (3 >= 2) return 1",
10085                 .u.insns_int = {
10086                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10087                         BPF_LD_IMM64(R1, 3),
10088                         BPF_JMP_IMM(BPF_JGE, R1, 2, 1),
10089                         BPF_EXIT_INSN(),
10090                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
10091                         BPF_EXIT_INSN(),
10092                 },
10093                 INTERNAL,
10094                 { },
10095                 { { 0, 1 } },
10096         },
10097         /* BPF_JMP | BPF_JLE | BPF_K */
10098         {
10099                 "JMP_JLE_K: if (2 <= 3) return 1",
10100                 .u.insns_int = {
10101                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10102                         BPF_LD_IMM64(R1, 2),
10103                         BPF_JMP_IMM(BPF_JLE, R1, 3, 1),
10104                         BPF_EXIT_INSN(),
10105                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
10106                         BPF_EXIT_INSN(),
10107                 },
10108                 INTERNAL,
10109                 { },
10110                 { { 0, 1 } },
10111         },
10112         /* BPF_JMP | BPF_JGT | BPF_K jump backwards */
10113         {
10114                 "JMP_JGT_K: if (3 > 2) return 1 (jump backwards)",
10115                 .u.insns_int = {
10116                         BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
10117                         BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */
10118                         BPF_EXIT_INSN(),
10119                         BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
10120                         BPF_LD_IMM64(R1, 3), /* note: this takes 2 insns */
10121                         BPF_JMP_IMM(BPF_JGT, R1, 2, -6), /* goto out */
10122                         BPF_EXIT_INSN(),
10123                 },
10124                 INTERNAL,
10125                 { },
10126                 { { 0, 1 } },
10127         },
10128         {
10129                 "JMP_JGE_K: if (3 >= 3) return 1",
10130                 .u.insns_int = {
10131                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10132                         BPF_LD_IMM64(R1, 3),
10133                         BPF_JMP_IMM(BPF_JGE, R1, 3, 1),
10134                         BPF_EXIT_INSN(),
10135                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
10136                         BPF_EXIT_INSN(),
10137                 },
10138                 INTERNAL,
10139                 { },
10140                 { { 0, 1 } },
10141         },
10142         /* BPF_JMP | BPF_JLT | BPF_K jump backwards */
10143         {
10144                 "JMP_JGT_K: if (2 < 3) return 1 (jump backwards)",
10145                 .u.insns_int = {
10146                         BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
10147                         BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */
10148                         BPF_EXIT_INSN(),
10149                         BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
10150                         BPF_LD_IMM64(R1, 2), /* note: this takes 2 insns */
10151                         BPF_JMP_IMM(BPF_JLT, R1, 3, -6), /* goto out */
10152                         BPF_EXIT_INSN(),
10153                 },
10154                 INTERNAL,
10155                 { },
10156                 { { 0, 1 } },
10157         },
10158         {
10159                 "JMP_JLE_K: if (3 <= 3) return 1",
10160                 .u.insns_int = {
10161                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10162                         BPF_LD_IMM64(R1, 3),
10163                         BPF_JMP_IMM(BPF_JLE, R1, 3, 1),
10164                         BPF_EXIT_INSN(),
10165                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
10166                         BPF_EXIT_INSN(),
10167                 },
10168                 INTERNAL,
10169                 { },
10170                 { { 0, 1 } },
10171         },
10172         /* BPF_JMP | BPF_JNE | BPF_K */
10173         {
10174                 "JMP_JNE_K: if (3 != 2) return 1",
10175                 .u.insns_int = {
10176                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10177                         BPF_LD_IMM64(R1, 3),
10178                         BPF_JMP_IMM(BPF_JNE, R1, 2, 1),
10179                         BPF_EXIT_INSN(),
10180                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
10181                         BPF_EXIT_INSN(),
10182                 },
10183                 INTERNAL,
10184                 { },
10185                 { { 0, 1 } },
10186         },
10187         /* BPF_JMP | BPF_JEQ | BPF_K */
10188         {
10189                 "JMP_JEQ_K: if (3 == 3) return 1",
10190                 .u.insns_int = {
10191                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10192                         BPF_LD_IMM64(R1, 3),
10193                         BPF_JMP_IMM(BPF_JEQ, R1, 3, 1),
10194                         BPF_EXIT_INSN(),
10195                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
10196                         BPF_EXIT_INSN(),
10197                 },
10198                 INTERNAL,
10199                 { },
10200                 { { 0, 1 } },
10201         },
10202         /* BPF_JMP | BPF_JSET | BPF_K */
10203         {
10204                 "JMP_JSET_K: if (0x3 & 0x2) return 1",
10205                 .u.insns_int = {
10206                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10207                         BPF_LD_IMM64(R1, 3),
10208                         BPF_JMP_IMM(BPF_JSET, R1, 2, 1),
10209                         BPF_EXIT_INSN(),
10210                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
10211                         BPF_EXIT_INSN(),
10212                 },
10213                 INTERNAL,
10214                 { },
10215                 { { 0, 1 } },
10216         },
10217         {
10218                 "JMP_JSET_K: if (0x3 & 0xffffffff) return 1",
10219                 .u.insns_int = {
10220                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10221                         BPF_LD_IMM64(R1, 3),
10222                         BPF_JMP_IMM(BPF_JSET, R1, 0xffffffff, 1),
10223                         BPF_EXIT_INSN(),
10224                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
10225                         BPF_EXIT_INSN(),
10226                 },
10227                 INTERNAL,
10228                 { },
10229                 { { 0, 1 } },
10230         },
10231         /* BPF_JMP | BPF_JSGT | BPF_X */
10232         {
10233                 "JMP_JSGT_X: Signed jump: if (-1 > -2) return 1",
10234                 .u.insns_int = {
10235                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10236                         BPF_LD_IMM64(R1, -1),
10237                         BPF_LD_IMM64(R2, -2),
10238                         BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
10239                         BPF_EXIT_INSN(),
10240                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
10241                         BPF_EXIT_INSN(),
10242                 },
10243                 INTERNAL,
10244                 { },
10245                 { { 0, 1 } },
10246         },
10247         {
10248                 "JMP_JSGT_X: Signed jump: if (-1 > -1) return 0",
10249                 .u.insns_int = {
10250                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
10251                         BPF_LD_IMM64(R1, -1),
10252                         BPF_LD_IMM64(R2, -1),
10253                         BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
10254                         BPF_EXIT_INSN(),
10255                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10256                         BPF_EXIT_INSN(),
10257                 },
10258                 INTERNAL,
10259                 { },
10260                 { { 0, 1 } },
10261         },
10262         /* BPF_JMP | BPF_JSLT | BPF_X */
10263         {
10264                 "JMP_JSLT_X: Signed jump: if (-2 < -1) return 1",
10265                 .u.insns_int = {
10266                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10267                         BPF_LD_IMM64(R1, -1),
10268                         BPF_LD_IMM64(R2, -2),
10269                         BPF_JMP_REG(BPF_JSLT, R2, R1, 1),
10270                         BPF_EXIT_INSN(),
10271                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
10272                         BPF_EXIT_INSN(),
10273                 },
10274                 INTERNAL,
10275                 { },
10276                 { { 0, 1 } },
10277         },
10278         {
10279                 "JMP_JSLT_X: Signed jump: if (-1 < -1) return 0",
10280                 .u.insns_int = {
10281                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
10282                         BPF_LD_IMM64(R1, -1),
10283                         BPF_LD_IMM64(R2, -1),
10284                         BPF_JMP_REG(BPF_JSLT, R1, R2, 1),
10285                         BPF_EXIT_INSN(),
10286                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10287                         BPF_EXIT_INSN(),
10288                 },
10289                 INTERNAL,
10290                 { },
10291                 { { 0, 1 } },
10292         },
10293         /* BPF_JMP | BPF_JSGE | BPF_X */
10294         {
10295                 "JMP_JSGE_X: Signed jump: if (-1 >= -2) return 1",
10296                 .u.insns_int = {
10297                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10298                         BPF_LD_IMM64(R1, -1),
10299                         BPF_LD_IMM64(R2, -2),
10300                         BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
10301                         BPF_EXIT_INSN(),
10302                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
10303                         BPF_EXIT_INSN(),
10304                 },
10305                 INTERNAL,
10306                 { },
10307                 { { 0, 1 } },
10308         },
10309         {
10310                 "JMP_JSGE_X: Signed jump: if (-1 >= -1) return 1",
10311                 .u.insns_int = {
10312                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10313                         BPF_LD_IMM64(R1, -1),
10314                         BPF_LD_IMM64(R2, -1),
10315                         BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
10316                         BPF_EXIT_INSN(),
10317                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
10318                         BPF_EXIT_INSN(),
10319                 },
10320                 INTERNAL,
10321                 { },
10322                 { { 0, 1 } },
10323         },
10324         /* BPF_JMP | BPF_JSLE | BPF_X */
10325         {
10326                 "JMP_JSLE_X: Signed jump: if (-2 <= -1) return 1",
10327                 .u.insns_int = {
10328                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10329                         BPF_LD_IMM64(R1, -1),
10330                         BPF_LD_IMM64(R2, -2),
10331                         BPF_JMP_REG(BPF_JSLE, R2, R1, 1),
10332                         BPF_EXIT_INSN(),
10333                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
10334                         BPF_EXIT_INSN(),
10335                 },
10336                 INTERNAL,
10337                 { },
10338                 { { 0, 1 } },
10339         },
10340         {
10341                 "JMP_JSLE_X: Signed jump: if (-1 <= -1) return 1",
10342                 .u.insns_int = {
10343                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10344                         BPF_LD_IMM64(R1, -1),
10345                         BPF_LD_IMM64(R2, -1),
10346                         BPF_JMP_REG(BPF_JSLE, R1, R2, 1),
10347                         BPF_EXIT_INSN(),
10348                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
10349                         BPF_EXIT_INSN(),
10350                 },
10351                 INTERNAL,
10352                 { },
10353                 { { 0, 1 } },
10354         },
10355         /* BPF_JMP | BPF_JGT | BPF_X */
10356         {
10357                 "JMP_JGT_X: if (3 > 2) return 1",
10358                 .u.insns_int = {
10359                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10360                         BPF_LD_IMM64(R1, 3),
10361                         BPF_LD_IMM64(R2, 2),
10362                         BPF_JMP_REG(BPF_JGT, R1, R2, 1),
10363                         BPF_EXIT_INSN(),
10364                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
10365                         BPF_EXIT_INSN(),
10366                 },
10367                 INTERNAL,
10368                 { },
10369                 { { 0, 1 } },
10370         },
10371         {
10372                 "JMP_JGT_X: Unsigned jump: if (-1 > 1) return 1",
10373                 .u.insns_int = {
10374                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10375                         BPF_LD_IMM64(R1, -1),
10376                         BPF_LD_IMM64(R2, 1),
10377                         BPF_JMP_REG(BPF_JGT, R1, R2, 1),
10378                         BPF_EXIT_INSN(),
10379                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
10380                         BPF_EXIT_INSN(),
10381                 },
10382                 INTERNAL,
10383                 { },
10384                 { { 0, 1 } },
10385         },
10386         /* BPF_JMP | BPF_JLT | BPF_X */
10387         {
10388                 "JMP_JLT_X: if (2 < 3) return 1",
10389                 .u.insns_int = {
10390                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10391                         BPF_LD_IMM64(R1, 3),
10392                         BPF_LD_IMM64(R2, 2),
10393                         BPF_JMP_REG(BPF_JLT, R2, R1, 1),
10394                         BPF_EXIT_INSN(),
10395                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
10396                         BPF_EXIT_INSN(),
10397                 },
10398                 INTERNAL,
10399                 { },
10400                 { { 0, 1 } },
10401         },
10402         {
10403                 "JMP_JLT_X: Unsigned jump: if (1 < -1) return 1",
10404                 .u.insns_int = {
10405                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10406                         BPF_LD_IMM64(R1, -1),
10407                         BPF_LD_IMM64(R2, 1),
10408                         BPF_JMP_REG(BPF_JLT, R2, R1, 1),
10409                         BPF_EXIT_INSN(),
10410                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
10411                         BPF_EXIT_INSN(),
10412                 },
10413                 INTERNAL,
10414                 { },
10415                 { { 0, 1 } },
10416         },
10417         /* BPF_JMP | BPF_JGE | BPF_X */
10418         {
10419                 "JMP_JGE_X: if (3 >= 2) return 1",
10420                 .u.insns_int = {
10421                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10422                         BPF_LD_IMM64(R1, 3),
10423                         BPF_LD_IMM64(R2, 2),
10424                         BPF_JMP_REG(BPF_JGE, R1, R2, 1),
10425                         BPF_EXIT_INSN(),
10426                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
10427                         BPF_EXIT_INSN(),
10428                 },
10429                 INTERNAL,
10430                 { },
10431                 { { 0, 1 } },
10432         },
10433         {
10434                 "JMP_JGE_X: if (3 >= 3) return 1",
10435                 .u.insns_int = {
10436                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10437                         BPF_LD_IMM64(R1, 3),
10438                         BPF_LD_IMM64(R2, 3),
10439                         BPF_JMP_REG(BPF_JGE, R1, R2, 1),
10440                         BPF_EXIT_INSN(),
10441                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
10442                         BPF_EXIT_INSN(),
10443                 },
10444                 INTERNAL,
10445                 { },
10446                 { { 0, 1 } },
10447         },
10448         /* BPF_JMP | BPF_JLE | BPF_X */
10449         {
10450                 "JMP_JLE_X: if (2 <= 3) return 1",
10451                 .u.insns_int = {
10452                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10453                         BPF_LD_IMM64(R1, 3),
10454                         BPF_LD_IMM64(R2, 2),
10455                         BPF_JMP_REG(BPF_JLE, R2, R1, 1),
10456                         BPF_EXIT_INSN(),
10457                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
10458                         BPF_EXIT_INSN(),
10459                 },
10460                 INTERNAL,
10461                 { },
10462                 { { 0, 1 } },
10463         },
10464         {
10465                 "JMP_JLE_X: if (3 <= 3) return 1",
10466                 .u.insns_int = {
10467                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10468                         BPF_LD_IMM64(R1, 3),
10469                         BPF_LD_IMM64(R2, 3),
10470                         BPF_JMP_REG(BPF_JLE, R1, R2, 1),
10471                         BPF_EXIT_INSN(),
10472                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
10473                         BPF_EXIT_INSN(),
10474                 },
10475                 INTERNAL,
10476                 { },
10477                 { { 0, 1 } },
10478         },
10479         {
10480                 /* Mainly testing JIT + imm64 here. */
10481                 "JMP_JGE_X: ldimm64 test 1",
10482                 .u.insns_int = {
10483                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10484                         BPF_LD_IMM64(R1, 3),
10485                         BPF_LD_IMM64(R2, 2),
10486                         BPF_JMP_REG(BPF_JGE, R1, R2, 2),
10487                         BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
10488                         BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
10489                         BPF_EXIT_INSN(),
10490                 },
10491                 INTERNAL,
10492                 { },
10493                 { { 0, 0xeeeeeeeeU } },
10494         },
10495         {
10496                 "JMP_JGE_X: ldimm64 test 2",
10497                 .u.insns_int = {
10498                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10499                         BPF_LD_IMM64(R1, 3),
10500                         BPF_LD_IMM64(R2, 2),
10501                         BPF_JMP_REG(BPF_JGE, R1, R2, 0),
10502                         BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
10503                         BPF_EXIT_INSN(),
10504                 },
10505                 INTERNAL,
10506                 { },
10507                 { { 0, 0xffffffffU } },
10508         },
10509         {
10510                 "JMP_JGE_X: ldimm64 test 3",
10511                 .u.insns_int = {
10512                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
10513                         BPF_LD_IMM64(R1, 3),
10514                         BPF_LD_IMM64(R2, 2),
10515                         BPF_JMP_REG(BPF_JGE, R1, R2, 4),
10516                         BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
10517                         BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
10518                         BPF_EXIT_INSN(),
10519                 },
10520                 INTERNAL,
10521                 { },
10522                 { { 0, 1 } },
10523         },
10524         {
10525                 "JMP_JLE_X: ldimm64 test 1",
10526                 .u.insns_int = {
10527                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10528                         BPF_LD_IMM64(R1, 3),
10529                         BPF_LD_IMM64(R2, 2),
10530                         BPF_JMP_REG(BPF_JLE, R2, R1, 2),
10531                         BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
10532                         BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
10533                         BPF_EXIT_INSN(),
10534                 },
10535                 INTERNAL,
10536                 { },
10537                 { { 0, 0xeeeeeeeeU } },
10538         },
10539         {
10540                 "JMP_JLE_X: ldimm64 test 2",
10541                 .u.insns_int = {
10542                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10543                         BPF_LD_IMM64(R1, 3),
10544                         BPF_LD_IMM64(R2, 2),
10545                         BPF_JMP_REG(BPF_JLE, R2, R1, 0),
10546                         BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
10547                         BPF_EXIT_INSN(),
10548                 },
10549                 INTERNAL,
10550                 { },
10551                 { { 0, 0xffffffffU } },
10552         },
10553         {
10554                 "JMP_JLE_X: ldimm64 test 3",
10555                 .u.insns_int = {
10556                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
10557                         BPF_LD_IMM64(R1, 3),
10558                         BPF_LD_IMM64(R2, 2),
10559                         BPF_JMP_REG(BPF_JLE, R2, R1, 4),
10560                         BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
10561                         BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
10562                         BPF_EXIT_INSN(),
10563                 },
10564                 INTERNAL,
10565                 { },
10566                 { { 0, 1 } },
10567         },
10568         /* BPF_JMP | BPF_JNE | BPF_X */
10569         {
10570                 "JMP_JNE_X: if (3 != 2) return 1",
10571                 .u.insns_int = {
10572                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10573                         BPF_LD_IMM64(R1, 3),
10574                         BPF_LD_IMM64(R2, 2),
10575                         BPF_JMP_REG(BPF_JNE, R1, R2, 1),
10576                         BPF_EXIT_INSN(),
10577                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
10578                         BPF_EXIT_INSN(),
10579                 },
10580                 INTERNAL,
10581                 { },
10582                 { { 0, 1 } },
10583         },
10584         /* BPF_JMP | BPF_JEQ | BPF_X */
10585         {
10586                 "JMP_JEQ_X: if (3 == 3) return 1",
10587                 .u.insns_int = {
10588                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10589                         BPF_LD_IMM64(R1, 3),
10590                         BPF_LD_IMM64(R2, 3),
10591                         BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
10592                         BPF_EXIT_INSN(),
10593                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
10594                         BPF_EXIT_INSN(),
10595                 },
10596                 INTERNAL,
10597                 { },
10598                 { { 0, 1 } },
10599         },
10600         /* BPF_JMP | BPF_JSET | BPF_X */
10601         {
10602                 "JMP_JSET_X: if (0x3 & 0x2) return 1",
10603                 .u.insns_int = {
10604                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10605                         BPF_LD_IMM64(R1, 3),
10606                         BPF_LD_IMM64(R2, 2),
10607                         BPF_JMP_REG(BPF_JSET, R1, R2, 1),
10608                         BPF_EXIT_INSN(),
10609                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
10610                         BPF_EXIT_INSN(),
10611                 },
10612                 INTERNAL,
10613                 { },
10614                 { { 0, 1 } },
10615         },
10616         {
10617                 "JMP_JSET_X: if (0x3 & 0xffffffff) return 1",
10618                 .u.insns_int = {
10619                         BPF_ALU32_IMM(BPF_MOV, R0, 0),
10620                         BPF_LD_IMM64(R1, 3),
10621                         BPF_LD_IMM64(R2, 0xffffffff),
10622                         BPF_JMP_REG(BPF_JSET, R1, R2, 1),
10623                         BPF_EXIT_INSN(),
10624                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
10625                         BPF_EXIT_INSN(),
10626                 },
10627                 INTERNAL,
10628                 { },
10629                 { { 0, 1 } },
10630         },
10631         {
10632                 "JMP_JA: Jump, gap, jump, ...",
10633                 { },
10634                 CLASSIC | FLAG_NO_DATA,
10635                 { },
10636                 { { 0, 0xababcbac } },
10637                 .fill_helper = bpf_fill_ja,
10638         },
10639         {       /* Mainly checking JIT here. */
10640                 "BPF_MAXINSNS: Maximum possible literals",
10641                 { },
10642                 CLASSIC | FLAG_NO_DATA,
10643                 { },
10644                 { { 0, 0xffffffff } },
10645                 .fill_helper = bpf_fill_maxinsns1,
10646         },
10647         {       /* Mainly checking JIT here. */
10648                 "BPF_MAXINSNS: Single literal",
10649                 { },
10650                 CLASSIC | FLAG_NO_DATA,
10651                 { },
10652                 { { 0, 0xfefefefe } },
10653                 .fill_helper = bpf_fill_maxinsns2,
10654         },
10655         {       /* Mainly checking JIT here. */
10656                 "BPF_MAXINSNS: Run/add until end",
10657                 { },
10658                 CLASSIC | FLAG_NO_DATA,
10659                 { },
10660                 { { 0, 0x947bf368 } },
10661                 .fill_helper = bpf_fill_maxinsns3,
10662         },
10663         {
10664                 "BPF_MAXINSNS: Too many instructions",
10665                 { },
10666                 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
10667                 { },
10668                 { },
10669                 .fill_helper = bpf_fill_maxinsns4,
10670                 .expected_errcode = -EINVAL,
10671         },
10672         {       /* Mainly checking JIT here. */
10673                 "BPF_MAXINSNS: Very long jump",
10674                 { },
10675                 CLASSIC | FLAG_NO_DATA,
10676                 { },
10677                 { { 0, 0xabababab } },
10678                 .fill_helper = bpf_fill_maxinsns5,
10679         },
10680         {       /* Mainly checking JIT here. */
10681                 "BPF_MAXINSNS: Ctx heavy transformations",
10682                 { },
10683                 CLASSIC,
10684                 { },
10685                 {
10686                         {  1, SKB_VLAN_PRESENT },
10687                         { 10, SKB_VLAN_PRESENT }
10688                 },
10689                 .fill_helper = bpf_fill_maxinsns6,
10690         },
10691         {       /* Mainly checking JIT here. */
10692                 "BPF_MAXINSNS: Call heavy transformations",
10693                 { },
10694                 CLASSIC | FLAG_NO_DATA,
10695                 { },
10696                 { { 1, 0 }, { 10, 0 } },
10697                 .fill_helper = bpf_fill_maxinsns7,
10698         },
10699         {       /* Mainly checking JIT here. */
10700                 "BPF_MAXINSNS: Jump heavy test",
10701                 { },
10702                 CLASSIC | FLAG_NO_DATA,
10703                 { },
10704                 { { 0, 0xffffffff } },
10705                 .fill_helper = bpf_fill_maxinsns8,
10706         },
10707         {       /* Mainly checking JIT here. */
10708                 "BPF_MAXINSNS: Very long jump backwards",
10709                 { },
10710                 INTERNAL | FLAG_NO_DATA,
10711                 { },
10712                 { { 0, 0xcbababab } },
10713                 .fill_helper = bpf_fill_maxinsns9,
10714         },
10715         {       /* Mainly checking JIT here. */
10716                 "BPF_MAXINSNS: Edge hopping nuthouse",
10717                 { },
10718                 INTERNAL | FLAG_NO_DATA,
10719                 { },
10720                 { { 0, 0xabababac } },
10721                 .fill_helper = bpf_fill_maxinsns10,
10722         },
10723         {
10724                 "BPF_MAXINSNS: Jump, gap, jump, ...",
10725                 { },
10726                 CLASSIC | FLAG_NO_DATA,
10727                 { },
10728                 { { 0, 0xababcbac } },
10729                 .fill_helper = bpf_fill_maxinsns11,
10730         },
10731         {
10732                 "BPF_MAXINSNS: jump over MSH",
10733                 { },
10734                 CLASSIC | FLAG_EXPECTED_FAIL,
10735                 { 0xfa, 0xfb, 0xfc, 0xfd, },
10736                 { { 4, 0xabababab } },
10737                 .fill_helper = bpf_fill_maxinsns12,
10738                 .expected_errcode = -EINVAL,
10739         },
10740         {
10741                 "BPF_MAXINSNS: exec all MSH",
10742                 { },
10743                 CLASSIC,
10744                 { 0xfa, 0xfb, 0xfc, 0xfd, },
10745                 { { 4, 0xababab83 } },
10746                 .fill_helper = bpf_fill_maxinsns13,
10747         },
10748         {
10749                 "BPF_MAXINSNS: ld_abs+get_processor_id",
10750                 { },
10751                 CLASSIC,
10752                 { },
10753                 { { 1, 0xbee } },
10754                 .fill_helper = bpf_fill_ld_abs_get_processor_id,
10755         },
10756         /*
10757          * LD_IND / LD_ABS on fragmented SKBs
10758          */
10759         {
10760                 "LD_IND byte frag",
10761                 .u.insns = {
10762                         BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
10763                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x0),
10764                         BPF_STMT(BPF_RET | BPF_A, 0x0),
10765                 },
10766                 CLASSIC | FLAG_SKB_FRAG,
10767                 { },
10768                 { {0x40, 0x42} },
10769                 .frag_data = {
10770                         0x42, 0x00, 0x00, 0x00,
10771                         0x43, 0x44, 0x00, 0x00,
10772                         0x21, 0x07, 0x19, 0x83,
10773                 },
10774         },
10775         {
10776                 "LD_IND halfword frag",
10777                 .u.insns = {
10778                         BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
10779                         BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x4),
10780                         BPF_STMT(BPF_RET | BPF_A, 0x0),
10781                 },
10782                 CLASSIC | FLAG_SKB_FRAG,
10783                 { },
10784                 { {0x40, 0x4344} },
10785                 .frag_data = {
10786                         0x42, 0x00, 0x00, 0x00,
10787                         0x43, 0x44, 0x00, 0x00,
10788                         0x21, 0x07, 0x19, 0x83,
10789                 },
10790         },
10791         {
10792                 "LD_IND word frag",
10793                 .u.insns = {
10794                         BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
10795                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x8),
10796                         BPF_STMT(BPF_RET | BPF_A, 0x0),
10797                 },
10798                 CLASSIC | FLAG_SKB_FRAG,
10799                 { },
10800                 { {0x40, 0x21071983} },
10801                 .frag_data = {
10802                         0x42, 0x00, 0x00, 0x00,
10803                         0x43, 0x44, 0x00, 0x00,
10804                         0x21, 0x07, 0x19, 0x83,
10805                 },
10806         },
10807         {
10808                 "LD_IND halfword mixed head/frag",
10809                 .u.insns = {
10810                         BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
10811                         BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
10812                         BPF_STMT(BPF_RET | BPF_A, 0x0),
10813                 },
10814                 CLASSIC | FLAG_SKB_FRAG,
10815                 { [0x3e] = 0x25, [0x3f] = 0x05, },
10816                 { {0x40, 0x0519} },
10817                 .frag_data = { 0x19, 0x82 },
10818         },
10819         {
10820                 "LD_IND word mixed head/frag",
10821                 .u.insns = {
10822                         BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
10823                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
10824                         BPF_STMT(BPF_RET | BPF_A, 0x0),
10825                 },
10826                 CLASSIC | FLAG_SKB_FRAG,
10827                 { [0x3e] = 0x25, [0x3f] = 0x05, },
10828                 { {0x40, 0x25051982} },
10829                 .frag_data = { 0x19, 0x82 },
10830         },
10831         {
10832                 "LD_ABS byte frag",
10833                 .u.insns = {
10834                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x40),
10835                         BPF_STMT(BPF_RET | BPF_A, 0x0),
10836                 },
10837                 CLASSIC | FLAG_SKB_FRAG,
10838                 { },
10839                 { {0x40, 0x42} },
10840                 .frag_data = {
10841                         0x42, 0x00, 0x00, 0x00,
10842                         0x43, 0x44, 0x00, 0x00,
10843                         0x21, 0x07, 0x19, 0x83,
10844                 },
10845         },
10846         {
10847                 "LD_ABS halfword frag",
10848                 .u.insns = {
10849                         BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x44),
10850                         BPF_STMT(BPF_RET | BPF_A, 0x0),
10851                 },
10852                 CLASSIC | FLAG_SKB_FRAG,
10853                 { },
10854                 { {0x40, 0x4344} },
10855                 .frag_data = {
10856                         0x42, 0x00, 0x00, 0x00,
10857                         0x43, 0x44, 0x00, 0x00,
10858                         0x21, 0x07, 0x19, 0x83,
10859                 },
10860         },
10861         {
10862                 "LD_ABS word frag",
10863                 .u.insns = {
10864                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x48),
10865                         BPF_STMT(BPF_RET | BPF_A, 0x0),
10866                 },
10867                 CLASSIC | FLAG_SKB_FRAG,
10868                 { },
10869                 { {0x40, 0x21071983} },
10870                 .frag_data = {
10871                         0x42, 0x00, 0x00, 0x00,
10872                         0x43, 0x44, 0x00, 0x00,
10873                         0x21, 0x07, 0x19, 0x83,
10874                 },
10875         },
10876         {
10877                 "LD_ABS halfword mixed head/frag",
10878                 .u.insns = {
10879                         BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f),
10880                         BPF_STMT(BPF_RET | BPF_A, 0x0),
10881                 },
10882                 CLASSIC | FLAG_SKB_FRAG,
10883                 { [0x3e] = 0x25, [0x3f] = 0x05, },
10884                 { {0x40, 0x0519} },
10885                 .frag_data = { 0x19, 0x82 },
10886         },
10887         {
10888                 "LD_ABS word mixed head/frag",
10889                 .u.insns = {
10890                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3e),
10891                         BPF_STMT(BPF_RET | BPF_A, 0x0),
10892                 },
10893                 CLASSIC | FLAG_SKB_FRAG,
10894                 { [0x3e] = 0x25, [0x3f] = 0x05, },
10895                 { {0x40, 0x25051982} },
10896                 .frag_data = { 0x19, 0x82 },
10897         },
10898         /*
10899          * LD_IND / LD_ABS on non fragmented SKBs
10900          */
10901         {
10902                 /*
10903                  * this tests that the JIT/interpreter correctly resets X
10904                  * before using it in an LD_IND instruction.
10905                  */
10906                 "LD_IND byte default X",
10907                 .u.insns = {
10908                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
10909                         BPF_STMT(BPF_RET | BPF_A, 0x0),
10910                 },
10911                 CLASSIC,
10912                 { [0x1] = 0x42 },
10913                 { {0x40, 0x42 } },
10914         },
10915         {
10916                 "LD_IND byte positive offset",
10917                 .u.insns = {
10918                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10919                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
10920                         BPF_STMT(BPF_RET | BPF_A, 0x0),
10921                 },
10922                 CLASSIC,
10923                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10924                 { {0x40, 0x82 } },
10925         },
10926         {
10927                 "LD_IND byte negative offset",
10928                 .u.insns = {
10929                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10930                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x1),
10931                         BPF_STMT(BPF_RET | BPF_A, 0x0),
10932                 },
10933                 CLASSIC,
10934                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10935                 { {0x40, 0x05 } },
10936         },
10937         {
10938                 "LD_IND byte positive offset, all ff",
10939                 .u.insns = {
10940                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10941                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
10942                         BPF_STMT(BPF_RET | BPF_A, 0x0),
10943                 },
10944                 CLASSIC,
10945                 { [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
10946                 { {0x40, 0xff } },
10947         },
10948         {
10949                 "LD_IND byte positive offset, out of bounds",
10950                 .u.insns = {
10951                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10952                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
10953                         BPF_STMT(BPF_RET | BPF_A, 0x0),
10954                 },
10955                 CLASSIC,
10956                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10957                 { {0x3f, 0 }, },
10958         },
10959         {
10960                 "LD_IND byte negative offset, out of bounds",
10961                 .u.insns = {
10962                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10963                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x3f),
10964                         BPF_STMT(BPF_RET | BPF_A, 0x0),
10965                 },
10966                 CLASSIC,
10967                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10968                 { {0x3f, 0 } },
10969         },
10970         {
10971                 "LD_IND byte negative offset, multiple calls",
10972                 .u.insns = {
10973                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3b),
10974                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 1),
10975                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 2),
10976                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 3),
10977                         BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 4),
10978                         BPF_STMT(BPF_RET | BPF_A, 0x0),
10979                 },
10980                 CLASSIC,
10981                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
10982                 { {0x40, 0x82 }, },
10983         },
10984         {
10985                 "LD_IND halfword positive offset",
10986                 .u.insns = {
10987                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
10988                         BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x2),
10989                         BPF_STMT(BPF_RET | BPF_A, 0x0),
10990                 },
10991                 CLASSIC,
10992                 {
10993                         [0x1c] = 0xaa, [0x1d] = 0x55,
10994                         [0x1e] = 0xbb, [0x1f] = 0x66,
10995                         [0x20] = 0xcc, [0x21] = 0x77,
10996                         [0x22] = 0xdd, [0x23] = 0x88,
10997                 },
10998                 { {0x40, 0xdd88 } },
10999         },
11000         {
11001                 "LD_IND halfword negative offset",
11002                 .u.insns = {
11003                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
11004                         BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x2),
11005                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11006                 },
11007                 CLASSIC,
11008                 {
11009                         [0x1c] = 0xaa, [0x1d] = 0x55,
11010                         [0x1e] = 0xbb, [0x1f] = 0x66,
11011                         [0x20] = 0xcc, [0x21] = 0x77,
11012                         [0x22] = 0xdd, [0x23] = 0x88,
11013                 },
11014                 { {0x40, 0xbb66 } },
11015         },
11016         {
11017                 "LD_IND halfword unaligned",
11018                 .u.insns = {
11019                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
11020                         BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
11021                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11022                 },
11023                 CLASSIC,
11024                 {
11025                         [0x1c] = 0xaa, [0x1d] = 0x55,
11026                         [0x1e] = 0xbb, [0x1f] = 0x66,
11027                         [0x20] = 0xcc, [0x21] = 0x77,
11028                         [0x22] = 0xdd, [0x23] = 0x88,
11029                 },
11030                 { {0x40, 0x66cc } },
11031         },
11032         {
11033                 "LD_IND halfword positive offset, all ff",
11034                 .u.insns = {
11035                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3d),
11036                         BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1),
11037                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11038                 },
11039                 CLASSIC,
11040                 { [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
11041                 { {0x40, 0xffff } },
11042         },
11043         {
11044                 "LD_IND halfword positive offset, out of bounds",
11045                 .u.insns = {
11046                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
11047                         BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1),
11048                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11049                 },
11050                 CLASSIC,
11051                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11052                 { {0x3f, 0 }, },
11053         },
11054         {
11055                 "LD_IND halfword negative offset, out of bounds",
11056                 .u.insns = {
11057                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
11058                         BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x3f),
11059                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11060                 },
11061                 CLASSIC,
11062                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11063                 { {0x3f, 0 } },
11064         },
11065         {
11066                 "LD_IND word positive offset",
11067                 .u.insns = {
11068                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
11069                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x4),
11070                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11071                 },
11072                 CLASSIC,
11073                 {
11074                         [0x1c] = 0xaa, [0x1d] = 0x55,
11075                         [0x1e] = 0xbb, [0x1f] = 0x66,
11076                         [0x20] = 0xcc, [0x21] = 0x77,
11077                         [0x22] = 0xdd, [0x23] = 0x88,
11078                         [0x24] = 0xee, [0x25] = 0x99,
11079                         [0x26] = 0xff, [0x27] = 0xaa,
11080                 },
11081                 { {0x40, 0xee99ffaa } },
11082         },
11083         {
11084                 "LD_IND word negative offset",
11085                 .u.insns = {
11086                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
11087                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x4),
11088                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11089                 },
11090                 CLASSIC,
11091                 {
11092                         [0x1c] = 0xaa, [0x1d] = 0x55,
11093                         [0x1e] = 0xbb, [0x1f] = 0x66,
11094                         [0x20] = 0xcc, [0x21] = 0x77,
11095                         [0x22] = 0xdd, [0x23] = 0x88,
11096                         [0x24] = 0xee, [0x25] = 0x99,
11097                         [0x26] = 0xff, [0x27] = 0xaa,
11098                 },
11099                 { {0x40, 0xaa55bb66 } },
11100         },
11101         {
11102                 "LD_IND word unaligned (addr & 3 == 2)",
11103                 .u.insns = {
11104                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
11105                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
11106                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11107                 },
11108                 CLASSIC,
11109                 {
11110                         [0x1c] = 0xaa, [0x1d] = 0x55,
11111                         [0x1e] = 0xbb, [0x1f] = 0x66,
11112                         [0x20] = 0xcc, [0x21] = 0x77,
11113                         [0x22] = 0xdd, [0x23] = 0x88,
11114                         [0x24] = 0xee, [0x25] = 0x99,
11115                         [0x26] = 0xff, [0x27] = 0xaa,
11116                 },
11117                 { {0x40, 0xbb66cc77 } },
11118         },
11119         {
11120                 "LD_IND word unaligned (addr & 3 == 1)",
11121                 .u.insns = {
11122                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
11123                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3),
11124                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11125                 },
11126                 CLASSIC,
11127                 {
11128                         [0x1c] = 0xaa, [0x1d] = 0x55,
11129                         [0x1e] = 0xbb, [0x1f] = 0x66,
11130                         [0x20] = 0xcc, [0x21] = 0x77,
11131                         [0x22] = 0xdd, [0x23] = 0x88,
11132                         [0x24] = 0xee, [0x25] = 0x99,
11133                         [0x26] = 0xff, [0x27] = 0xaa,
11134                 },
11135                 { {0x40, 0x55bb66cc } },
11136         },
11137         {
11138                 "LD_IND word unaligned (addr & 3 == 3)",
11139                 .u.insns = {
11140                         BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
11141                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x1),
11142                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11143                 },
11144                 CLASSIC,
11145                 {
11146                         [0x1c] = 0xaa, [0x1d] = 0x55,
11147                         [0x1e] = 0xbb, [0x1f] = 0x66,
11148                         [0x20] = 0xcc, [0x21] = 0x77,
11149                         [0x22] = 0xdd, [0x23] = 0x88,
11150                         [0x24] = 0xee, [0x25] = 0x99,
11151                         [0x26] = 0xff, [0x27] = 0xaa,
11152                 },
11153                 { {0x40, 0x66cc77dd } },
11154         },
11155         {
11156                 "LD_IND word positive offset, all ff",
11157                 .u.insns = {
11158                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3b),
11159                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1),
11160                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11161                 },
11162                 CLASSIC,
11163                 { [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
11164                 { {0x40, 0xffffffff } },
11165         },
11166         {
11167                 "LD_IND word positive offset, out of bounds",
11168                 .u.insns = {
11169                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
11170                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1),
11171                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11172                 },
11173                 CLASSIC,
11174                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11175                 { {0x3f, 0 }, },
11176         },
11177         {
11178                 "LD_IND word negative offset, out of bounds",
11179                 .u.insns = {
11180                         BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
11181                         BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3f),
11182                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11183                 },
11184                 CLASSIC,
11185                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11186                 { {0x3f, 0 } },
11187         },
11188         {
11189                 "LD_ABS byte",
11190                 .u.insns = {
11191                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x20),
11192                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11193                 },
11194                 CLASSIC,
11195                 {
11196                         [0x1c] = 0xaa, [0x1d] = 0x55,
11197                         [0x1e] = 0xbb, [0x1f] = 0x66,
11198                         [0x20] = 0xcc, [0x21] = 0x77,
11199                         [0x22] = 0xdd, [0x23] = 0x88,
11200                         [0x24] = 0xee, [0x25] = 0x99,
11201                         [0x26] = 0xff, [0x27] = 0xaa,
11202                 },
11203                 { {0x40, 0xcc } },
11204         },
11205         {
11206                 "LD_ABS byte positive offset, all ff",
11207                 .u.insns = {
11208                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f),
11209                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11210                 },
11211                 CLASSIC,
11212                 { [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
11213                 { {0x40, 0xff } },
11214         },
11215         {
11216                 "LD_ABS byte positive offset, out of bounds",
11217                 .u.insns = {
11218                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f),
11219                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11220                 },
11221                 CLASSIC,
11222                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11223                 { {0x3f, 0 }, },
11224         },
11225         {
11226                 "LD_ABS byte negative offset, out of bounds load",
11227                 .u.insns = {
11228                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, -1),
11229                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11230                 },
11231                 CLASSIC | FLAG_EXPECTED_FAIL,
11232                 .expected_errcode = -EINVAL,
11233         },
11234         {
11235                 "LD_ABS byte negative offset, in bounds",
11236                 .u.insns = {
11237                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
11238                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11239                 },
11240                 CLASSIC,
11241                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11242                 { {0x40, 0x82 }, },
11243         },
11244         {
11245                 "LD_ABS byte negative offset, out of bounds",
11246                 .u.insns = {
11247                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
11248                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11249                 },
11250                 CLASSIC,
11251                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11252                 { {0x3f, 0 }, },
11253         },
11254         {
11255                 "LD_ABS byte negative offset, multiple calls",
11256                 .u.insns = {
11257                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3c),
11258                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3d),
11259                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3e),
11260                         BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
11261                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11262                 },
11263                 CLASSIC,
11264                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11265                 { {0x40, 0x82 }, },
11266         },
11267         {
11268                 "LD_ABS halfword",
11269                 .u.insns = {
11270                         BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x22),
11271                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11272                 },
11273                 CLASSIC,
11274                 {
11275                         [0x1c] = 0xaa, [0x1d] = 0x55,
11276                         [0x1e] = 0xbb, [0x1f] = 0x66,
11277                         [0x20] = 0xcc, [0x21] = 0x77,
11278                         [0x22] = 0xdd, [0x23] = 0x88,
11279                         [0x24] = 0xee, [0x25] = 0x99,
11280                         [0x26] = 0xff, [0x27] = 0xaa,
11281                 },
11282                 { {0x40, 0xdd88 } },
11283         },
11284         {
11285                 "LD_ABS halfword unaligned",
11286                 .u.insns = {
11287                         BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x25),
11288                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11289                 },
11290                 CLASSIC,
11291                 {
11292                         [0x1c] = 0xaa, [0x1d] = 0x55,
11293                         [0x1e] = 0xbb, [0x1f] = 0x66,
11294                         [0x20] = 0xcc, [0x21] = 0x77,
11295                         [0x22] = 0xdd, [0x23] = 0x88,
11296                         [0x24] = 0xee, [0x25] = 0x99,
11297                         [0x26] = 0xff, [0x27] = 0xaa,
11298                 },
11299                 { {0x40, 0x99ff } },
11300         },
11301         {
11302                 "LD_ABS halfword positive offset, all ff",
11303                 .u.insns = {
11304                         BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3e),
11305                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11306                 },
11307                 CLASSIC,
11308                 { [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
11309                 { {0x40, 0xffff } },
11310         },
11311         {
11312                 "LD_ABS halfword positive offset, out of bounds",
11313                 .u.insns = {
11314                         BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f),
11315                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11316                 },
11317                 CLASSIC,
11318                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11319                 { {0x3f, 0 }, },
11320         },
11321         {
11322                 "LD_ABS halfword negative offset, out of bounds load",
11323                 .u.insns = {
11324                         BPF_STMT(BPF_LD | BPF_ABS | BPF_H, -1),
11325                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11326                 },
11327                 CLASSIC | FLAG_EXPECTED_FAIL,
11328                 .expected_errcode = -EINVAL,
11329         },
11330         {
11331                 "LD_ABS halfword negative offset, in bounds",
11332                 .u.insns = {
11333                         BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e),
11334                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11335                 },
11336                 CLASSIC,
11337                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11338                 { {0x40, 0x1982 }, },
11339         },
11340         {
11341                 "LD_ABS halfword negative offset, out of bounds",
11342                 .u.insns = {
11343                         BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e),
11344                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11345                 },
11346                 CLASSIC,
11347                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11348                 { {0x3f, 0 }, },
11349         },
11350         {
11351                 "LD_ABS word",
11352                 .u.insns = {
11353                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x1c),
11354                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11355                 },
11356                 CLASSIC,
11357                 {
11358                         [0x1c] = 0xaa, [0x1d] = 0x55,
11359                         [0x1e] = 0xbb, [0x1f] = 0x66,
11360                         [0x20] = 0xcc, [0x21] = 0x77,
11361                         [0x22] = 0xdd, [0x23] = 0x88,
11362                         [0x24] = 0xee, [0x25] = 0x99,
11363                         [0x26] = 0xff, [0x27] = 0xaa,
11364                 },
11365                 { {0x40, 0xaa55bb66 } },
11366         },
11367         {
11368                 "LD_ABS word unaligned (addr & 3 == 2)",
11369                 .u.insns = {
11370                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x22),
11371                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11372                 },
11373                 CLASSIC,
11374                 {
11375                         [0x1c] = 0xaa, [0x1d] = 0x55,
11376                         [0x1e] = 0xbb, [0x1f] = 0x66,
11377                         [0x20] = 0xcc, [0x21] = 0x77,
11378                         [0x22] = 0xdd, [0x23] = 0x88,
11379                         [0x24] = 0xee, [0x25] = 0x99,
11380                         [0x26] = 0xff, [0x27] = 0xaa,
11381                 },
11382                 { {0x40, 0xdd88ee99 } },
11383         },
11384         {
11385                 "LD_ABS word unaligned (addr & 3 == 1)",
11386                 .u.insns = {
11387                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x21),
11388                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11389                 },
11390                 CLASSIC,
11391                 {
11392                         [0x1c] = 0xaa, [0x1d] = 0x55,
11393                         [0x1e] = 0xbb, [0x1f] = 0x66,
11394                         [0x20] = 0xcc, [0x21] = 0x77,
11395                         [0x22] = 0xdd, [0x23] = 0x88,
11396                         [0x24] = 0xee, [0x25] = 0x99,
11397                         [0x26] = 0xff, [0x27] = 0xaa,
11398                 },
11399                 { {0x40, 0x77dd88ee } },
11400         },
11401         {
11402                 "LD_ABS word unaligned (addr & 3 == 3)",
11403                 .u.insns = {
11404                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x23),
11405                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11406                 },
11407                 CLASSIC,
11408                 {
11409                         [0x1c] = 0xaa, [0x1d] = 0x55,
11410                         [0x1e] = 0xbb, [0x1f] = 0x66,
11411                         [0x20] = 0xcc, [0x21] = 0x77,
11412                         [0x22] = 0xdd, [0x23] = 0x88,
11413                         [0x24] = 0xee, [0x25] = 0x99,
11414                         [0x26] = 0xff, [0x27] = 0xaa,
11415                 },
11416                 { {0x40, 0x88ee99ff } },
11417         },
11418         {
11419                 "LD_ABS word positive offset, all ff",
11420                 .u.insns = {
11421                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3c),
11422                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11423                 },
11424                 CLASSIC,
11425                 { [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
11426                 { {0x40, 0xffffffff } },
11427         },
11428         {
11429                 "LD_ABS word positive offset, out of bounds",
11430                 .u.insns = {
11431                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3f),
11432                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11433                 },
11434                 CLASSIC,
11435                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11436                 { {0x3f, 0 }, },
11437         },
11438         {
11439                 "LD_ABS word negative offset, out of bounds load",
11440                 .u.insns = {
11441                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, -1),
11442                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11443                 },
11444                 CLASSIC | FLAG_EXPECTED_FAIL,
11445                 .expected_errcode = -EINVAL,
11446         },
11447         {
11448                 "LD_ABS word negative offset, in bounds",
11449                 .u.insns = {
11450                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c),
11451                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11452                 },
11453                 CLASSIC,
11454                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11455                 { {0x40, 0x25051982 }, },
11456         },
11457         {
11458                 "LD_ABS word negative offset, out of bounds",
11459                 .u.insns = {
11460                         BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c),
11461                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11462                 },
11463                 CLASSIC,
11464                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11465                 { {0x3f, 0 }, },
11466         },
11467         {
11468                 "LDX_MSH standalone, preserved A",
11469                 .u.insns = {
11470                         BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
11471                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
11472                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11473                 },
11474                 CLASSIC,
11475                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11476                 { {0x40, 0xffeebbaa }, },
11477         },
11478         {
11479                 "LDX_MSH standalone, preserved A 2",
11480                 .u.insns = {
11481                         BPF_STMT(BPF_LD | BPF_IMM, 0x175e9d63),
11482                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
11483                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3d),
11484                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e),
11485                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3f),
11486                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11487                 },
11488                 CLASSIC,
11489                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11490                 { {0x40, 0x175e9d63 }, },
11491         },
11492         {
11493                 "LDX_MSH standalone, test result 1",
11494                 .u.insns = {
11495                         BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
11496                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
11497                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
11498                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11499                 },
11500                 CLASSIC,
11501                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11502                 { {0x40, 0x14 }, },
11503         },
11504         {
11505                 "LDX_MSH standalone, test result 2",
11506                 .u.insns = {
11507                         BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
11508                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e),
11509                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
11510                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11511                 },
11512                 CLASSIC,
11513                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11514                 { {0x40, 0x24 }, },
11515         },
11516         {
11517                 "LDX_MSH standalone, negative offset",
11518                 .u.insns = {
11519                         BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
11520                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, -1),
11521                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
11522                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11523                 },
11524                 CLASSIC,
11525                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11526                 { {0x40, 0 }, },
11527         },
11528         {
11529                 "LDX_MSH standalone, negative offset 2",
11530                 .u.insns = {
11531                         BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
11532                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, SKF_LL_OFF + 0x3e),
11533                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
11534                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11535                 },
11536                 CLASSIC,
11537                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11538                 { {0x40, 0x24 }, },
11539         },
11540         {
11541                 "LDX_MSH standalone, out of bounds",
11542                 .u.insns = {
11543                         BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
11544                         BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x40),
11545                         BPF_STMT(BPF_MISC | BPF_TXA, 0),
11546                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11547                 },
11548                 CLASSIC,
11549                 { [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
11550                 { {0x40, 0 }, },
11551         },
11552         /*
11553          * verify that the interpreter or JIT correctly sets A and X
11554          * to 0.
11555          */
11556         {
11557                 "ADD default X",
11558                 .u.insns = {
11559                         /*
11560                          * A = 0x42
11561                          * A = A + X
11562                          * ret A
11563                          */
11564                         BPF_STMT(BPF_LD | BPF_IMM, 0x42),
11565                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
11566                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11567                 },
11568                 CLASSIC | FLAG_NO_DATA,
11569                 {},
11570                 { {0x1, 0x42 } },
11571         },
11572         {
11573                 "ADD default A",
11574                 .u.insns = {
11575                         /*
11576                          * A = A + 0x42
11577                          * ret A
11578                          */
11579                         BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0x42),
11580                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11581                 },
11582                 CLASSIC | FLAG_NO_DATA,
11583                 {},
11584                 { {0x1, 0x42 } },
11585         },
11586         {
11587                 "SUB default X",
11588                 .u.insns = {
11589                         /*
11590                          * A = 0x66
11591                          * A = A - X
11592                          * ret A
11593                          */
11594                         BPF_STMT(BPF_LD | BPF_IMM, 0x66),
11595                         BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
11596                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11597                 },
11598                 CLASSIC | FLAG_NO_DATA,
11599                 {},
11600                 { {0x1, 0x66 } },
11601         },
11602         {
11603                 "SUB default A",
11604                 .u.insns = {
11605                         /*
11606                          * A = A - -0x66
11607                          * ret A
11608                          */
11609                         BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, -0x66),
11610                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11611                 },
11612                 CLASSIC | FLAG_NO_DATA,
11613                 {},
11614                 { {0x1, 0x66 } },
11615         },
11616         {
11617                 "MUL default X",
11618                 .u.insns = {
11619                         /*
11620                          * A = 0x42
11621                          * A = A * X
11622                          * ret A
11623                          */
11624                         BPF_STMT(BPF_LD | BPF_IMM, 0x42),
11625                         BPF_STMT(BPF_ALU | BPF_MUL | BPF_X, 0),
11626                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11627                 },
11628                 CLASSIC | FLAG_NO_DATA,
11629                 {},
11630                 { {0x1, 0x0 } },
11631         },
11632         {
11633                 "MUL default A",
11634                 .u.insns = {
11635                         /*
11636                          * A = A * 0x66
11637                          * ret A
11638                          */
11639                         BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 0x66),
11640                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11641                 },
11642                 CLASSIC | FLAG_NO_DATA,
11643                 {},
11644                 { {0x1, 0x0 } },
11645         },
11646         {
11647                 "DIV default X",
11648                 .u.insns = {
11649                         /*
11650                          * A = 0x42
11651                          * A = A / X ; this halt the filter execution if X is 0
11652                          * ret 0x42
11653                          */
11654                         BPF_STMT(BPF_LD | BPF_IMM, 0x42),
11655                         BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
11656                         BPF_STMT(BPF_RET | BPF_K, 0x42),
11657                 },
11658                 CLASSIC | FLAG_NO_DATA,
11659                 {},
11660                 { {0x1, 0x0 } },
11661         },
11662         {
11663                 "DIV default A",
11664                 .u.insns = {
11665                         /*
11666                          * A = A / 1
11667                          * ret A
11668                          */
11669                         BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x1),
11670                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11671                 },
11672                 CLASSIC | FLAG_NO_DATA,
11673                 {},
11674                 { {0x1, 0x0 } },
11675         },
11676         {
11677                 "MOD default X",
11678                 .u.insns = {
11679                         /*
11680                          * A = 0x42
11681                          * A = A mod X ; this halt the filter execution if X is 0
11682                          * ret 0x42
11683                          */
11684                         BPF_STMT(BPF_LD | BPF_IMM, 0x42),
11685                         BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
11686                         BPF_STMT(BPF_RET | BPF_K, 0x42),
11687                 },
11688                 CLASSIC | FLAG_NO_DATA,
11689                 {},
11690                 { {0x1, 0x0 } },
11691         },
11692         {
11693                 "MOD default A",
11694                 .u.insns = {
11695                         /*
11696                          * A = A mod 1
11697                          * ret A
11698                          */
11699                         BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x1),
11700                         BPF_STMT(BPF_RET | BPF_A, 0x0),
11701                 },
11702                 CLASSIC | FLAG_NO_DATA,
11703                 {},
11704                 { {0x1, 0x0 } },
11705         },
11706         {
11707                 "JMP EQ default A",
11708                 .u.insns = {
11709                         /*
11710                          * cmp A, 0x0, 0, 1
11711                          * ret 0x42
11712                          * ret 0x66
11713                          */
11714                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0, 0, 1),
11715                         BPF_STMT(BPF_RET | BPF_K, 0x42),
11716                         BPF_STMT(BPF_RET | BPF_K, 0x66),
11717                 },
11718                 CLASSIC | FLAG_NO_DATA,
11719                 {},
11720                 { {0x1, 0x42 } },
11721         },
11722         {
11723                 "JMP EQ default X",
11724                 .u.insns = {
11725                         /*
11726                          * A = 0x0
11727                          * cmp A, X, 0, 1
11728                          * ret 0x42
11729                          * ret 0x66
11730                          */
11731                         BPF_STMT(BPF_LD | BPF_IMM, 0x0),
11732                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0x0, 0, 1),
11733                         BPF_STMT(BPF_RET | BPF_K, 0x42),
11734                         BPF_STMT(BPF_RET | BPF_K, 0x66),
11735                 },
11736                 CLASSIC | FLAG_NO_DATA,
11737                 {},
11738                 { {0x1, 0x42 } },
11739         },
11740         /* Checking interpreter vs JIT wrt signed extended imms. */
11741         {
11742                 "JNE signed compare, test 1",
11743                 .u.insns_int = {
11744                         BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
11745                         BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
11746                         BPF_MOV64_REG(R2, R1),
11747                         BPF_ALU64_REG(BPF_AND, R2, R3),
11748                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
11749                         BPF_JMP_IMM(BPF_JNE, R2, -17104896, 1),
11750                         BPF_ALU32_IMM(BPF_MOV, R0, 2),
11751                         BPF_EXIT_INSN(),
11752                 },
11753                 INTERNAL,
11754                 { },
11755                 { { 0, 1 } },
11756         },
11757         {
11758                 "JNE signed compare, test 2",
11759                 .u.insns_int = {
11760                         BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
11761                         BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
11762                         BPF_MOV64_REG(R2, R1),
11763                         BPF_ALU64_REG(BPF_AND, R2, R3),
11764                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
11765                         BPF_JMP_IMM(BPF_JNE, R2, 0xfefb0000, 1),
11766                         BPF_ALU32_IMM(BPF_MOV, R0, 2),
11767                         BPF_EXIT_INSN(),
11768                 },
11769                 INTERNAL,
11770                 { },
11771                 { { 0, 1 } },
11772         },
11773         {
11774                 "JNE signed compare, test 3",
11775                 .u.insns_int = {
11776                         BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
11777                         BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
11778                         BPF_ALU32_IMM(BPF_MOV, R4, 0xfefb0000),
11779                         BPF_MOV64_REG(R2, R1),
11780                         BPF_ALU64_REG(BPF_AND, R2, R3),
11781                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
11782                         BPF_JMP_REG(BPF_JNE, R2, R4, 1),
11783                         BPF_ALU32_IMM(BPF_MOV, R0, 2),
11784                         BPF_EXIT_INSN(),
11785                 },
11786                 INTERNAL,
11787                 { },
11788                 { { 0, 2 } },
11789         },
11790         {
11791                 "JNE signed compare, test 4",
11792                 .u.insns_int = {
11793                         BPF_LD_IMM64(R1, -17104896),
11794                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
11795                         BPF_JMP_IMM(BPF_JNE, R1, -17104896, 1),
11796                         BPF_ALU32_IMM(BPF_MOV, R0, 2),
11797                         BPF_EXIT_INSN(),
11798                 },
11799                 INTERNAL,
11800                 { },
11801                 { { 0, 2 } },
11802         },
11803         {
11804                 "JNE signed compare, test 5",
11805                 .u.insns_int = {
11806                         BPF_LD_IMM64(R1, 0xfefb0000),
11807                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
11808                         BPF_JMP_IMM(BPF_JNE, R1, 0xfefb0000, 1),
11809                         BPF_ALU32_IMM(BPF_MOV, R0, 2),
11810                         BPF_EXIT_INSN(),
11811                 },
11812                 INTERNAL,
11813                 { },
11814                 { { 0, 1 } },
11815         },
11816         {
11817                 "JNE signed compare, test 6",
11818                 .u.insns_int = {
11819                         BPF_LD_IMM64(R1, 0x7efb0000),
11820                         BPF_ALU32_IMM(BPF_MOV, R0, 1),
11821                         BPF_JMP_IMM(BPF_JNE, R1, 0x7efb0000, 1),
11822                         BPF_ALU32_IMM(BPF_MOV, R0, 2),
11823                         BPF_EXIT_INSN(),
11824                 },
11825                 INTERNAL,
11826                 { },
11827                 { { 0, 2 } },
11828         },
11829         {
11830                 "JNE signed compare, test 7",
11831                 .u.insns = {
11832                         BPF_STMT(BPF_LD | BPF_IMM, 0xffff0000),
11833                         BPF_STMT(BPF_MISC | BPF_TAX, 0),
11834                         BPF_STMT(BPF_LD | BPF_IMM, 0xfefbbc12),
11835                         BPF_STMT(BPF_ALU | BPF_AND | BPF_X, 0),
11836                         BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0xfefb0000, 1, 0),
11837                         BPF_STMT(BPF_RET | BPF_K, 1),
11838                         BPF_STMT(BPF_RET | BPF_K, 2),
11839                 },
11840                 CLASSIC | FLAG_NO_DATA,
11841                 {},
11842                 { { 0, 2 } },
11843         },
11844         /* BPF_LDX_MEM with operand aliasing */
11845         {
11846                 "LDX_MEM_B: operand register aliasing",
11847                 .u.insns_int = {
11848                         BPF_ST_MEM(BPF_B, R10, -8, 123),
11849                         BPF_MOV64_REG(R0, R10),
11850                         BPF_LDX_MEM(BPF_B, R0, R0, -8),
11851                         BPF_EXIT_INSN(),
11852                 },
11853                 INTERNAL,
11854                 { },
11855                 { { 0, 123 } },
11856                 .stack_depth = 8,
11857         },
11858         {
11859                 "LDX_MEM_H: operand register aliasing",
11860                 .u.insns_int = {
11861                         BPF_ST_MEM(BPF_H, R10, -8, 12345),
11862                         BPF_MOV64_REG(R0, R10),
11863                         BPF_LDX_MEM(BPF_H, R0, R0, -8),
11864                         BPF_EXIT_INSN(),
11865                 },
11866                 INTERNAL,
11867                 { },
11868                 { { 0, 12345 } },
11869                 .stack_depth = 8,
11870         },
11871         {
11872                 "LDX_MEM_W: operand register aliasing",
11873                 .u.insns_int = {
11874                         BPF_ST_MEM(BPF_W, R10, -8, 123456789),
11875                         BPF_MOV64_REG(R0, R10),
11876                         BPF_LDX_MEM(BPF_W, R0, R0, -8),
11877                         BPF_EXIT_INSN(),
11878                 },
11879                 INTERNAL,
11880                 { },
11881                 { { 0, 123456789 } },
11882                 .stack_depth = 8,
11883         },
11884         {
11885                 "LDX_MEM_DW: operand register aliasing",
11886                 .u.insns_int = {
11887                         BPF_LD_IMM64(R1, 0x123456789abcdefULL),
11888                         BPF_STX_MEM(BPF_DW, R10, R1, -8),
11889                         BPF_MOV64_REG(R0, R10),
11890                         BPF_LDX_MEM(BPF_DW, R0, R0, -8),
11891                         BPF_ALU64_REG(BPF_SUB, R0, R1),
11892                         BPF_MOV64_REG(R1, R0),
11893                         BPF_ALU64_IMM(BPF_RSH, R1, 32),
11894                         BPF_ALU64_REG(BPF_OR, R0, R1),
11895                         BPF_EXIT_INSN(),
11896                 },
11897                 INTERNAL,
11898                 { },
11899                 { { 0, 0 } },
11900                 .stack_depth = 8,
11901         },
11902         /*
11903          * Register (non-)clobbering tests for the case where a JIT implements
11904          * complex ALU or ATOMIC operations via function calls. If so, the
11905          * function call must be transparent to the eBPF registers. The JIT
11906          * must therefore save and restore relevant registers across the call.
11907          * The following tests check that the eBPF registers retain their
11908          * values after such an operation. Mainly intended for complex ALU
11909          * and atomic operation, but we run it for all. You never know...
11910          *
11911          * Note that each operations should be tested twice with different
11912          * destinations, to check preservation for all registers.
11913          */
11914 #define BPF_TEST_CLOBBER_ALU(alu, op, dst, src)                 \
11915         {                                                       \
11916                 #alu "_" #op " to " #dst ": no clobbering",     \
11917                 .u.insns_int = {                                \
11918                         BPF_ALU64_IMM(BPF_MOV, R0, R0),         \
11919                         BPF_ALU64_IMM(BPF_MOV, R1, R1),         \
11920                         BPF_ALU64_IMM(BPF_MOV, R2, R2),         \
11921                         BPF_ALU64_IMM(BPF_MOV, R3, R3),         \
11922                         BPF_ALU64_IMM(BPF_MOV, R4, R4),         \
11923                         BPF_ALU64_IMM(BPF_MOV, R5, R5),         \
11924                         BPF_ALU64_IMM(BPF_MOV, R6, R6),         \
11925                         BPF_ALU64_IMM(BPF_MOV, R7, R7),         \
11926                         BPF_ALU64_IMM(BPF_MOV, R8, R8),         \
11927                         BPF_ALU64_IMM(BPF_MOV, R9, R9),         \
11928                         BPF_##alu(BPF_ ##op, dst, src),         \
11929                         BPF_ALU32_IMM(BPF_MOV, dst, dst),       \
11930                         BPF_JMP_IMM(BPF_JNE, R0, R0, 10),       \
11931                         BPF_JMP_IMM(BPF_JNE, R1, R1, 9),        \
11932                         BPF_JMP_IMM(BPF_JNE, R2, R2, 8),        \
11933                         BPF_JMP_IMM(BPF_JNE, R3, R3, 7),        \
11934                         BPF_JMP_IMM(BPF_JNE, R4, R4, 6),        \
11935                         BPF_JMP_IMM(BPF_JNE, R5, R5, 5),        \
11936                         BPF_JMP_IMM(BPF_JNE, R6, R6, 4),        \
11937                         BPF_JMP_IMM(BPF_JNE, R7, R7, 3),        \
11938                         BPF_JMP_IMM(BPF_JNE, R8, R8, 2),        \
11939                         BPF_JMP_IMM(BPF_JNE, R9, R9, 1),        \
11940                         BPF_ALU64_IMM(BPF_MOV, R0, 1),          \
11941                         BPF_EXIT_INSN(),                        \
11942                 },                                              \
11943                 INTERNAL,                                       \
11944                 { },                                            \
11945                 { { 0, 1 } }                                    \
11946         }
11947         /* ALU64 operations, register clobbering */
11948         BPF_TEST_CLOBBER_ALU(ALU64_IMM, AND, R8, 123456789),
11949         BPF_TEST_CLOBBER_ALU(ALU64_IMM, AND, R9, 123456789),
11950         BPF_TEST_CLOBBER_ALU(ALU64_IMM, OR, R8, 123456789),
11951         BPF_TEST_CLOBBER_ALU(ALU64_IMM, OR, R9, 123456789),
11952         BPF_TEST_CLOBBER_ALU(ALU64_IMM, XOR, R8, 123456789),
11953         BPF_TEST_CLOBBER_ALU(ALU64_IMM, XOR, R9, 123456789),
11954         BPF_TEST_CLOBBER_ALU(ALU64_IMM, LSH, R8, 12),
11955         BPF_TEST_CLOBBER_ALU(ALU64_IMM, LSH, R9, 12),
11956         BPF_TEST_CLOBBER_ALU(ALU64_IMM, RSH, R8, 12),
11957         BPF_TEST_CLOBBER_ALU(ALU64_IMM, RSH, R9, 12),
11958         BPF_TEST_CLOBBER_ALU(ALU64_IMM, ARSH, R8, 12),
11959         BPF_TEST_CLOBBER_ALU(ALU64_IMM, ARSH, R9, 12),
11960         BPF_TEST_CLOBBER_ALU(ALU64_IMM, ADD, R8, 123456789),
11961         BPF_TEST_CLOBBER_ALU(ALU64_IMM, ADD, R9, 123456789),
11962         BPF_TEST_CLOBBER_ALU(ALU64_IMM, SUB, R8, 123456789),
11963         BPF_TEST_CLOBBER_ALU(ALU64_IMM, SUB, R9, 123456789),
11964         BPF_TEST_CLOBBER_ALU(ALU64_IMM, MUL, R8, 123456789),
11965         BPF_TEST_CLOBBER_ALU(ALU64_IMM, MUL, R9, 123456789),
11966         BPF_TEST_CLOBBER_ALU(ALU64_IMM, DIV, R8, 123456789),
11967         BPF_TEST_CLOBBER_ALU(ALU64_IMM, DIV, R9, 123456789),
11968         BPF_TEST_CLOBBER_ALU(ALU64_IMM, MOD, R8, 123456789),
11969         BPF_TEST_CLOBBER_ALU(ALU64_IMM, MOD, R9, 123456789),
11970         /* ALU32 immediate operations, register clobbering */
11971         BPF_TEST_CLOBBER_ALU(ALU32_IMM, AND, R8, 123456789),
11972         BPF_TEST_CLOBBER_ALU(ALU32_IMM, AND, R9, 123456789),
11973         BPF_TEST_CLOBBER_ALU(ALU32_IMM, OR, R8, 123456789),
11974         BPF_TEST_CLOBBER_ALU(ALU32_IMM, OR, R9, 123456789),
11975         BPF_TEST_CLOBBER_ALU(ALU32_IMM, XOR, R8, 123456789),
11976         BPF_TEST_CLOBBER_ALU(ALU32_IMM, XOR, R9, 123456789),
11977         BPF_TEST_CLOBBER_ALU(ALU32_IMM, LSH, R8, 12),
11978         BPF_TEST_CLOBBER_ALU(ALU32_IMM, LSH, R9, 12),
11979         BPF_TEST_CLOBBER_ALU(ALU32_IMM, RSH, R8, 12),
11980         BPF_TEST_CLOBBER_ALU(ALU32_IMM, RSH, R9, 12),
11981         BPF_TEST_CLOBBER_ALU(ALU32_IMM, ARSH, R8, 12),
11982         BPF_TEST_CLOBBER_ALU(ALU32_IMM, ARSH, R9, 12),
11983         BPF_TEST_CLOBBER_ALU(ALU32_IMM, ADD, R8, 123456789),
11984         BPF_TEST_CLOBBER_ALU(ALU32_IMM, ADD, R9, 123456789),
11985         BPF_TEST_CLOBBER_ALU(ALU32_IMM, SUB, R8, 123456789),
11986         BPF_TEST_CLOBBER_ALU(ALU32_IMM, SUB, R9, 123456789),
11987         BPF_TEST_CLOBBER_ALU(ALU32_IMM, MUL, R8, 123456789),
11988         BPF_TEST_CLOBBER_ALU(ALU32_IMM, MUL, R9, 123456789),
11989         BPF_TEST_CLOBBER_ALU(ALU32_IMM, DIV, R8, 123456789),
11990         BPF_TEST_CLOBBER_ALU(ALU32_IMM, DIV, R9, 123456789),
11991         BPF_TEST_CLOBBER_ALU(ALU32_IMM, MOD, R8, 123456789),
11992         BPF_TEST_CLOBBER_ALU(ALU32_IMM, MOD, R9, 123456789),
11993         /* ALU64 register operations, register clobbering */
11994         BPF_TEST_CLOBBER_ALU(ALU64_REG, AND, R8, R1),
11995         BPF_TEST_CLOBBER_ALU(ALU64_REG, AND, R9, R1),
11996         BPF_TEST_CLOBBER_ALU(ALU64_REG, OR, R8, R1),
11997         BPF_TEST_CLOBBER_ALU(ALU64_REG, OR, R9, R1),
11998         BPF_TEST_CLOBBER_ALU(ALU64_REG, XOR, R8, R1),
11999         BPF_TEST_CLOBBER_ALU(ALU64_REG, XOR, R9, R1),
12000         BPF_TEST_CLOBBER_ALU(ALU64_REG, LSH, R8, R1),
12001         BPF_TEST_CLOBBER_ALU(ALU64_REG, LSH, R9, R1),
12002         BPF_TEST_CLOBBER_ALU(ALU64_REG, RSH, R8, R1),
12003         BPF_TEST_CLOBBER_ALU(ALU64_REG, RSH, R9, R1),
12004         BPF_TEST_CLOBBER_ALU(ALU64_REG, ARSH, R8, R1),
12005         BPF_TEST_CLOBBER_ALU(ALU64_REG, ARSH, R9, R1),
12006         BPF_TEST_CLOBBER_ALU(ALU64_REG, ADD, R8, R1),
12007         BPF_TEST_CLOBBER_ALU(ALU64_REG, ADD, R9, R1),
12008         BPF_TEST_CLOBBER_ALU(ALU64_REG, SUB, R8, R1),
12009         BPF_TEST_CLOBBER_ALU(ALU64_REG, SUB, R9, R1),
12010         BPF_TEST_CLOBBER_ALU(ALU64_REG, MUL, R8, R1),
12011         BPF_TEST_CLOBBER_ALU(ALU64_REG, MUL, R9, R1),
12012         BPF_TEST_CLOBBER_ALU(ALU64_REG, DIV, R8, R1),
12013         BPF_TEST_CLOBBER_ALU(ALU64_REG, DIV, R9, R1),
12014         BPF_TEST_CLOBBER_ALU(ALU64_REG, MOD, R8, R1),
12015         BPF_TEST_CLOBBER_ALU(ALU64_REG, MOD, R9, R1),
12016         /* ALU32 register operations, register clobbering */
12017         BPF_TEST_CLOBBER_ALU(ALU32_REG, AND, R8, R1),
12018         BPF_TEST_CLOBBER_ALU(ALU32_REG, AND, R9, R1),
12019         BPF_TEST_CLOBBER_ALU(ALU32_REG, OR, R8, R1),
12020         BPF_TEST_CLOBBER_ALU(ALU32_REG, OR, R9, R1),
12021         BPF_TEST_CLOBBER_ALU(ALU32_REG, XOR, R8, R1),
12022         BPF_TEST_CLOBBER_ALU(ALU32_REG, XOR, R9, R1),
12023         BPF_TEST_CLOBBER_ALU(ALU32_REG, LSH, R8, R1),
12024         BPF_TEST_CLOBBER_ALU(ALU32_REG, LSH, R9, R1),
12025         BPF_TEST_CLOBBER_ALU(ALU32_REG, RSH, R8, R1),
12026         BPF_TEST_CLOBBER_ALU(ALU32_REG, RSH, R9, R1),
12027         BPF_TEST_CLOBBER_ALU(ALU32_REG, ARSH, R8, R1),
12028         BPF_TEST_CLOBBER_ALU(ALU32_REG, ARSH, R9, R1),
12029         BPF_TEST_CLOBBER_ALU(ALU32_REG, ADD, R8, R1),
12030         BPF_TEST_CLOBBER_ALU(ALU32_REG, ADD, R9, R1),
12031         BPF_TEST_CLOBBER_ALU(ALU32_REG, SUB, R8, R1),
12032         BPF_TEST_CLOBBER_ALU(ALU32_REG, SUB, R9, R1),
12033         BPF_TEST_CLOBBER_ALU(ALU32_REG, MUL, R8, R1),
12034         BPF_TEST_CLOBBER_ALU(ALU32_REG, MUL, R9, R1),
12035         BPF_TEST_CLOBBER_ALU(ALU32_REG, DIV, R8, R1),
12036         BPF_TEST_CLOBBER_ALU(ALU32_REG, DIV, R9, R1),
12037         BPF_TEST_CLOBBER_ALU(ALU32_REG, MOD, R8, R1),
12038         BPF_TEST_CLOBBER_ALU(ALU32_REG, MOD, R9, R1),
12039 #undef BPF_TEST_CLOBBER_ALU
12040 #define BPF_TEST_CLOBBER_ATOMIC(width, op)                      \
12041         {                                                       \
12042                 "Atomic_" #width " " #op ": no clobbering",     \
12043                 .u.insns_int = {                                \
12044                         BPF_ALU64_IMM(BPF_MOV, R0, 0),          \
12045                         BPF_ALU64_IMM(BPF_MOV, R1, 1),          \
12046                         BPF_ALU64_IMM(BPF_MOV, R2, 2),          \
12047                         BPF_ALU64_IMM(BPF_MOV, R3, 3),          \
12048                         BPF_ALU64_IMM(BPF_MOV, R4, 4),          \
12049                         BPF_ALU64_IMM(BPF_MOV, R5, 5),          \
12050                         BPF_ALU64_IMM(BPF_MOV, R6, 6),          \
12051                         BPF_ALU64_IMM(BPF_MOV, R7, 7),          \
12052                         BPF_ALU64_IMM(BPF_MOV, R8, 8),          \
12053                         BPF_ALU64_IMM(BPF_MOV, R9, 9),          \
12054                         BPF_ST_MEM(width, R10, -8,              \
12055                                    (op) == BPF_CMPXCHG ? 0 :    \
12056                                    (op) & BPF_FETCH ? 1 : 0),   \
12057                         BPF_ATOMIC_OP(width, op, R10, R1, -8),  \
12058                         BPF_JMP_IMM(BPF_JNE, R0, 0, 10),        \
12059                         BPF_JMP_IMM(BPF_JNE, R1, 1, 9),         \
12060                         BPF_JMP_IMM(BPF_JNE, R2, 2, 8),         \
12061                         BPF_JMP_IMM(BPF_JNE, R3, 3, 7),         \
12062                         BPF_JMP_IMM(BPF_JNE, R4, 4, 6),         \
12063                         BPF_JMP_IMM(BPF_JNE, R5, 5, 5),         \
12064                         BPF_JMP_IMM(BPF_JNE, R6, 6, 4),         \
12065                         BPF_JMP_IMM(BPF_JNE, R7, 7, 3),         \
12066                         BPF_JMP_IMM(BPF_JNE, R8, 8, 2),         \
12067                         BPF_JMP_IMM(BPF_JNE, R9, 9, 1),         \
12068                         BPF_ALU64_IMM(BPF_MOV, R0, 1),          \
12069                         BPF_EXIT_INSN(),                        \
12070                 },                                              \
12071                 INTERNAL,                                       \
12072                 { },                                            \
12073                 { { 0, 1 } },                                   \
12074                 .stack_depth = 8,                               \
12075         }
12076         /* 64-bit atomic operations, register clobbering */
12077         BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_ADD),
12078         BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_AND),
12079         BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_OR),
12080         BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_XOR),
12081         BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_ADD | BPF_FETCH),
12082         BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_AND | BPF_FETCH),
12083         BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_OR | BPF_FETCH),
12084         BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_XOR | BPF_FETCH),
12085         BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_XCHG),
12086         BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_CMPXCHG),
12087         /* 32-bit atomic operations, register clobbering */
12088         BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_ADD),
12089         BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_AND),
12090         BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_OR),
12091         BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_XOR),
12092         BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_ADD | BPF_FETCH),
12093         BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_AND | BPF_FETCH),
12094         BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_OR | BPF_FETCH),
12095         BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_XOR | BPF_FETCH),
12096         BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_XCHG),
12097         BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_CMPXCHG),
12098 #undef BPF_TEST_CLOBBER_ATOMIC
12099         /* Checking that ALU32 src is not zero extended in place */
12100 #define BPF_ALU32_SRC_ZEXT(op)                                  \
12101         {                                                       \
12102                 "ALU32_" #op "_X: src preserved in zext",       \
12103                 .u.insns_int = {                                \
12104                         BPF_LD_IMM64(R1, 0x0123456789acbdefULL),\
12105                         BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),\
12106                         BPF_ALU64_REG(BPF_MOV, R0, R1),         \
12107                         BPF_ALU32_REG(BPF_##op, R2, R1),        \
12108                         BPF_ALU64_REG(BPF_SUB, R0, R1),         \
12109                         BPF_ALU64_REG(BPF_MOV, R1, R0),         \
12110                         BPF_ALU64_IMM(BPF_RSH, R1, 32),         \
12111                         BPF_ALU64_REG(BPF_OR, R0, R1),          \
12112                         BPF_EXIT_INSN(),                        \
12113                 },                                              \
12114                 INTERNAL,                                       \
12115                 { },                                            \
12116                 { { 0, 0 } },                                   \
12117         }
12118         BPF_ALU32_SRC_ZEXT(MOV),
12119         BPF_ALU32_SRC_ZEXT(AND),
12120         BPF_ALU32_SRC_ZEXT(OR),
12121         BPF_ALU32_SRC_ZEXT(XOR),
12122         BPF_ALU32_SRC_ZEXT(ADD),
12123         BPF_ALU32_SRC_ZEXT(SUB),
12124         BPF_ALU32_SRC_ZEXT(MUL),
12125         BPF_ALU32_SRC_ZEXT(DIV),
12126         BPF_ALU32_SRC_ZEXT(MOD),
12127 #undef BPF_ALU32_SRC_ZEXT
12128         /* Checking that ATOMIC32 src is not zero extended in place */
12129 #define BPF_ATOMIC32_SRC_ZEXT(op)                                       \
12130         {                                                               \
12131                 "ATOMIC_W_" #op ": src preserved in zext",              \
12132                 .u.insns_int = {                                        \
12133                         BPF_LD_IMM64(R0, 0x0123456789acbdefULL),        \
12134                         BPF_ALU64_REG(BPF_MOV, R1, R0),                 \
12135                         BPF_ST_MEM(BPF_W, R10, -4, 0),                  \
12136                         BPF_ATOMIC_OP(BPF_W, BPF_##op, R10, R1, -4),    \
12137                         BPF_ALU64_REG(BPF_SUB, R0, R1),                 \
12138                         BPF_ALU64_REG(BPF_MOV, R1, R0),                 \
12139                         BPF_ALU64_IMM(BPF_RSH, R1, 32),                 \
12140                         BPF_ALU64_REG(BPF_OR, R0, R1),                  \
12141                         BPF_EXIT_INSN(),                                \
12142                 },                                                      \
12143                 INTERNAL,                                               \
12144                 { },                                                    \
12145                 { { 0, 0 } },                                           \
12146                 .stack_depth = 8,                                       \
12147         }
12148         BPF_ATOMIC32_SRC_ZEXT(ADD),
12149         BPF_ATOMIC32_SRC_ZEXT(AND),
12150         BPF_ATOMIC32_SRC_ZEXT(OR),
12151         BPF_ATOMIC32_SRC_ZEXT(XOR),
12152 #undef BPF_ATOMIC32_SRC_ZEXT
12153         /* Checking that CMPXCHG32 src is not zero extended in place */
12154         {
12155                 "ATOMIC_W_CMPXCHG: src preserved in zext",
12156                 .u.insns_int = {
12157                         BPF_LD_IMM64(R1, 0x0123456789acbdefULL),
12158                         BPF_ALU64_REG(BPF_MOV, R2, R1),
12159                         BPF_ALU64_REG(BPF_MOV, R0, 0),
12160                         BPF_ST_MEM(BPF_W, R10, -4, 0),
12161                         BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R1, -4),
12162                         BPF_ALU64_REG(BPF_SUB, R1, R2),
12163                         BPF_ALU64_REG(BPF_MOV, R2, R1),
12164                         BPF_ALU64_IMM(BPF_RSH, R2, 32),
12165                         BPF_ALU64_REG(BPF_OR, R1, R2),
12166                         BPF_ALU64_REG(BPF_MOV, R0, R1),
12167                         BPF_EXIT_INSN(),
12168                 },
12169                 INTERNAL,
12170                 { },
12171                 { { 0, 0 } },
12172                 .stack_depth = 8,
12173         },
12174         /* Checking that JMP32 immediate src is not zero extended in place */
12175 #define BPF_JMP32_IMM_ZEXT(op)                                  \
12176         {                                                       \
12177                 "JMP32_" #op "_K: operand preserved in zext",   \
12178                 .u.insns_int = {                                \
12179                         BPF_LD_IMM64(R0, 0x0123456789acbdefULL),\
12180                         BPF_ALU64_REG(BPF_MOV, R1, R0),         \
12181                         BPF_JMP32_IMM(BPF_##op, R0, 1234, 1),   \
12182                         BPF_JMP_A(0), /* Nop */                 \
12183                         BPF_ALU64_REG(BPF_SUB, R0, R1),         \
12184                         BPF_ALU64_REG(BPF_MOV, R1, R0),         \
12185                         BPF_ALU64_IMM(BPF_RSH, R1, 32),         \
12186                         BPF_ALU64_REG(BPF_OR, R0, R1),          \
12187                         BPF_EXIT_INSN(),                        \
12188                 },                                              \
12189                 INTERNAL,                                       \
12190                 { },                                            \
12191                 { { 0, 0 } },                                   \
12192         }
12193         BPF_JMP32_IMM_ZEXT(JEQ),
12194         BPF_JMP32_IMM_ZEXT(JNE),
12195         BPF_JMP32_IMM_ZEXT(JSET),
12196         BPF_JMP32_IMM_ZEXT(JGT),
12197         BPF_JMP32_IMM_ZEXT(JGE),
12198         BPF_JMP32_IMM_ZEXT(JLT),
12199         BPF_JMP32_IMM_ZEXT(JLE),
12200         BPF_JMP32_IMM_ZEXT(JSGT),
12201         BPF_JMP32_IMM_ZEXT(JSGE),
12202         BPF_JMP32_IMM_ZEXT(JSLT),
12203         BPF_JMP32_IMM_ZEXT(JSLE),
12204 #undef BPF_JMP2_IMM_ZEXT
12205         /* Checking that JMP32 dst & src are not zero extended in place */
12206 #define BPF_JMP32_REG_ZEXT(op)                                  \
12207         {                                                       \
12208                 "JMP32_" #op "_X: operands preserved in zext",  \
12209                 .u.insns_int = {                                \
12210                         BPF_LD_IMM64(R0, 0x0123456789acbdefULL),\
12211                         BPF_LD_IMM64(R1, 0xfedcba9876543210ULL),\
12212                         BPF_ALU64_REG(BPF_MOV, R2, R0),         \
12213                         BPF_ALU64_REG(BPF_MOV, R3, R1),         \
12214                         BPF_JMP32_IMM(BPF_##op, R0, R1, 1),     \
12215                         BPF_JMP_A(0), /* Nop */                 \
12216                         BPF_ALU64_REG(BPF_SUB, R0, R2),         \
12217                         BPF_ALU64_REG(BPF_SUB, R1, R3),         \
12218                         BPF_ALU64_REG(BPF_OR, R0, R1),          \
12219                         BPF_ALU64_REG(BPF_MOV, R1, R0),         \
12220                         BPF_ALU64_IMM(BPF_RSH, R1, 32),         \
12221                         BPF_ALU64_REG(BPF_OR, R0, R1),          \
12222                         BPF_EXIT_INSN(),                        \
12223                 },                                              \
12224                 INTERNAL,                                       \
12225                 { },                                            \
12226                 { { 0, 0 } },                                   \
12227         }
12228         BPF_JMP32_REG_ZEXT(JEQ),
12229         BPF_JMP32_REG_ZEXT(JNE),
12230         BPF_JMP32_REG_ZEXT(JSET),
12231         BPF_JMP32_REG_ZEXT(JGT),
12232         BPF_JMP32_REG_ZEXT(JGE),
12233         BPF_JMP32_REG_ZEXT(JLT),
12234         BPF_JMP32_REG_ZEXT(JLE),
12235         BPF_JMP32_REG_ZEXT(JSGT),
12236         BPF_JMP32_REG_ZEXT(JSGE),
12237         BPF_JMP32_REG_ZEXT(JSLT),
12238         BPF_JMP32_REG_ZEXT(JSLE),
12239 #undef BPF_JMP2_REG_ZEXT
12240         /* ALU64 K register combinations */
12241         {
12242                 "ALU64_MOV_K: registers",
12243                 { },
12244                 INTERNAL,
12245                 { },
12246                 { { 0, 1 } },
12247                 .fill_helper = bpf_fill_alu64_mov_imm_regs,
12248         },
12249         {
12250                 "ALU64_AND_K: registers",
12251                 { },
12252                 INTERNAL,
12253                 { },
12254                 { { 0, 1 } },
12255                 .fill_helper = bpf_fill_alu64_and_imm_regs,
12256         },
12257         {
12258                 "ALU64_OR_K: registers",
12259                 { },
12260                 INTERNAL,
12261                 { },
12262                 { { 0, 1 } },
12263                 .fill_helper = bpf_fill_alu64_or_imm_regs,
12264         },
12265         {
12266                 "ALU64_XOR_K: registers",
12267                 { },
12268                 INTERNAL,
12269                 { },
12270                 { { 0, 1 } },
12271                 .fill_helper = bpf_fill_alu64_xor_imm_regs,
12272         },
12273         {
12274                 "ALU64_LSH_K: registers",
12275                 { },
12276                 INTERNAL,
12277                 { },
12278                 { { 0, 1 } },
12279                 .fill_helper = bpf_fill_alu64_lsh_imm_regs,
12280         },
12281         {
12282                 "ALU64_RSH_K: registers",
12283                 { },
12284                 INTERNAL,
12285                 { },
12286                 { { 0, 1 } },
12287                 .fill_helper = bpf_fill_alu64_rsh_imm_regs,
12288         },
12289         {
12290                 "ALU64_ARSH_K: registers",
12291                 { },
12292                 INTERNAL,
12293                 { },
12294                 { { 0, 1 } },
12295                 .fill_helper = bpf_fill_alu64_arsh_imm_regs,
12296         },
12297         {
12298                 "ALU64_ADD_K: registers",
12299                 { },
12300                 INTERNAL,
12301                 { },
12302                 { { 0, 1 } },
12303                 .fill_helper = bpf_fill_alu64_add_imm_regs,
12304         },
12305         {
12306                 "ALU64_SUB_K: registers",
12307                 { },
12308                 INTERNAL,
12309                 { },
12310                 { { 0, 1 } },
12311                 .fill_helper = bpf_fill_alu64_sub_imm_regs,
12312         },
12313         {
12314                 "ALU64_MUL_K: registers",
12315                 { },
12316                 INTERNAL,
12317                 { },
12318                 { { 0, 1 } },
12319                 .fill_helper = bpf_fill_alu64_mul_imm_regs,
12320         },
12321         {
12322                 "ALU64_DIV_K: registers",
12323                 { },
12324                 INTERNAL,
12325                 { },
12326                 { { 0, 1 } },
12327                 .fill_helper = bpf_fill_alu64_div_imm_regs,
12328         },
12329         {
12330                 "ALU64_MOD_K: registers",
12331                 { },
12332                 INTERNAL,
12333                 { },
12334                 { { 0, 1 } },
12335                 .fill_helper = bpf_fill_alu64_mod_imm_regs,
12336         },
12337         /* ALU32 K registers */
12338         {
12339                 "ALU32_MOV_K: registers",
12340                 { },
12341                 INTERNAL,
12342                 { },
12343                 { { 0, 1 } },
12344                 .fill_helper = bpf_fill_alu32_mov_imm_regs,
12345         },
12346         {
12347                 "ALU32_AND_K: registers",
12348                 { },
12349                 INTERNAL,
12350                 { },
12351                 { { 0, 1 } },
12352                 .fill_helper = bpf_fill_alu32_and_imm_regs,
12353         },
12354         {
12355                 "ALU32_OR_K: registers",
12356                 { },
12357                 INTERNAL,
12358                 { },
12359                 { { 0, 1 } },
12360                 .fill_helper = bpf_fill_alu32_or_imm_regs,
12361         },
12362         {
12363                 "ALU32_XOR_K: registers",
12364                 { },
12365                 INTERNAL,
12366                 { },
12367                 { { 0, 1 } },
12368                 .fill_helper = bpf_fill_alu32_xor_imm_regs,
12369         },
12370         {
12371                 "ALU32_LSH_K: registers",
12372                 { },
12373                 INTERNAL,
12374                 { },
12375                 { { 0, 1 } },
12376                 .fill_helper = bpf_fill_alu32_lsh_imm_regs,
12377         },
12378         {
12379                 "ALU32_RSH_K: registers",
12380                 { },
12381                 INTERNAL,
12382                 { },
12383                 { { 0, 1 } },
12384                 .fill_helper = bpf_fill_alu32_rsh_imm_regs,
12385         },
12386         {
12387                 "ALU32_ARSH_K: registers",
12388                 { },
12389                 INTERNAL,
12390                 { },
12391                 { { 0, 1 } },
12392                 .fill_helper = bpf_fill_alu32_arsh_imm_regs,
12393         },
12394         {
12395                 "ALU32_ADD_K: registers",
12396                 { },
12397                 INTERNAL,
12398                 { },
12399                 { { 0, 1 } },
12400                 .fill_helper = bpf_fill_alu32_add_imm_regs,
12401         },
12402         {
12403                 "ALU32_SUB_K: registers",
12404                 { },
12405                 INTERNAL,
12406                 { },
12407                 { { 0, 1 } },
12408                 .fill_helper = bpf_fill_alu32_sub_imm_regs,
12409         },
12410         {
12411                 "ALU32_MUL_K: registers",
12412                 { },
12413                 INTERNAL,
12414                 { },
12415                 { { 0, 1 } },
12416                 .fill_helper = bpf_fill_alu32_mul_imm_regs,
12417         },
12418         {
12419                 "ALU32_DIV_K: registers",
12420                 { },
12421                 INTERNAL,
12422                 { },
12423                 { { 0, 1 } },
12424                 .fill_helper = bpf_fill_alu32_div_imm_regs,
12425         },
12426         {
12427                 "ALU32_MOD_K: registers",
12428                 { },
12429                 INTERNAL,
12430                 { },
12431                 { { 0, 1 } },
12432                 .fill_helper = bpf_fill_alu32_mod_imm_regs,
12433         },
12434         /* ALU64 X register combinations */
12435         {
12436                 "ALU64_MOV_X: register combinations",
12437                 { },
12438                 INTERNAL,
12439                 { },
12440                 { { 0, 1 } },
12441                 .fill_helper = bpf_fill_alu64_mov_reg_pairs,
12442         },
12443         {
12444                 "ALU64_AND_X: register combinations",
12445                 { },
12446                 INTERNAL,
12447                 { },
12448                 { { 0, 1 } },
12449                 .fill_helper = bpf_fill_alu64_and_reg_pairs,
12450         },
12451         {
12452                 "ALU64_OR_X: register combinations",
12453                 { },
12454                 INTERNAL,
12455                 { },
12456                 { { 0, 1 } },
12457                 .fill_helper = bpf_fill_alu64_or_reg_pairs,
12458         },
12459         {
12460                 "ALU64_XOR_X: register combinations",
12461                 { },
12462                 INTERNAL,
12463                 { },
12464                 { { 0, 1 } },
12465                 .fill_helper = bpf_fill_alu64_xor_reg_pairs,
12466         },
12467         {
12468                 "ALU64_LSH_X: register combinations",
12469                 { },
12470                 INTERNAL,
12471                 { },
12472                 { { 0, 1 } },
12473                 .fill_helper = bpf_fill_alu64_lsh_reg_pairs,
12474         },
12475         {
12476                 "ALU64_RSH_X: register combinations",
12477                 { },
12478                 INTERNAL,
12479                 { },
12480                 { { 0, 1 } },
12481                 .fill_helper = bpf_fill_alu64_rsh_reg_pairs,
12482         },
12483         {
12484                 "ALU64_ARSH_X: register combinations",
12485                 { },
12486                 INTERNAL,
12487                 { },
12488                 { { 0, 1 } },
12489                 .fill_helper = bpf_fill_alu64_arsh_reg_pairs,
12490         },
12491         {
12492                 "ALU64_ADD_X: register combinations",
12493                 { },
12494                 INTERNAL,
12495                 { },
12496                 { { 0, 1 } },
12497                 .fill_helper = bpf_fill_alu64_add_reg_pairs,
12498         },
12499         {
12500                 "ALU64_SUB_X: register combinations",
12501                 { },
12502                 INTERNAL,
12503                 { },
12504                 { { 0, 1 } },
12505                 .fill_helper = bpf_fill_alu64_sub_reg_pairs,
12506         },
12507         {
12508                 "ALU64_MUL_X: register combinations",
12509                 { },
12510                 INTERNAL,
12511                 { },
12512                 { { 0, 1 } },
12513                 .fill_helper = bpf_fill_alu64_mul_reg_pairs,
12514         },
12515         {
12516                 "ALU64_DIV_X: register combinations",
12517                 { },
12518                 INTERNAL,
12519                 { },
12520                 { { 0, 1 } },
12521                 .fill_helper = bpf_fill_alu64_div_reg_pairs,
12522         },
12523         {
12524                 "ALU64_MOD_X: register combinations",
12525                 { },
12526                 INTERNAL,
12527                 { },
12528                 { { 0, 1 } },
12529                 .fill_helper = bpf_fill_alu64_mod_reg_pairs,
12530         },
12531         /* ALU32 X register combinations */
12532         {
12533                 "ALU32_MOV_X: register combinations",
12534                 { },
12535                 INTERNAL,
12536                 { },
12537                 { { 0, 1 } },
12538                 .fill_helper = bpf_fill_alu32_mov_reg_pairs,
12539         },
12540         {
12541                 "ALU32_AND_X: register combinations",
12542                 { },
12543                 INTERNAL,
12544                 { },
12545                 { { 0, 1 } },
12546                 .fill_helper = bpf_fill_alu32_and_reg_pairs,
12547         },
12548         {
12549                 "ALU32_OR_X: register combinations",
12550                 { },
12551                 INTERNAL,
12552                 { },
12553                 { { 0, 1 } },
12554                 .fill_helper = bpf_fill_alu32_or_reg_pairs,
12555         },
12556         {
12557                 "ALU32_XOR_X: register combinations",
12558                 { },
12559                 INTERNAL,
12560                 { },
12561                 { { 0, 1 } },
12562                 .fill_helper = bpf_fill_alu32_xor_reg_pairs,
12563         },
12564         {
12565                 "ALU32_LSH_X: register combinations",
12566                 { },
12567                 INTERNAL,
12568                 { },
12569                 { { 0, 1 } },
12570                 .fill_helper = bpf_fill_alu32_lsh_reg_pairs,
12571         },
12572         {
12573                 "ALU32_RSH_X: register combinations",
12574                 { },
12575                 INTERNAL,
12576                 { },
12577                 { { 0, 1 } },
12578                 .fill_helper = bpf_fill_alu32_rsh_reg_pairs,
12579         },
12580         {
12581                 "ALU32_ARSH_X: register combinations",
12582                 { },
12583                 INTERNAL,
12584                 { },
12585                 { { 0, 1 } },
12586                 .fill_helper = bpf_fill_alu32_arsh_reg_pairs,
12587         },
12588         {
12589                 "ALU32_ADD_X: register combinations",
12590                 { },
12591                 INTERNAL,
12592                 { },
12593                 { { 0, 1 } },
12594                 .fill_helper = bpf_fill_alu32_add_reg_pairs,
12595         },
12596         {
12597                 "ALU32_SUB_X: register combinations",
12598                 { },
12599                 INTERNAL,
12600                 { },
12601                 { { 0, 1 } },
12602                 .fill_helper = bpf_fill_alu32_sub_reg_pairs,
12603         },
12604         {
12605                 "ALU32_MUL_X: register combinations",
12606                 { },
12607                 INTERNAL,
12608                 { },
12609                 { { 0, 1 } },
12610                 .fill_helper = bpf_fill_alu32_mul_reg_pairs,
12611         },
12612         {
12613                 "ALU32_DIV_X: register combinations",
12614                 { },
12615                 INTERNAL,
12616                 { },
12617                 { { 0, 1 } },
12618                 .fill_helper = bpf_fill_alu32_div_reg_pairs,
12619         },
12620         {
12621                 "ALU32_MOD_X register combinations",
12622                 { },
12623                 INTERNAL,
12624                 { },
12625                 { { 0, 1 } },
12626                 .fill_helper = bpf_fill_alu32_mod_reg_pairs,
12627         },
12628         /* Exhaustive test of ALU64 shift operations */
12629         {
12630                 "ALU64_LSH_K: all shift values",
12631                 { },
12632                 INTERNAL | FLAG_NO_DATA,
12633                 { },
12634                 { { 0, 1 } },
12635                 .fill_helper = bpf_fill_alu64_lsh_imm,
12636         },
12637         {
12638                 "ALU64_RSH_K: all shift values",
12639                 { },
12640                 INTERNAL | FLAG_NO_DATA,
12641                 { },
12642                 { { 0, 1 } },
12643                 .fill_helper = bpf_fill_alu64_rsh_imm,
12644         },
12645         {
12646                 "ALU64_ARSH_K: all shift values",
12647                 { },
12648                 INTERNAL | FLAG_NO_DATA,
12649                 { },
12650                 { { 0, 1 } },
12651                 .fill_helper = bpf_fill_alu64_arsh_imm,
12652         },
12653         {
12654                 "ALU64_LSH_X: all shift values",
12655                 { },
12656                 INTERNAL | FLAG_NO_DATA,
12657                 { },
12658                 { { 0, 1 } },
12659                 .fill_helper = bpf_fill_alu64_lsh_reg,
12660         },
12661         {
12662                 "ALU64_RSH_X: all shift values",
12663                 { },
12664                 INTERNAL | FLAG_NO_DATA,
12665                 { },
12666                 { { 0, 1 } },
12667                 .fill_helper = bpf_fill_alu64_rsh_reg,
12668         },
12669         {
12670                 "ALU64_ARSH_X: all shift values",
12671                 { },
12672                 INTERNAL | FLAG_NO_DATA,
12673                 { },
12674                 { { 0, 1 } },
12675                 .fill_helper = bpf_fill_alu64_arsh_reg,
12676         },
12677         /* Exhaustive test of ALU32 shift operations */
12678         {
12679                 "ALU32_LSH_K: all shift values",
12680                 { },
12681                 INTERNAL | FLAG_NO_DATA,
12682                 { },
12683                 { { 0, 1 } },
12684                 .fill_helper = bpf_fill_alu32_lsh_imm,
12685         },
12686         {
12687                 "ALU32_RSH_K: all shift values",
12688                 { },
12689                 INTERNAL | FLAG_NO_DATA,
12690                 { },
12691                 { { 0, 1 } },
12692                 .fill_helper = bpf_fill_alu32_rsh_imm,
12693         },
12694         {
12695                 "ALU32_ARSH_K: all shift values",
12696                 { },
12697                 INTERNAL | FLAG_NO_DATA,
12698                 { },
12699                 { { 0, 1 } },
12700                 .fill_helper = bpf_fill_alu32_arsh_imm,
12701         },
12702         {
12703                 "ALU32_LSH_X: all shift values",
12704                 { },
12705                 INTERNAL | FLAG_NO_DATA,
12706                 { },
12707                 { { 0, 1 } },
12708                 .fill_helper = bpf_fill_alu32_lsh_reg,
12709         },
12710         {
12711                 "ALU32_RSH_X: all shift values",
12712                 { },
12713                 INTERNAL | FLAG_NO_DATA,
12714                 { },
12715                 { { 0, 1 } },
12716                 .fill_helper = bpf_fill_alu32_rsh_reg,
12717         },
12718         {
12719                 "ALU32_ARSH_X: all shift values",
12720                 { },
12721                 INTERNAL | FLAG_NO_DATA,
12722                 { },
12723                 { { 0, 1 } },
12724                 .fill_helper = bpf_fill_alu32_arsh_reg,
12725         },
12726         /*
12727          * Exhaustive test of ALU64 shift operations when
12728          * source and destination register are the same.
12729          */
12730         {
12731                 "ALU64_LSH_X: all shift values with the same register",
12732                 { },
12733                 INTERNAL | FLAG_NO_DATA,
12734                 { },
12735                 { { 0, 1 } },
12736                 .fill_helper = bpf_fill_alu64_lsh_same_reg,
12737         },
12738         {
12739                 "ALU64_RSH_X: all shift values with the same register",
12740                 { },
12741                 INTERNAL | FLAG_NO_DATA,
12742                 { },
12743                 { { 0, 1 } },
12744                 .fill_helper = bpf_fill_alu64_rsh_same_reg,
12745         },
12746         {
12747                 "ALU64_ARSH_X: all shift values with the same register",
12748                 { },
12749                 INTERNAL | FLAG_NO_DATA,
12750                 { },
12751                 { { 0, 1 } },
12752                 .fill_helper = bpf_fill_alu64_arsh_same_reg,
12753         },
12754         /*
12755          * Exhaustive test of ALU32 shift operations when
12756          * source and destination register are the same.
12757          */
12758         {
12759                 "ALU32_LSH_X: all shift values with the same register",
12760                 { },
12761                 INTERNAL | FLAG_NO_DATA,
12762                 { },
12763                 { { 0, 1 } },
12764                 .fill_helper = bpf_fill_alu32_lsh_same_reg,
12765         },
12766         {
12767                 "ALU32_RSH_X: all shift values with the same register",
12768                 { },
12769                 INTERNAL | FLAG_NO_DATA,
12770                 { },
12771                 { { 0, 1 } },
12772                 .fill_helper = bpf_fill_alu32_rsh_same_reg,
12773         },
12774         {
12775                 "ALU32_ARSH_X: all shift values with the same register",
12776                 { },
12777                 INTERNAL | FLAG_NO_DATA,
12778                 { },
12779                 { { 0, 1 } },
12780                 .fill_helper = bpf_fill_alu32_arsh_same_reg,
12781         },
12782         /* ALU64 immediate magnitudes */
12783         {
12784                 "ALU64_MOV_K: all immediate value magnitudes",
12785                 { },
12786                 INTERNAL | FLAG_NO_DATA,
12787                 { },
12788                 { { 0, 1 } },
12789                 .fill_helper = bpf_fill_alu64_mov_imm,
12790                 .nr_testruns = NR_PATTERN_RUNS,
12791         },
12792         {
12793                 "ALU64_AND_K: all immediate value magnitudes",
12794                 { },
12795                 INTERNAL | FLAG_NO_DATA,
12796                 { },
12797                 { { 0, 1 } },
12798                 .fill_helper = bpf_fill_alu64_and_imm,
12799                 .nr_testruns = NR_PATTERN_RUNS,
12800         },
12801         {
12802                 "ALU64_OR_K: all immediate value magnitudes",
12803                 { },
12804                 INTERNAL | FLAG_NO_DATA,
12805                 { },
12806                 { { 0, 1 } },
12807                 .fill_helper = bpf_fill_alu64_or_imm,
12808                 .nr_testruns = NR_PATTERN_RUNS,
12809         },
12810         {
12811                 "ALU64_XOR_K: all immediate value magnitudes",
12812                 { },
12813                 INTERNAL | FLAG_NO_DATA,
12814                 { },
12815                 { { 0, 1 } },
12816                 .fill_helper = bpf_fill_alu64_xor_imm,
12817                 .nr_testruns = NR_PATTERN_RUNS,
12818         },
12819         {
12820                 "ALU64_ADD_K: all immediate value magnitudes",
12821                 { },
12822                 INTERNAL | FLAG_NO_DATA,
12823                 { },
12824                 { { 0, 1 } },
12825                 .fill_helper = bpf_fill_alu64_add_imm,
12826                 .nr_testruns = NR_PATTERN_RUNS,
12827         },
12828         {
12829                 "ALU64_SUB_K: all immediate value magnitudes",
12830                 { },
12831                 INTERNAL | FLAG_NO_DATA,
12832                 { },
12833                 { { 0, 1 } },
12834                 .fill_helper = bpf_fill_alu64_sub_imm,
12835                 .nr_testruns = NR_PATTERN_RUNS,
12836         },
12837         {
12838                 "ALU64_MUL_K: all immediate value magnitudes",
12839                 { },
12840                 INTERNAL | FLAG_NO_DATA,
12841                 { },
12842                 { { 0, 1 } },
12843                 .fill_helper = bpf_fill_alu64_mul_imm,
12844                 .nr_testruns = NR_PATTERN_RUNS,
12845         },
12846         {
12847                 "ALU64_DIV_K: all immediate value magnitudes",
12848                 { },
12849                 INTERNAL | FLAG_NO_DATA,
12850                 { },
12851                 { { 0, 1 } },
12852                 .fill_helper = bpf_fill_alu64_div_imm,
12853                 .nr_testruns = NR_PATTERN_RUNS,
12854         },
12855         {
12856                 "ALU64_MOD_K: all immediate value magnitudes",
12857                 { },
12858                 INTERNAL | FLAG_NO_DATA,
12859                 { },
12860                 { { 0, 1 } },
12861                 .fill_helper = bpf_fill_alu64_mod_imm,
12862                 .nr_testruns = NR_PATTERN_RUNS,
12863         },
12864         /* ALU32 immediate magnitudes */
12865         {
12866                 "ALU32_MOV_K: all immediate value magnitudes",
12867                 { },
12868                 INTERNAL | FLAG_NO_DATA,
12869                 { },
12870                 { { 0, 1 } },
12871                 .fill_helper = bpf_fill_alu32_mov_imm,
12872                 .nr_testruns = NR_PATTERN_RUNS,
12873         },
12874         {
12875                 "ALU32_AND_K: all immediate value magnitudes",
12876                 { },
12877                 INTERNAL | FLAG_NO_DATA,
12878                 { },
12879                 { { 0, 1 } },
12880                 .fill_helper = bpf_fill_alu32_and_imm,
12881                 .nr_testruns = NR_PATTERN_RUNS,
12882         },
12883         {
12884                 "ALU32_OR_K: all immediate value magnitudes",
12885                 { },
12886                 INTERNAL | FLAG_NO_DATA,
12887                 { },
12888                 { { 0, 1 } },
12889                 .fill_helper = bpf_fill_alu32_or_imm,
12890                 .nr_testruns = NR_PATTERN_RUNS,
12891         },
12892         {
12893                 "ALU32_XOR_K: all immediate value magnitudes",
12894                 { },
12895                 INTERNAL | FLAG_NO_DATA,
12896                 { },
12897                 { { 0, 1 } },
12898                 .fill_helper = bpf_fill_alu32_xor_imm,
12899                 .nr_testruns = NR_PATTERN_RUNS,
12900         },
12901         {
12902                 "ALU32_ADD_K: all immediate value magnitudes",
12903                 { },
12904                 INTERNAL | FLAG_NO_DATA,
12905                 { },
12906                 { { 0, 1 } },
12907                 .fill_helper = bpf_fill_alu32_add_imm,
12908                 .nr_testruns = NR_PATTERN_RUNS,
12909         },
12910         {
12911                 "ALU32_SUB_K: all immediate value magnitudes",
12912                 { },
12913                 INTERNAL | FLAG_NO_DATA,
12914                 { },
12915                 { { 0, 1 } },
12916                 .fill_helper = bpf_fill_alu32_sub_imm,
12917                 .nr_testruns = NR_PATTERN_RUNS,
12918         },
12919         {
12920                 "ALU32_MUL_K: all immediate value magnitudes",
12921                 { },
12922                 INTERNAL | FLAG_NO_DATA,
12923                 { },
12924                 { { 0, 1 } },
12925                 .fill_helper = bpf_fill_alu32_mul_imm,
12926                 .nr_testruns = NR_PATTERN_RUNS,
12927         },
12928         {
12929                 "ALU32_DIV_K: all immediate value magnitudes",
12930                 { },
12931                 INTERNAL | FLAG_NO_DATA,
12932                 { },
12933                 { { 0, 1 } },
12934                 .fill_helper = bpf_fill_alu32_div_imm,
12935                 .nr_testruns = NR_PATTERN_RUNS,
12936         },
12937         {
12938                 "ALU32_MOD_K: all immediate value magnitudes",
12939                 { },
12940                 INTERNAL | FLAG_NO_DATA,
12941                 { },
12942                 { { 0, 1 } },
12943                 .fill_helper = bpf_fill_alu32_mod_imm,
12944                 .nr_testruns = NR_PATTERN_RUNS,
12945         },
12946         /* ALU64 register magnitudes */
12947         {
12948                 "ALU64_MOV_X: all register value magnitudes",
12949                 { },
12950                 INTERNAL | FLAG_NO_DATA,
12951                 { },
12952                 { { 0, 1 } },
12953                 .fill_helper = bpf_fill_alu64_mov_reg,
12954                 .nr_testruns = NR_PATTERN_RUNS,
12955         },
12956         {
12957                 "ALU64_AND_X: all register value magnitudes",
12958                 { },
12959                 INTERNAL | FLAG_NO_DATA,
12960                 { },
12961                 { { 0, 1 } },
12962                 .fill_helper = bpf_fill_alu64_and_reg,
12963                 .nr_testruns = NR_PATTERN_RUNS,
12964         },
12965         {
12966                 "ALU64_OR_X: all register value magnitudes",
12967                 { },
12968                 INTERNAL | FLAG_NO_DATA,
12969                 { },
12970                 { { 0, 1 } },
12971                 .fill_helper = bpf_fill_alu64_or_reg,
12972                 .nr_testruns = NR_PATTERN_RUNS,
12973         },
12974         {
12975                 "ALU64_XOR_X: all register value magnitudes",
12976                 { },
12977                 INTERNAL | FLAG_NO_DATA,
12978                 { },
12979                 { { 0, 1 } },
12980                 .fill_helper = bpf_fill_alu64_xor_reg,
12981                 .nr_testruns = NR_PATTERN_RUNS,
12982         },
12983         {
12984                 "ALU64_ADD_X: all register value magnitudes",
12985                 { },
12986                 INTERNAL | FLAG_NO_DATA,
12987                 { },
12988                 { { 0, 1 } },
12989                 .fill_helper = bpf_fill_alu64_add_reg,
12990                 .nr_testruns = NR_PATTERN_RUNS,
12991         },
12992         {
12993                 "ALU64_SUB_X: all register value magnitudes",
12994                 { },
12995                 INTERNAL | FLAG_NO_DATA,
12996                 { },
12997                 { { 0, 1 } },
12998                 .fill_helper = bpf_fill_alu64_sub_reg,
12999                 .nr_testruns = NR_PATTERN_RUNS,
13000         },
13001         {
13002                 "ALU64_MUL_X: all register value magnitudes",
13003                 { },
13004                 INTERNAL | FLAG_NO_DATA,
13005                 { },
13006                 { { 0, 1 } },
13007                 .fill_helper = bpf_fill_alu64_mul_reg,
13008                 .nr_testruns = NR_PATTERN_RUNS,
13009         },
13010         {
13011                 "ALU64_DIV_X: all register value magnitudes",
13012                 { },
13013                 INTERNAL | FLAG_NO_DATA,
13014                 { },
13015                 { { 0, 1 } },
13016                 .fill_helper = bpf_fill_alu64_div_reg,
13017                 .nr_testruns = NR_PATTERN_RUNS,
13018         },
13019         {
13020                 "ALU64_MOD_X: all register value magnitudes",
13021                 { },
13022                 INTERNAL | FLAG_NO_DATA,
13023                 { },
13024                 { { 0, 1 } },
13025                 .fill_helper = bpf_fill_alu64_mod_reg,
13026                 .nr_testruns = NR_PATTERN_RUNS,
13027         },
13028         /* ALU32 register magnitudes */
13029         {
13030                 "ALU32_MOV_X: all register value magnitudes",
13031                 { },
13032                 INTERNAL | FLAG_NO_DATA,
13033                 { },
13034                 { { 0, 1 } },
13035                 .fill_helper = bpf_fill_alu32_mov_reg,
13036                 .nr_testruns = NR_PATTERN_RUNS,
13037         },
13038         {
13039                 "ALU32_AND_X: all register value magnitudes",
13040                 { },
13041                 INTERNAL | FLAG_NO_DATA,
13042                 { },
13043                 { { 0, 1 } },
13044                 .fill_helper = bpf_fill_alu32_and_reg,
13045                 .nr_testruns = NR_PATTERN_RUNS,
13046         },
13047         {
13048                 "ALU32_OR_X: all register value magnitudes",
13049                 { },
13050                 INTERNAL | FLAG_NO_DATA,
13051                 { },
13052                 { { 0, 1 } },
13053                 .fill_helper = bpf_fill_alu32_or_reg,
13054                 .nr_testruns = NR_PATTERN_RUNS,
13055         },
13056         {
13057                 "ALU32_XOR_X: all register value magnitudes",
13058                 { },
13059                 INTERNAL | FLAG_NO_DATA,
13060                 { },
13061                 { { 0, 1 } },
13062                 .fill_helper = bpf_fill_alu32_xor_reg,
13063                 .nr_testruns = NR_PATTERN_RUNS,
13064         },
13065         {
13066                 "ALU32_ADD_X: all register value magnitudes",
13067                 { },
13068                 INTERNAL | FLAG_NO_DATA,
13069                 { },
13070                 { { 0, 1 } },
13071                 .fill_helper = bpf_fill_alu32_add_reg,
13072                 .nr_testruns = NR_PATTERN_RUNS,
13073         },
13074         {
13075                 "ALU32_SUB_X: all register value magnitudes",
13076                 { },
13077                 INTERNAL | FLAG_NO_DATA,
13078                 { },
13079                 { { 0, 1 } },
13080                 .fill_helper = bpf_fill_alu32_sub_reg,
13081                 .nr_testruns = NR_PATTERN_RUNS,
13082         },
13083         {
13084                 "ALU32_MUL_X: all register value magnitudes",
13085                 { },
13086                 INTERNAL | FLAG_NO_DATA,
13087                 { },
13088                 { { 0, 1 } },
13089                 .fill_helper = bpf_fill_alu32_mul_reg,
13090                 .nr_testruns = NR_PATTERN_RUNS,
13091         },
13092         {
13093                 "ALU32_DIV_X: all register value magnitudes",
13094                 { },
13095                 INTERNAL | FLAG_NO_DATA,
13096                 { },
13097                 { { 0, 1 } },
13098                 .fill_helper = bpf_fill_alu32_div_reg,
13099                 .nr_testruns = NR_PATTERN_RUNS,
13100         },
13101         {
13102                 "ALU32_MOD_X: all register value magnitudes",
13103                 { },
13104                 INTERNAL | FLAG_NO_DATA,
13105                 { },
13106                 { { 0, 1 } },
13107                 .fill_helper = bpf_fill_alu32_mod_reg,
13108                 .nr_testruns = NR_PATTERN_RUNS,
13109         },
13110         /* LD_IMM64 immediate magnitudes and byte patterns */
13111         {
13112                 "LD_IMM64: all immediate value magnitudes",
13113                 { },
13114                 INTERNAL | FLAG_NO_DATA,
13115                 { },
13116                 { { 0, 1 } },
13117                 .fill_helper = bpf_fill_ld_imm64_magn,
13118         },
13119         {
13120                 "LD_IMM64: checker byte patterns",
13121                 { },
13122                 INTERNAL | FLAG_NO_DATA,
13123                 { },
13124                 { { 0, 1 } },
13125                 .fill_helper = bpf_fill_ld_imm64_checker,
13126         },
13127         {
13128                 "LD_IMM64: random positive and zero byte patterns",
13129                 { },
13130                 INTERNAL | FLAG_NO_DATA,
13131                 { },
13132                 { { 0, 1 } },
13133                 .fill_helper = bpf_fill_ld_imm64_pos_zero,
13134         },
13135         {
13136                 "LD_IMM64: random negative and zero byte patterns",
13137                 { },
13138                 INTERNAL | FLAG_NO_DATA,
13139                 { },
13140                 { { 0, 1 } },
13141                 .fill_helper = bpf_fill_ld_imm64_neg_zero,
13142         },
13143         {
13144                 "LD_IMM64: random positive and negative byte patterns",
13145                 { },
13146                 INTERNAL | FLAG_NO_DATA,
13147                 { },
13148                 { { 0, 1 } },
13149                 .fill_helper = bpf_fill_ld_imm64_pos_neg,
13150         },
13151         /* 64-bit ATOMIC register combinations */
13152         {
13153                 "ATOMIC_DW_ADD: register combinations",
13154                 { },
13155                 INTERNAL,
13156                 { },
13157                 { { 0, 1 } },
13158                 .fill_helper = bpf_fill_atomic64_add_reg_pairs,
13159                 .stack_depth = 8,
13160         },
13161         {
13162                 "ATOMIC_DW_AND: register combinations",
13163                 { },
13164                 INTERNAL,
13165                 { },
13166                 { { 0, 1 } },
13167                 .fill_helper = bpf_fill_atomic64_and_reg_pairs,
13168                 .stack_depth = 8,
13169         },
13170         {
13171                 "ATOMIC_DW_OR: register combinations",
13172                 { },
13173                 INTERNAL,
13174                 { },
13175                 { { 0, 1 } },
13176                 .fill_helper = bpf_fill_atomic64_or_reg_pairs,
13177                 .stack_depth = 8,
13178         },
13179         {
13180                 "ATOMIC_DW_XOR: register combinations",
13181                 { },
13182                 INTERNAL,
13183                 { },
13184                 { { 0, 1 } },
13185                 .fill_helper = bpf_fill_atomic64_xor_reg_pairs,
13186                 .stack_depth = 8,
13187         },
13188         {
13189                 "ATOMIC_DW_ADD_FETCH: register combinations",
13190                 { },
13191                 INTERNAL,
13192                 { },
13193                 { { 0, 1 } },
13194                 .fill_helper = bpf_fill_atomic64_add_fetch_reg_pairs,
13195                 .stack_depth = 8,
13196         },
13197         {
13198                 "ATOMIC_DW_AND_FETCH: register combinations",
13199                 { },
13200                 INTERNAL,
13201                 { },
13202                 { { 0, 1 } },
13203                 .fill_helper = bpf_fill_atomic64_and_fetch_reg_pairs,
13204                 .stack_depth = 8,
13205         },
13206         {
13207                 "ATOMIC_DW_OR_FETCH: register combinations",
13208                 { },
13209                 INTERNAL,
13210                 { },
13211                 { { 0, 1 } },
13212                 .fill_helper = bpf_fill_atomic64_or_fetch_reg_pairs,
13213                 .stack_depth = 8,
13214         },
13215         {
13216                 "ATOMIC_DW_XOR_FETCH: register combinations",
13217                 { },
13218                 INTERNAL,
13219                 { },
13220                 { { 0, 1 } },
13221                 .fill_helper = bpf_fill_atomic64_xor_fetch_reg_pairs,
13222                 .stack_depth = 8,
13223         },
13224         {
13225                 "ATOMIC_DW_XCHG: register combinations",
13226                 { },
13227                 INTERNAL,
13228                 { },
13229                 { { 0, 1 } },
13230                 .fill_helper = bpf_fill_atomic64_xchg_reg_pairs,
13231                 .stack_depth = 8,
13232         },
13233         {
13234                 "ATOMIC_DW_CMPXCHG: register combinations",
13235                 { },
13236                 INTERNAL,
13237                 { },
13238                 { { 0, 1 } },
13239                 .fill_helper = bpf_fill_atomic64_cmpxchg_reg_pairs,
13240                 .stack_depth = 8,
13241         },
13242         /* 32-bit ATOMIC register combinations */
13243         {
13244                 "ATOMIC_W_ADD: register combinations",
13245                 { },
13246                 INTERNAL,
13247                 { },
13248                 { { 0, 1 } },
13249                 .fill_helper = bpf_fill_atomic32_add_reg_pairs,
13250                 .stack_depth = 8,
13251         },
13252         {
13253                 "ATOMIC_W_AND: register combinations",
13254                 { },
13255                 INTERNAL,
13256                 { },
13257                 { { 0, 1 } },
13258                 .fill_helper = bpf_fill_atomic32_and_reg_pairs,
13259                 .stack_depth = 8,
13260         },
13261         {
13262                 "ATOMIC_W_OR: register combinations",
13263                 { },
13264                 INTERNAL,
13265                 { },
13266                 { { 0, 1 } },
13267                 .fill_helper = bpf_fill_atomic32_or_reg_pairs,
13268                 .stack_depth = 8,
13269         },
13270         {
13271                 "ATOMIC_W_XOR: register combinations",
13272                 { },
13273                 INTERNAL,
13274                 { },
13275                 { { 0, 1 } },
13276                 .fill_helper = bpf_fill_atomic32_xor_reg_pairs,
13277                 .stack_depth = 8,
13278         },
13279         {
13280                 "ATOMIC_W_ADD_FETCH: register combinations",
13281                 { },
13282                 INTERNAL,
13283                 { },
13284                 { { 0, 1 } },
13285                 .fill_helper = bpf_fill_atomic32_add_fetch_reg_pairs,
13286                 .stack_depth = 8,
13287         },
13288         {
13289                 "ATOMIC_W_AND_FETCH: register combinations",
13290                 { },
13291                 INTERNAL,
13292                 { },
13293                 { { 0, 1 } },
13294                 .fill_helper = bpf_fill_atomic32_and_fetch_reg_pairs,
13295                 .stack_depth = 8,
13296         },
13297         {
13298                 "ATOMIC_W_OR_FETCH: register combinations",
13299                 { },
13300                 INTERNAL,
13301                 { },
13302                 { { 0, 1 } },
13303                 .fill_helper = bpf_fill_atomic32_or_fetch_reg_pairs,
13304                 .stack_depth = 8,
13305         },
13306         {
13307                 "ATOMIC_W_XOR_FETCH: register combinations",
13308                 { },
13309                 INTERNAL,
13310                 { },
13311                 { { 0, 1 } },
13312                 .fill_helper = bpf_fill_atomic32_xor_fetch_reg_pairs,
13313                 .stack_depth = 8,
13314         },
13315         {
13316                 "ATOMIC_W_XCHG: register combinations",
13317                 { },
13318                 INTERNAL,
13319                 { },
13320                 { { 0, 1 } },
13321                 .fill_helper = bpf_fill_atomic32_xchg_reg_pairs,
13322                 .stack_depth = 8,
13323         },
13324         {
13325                 "ATOMIC_W_CMPXCHG: register combinations",
13326                 { },
13327                 INTERNAL,
13328                 { },
13329                 { { 0, 1 } },
13330                 .fill_helper = bpf_fill_atomic32_cmpxchg_reg_pairs,
13331                 .stack_depth = 8,
13332         },
13333         /* 64-bit ATOMIC magnitudes */
13334         {
13335                 "ATOMIC_DW_ADD: all operand magnitudes",
13336                 { },
13337                 INTERNAL | FLAG_NO_DATA,
13338                 { },
13339                 { { 0, 1 } },
13340                 .fill_helper = bpf_fill_atomic64_add,
13341                 .stack_depth = 8,
13342                 .nr_testruns = NR_PATTERN_RUNS,
13343         },
13344         {
13345                 "ATOMIC_DW_AND: all operand magnitudes",
13346                 { },
13347                 INTERNAL | FLAG_NO_DATA,
13348                 { },
13349                 { { 0, 1 } },
13350                 .fill_helper = bpf_fill_atomic64_and,
13351                 .stack_depth = 8,
13352                 .nr_testruns = NR_PATTERN_RUNS,
13353         },
13354         {
13355                 "ATOMIC_DW_OR: all operand magnitudes",
13356                 { },
13357                 INTERNAL | FLAG_NO_DATA,
13358                 { },
13359                 { { 0, 1 } },
13360                 .fill_helper = bpf_fill_atomic64_or,
13361                 .stack_depth = 8,
13362                 .nr_testruns = NR_PATTERN_RUNS,
13363         },
13364         {
13365                 "ATOMIC_DW_XOR: all operand magnitudes",
13366                 { },
13367                 INTERNAL | FLAG_NO_DATA,
13368                 { },
13369                 { { 0, 1 } },
13370                 .fill_helper = bpf_fill_atomic64_xor,
13371                 .stack_depth = 8,
13372                 .nr_testruns = NR_PATTERN_RUNS,
13373         },
13374         {
13375                 "ATOMIC_DW_ADD_FETCH: all operand magnitudes",
13376                 { },
13377                 INTERNAL | FLAG_NO_DATA,
13378                 { },
13379                 { { 0, 1 } },
13380                 .fill_helper = bpf_fill_atomic64_add_fetch,
13381                 .stack_depth = 8,
13382                 .nr_testruns = NR_PATTERN_RUNS,
13383         },
13384         {
13385                 "ATOMIC_DW_AND_FETCH: all operand magnitudes",
13386                 { },
13387                 INTERNAL | FLAG_NO_DATA,
13388                 { },
13389                 { { 0, 1 } },
13390                 .fill_helper = bpf_fill_atomic64_and_fetch,
13391                 .stack_depth = 8,
13392                 .nr_testruns = NR_PATTERN_RUNS,
13393         },
13394         {
13395                 "ATOMIC_DW_OR_FETCH: all operand magnitudes",
13396                 { },
13397                 INTERNAL | FLAG_NO_DATA,
13398                 { },
13399                 { { 0, 1 } },
13400                 .fill_helper = bpf_fill_atomic64_or_fetch,
13401                 .stack_depth = 8,
13402                 .nr_testruns = NR_PATTERN_RUNS,
13403         },
13404         {
13405                 "ATOMIC_DW_XOR_FETCH: all operand magnitudes",
13406                 { },
13407                 INTERNAL | FLAG_NO_DATA,
13408                 { },
13409                 { { 0, 1 } },
13410                 .fill_helper = bpf_fill_atomic64_xor_fetch,
13411                 .stack_depth = 8,
13412                 .nr_testruns = NR_PATTERN_RUNS,
13413         },
13414         {
13415                 "ATOMIC_DW_XCHG: all operand magnitudes",
13416                 { },
13417                 INTERNAL | FLAG_NO_DATA,
13418                 { },
13419                 { { 0, 1 } },
13420                 .fill_helper = bpf_fill_atomic64_xchg,
13421                 .stack_depth = 8,
13422                 .nr_testruns = NR_PATTERN_RUNS,
13423         },
13424         {
13425                 "ATOMIC_DW_CMPXCHG: all operand magnitudes",
13426                 { },
13427                 INTERNAL | FLAG_NO_DATA,
13428                 { },
13429                 { { 0, 1 } },
13430                 .fill_helper = bpf_fill_cmpxchg64,
13431                 .stack_depth = 8,
13432                 .nr_testruns = NR_PATTERN_RUNS,
13433         },
13434         /* 64-bit atomic magnitudes */
13435         {
13436                 "ATOMIC_W_ADD: all operand magnitudes",
13437                 { },
13438                 INTERNAL | FLAG_NO_DATA,
13439                 { },
13440                 { { 0, 1 } },
13441                 .fill_helper = bpf_fill_atomic32_add,
13442                 .stack_depth = 8,
13443                 .nr_testruns = NR_PATTERN_RUNS,
13444         },
13445         {
13446                 "ATOMIC_W_AND: all operand magnitudes",
13447                 { },
13448                 INTERNAL | FLAG_NO_DATA,
13449                 { },
13450                 { { 0, 1 } },
13451                 .fill_helper = bpf_fill_atomic32_and,
13452                 .stack_depth = 8,
13453                 .nr_testruns = NR_PATTERN_RUNS,
13454         },
13455         {
13456                 "ATOMIC_W_OR: all operand magnitudes",
13457                 { },
13458                 INTERNAL | FLAG_NO_DATA,
13459                 { },
13460                 { { 0, 1 } },
13461                 .fill_helper = bpf_fill_atomic32_or,
13462                 .stack_depth = 8,
13463                 .nr_testruns = NR_PATTERN_RUNS,
13464         },
13465         {
13466                 "ATOMIC_W_XOR: all operand magnitudes",
13467                 { },
13468                 INTERNAL | FLAG_NO_DATA,
13469                 { },
13470                 { { 0, 1 } },
13471                 .fill_helper = bpf_fill_atomic32_xor,
13472                 .stack_depth = 8,
13473                 .nr_testruns = NR_PATTERN_RUNS,
13474         },
13475         {
13476                 "ATOMIC_W_ADD_FETCH: all operand magnitudes",
13477                 { },
13478                 INTERNAL | FLAG_NO_DATA,
13479                 { },
13480                 { { 0, 1 } },
13481                 .fill_helper = bpf_fill_atomic32_add_fetch,
13482                 .stack_depth = 8,
13483                 .nr_testruns = NR_PATTERN_RUNS,
13484         },
13485         {
13486                 "ATOMIC_W_AND_FETCH: all operand magnitudes",
13487                 { },
13488                 INTERNAL | FLAG_NO_DATA,
13489                 { },
13490                 { { 0, 1 } },
13491                 .fill_helper = bpf_fill_atomic32_and_fetch,
13492                 .stack_depth = 8,
13493                 .nr_testruns = NR_PATTERN_RUNS,
13494         },
13495         {
13496                 "ATOMIC_W_OR_FETCH: all operand magnitudes",
13497                 { },
13498                 INTERNAL | FLAG_NO_DATA,
13499                 { },
13500                 { { 0, 1 } },
13501                 .fill_helper = bpf_fill_atomic32_or_fetch,
13502                 .stack_depth = 8,
13503                 .nr_testruns = NR_PATTERN_RUNS,
13504         },
13505         {
13506                 "ATOMIC_W_XOR_FETCH: all operand magnitudes",
13507                 { },
13508                 INTERNAL | FLAG_NO_DATA,
13509                 { },
13510                 { { 0, 1 } },
13511                 .fill_helper = bpf_fill_atomic32_xor_fetch,
13512                 .stack_depth = 8,
13513                 .nr_testruns = NR_PATTERN_RUNS,
13514         },
13515         {
13516                 "ATOMIC_W_XCHG: all operand magnitudes",
13517                 { },
13518                 INTERNAL | FLAG_NO_DATA,
13519                 { },
13520                 { { 0, 1 } },
13521                 .fill_helper = bpf_fill_atomic32_xchg,
13522                 .stack_depth = 8,
13523                 .nr_testruns = NR_PATTERN_RUNS,
13524         },
13525         {
13526                 "ATOMIC_W_CMPXCHG: all operand magnitudes",
13527                 { },
13528                 INTERNAL | FLAG_NO_DATA,
13529                 { },
13530                 { { 0, 1 } },
13531                 .fill_helper = bpf_fill_cmpxchg32,
13532                 .stack_depth = 8,
13533                 .nr_testruns = NR_PATTERN_RUNS,
13534         },
13535         /* JMP immediate magnitudes */
13536         {
13537                 "JMP_JSET_K: all immediate value magnitudes",
13538                 { },
13539                 INTERNAL | FLAG_NO_DATA,
13540                 { },
13541                 { { 0, 1 } },
13542                 .fill_helper = bpf_fill_jmp_jset_imm,
13543                 .nr_testruns = NR_PATTERN_RUNS,
13544         },
13545         {
13546                 "JMP_JEQ_K: all immediate value magnitudes",
13547                 { },
13548                 INTERNAL | FLAG_NO_DATA,
13549                 { },
13550                 { { 0, 1 } },
13551                 .fill_helper = bpf_fill_jmp_jeq_imm,
13552                 .nr_testruns = NR_PATTERN_RUNS,
13553         },
13554         {
13555                 "JMP_JNE_K: all immediate value magnitudes",
13556                 { },
13557                 INTERNAL | FLAG_NO_DATA,
13558                 { },
13559                 { { 0, 1 } },
13560                 .fill_helper = bpf_fill_jmp_jne_imm,
13561                 .nr_testruns = NR_PATTERN_RUNS,
13562         },
13563         {
13564                 "JMP_JGT_K: all immediate value magnitudes",
13565                 { },
13566                 INTERNAL | FLAG_NO_DATA,
13567                 { },
13568                 { { 0, 1 } },
13569                 .fill_helper = bpf_fill_jmp_jgt_imm,
13570                 .nr_testruns = NR_PATTERN_RUNS,
13571         },
13572         {
13573                 "JMP_JGE_K: all immediate value magnitudes",
13574                 { },
13575                 INTERNAL | FLAG_NO_DATA,
13576                 { },
13577                 { { 0, 1 } },
13578                 .fill_helper = bpf_fill_jmp_jge_imm,
13579                 .nr_testruns = NR_PATTERN_RUNS,
13580         },
13581         {
13582                 "JMP_JLT_K: all immediate value magnitudes",
13583                 { },
13584                 INTERNAL | FLAG_NO_DATA,
13585                 { },
13586                 { { 0, 1 } },
13587                 .fill_helper = bpf_fill_jmp_jlt_imm,
13588                 .nr_testruns = NR_PATTERN_RUNS,
13589         },
13590         {
13591                 "JMP_JLE_K: all immediate value magnitudes",
13592                 { },
13593                 INTERNAL | FLAG_NO_DATA,
13594                 { },
13595                 { { 0, 1 } },
13596                 .fill_helper = bpf_fill_jmp_jle_imm,
13597                 .nr_testruns = NR_PATTERN_RUNS,
13598         },
13599         {
13600                 "JMP_JSGT_K: all immediate value magnitudes",
13601                 { },
13602                 INTERNAL | FLAG_NO_DATA,
13603                 { },
13604                 { { 0, 1 } },
13605                 .fill_helper = bpf_fill_jmp_jsgt_imm,
13606                 .nr_testruns = NR_PATTERN_RUNS,
13607         },
13608         {
13609                 "JMP_JSGE_K: all immediate value magnitudes",
13610                 { },
13611                 INTERNAL | FLAG_NO_DATA,
13612                 { },
13613                 { { 0, 1 } },
13614                 .fill_helper = bpf_fill_jmp_jsge_imm,
13615                 .nr_testruns = NR_PATTERN_RUNS,
13616         },
13617         {
13618                 "JMP_JSLT_K: all immediate value magnitudes",
13619                 { },
13620                 INTERNAL | FLAG_NO_DATA,
13621                 { },
13622                 { { 0, 1 } },
13623                 .fill_helper = bpf_fill_jmp_jslt_imm,
13624                 .nr_testruns = NR_PATTERN_RUNS,
13625         },
13626         {
13627                 "JMP_JSLE_K: all immediate value magnitudes",
13628                 { },
13629                 INTERNAL | FLAG_NO_DATA,
13630                 { },
13631                 { { 0, 1 } },
13632                 .fill_helper = bpf_fill_jmp_jsle_imm,
13633                 .nr_testruns = NR_PATTERN_RUNS,
13634         },
13635         /* JMP register magnitudes */
13636         {
13637                 "JMP_JSET_X: all register value magnitudes",
13638                 { },
13639                 INTERNAL | FLAG_NO_DATA,
13640                 { },
13641                 { { 0, 1 } },
13642                 .fill_helper = bpf_fill_jmp_jset_reg,
13643                 .nr_testruns = NR_PATTERN_RUNS,
13644         },
13645         {
13646                 "JMP_JEQ_X: all register value magnitudes",
13647                 { },
13648                 INTERNAL | FLAG_NO_DATA,
13649                 { },
13650                 { { 0, 1 } },
13651                 .fill_helper = bpf_fill_jmp_jeq_reg,
13652                 .nr_testruns = NR_PATTERN_RUNS,
13653         },
13654         {
13655                 "JMP_JNE_X: all register value magnitudes",
13656                 { },
13657                 INTERNAL | FLAG_NO_DATA,
13658                 { },
13659                 { { 0, 1 } },
13660                 .fill_helper = bpf_fill_jmp_jne_reg,
13661                 .nr_testruns = NR_PATTERN_RUNS,
13662         },
13663         {
13664                 "JMP_JGT_X: all register value magnitudes",
13665                 { },
13666                 INTERNAL | FLAG_NO_DATA,
13667                 { },
13668                 { { 0, 1 } },
13669                 .fill_helper = bpf_fill_jmp_jgt_reg,
13670                 .nr_testruns = NR_PATTERN_RUNS,
13671         },
13672         {
13673                 "JMP_JGE_X: all register value magnitudes",
13674                 { },
13675                 INTERNAL | FLAG_NO_DATA,
13676                 { },
13677                 { { 0, 1 } },
13678                 .fill_helper = bpf_fill_jmp_jge_reg,
13679                 .nr_testruns = NR_PATTERN_RUNS,
13680         },
13681         {
13682                 "JMP_JLT_X: all register value magnitudes",
13683                 { },
13684                 INTERNAL | FLAG_NO_DATA,
13685                 { },
13686                 { { 0, 1 } },
13687                 .fill_helper = bpf_fill_jmp_jlt_reg,
13688                 .nr_testruns = NR_PATTERN_RUNS,
13689         },
13690         {
13691                 "JMP_JLE_X: all register value magnitudes",
13692                 { },
13693                 INTERNAL | FLAG_NO_DATA,
13694                 { },
13695                 { { 0, 1 } },
13696                 .fill_helper = bpf_fill_jmp_jle_reg,
13697                 .nr_testruns = NR_PATTERN_RUNS,
13698         },
13699         {
13700                 "JMP_JSGT_X: all register value magnitudes",
13701                 { },
13702                 INTERNAL | FLAG_NO_DATA,
13703                 { },
13704                 { { 0, 1 } },
13705                 .fill_helper = bpf_fill_jmp_jsgt_reg,
13706                 .nr_testruns = NR_PATTERN_RUNS,
13707         },
13708         {
13709                 "JMP_JSGE_X: all register value magnitudes",
13710                 { },
13711                 INTERNAL | FLAG_NO_DATA,
13712                 { },
13713                 { { 0, 1 } },
13714                 .fill_helper = bpf_fill_jmp_jsge_reg,
13715                 .nr_testruns = NR_PATTERN_RUNS,
13716         },
13717         {
13718                 "JMP_JSLT_X: all register value magnitudes",
13719                 { },
13720                 INTERNAL | FLAG_NO_DATA,
13721                 { },
13722                 { { 0, 1 } },
13723                 .fill_helper = bpf_fill_jmp_jslt_reg,
13724                 .nr_testruns = NR_PATTERN_RUNS,
13725         },
13726         {
13727                 "JMP_JSLE_X: all register value magnitudes",
13728                 { },
13729                 INTERNAL | FLAG_NO_DATA,
13730                 { },
13731                 { { 0, 1 } },
13732                 .fill_helper = bpf_fill_jmp_jsle_reg,
13733                 .nr_testruns = NR_PATTERN_RUNS,
13734         },
13735         /* JMP32 immediate magnitudes */
13736         {
13737                 "JMP32_JSET_K: all immediate value magnitudes",
13738                 { },
13739                 INTERNAL | FLAG_NO_DATA,
13740                 { },
13741                 { { 0, 1 } },
13742                 .fill_helper = bpf_fill_jmp32_jset_imm,
13743                 .nr_testruns = NR_PATTERN_RUNS,
13744         },
13745         {
13746                 "JMP32_JEQ_K: all immediate value magnitudes",
13747                 { },
13748                 INTERNAL | FLAG_NO_DATA,
13749                 { },
13750                 { { 0, 1 } },
13751                 .fill_helper = bpf_fill_jmp32_jeq_imm,
13752                 .nr_testruns = NR_PATTERN_RUNS,
13753         },
13754         {
13755                 "JMP32_JNE_K: all immediate value magnitudes",
13756                 { },
13757                 INTERNAL | FLAG_NO_DATA,
13758                 { },
13759                 { { 0, 1 } },
13760                 .fill_helper = bpf_fill_jmp32_jne_imm,
13761                 .nr_testruns = NR_PATTERN_RUNS,
13762         },
13763         {
13764                 "JMP32_JGT_K: all immediate value magnitudes",
13765                 { },
13766                 INTERNAL | FLAG_NO_DATA,
13767                 { },
13768                 { { 0, 1 } },
13769                 .fill_helper = bpf_fill_jmp32_jgt_imm,
13770                 .nr_testruns = NR_PATTERN_RUNS,
13771         },
13772         {
13773                 "JMP32_JGE_K: all immediate value magnitudes",
13774                 { },
13775                 INTERNAL | FLAG_NO_DATA,
13776                 { },
13777                 { { 0, 1 } },
13778                 .fill_helper = bpf_fill_jmp32_jge_imm,
13779                 .nr_testruns = NR_PATTERN_RUNS,
13780         },
13781         {
13782                 "JMP32_JLT_K: all immediate value magnitudes",
13783                 { },
13784                 INTERNAL | FLAG_NO_DATA,
13785                 { },
13786                 { { 0, 1 } },
13787                 .fill_helper = bpf_fill_jmp32_jlt_imm,
13788                 .nr_testruns = NR_PATTERN_RUNS,
13789         },
13790         {
13791                 "JMP32_JLE_K: all immediate value magnitudes",
13792                 { },
13793                 INTERNAL | FLAG_NO_DATA,
13794                 { },
13795                 { { 0, 1 } },
13796                 .fill_helper = bpf_fill_jmp32_jle_imm,
13797                 .nr_testruns = NR_PATTERN_RUNS,
13798         },
13799         {
13800                 "JMP32_JSGT_K: all immediate value magnitudes",
13801                 { },
13802                 INTERNAL | FLAG_NO_DATA,
13803                 { },
13804                 { { 0, 1 } },
13805                 .fill_helper = bpf_fill_jmp32_jsgt_imm,
13806                 .nr_testruns = NR_PATTERN_RUNS,
13807         },
13808         {
13809                 "JMP32_JSGE_K: all immediate value magnitudes",
13810                 { },
13811                 INTERNAL | FLAG_NO_DATA,
13812                 { },
13813                 { { 0, 1 } },
13814                 .fill_helper = bpf_fill_jmp32_jsge_imm,
13815                 .nr_testruns = NR_PATTERN_RUNS,
13816         },
13817         {
13818                 "JMP32_JSLT_K: all immediate value magnitudes",
13819                 { },
13820                 INTERNAL | FLAG_NO_DATA,
13821                 { },
13822                 { { 0, 1 } },
13823                 .fill_helper = bpf_fill_jmp32_jslt_imm,
13824                 .nr_testruns = NR_PATTERN_RUNS,
13825         },
13826         {
13827                 "JMP32_JSLE_K: all immediate value magnitudes",
13828                 { },
13829                 INTERNAL | FLAG_NO_DATA,
13830                 { },
13831                 { { 0, 1 } },
13832                 .fill_helper = bpf_fill_jmp32_jsle_imm,
13833                 .nr_testruns = NR_PATTERN_RUNS,
13834         },
13835         /* JMP32 register magnitudes */
13836         {
13837                 "JMP32_JSET_X: all register value magnitudes",
13838                 { },
13839                 INTERNAL | FLAG_NO_DATA,
13840                 { },
13841                 { { 0, 1 } },
13842                 .fill_helper = bpf_fill_jmp32_jset_reg,
13843                 .nr_testruns = NR_PATTERN_RUNS,
13844         },
13845         {
13846                 "JMP32_JEQ_X: all register value magnitudes",
13847                 { },
13848                 INTERNAL | FLAG_NO_DATA,
13849                 { },
13850                 { { 0, 1 } },
13851                 .fill_helper = bpf_fill_jmp32_jeq_reg,
13852                 .nr_testruns = NR_PATTERN_RUNS,
13853         },
13854         {
13855                 "JMP32_JNE_X: all register value magnitudes",
13856                 { },
13857                 INTERNAL | FLAG_NO_DATA,
13858                 { },
13859                 { { 0, 1 } },
13860                 .fill_helper = bpf_fill_jmp32_jne_reg,
13861                 .nr_testruns = NR_PATTERN_RUNS,
13862         },
13863         {
13864                 "JMP32_JGT_X: all register value magnitudes",
13865                 { },
13866                 INTERNAL | FLAG_NO_DATA,
13867                 { },
13868                 { { 0, 1 } },
13869                 .fill_helper = bpf_fill_jmp32_jgt_reg,
13870                 .nr_testruns = NR_PATTERN_RUNS,
13871         },
13872         {
13873                 "JMP32_JGE_X: all register value magnitudes",
13874                 { },
13875                 INTERNAL | FLAG_NO_DATA,
13876                 { },
13877                 { { 0, 1 } },
13878                 .fill_helper = bpf_fill_jmp32_jge_reg,
13879                 .nr_testruns = NR_PATTERN_RUNS,
13880         },
13881         {
13882                 "JMP32_JLT_X: all register value magnitudes",
13883                 { },
13884                 INTERNAL | FLAG_NO_DATA,
13885                 { },
13886                 { { 0, 1 } },
13887                 .fill_helper = bpf_fill_jmp32_jlt_reg,
13888                 .nr_testruns = NR_PATTERN_RUNS,
13889         },
13890         {
13891                 "JMP32_JLE_X: all register value magnitudes",
13892                 { },
13893                 INTERNAL | FLAG_NO_DATA,
13894                 { },
13895                 { { 0, 1 } },
13896                 .fill_helper = bpf_fill_jmp32_jle_reg,
13897                 .nr_testruns = NR_PATTERN_RUNS,
13898         },
13899         {
13900                 "JMP32_JSGT_X: all register value magnitudes",
13901                 { },
13902                 INTERNAL | FLAG_NO_DATA,
13903                 { },
13904                 { { 0, 1 } },
13905                 .fill_helper = bpf_fill_jmp32_jsgt_reg,
13906                 .nr_testruns = NR_PATTERN_RUNS,
13907         },
13908         {
13909                 "JMP32_JSGE_X: all register value magnitudes",
13910                 { },
13911                 INTERNAL | FLAG_NO_DATA,
13912                 { },
13913                 { { 0, 1 } },
13914                 .fill_helper = bpf_fill_jmp32_jsge_reg,
13915                 .nr_testruns = NR_PATTERN_RUNS,
13916         },
13917         {
13918                 "JMP32_JSLT_X: all register value magnitudes",
13919                 { },
13920                 INTERNAL | FLAG_NO_DATA,
13921                 { },
13922                 { { 0, 1 } },
13923                 .fill_helper = bpf_fill_jmp32_jslt_reg,
13924                 .nr_testruns = NR_PATTERN_RUNS,
13925         },
13926         {
13927                 "JMP32_JSLE_X: all register value magnitudes",
13928                 { },
13929                 INTERNAL | FLAG_NO_DATA,
13930                 { },
13931                 { { 0, 1 } },
13932                 .fill_helper = bpf_fill_jmp32_jsle_reg,
13933                 .nr_testruns = NR_PATTERN_RUNS,
13934         },
13935         /* Conditional jumps with constant decision */
13936         {
13937                 "JMP_JSET_K: imm = 0 -> never taken",
13938                 .u.insns_int = {
13939                         BPF_ALU64_IMM(BPF_MOV, R0, 1),
13940                         BPF_JMP_IMM(BPF_JSET, R1, 0, 1),
13941                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
13942                         BPF_EXIT_INSN(),
13943                 },
13944                 INTERNAL | FLAG_NO_DATA,
13945                 { },
13946                 { { 0, 0 } },
13947         },
13948         {
13949                 "JMP_JLT_K: imm = 0 -> never taken",
13950                 .u.insns_int = {
13951                         BPF_ALU64_IMM(BPF_MOV, R0, 1),
13952                         BPF_JMP_IMM(BPF_JLT, R1, 0, 1),
13953                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
13954                         BPF_EXIT_INSN(),
13955                 },
13956                 INTERNAL | FLAG_NO_DATA,
13957                 { },
13958                 { { 0, 0 } },
13959         },
13960         {
13961                 "JMP_JGE_K: imm = 0 -> always taken",
13962                 .u.insns_int = {
13963                         BPF_ALU64_IMM(BPF_MOV, R0, 1),
13964                         BPF_JMP_IMM(BPF_JGE, R1, 0, 1),
13965                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
13966                         BPF_EXIT_INSN(),
13967                 },
13968                 INTERNAL | FLAG_NO_DATA,
13969                 { },
13970                 { { 0, 1 } },
13971         },
13972         {
13973                 "JMP_JGT_K: imm = 0xffffffff -> never taken",
13974                 .u.insns_int = {
13975                         BPF_ALU64_IMM(BPF_MOV, R0, 1),
13976                         BPF_JMP_IMM(BPF_JGT, R1, U32_MAX, 1),
13977                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
13978                         BPF_EXIT_INSN(),
13979                 },
13980                 INTERNAL | FLAG_NO_DATA,
13981                 { },
13982                 { { 0, 0 } },
13983         },
13984         {
13985                 "JMP_JLE_K: imm = 0xffffffff -> always taken",
13986                 .u.insns_int = {
13987                         BPF_ALU64_IMM(BPF_MOV, R0, 1),
13988                         BPF_JMP_IMM(BPF_JLE, R1, U32_MAX, 1),
13989                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
13990                         BPF_EXIT_INSN(),
13991                 },
13992                 INTERNAL | FLAG_NO_DATA,
13993                 { },
13994                 { { 0, 1 } },
13995         },
13996         {
13997                 "JMP32_JSGT_K: imm = 0x7fffffff -> never taken",
13998                 .u.insns_int = {
13999                         BPF_ALU64_IMM(BPF_MOV, R0, 1),
14000                         BPF_JMP32_IMM(BPF_JSGT, R1, S32_MAX, 1),
14001                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
14002                         BPF_EXIT_INSN(),
14003                 },
14004                 INTERNAL | FLAG_NO_DATA,
14005                 { },
14006                 { { 0, 0 } },
14007         },
14008         {
14009                 "JMP32_JSGE_K: imm = -0x80000000 -> always taken",
14010                 .u.insns_int = {
14011                         BPF_ALU64_IMM(BPF_MOV, R0, 1),
14012                         BPF_JMP32_IMM(BPF_JSGE, R1, S32_MIN, 1),
14013                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
14014                         BPF_EXIT_INSN(),
14015                 },
14016                 INTERNAL | FLAG_NO_DATA,
14017                 { },
14018                 { { 0, 1 } },
14019         },
14020         {
14021                 "JMP32_JSLT_K: imm = -0x80000000 -> never taken",
14022                 .u.insns_int = {
14023                         BPF_ALU64_IMM(BPF_MOV, R0, 1),
14024                         BPF_JMP32_IMM(BPF_JSLT, R1, S32_MIN, 1),
14025                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
14026                         BPF_EXIT_INSN(),
14027                 },
14028                 INTERNAL | FLAG_NO_DATA,
14029                 { },
14030                 { { 0, 0 } },
14031         },
14032         {
14033                 "JMP32_JSLE_K: imm = 0x7fffffff -> always taken",
14034                 .u.insns_int = {
14035                         BPF_ALU64_IMM(BPF_MOV, R0, 1),
14036                         BPF_JMP32_IMM(BPF_JSLE, R1, S32_MAX, 1),
14037                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
14038                         BPF_EXIT_INSN(),
14039                 },
14040                 INTERNAL | FLAG_NO_DATA,
14041                 { },
14042                 { { 0, 1 } },
14043         },
14044         {
14045                 "JMP_JEQ_X: dst = src -> always taken",
14046                 .u.insns_int = {
14047                         BPF_ALU64_IMM(BPF_MOV, R0, 1),
14048                         BPF_JMP_REG(BPF_JEQ, R1, R1, 1),
14049                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
14050                         BPF_EXIT_INSN(),
14051                 },
14052                 INTERNAL | FLAG_NO_DATA,
14053                 { },
14054                 { { 0, 1 } },
14055         },
14056         {
14057                 "JMP_JGE_X: dst = src -> always taken",
14058                 .u.insns_int = {
14059                         BPF_ALU64_IMM(BPF_MOV, R0, 1),
14060                         BPF_JMP_REG(BPF_JGE, R1, R1, 1),
14061                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
14062                         BPF_EXIT_INSN(),
14063                 },
14064                 INTERNAL | FLAG_NO_DATA,
14065                 { },
14066                 { { 0, 1 } },
14067         },
14068         {
14069                 "JMP_JLE_X: dst = src -> always taken",
14070                 .u.insns_int = {
14071                         BPF_ALU64_IMM(BPF_MOV, R0, 1),
14072                         BPF_JMP_REG(BPF_JLE, R1, R1, 1),
14073                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
14074                         BPF_EXIT_INSN(),
14075                 },
14076                 INTERNAL | FLAG_NO_DATA,
14077                 { },
14078                 { { 0, 1 } },
14079         },
14080         {
14081                 "JMP_JSGE_X: dst = src -> always taken",
14082                 .u.insns_int = {
14083                         BPF_ALU64_IMM(BPF_MOV, R0, 1),
14084                         BPF_JMP_REG(BPF_JSGE, R1, R1, 1),
14085                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
14086                         BPF_EXIT_INSN(),
14087                 },
14088                 INTERNAL | FLAG_NO_DATA,
14089                 { },
14090                 { { 0, 1 } },
14091         },
14092         {
14093                 "JMP_JSLE_X: dst = src -> always taken",
14094                 .u.insns_int = {
14095                         BPF_ALU64_IMM(BPF_MOV, R0, 1),
14096                         BPF_JMP_REG(BPF_JSLE, R1, R1, 1),
14097                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
14098                         BPF_EXIT_INSN(),
14099                 },
14100                 INTERNAL | FLAG_NO_DATA,
14101                 { },
14102                 { { 0, 1 } },
14103         },
14104         {
14105                 "JMP_JNE_X: dst = src -> never taken",
14106                 .u.insns_int = {
14107                         BPF_ALU64_IMM(BPF_MOV, R0, 1),
14108                         BPF_JMP_REG(BPF_JNE, R1, R1, 1),
14109                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
14110                         BPF_EXIT_INSN(),
14111                 },
14112                 INTERNAL | FLAG_NO_DATA,
14113                 { },
14114                 { { 0, 0 } },
14115         },
14116         {
14117                 "JMP_JGT_X: dst = src -> never taken",
14118                 .u.insns_int = {
14119                         BPF_ALU64_IMM(BPF_MOV, R0, 1),
14120                         BPF_JMP_REG(BPF_JGT, R1, R1, 1),
14121                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
14122                         BPF_EXIT_INSN(),
14123                 },
14124                 INTERNAL | FLAG_NO_DATA,
14125                 { },
14126                 { { 0, 0 } },
14127         },
14128         {
14129                 "JMP_JLT_X: dst = src -> never taken",
14130                 .u.insns_int = {
14131                         BPF_ALU64_IMM(BPF_MOV, R0, 1),
14132                         BPF_JMP_REG(BPF_JLT, R1, R1, 1),
14133                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
14134                         BPF_EXIT_INSN(),
14135                 },
14136                 INTERNAL | FLAG_NO_DATA,
14137                 { },
14138                 { { 0, 0 } },
14139         },
14140         {
14141                 "JMP_JSGT_X: dst = src -> never taken",
14142                 .u.insns_int = {
14143                         BPF_ALU64_IMM(BPF_MOV, R0, 1),
14144                         BPF_JMP_REG(BPF_JSGT, R1, R1, 1),
14145                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
14146                         BPF_EXIT_INSN(),
14147                 },
14148                 INTERNAL | FLAG_NO_DATA,
14149                 { },
14150                 { { 0, 0 } },
14151         },
14152         {
14153                 "JMP_JSLT_X: dst = src -> never taken",
14154                 .u.insns_int = {
14155                         BPF_ALU64_IMM(BPF_MOV, R0, 1),
14156                         BPF_JMP_REG(BPF_JSLT, R1, R1, 1),
14157                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
14158                         BPF_EXIT_INSN(),
14159                 },
14160                 INTERNAL | FLAG_NO_DATA,
14161                 { },
14162                 { { 0, 0 } },
14163         },
14164         /* Short relative jumps */
14165         {
14166                 "Short relative jump: offset=0",
14167                 .u.insns_int = {
14168                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
14169                         BPF_JMP_IMM(BPF_JEQ, R0, 0, 0),
14170                         BPF_EXIT_INSN(),
14171                         BPF_ALU32_IMM(BPF_MOV, R0, -1),
14172                 },
14173                 INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
14174                 { },
14175                 { { 0, 0 } },
14176         },
14177         {
14178                 "Short relative jump: offset=1",
14179                 .u.insns_int = {
14180                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
14181                         BPF_JMP_IMM(BPF_JEQ, R0, 0, 1),
14182                         BPF_ALU32_IMM(BPF_ADD, R0, 1),
14183                         BPF_EXIT_INSN(),
14184                         BPF_ALU32_IMM(BPF_MOV, R0, -1),
14185                 },
14186                 INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
14187                 { },
14188                 { { 0, 0 } },
14189         },
14190         {
14191                 "Short relative jump: offset=2",
14192                 .u.insns_int = {
14193                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
14194                         BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
14195                         BPF_ALU32_IMM(BPF_ADD, R0, 1),
14196                         BPF_ALU32_IMM(BPF_ADD, R0, 1),
14197                         BPF_EXIT_INSN(),
14198                         BPF_ALU32_IMM(BPF_MOV, R0, -1),
14199                 },
14200                 INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
14201                 { },
14202                 { { 0, 0 } },
14203         },
14204         {
14205                 "Short relative jump: offset=3",
14206                 .u.insns_int = {
14207                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
14208                         BPF_JMP_IMM(BPF_JEQ, R0, 0, 3),
14209                         BPF_ALU32_IMM(BPF_ADD, R0, 1),
14210                         BPF_ALU32_IMM(BPF_ADD, R0, 1),
14211                         BPF_ALU32_IMM(BPF_ADD, R0, 1),
14212                         BPF_EXIT_INSN(),
14213                         BPF_ALU32_IMM(BPF_MOV, R0, -1),
14214                 },
14215                 INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
14216                 { },
14217                 { { 0, 0 } },
14218         },
14219         {
14220                 "Short relative jump: offset=4",
14221                 .u.insns_int = {
14222                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
14223                         BPF_JMP_IMM(BPF_JEQ, R0, 0, 4),
14224                         BPF_ALU32_IMM(BPF_ADD, R0, 1),
14225                         BPF_ALU32_IMM(BPF_ADD, R0, 1),
14226                         BPF_ALU32_IMM(BPF_ADD, R0, 1),
14227                         BPF_ALU32_IMM(BPF_ADD, R0, 1),
14228                         BPF_EXIT_INSN(),
14229                         BPF_ALU32_IMM(BPF_MOV, R0, -1),
14230                 },
14231                 INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
14232                 { },
14233                 { { 0, 0 } },
14234         },
14235         /* Conditional branch conversions */
14236         {
14237                 "Long conditional jump: taken at runtime",
14238                 { },
14239                 INTERNAL | FLAG_NO_DATA,
14240                 { },
14241                 { { 0, 1 } },
14242                 .fill_helper = bpf_fill_max_jmp_taken,
14243         },
14244         {
14245                 "Long conditional jump: not taken at runtime",
14246                 { },
14247                 INTERNAL | FLAG_NO_DATA,
14248                 { },
14249                 { { 0, 2 } },
14250                 .fill_helper = bpf_fill_max_jmp_not_taken,
14251         },
14252         {
14253                 "Long conditional jump: always taken, known at JIT time",
14254                 { },
14255                 INTERNAL | FLAG_NO_DATA,
14256                 { },
14257                 { { 0, 1 } },
14258                 .fill_helper = bpf_fill_max_jmp_always_taken,
14259         },
14260         {
14261                 "Long conditional jump: never taken, known at JIT time",
14262                 { },
14263                 INTERNAL | FLAG_NO_DATA,
14264                 { },
14265                 { { 0, 2 } },
14266                 .fill_helper = bpf_fill_max_jmp_never_taken,
14267         },
14268         /* Staggered jump sequences, immediate */
14269         {
14270                 "Staggered jumps: JMP_JA",
14271                 { },
14272                 INTERNAL | FLAG_NO_DATA,
14273                 { },
14274                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14275                 .fill_helper = bpf_fill_staggered_ja,
14276                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14277         },
14278         {
14279                 "Staggered jumps: JMP_JEQ_K",
14280                 { },
14281                 INTERNAL | FLAG_NO_DATA,
14282                 { },
14283                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14284                 .fill_helper = bpf_fill_staggered_jeq_imm,
14285                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14286         },
14287         {
14288                 "Staggered jumps: JMP_JNE_K",
14289                 { },
14290                 INTERNAL | FLAG_NO_DATA,
14291                 { },
14292                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14293                 .fill_helper = bpf_fill_staggered_jne_imm,
14294                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14295         },
14296         {
14297                 "Staggered jumps: JMP_JSET_K",
14298                 { },
14299                 INTERNAL | FLAG_NO_DATA,
14300                 { },
14301                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14302                 .fill_helper = bpf_fill_staggered_jset_imm,
14303                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14304         },
14305         {
14306                 "Staggered jumps: JMP_JGT_K",
14307                 { },
14308                 INTERNAL | FLAG_NO_DATA,
14309                 { },
14310                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14311                 .fill_helper = bpf_fill_staggered_jgt_imm,
14312                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14313         },
14314         {
14315                 "Staggered jumps: JMP_JGE_K",
14316                 { },
14317                 INTERNAL | FLAG_NO_DATA,
14318                 { },
14319                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14320                 .fill_helper = bpf_fill_staggered_jge_imm,
14321                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14322         },
14323         {
14324                 "Staggered jumps: JMP_JLT_K",
14325                 { },
14326                 INTERNAL | FLAG_NO_DATA,
14327                 { },
14328                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14329                 .fill_helper = bpf_fill_staggered_jlt_imm,
14330                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14331         },
14332         {
14333                 "Staggered jumps: JMP_JLE_K",
14334                 { },
14335                 INTERNAL | FLAG_NO_DATA,
14336                 { },
14337                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14338                 .fill_helper = bpf_fill_staggered_jle_imm,
14339                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14340         },
14341         {
14342                 "Staggered jumps: JMP_JSGT_K",
14343                 { },
14344                 INTERNAL | FLAG_NO_DATA,
14345                 { },
14346                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14347                 .fill_helper = bpf_fill_staggered_jsgt_imm,
14348                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14349         },
14350         {
14351                 "Staggered jumps: JMP_JSGE_K",
14352                 { },
14353                 INTERNAL | FLAG_NO_DATA,
14354                 { },
14355                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14356                 .fill_helper = bpf_fill_staggered_jsge_imm,
14357                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14358         },
14359         {
14360                 "Staggered jumps: JMP_JSLT_K",
14361                 { },
14362                 INTERNAL | FLAG_NO_DATA,
14363                 { },
14364                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14365                 .fill_helper = bpf_fill_staggered_jslt_imm,
14366                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14367         },
14368         {
14369                 "Staggered jumps: JMP_JSLE_K",
14370                 { },
14371                 INTERNAL | FLAG_NO_DATA,
14372                 { },
14373                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14374                 .fill_helper = bpf_fill_staggered_jsle_imm,
14375                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14376         },
14377         /* Staggered jump sequences, register */
14378         {
14379                 "Staggered jumps: JMP_JEQ_X",
14380                 { },
14381                 INTERNAL | FLAG_NO_DATA,
14382                 { },
14383                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14384                 .fill_helper = bpf_fill_staggered_jeq_reg,
14385                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14386         },
14387         {
14388                 "Staggered jumps: JMP_JNE_X",
14389                 { },
14390                 INTERNAL | FLAG_NO_DATA,
14391                 { },
14392                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14393                 .fill_helper = bpf_fill_staggered_jne_reg,
14394                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14395         },
14396         {
14397                 "Staggered jumps: JMP_JSET_X",
14398                 { },
14399                 INTERNAL | FLAG_NO_DATA,
14400                 { },
14401                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14402                 .fill_helper = bpf_fill_staggered_jset_reg,
14403                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14404         },
14405         {
14406                 "Staggered jumps: JMP_JGT_X",
14407                 { },
14408                 INTERNAL | FLAG_NO_DATA,
14409                 { },
14410                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14411                 .fill_helper = bpf_fill_staggered_jgt_reg,
14412                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14413         },
14414         {
14415                 "Staggered jumps: JMP_JGE_X",
14416                 { },
14417                 INTERNAL | FLAG_NO_DATA,
14418                 { },
14419                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14420                 .fill_helper = bpf_fill_staggered_jge_reg,
14421                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14422         },
14423         {
14424                 "Staggered jumps: JMP_JLT_X",
14425                 { },
14426                 INTERNAL | FLAG_NO_DATA,
14427                 { },
14428                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14429                 .fill_helper = bpf_fill_staggered_jlt_reg,
14430                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14431         },
14432         {
14433                 "Staggered jumps: JMP_JLE_X",
14434                 { },
14435                 INTERNAL | FLAG_NO_DATA,
14436                 { },
14437                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14438                 .fill_helper = bpf_fill_staggered_jle_reg,
14439                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14440         },
14441         {
14442                 "Staggered jumps: JMP_JSGT_X",
14443                 { },
14444                 INTERNAL | FLAG_NO_DATA,
14445                 { },
14446                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14447                 .fill_helper = bpf_fill_staggered_jsgt_reg,
14448                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14449         },
14450         {
14451                 "Staggered jumps: JMP_JSGE_X",
14452                 { },
14453                 INTERNAL | FLAG_NO_DATA,
14454                 { },
14455                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14456                 .fill_helper = bpf_fill_staggered_jsge_reg,
14457                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14458         },
14459         {
14460                 "Staggered jumps: JMP_JSLT_X",
14461                 { },
14462                 INTERNAL | FLAG_NO_DATA,
14463                 { },
14464                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14465                 .fill_helper = bpf_fill_staggered_jslt_reg,
14466                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14467         },
14468         {
14469                 "Staggered jumps: JMP_JSLE_X",
14470                 { },
14471                 INTERNAL | FLAG_NO_DATA,
14472                 { },
14473                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14474                 .fill_helper = bpf_fill_staggered_jsle_reg,
14475                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14476         },
14477         /* Staggered jump sequences, JMP32 immediate */
14478         {
14479                 "Staggered jumps: JMP32_JEQ_K",
14480                 { },
14481                 INTERNAL | FLAG_NO_DATA,
14482                 { },
14483                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14484                 .fill_helper = bpf_fill_staggered_jeq32_imm,
14485                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14486         },
14487         {
14488                 "Staggered jumps: JMP32_JNE_K",
14489                 { },
14490                 INTERNAL | FLAG_NO_DATA,
14491                 { },
14492                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14493                 .fill_helper = bpf_fill_staggered_jne32_imm,
14494                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14495         },
14496         {
14497                 "Staggered jumps: JMP32_JSET_K",
14498                 { },
14499                 INTERNAL | FLAG_NO_DATA,
14500                 { },
14501                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14502                 .fill_helper = bpf_fill_staggered_jset32_imm,
14503                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14504         },
14505         {
14506                 "Staggered jumps: JMP32_JGT_K",
14507                 { },
14508                 INTERNAL | FLAG_NO_DATA,
14509                 { },
14510                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14511                 .fill_helper = bpf_fill_staggered_jgt32_imm,
14512                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14513         },
14514         {
14515                 "Staggered jumps: JMP32_JGE_K",
14516                 { },
14517                 INTERNAL | FLAG_NO_DATA,
14518                 { },
14519                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14520                 .fill_helper = bpf_fill_staggered_jge32_imm,
14521                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14522         },
14523         {
14524                 "Staggered jumps: JMP32_JLT_K",
14525                 { },
14526                 INTERNAL | FLAG_NO_DATA,
14527                 { },
14528                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14529                 .fill_helper = bpf_fill_staggered_jlt32_imm,
14530                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14531         },
14532         {
14533                 "Staggered jumps: JMP32_JLE_K",
14534                 { },
14535                 INTERNAL | FLAG_NO_DATA,
14536                 { },
14537                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14538                 .fill_helper = bpf_fill_staggered_jle32_imm,
14539                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14540         },
14541         {
14542                 "Staggered jumps: JMP32_JSGT_K",
14543                 { },
14544                 INTERNAL | FLAG_NO_DATA,
14545                 { },
14546                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14547                 .fill_helper = bpf_fill_staggered_jsgt32_imm,
14548                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14549         },
14550         {
14551                 "Staggered jumps: JMP32_JSGE_K",
14552                 { },
14553                 INTERNAL | FLAG_NO_DATA,
14554                 { },
14555                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14556                 .fill_helper = bpf_fill_staggered_jsge32_imm,
14557                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14558         },
14559         {
14560                 "Staggered jumps: JMP32_JSLT_K",
14561                 { },
14562                 INTERNAL | FLAG_NO_DATA,
14563                 { },
14564                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14565                 .fill_helper = bpf_fill_staggered_jslt32_imm,
14566                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14567         },
14568         {
14569                 "Staggered jumps: JMP32_JSLE_K",
14570                 { },
14571                 INTERNAL | FLAG_NO_DATA,
14572                 { },
14573                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14574                 .fill_helper = bpf_fill_staggered_jsle32_imm,
14575                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14576         },
14577         /* Staggered jump sequences, JMP32 register */
14578         {
14579                 "Staggered jumps: JMP32_JEQ_X",
14580                 { },
14581                 INTERNAL | FLAG_NO_DATA,
14582                 { },
14583                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14584                 .fill_helper = bpf_fill_staggered_jeq32_reg,
14585                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14586         },
14587         {
14588                 "Staggered jumps: JMP32_JNE_X",
14589                 { },
14590                 INTERNAL | FLAG_NO_DATA,
14591                 { },
14592                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14593                 .fill_helper = bpf_fill_staggered_jne32_reg,
14594                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14595         },
14596         {
14597                 "Staggered jumps: JMP32_JSET_X",
14598                 { },
14599                 INTERNAL | FLAG_NO_DATA,
14600                 { },
14601                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14602                 .fill_helper = bpf_fill_staggered_jset32_reg,
14603                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14604         },
14605         {
14606                 "Staggered jumps: JMP32_JGT_X",
14607                 { },
14608                 INTERNAL | FLAG_NO_DATA,
14609                 { },
14610                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14611                 .fill_helper = bpf_fill_staggered_jgt32_reg,
14612                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14613         },
14614         {
14615                 "Staggered jumps: JMP32_JGE_X",
14616                 { },
14617                 INTERNAL | FLAG_NO_DATA,
14618                 { },
14619                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14620                 .fill_helper = bpf_fill_staggered_jge32_reg,
14621                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14622         },
14623         {
14624                 "Staggered jumps: JMP32_JLT_X",
14625                 { },
14626                 INTERNAL | FLAG_NO_DATA,
14627                 { },
14628                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14629                 .fill_helper = bpf_fill_staggered_jlt32_reg,
14630                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14631         },
14632         {
14633                 "Staggered jumps: JMP32_JLE_X",
14634                 { },
14635                 INTERNAL | FLAG_NO_DATA,
14636                 { },
14637                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14638                 .fill_helper = bpf_fill_staggered_jle32_reg,
14639                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14640         },
14641         {
14642                 "Staggered jumps: JMP32_JSGT_X",
14643                 { },
14644                 INTERNAL | FLAG_NO_DATA,
14645                 { },
14646                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14647                 .fill_helper = bpf_fill_staggered_jsgt32_reg,
14648                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14649         },
14650         {
14651                 "Staggered jumps: JMP32_JSGE_X",
14652                 { },
14653                 INTERNAL | FLAG_NO_DATA,
14654                 { },
14655                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14656                 .fill_helper = bpf_fill_staggered_jsge32_reg,
14657                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14658         },
14659         {
14660                 "Staggered jumps: JMP32_JSLT_X",
14661                 { },
14662                 INTERNAL | FLAG_NO_DATA,
14663                 { },
14664                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14665                 .fill_helper = bpf_fill_staggered_jslt32_reg,
14666                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14667         },
14668         {
14669                 "Staggered jumps: JMP32_JSLE_X",
14670                 { },
14671                 INTERNAL | FLAG_NO_DATA,
14672                 { },
14673                 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14674                 .fill_helper = bpf_fill_staggered_jsle32_reg,
14675                 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14676         },
14677 };
14678
14679 static struct net_device dev;
14680
14681 static struct sk_buff *populate_skb(char *buf, int size)
14682 {
14683         struct sk_buff *skb;
14684
14685         if (size >= MAX_DATA)
14686                 return NULL;
14687
14688         skb = alloc_skb(MAX_DATA, GFP_KERNEL);
14689         if (!skb)
14690                 return NULL;
14691
14692         __skb_put_data(skb, buf, size);
14693
14694         /* Initialize a fake skb with test pattern. */
14695         skb_reset_mac_header(skb);
14696         skb->protocol = htons(ETH_P_IP);
14697         skb->pkt_type = SKB_TYPE;
14698         skb->mark = SKB_MARK;
14699         skb->hash = SKB_HASH;
14700         skb->queue_mapping = SKB_QUEUE_MAP;
14701         skb->vlan_tci = SKB_VLAN_TCI;
14702         skb->vlan_proto = htons(ETH_P_IP);
14703         dev_net_set(&dev, &init_net);
14704         skb->dev = &dev;
14705         skb->dev->ifindex = SKB_DEV_IFINDEX;
14706         skb->dev->type = SKB_DEV_TYPE;
14707         skb_set_network_header(skb, min(size, ETH_HLEN));
14708
14709         return skb;
14710 }
14711
14712 static void *generate_test_data(struct bpf_test *test, int sub)
14713 {
14714         struct sk_buff *skb;
14715         struct page *page;
14716
14717         if (test->aux & FLAG_NO_DATA)
14718                 return NULL;
14719
14720         if (test->aux & FLAG_LARGE_MEM)
14721                 return kmalloc(test->test[sub].data_size, GFP_KERNEL);
14722
14723         /* Test case expects an skb, so populate one. Various
14724          * subtests generate skbs of different sizes based on
14725          * the same data.
14726          */
14727         skb = populate_skb(test->data, test->test[sub].data_size);
14728         if (!skb)
14729                 return NULL;
14730
14731         if (test->aux & FLAG_SKB_FRAG) {
14732                 /*
14733                  * when the test requires a fragmented skb, add a
14734                  * single fragment to the skb, filled with
14735                  * test->frag_data.
14736                  */
14737                 page = alloc_page(GFP_KERNEL);
14738                 if (!page)
14739                         goto err_kfree_skb;
14740
14741                 memcpy(page_address(page), test->frag_data, MAX_DATA);
14742                 skb_add_rx_frag(skb, 0, page, 0, MAX_DATA, MAX_DATA);
14743         }
14744
14745         return skb;
14746 err_kfree_skb:
14747         kfree_skb(skb);
14748         return NULL;
14749 }
14750
14751 static void release_test_data(const struct bpf_test *test, void *data)
14752 {
14753         if (test->aux & FLAG_NO_DATA)
14754                 return;
14755
14756         if (test->aux & FLAG_LARGE_MEM)
14757                 kfree(data);
14758         else
14759                 kfree_skb(data);
14760 }
14761
14762 static int filter_length(int which)
14763 {
14764         struct sock_filter *fp;
14765         int len;
14766
14767         if (tests[which].fill_helper)
14768                 return tests[which].u.ptr.len;
14769
14770         fp = tests[which].u.insns;
14771         for (len = MAX_INSNS - 1; len > 0; --len)
14772                 if (fp[len].code != 0 || fp[len].k != 0)
14773                         break;
14774
14775         return len + 1;
14776 }
14777
14778 static void *filter_pointer(int which)
14779 {
14780         if (tests[which].fill_helper)
14781                 return tests[which].u.ptr.insns;
14782         else
14783                 return tests[which].u.insns;
14784 }
14785
14786 static struct bpf_prog *generate_filter(int which, int *err)
14787 {
14788         __u8 test_type = tests[which].aux & TEST_TYPE_MASK;
14789         unsigned int flen = filter_length(which);
14790         void *fptr = filter_pointer(which);
14791         struct sock_fprog_kern fprog;
14792         struct bpf_prog *fp;
14793
14794         switch (test_type) {
14795         case CLASSIC:
14796                 fprog.filter = fptr;
14797                 fprog.len = flen;
14798
14799                 *err = bpf_prog_create(&fp, &fprog);
14800                 if (tests[which].aux & FLAG_EXPECTED_FAIL) {
14801                         if (*err == tests[which].expected_errcode) {
14802                                 pr_cont("PASS\n");
14803                                 /* Verifier rejected filter as expected. */
14804                                 *err = 0;
14805                                 return NULL;
14806                         } else {
14807                                 pr_cont("UNEXPECTED_PASS\n");
14808                                 /* Verifier didn't reject the test that's
14809                                  * bad enough, just return!
14810                                  */
14811                                 *err = -EINVAL;
14812                                 return NULL;
14813                         }
14814                 }
14815                 if (*err) {
14816                         pr_cont("FAIL to prog_create err=%d len=%d\n",
14817                                 *err, fprog.len);
14818                         return NULL;
14819                 }
14820                 break;
14821
14822         case INTERNAL:
14823                 fp = bpf_prog_alloc(bpf_prog_size(flen), 0);
14824                 if (fp == NULL) {
14825                         pr_cont("UNEXPECTED_FAIL no memory left\n");
14826                         *err = -ENOMEM;
14827                         return NULL;
14828                 }
14829
14830                 fp->len = flen;
14831                 /* Type doesn't really matter here as long as it's not unspec. */
14832                 fp->type = BPF_PROG_TYPE_SOCKET_FILTER;
14833                 memcpy(fp->insnsi, fptr, fp->len * sizeof(struct bpf_insn));
14834                 fp->aux->stack_depth = tests[which].stack_depth;
14835                 fp->aux->verifier_zext = !!(tests[which].aux &
14836                                             FLAG_VERIFIER_ZEXT);
14837
14838                 /* We cannot error here as we don't need type compatibility
14839                  * checks.
14840                  */
14841                 fp = bpf_prog_select_runtime(fp, err);
14842                 if (*err) {
14843                         pr_cont("FAIL to select_runtime err=%d\n", *err);
14844                         return NULL;
14845                 }
14846                 break;
14847         }
14848
14849         *err = 0;
14850         return fp;
14851 }
14852
14853 static void release_filter(struct bpf_prog *fp, int which)
14854 {
14855         __u8 test_type = tests[which].aux & TEST_TYPE_MASK;
14856
14857         switch (test_type) {
14858         case CLASSIC:
14859                 bpf_prog_destroy(fp);
14860                 break;
14861         case INTERNAL:
14862                 bpf_prog_free(fp);
14863                 break;
14864         }
14865 }
14866
14867 static int __run_one(const struct bpf_prog *fp, const void *data,
14868                      int runs, u64 *duration)
14869 {
14870         u64 start, finish;
14871         int ret = 0, i;
14872
14873         migrate_disable();
14874         start = ktime_get_ns();
14875
14876         for (i = 0; i < runs; i++)
14877                 ret = bpf_prog_run(fp, data);
14878
14879         finish = ktime_get_ns();
14880         migrate_enable();
14881
14882         *duration = finish - start;
14883         do_div(*duration, runs);
14884
14885         return ret;
14886 }
14887
14888 static int run_one(const struct bpf_prog *fp, struct bpf_test *test)
14889 {
14890         int err_cnt = 0, i, runs = MAX_TESTRUNS;
14891
14892         if (test->nr_testruns)
14893                 runs = min(test->nr_testruns, MAX_TESTRUNS);
14894
14895         for (i = 0; i < MAX_SUBTESTS; i++) {
14896                 void *data;
14897                 u64 duration;
14898                 u32 ret;
14899
14900                 /*
14901                  * NOTE: Several sub-tests may be present, in which case
14902                  * a zero {data_size, result} tuple indicates the end of
14903                  * the sub-test array. The first test is always run,
14904                  * even if both data_size and result happen to be zero.
14905                  */
14906                 if (i > 0 &&
14907                     test->test[i].data_size == 0 &&
14908                     test->test[i].result == 0)
14909                         break;
14910
14911                 data = generate_test_data(test, i);
14912                 if (!data && !(test->aux & FLAG_NO_DATA)) {
14913                         pr_cont("data generation failed ");
14914                         err_cnt++;
14915                         break;
14916                 }
14917                 ret = __run_one(fp, data, runs, &duration);
14918                 release_test_data(test, data);
14919
14920                 if (ret == test->test[i].result) {
14921                         pr_cont("%lld ", duration);
14922                 } else {
14923                         s32 res = test->test[i].result;
14924
14925                         pr_cont("ret %d != %d (%#x != %#x)",
14926                                 ret, res, ret, res);
14927                         err_cnt++;
14928                 }
14929         }
14930
14931         return err_cnt;
14932 }
14933
14934 static char test_name[64];
14935 module_param_string(test_name, test_name, sizeof(test_name), 0);
14936
14937 static int test_id = -1;
14938 module_param(test_id, int, 0);
14939
14940 static int test_range[2] = { 0, INT_MAX };
14941 module_param_array(test_range, int, NULL, 0);
14942
14943 static bool exclude_test(int test_id)
14944 {
14945         return test_id < test_range[0] || test_id > test_range[1];
14946 }
14947
14948 static __init struct sk_buff *build_test_skb(void)
14949 {
14950         u32 headroom = NET_SKB_PAD + NET_IP_ALIGN + ETH_HLEN;
14951         struct sk_buff *skb[2];
14952         struct page *page[2];
14953         int i, data_size = 8;
14954
14955         for (i = 0; i < 2; i++) {
14956                 page[i] = alloc_page(GFP_KERNEL);
14957                 if (!page[i]) {
14958                         if (i == 0)
14959                                 goto err_page0;
14960                         else
14961                                 goto err_page1;
14962                 }
14963
14964                 /* this will set skb[i]->head_frag */
14965                 skb[i] = dev_alloc_skb(headroom + data_size);
14966                 if (!skb[i]) {
14967                         if (i == 0)
14968                                 goto err_skb0;
14969                         else
14970                                 goto err_skb1;
14971                 }
14972
14973                 skb_reserve(skb[i], headroom);
14974                 skb_put(skb[i], data_size);
14975                 skb[i]->protocol = htons(ETH_P_IP);
14976                 skb_reset_network_header(skb[i]);
14977                 skb_set_mac_header(skb[i], -ETH_HLEN);
14978
14979                 skb_add_rx_frag(skb[i], 0, page[i], 0, 64, 64);
14980                 // skb_headlen(skb[i]): 8, skb[i]->head_frag = 1
14981         }
14982
14983         /* setup shinfo */
14984         skb_shinfo(skb[0])->gso_size = 1448;
14985         skb_shinfo(skb[0])->gso_type = SKB_GSO_TCPV4;
14986         skb_shinfo(skb[0])->gso_type |= SKB_GSO_DODGY;
14987         skb_shinfo(skb[0])->gso_segs = 0;
14988         skb_shinfo(skb[0])->frag_list = skb[1];
14989         skb_shinfo(skb[0])->hwtstamps.hwtstamp = 1000;
14990
14991         /* adjust skb[0]'s len */
14992         skb[0]->len += skb[1]->len;
14993         skb[0]->data_len += skb[1]->data_len;
14994         skb[0]->truesize += skb[1]->truesize;
14995
14996         return skb[0];
14997
14998 err_skb1:
14999         __free_page(page[1]);
15000 err_page1:
15001         kfree_skb(skb[0]);
15002 err_skb0:
15003         __free_page(page[0]);
15004 err_page0:
15005         return NULL;
15006 }
15007
15008 static __init struct sk_buff *build_test_skb_linear_no_head_frag(void)
15009 {
15010         unsigned int alloc_size = 2000;
15011         unsigned int headroom = 102, doffset = 72, data_size = 1308;
15012         struct sk_buff *skb[2];
15013         int i;
15014
15015         /* skbs linked in a frag_list, both with linear data, with head_frag=0
15016          * (data allocated by kmalloc), both have tcp data of 1308 bytes
15017          * (total payload is 2616 bytes).
15018          * Data offset is 72 bytes (40 ipv6 hdr, 32 tcp hdr). Some headroom.
15019          */
15020         for (i = 0; i < 2; i++) {
15021                 skb[i] = alloc_skb(alloc_size, GFP_KERNEL);
15022                 if (!skb[i]) {
15023                         if (i == 0)
15024                                 goto err_skb0;
15025                         else
15026                                 goto err_skb1;
15027                 }
15028
15029                 skb[i]->protocol = htons(ETH_P_IPV6);
15030                 skb_reserve(skb[i], headroom);
15031                 skb_put(skb[i], doffset + data_size);
15032                 skb_reset_network_header(skb[i]);
15033                 if (i == 0)
15034                         skb_reset_mac_header(skb[i]);
15035                 else
15036                         skb_set_mac_header(skb[i], -ETH_HLEN);
15037                 __skb_pull(skb[i], doffset);
15038         }
15039
15040         /* setup shinfo.
15041          * mimic bpf_skb_proto_4_to_6, which resets gso_segs and assigns a
15042          * reduced gso_size.
15043          */
15044         skb_shinfo(skb[0])->gso_size = 1288;
15045         skb_shinfo(skb[0])->gso_type = SKB_GSO_TCPV6 | SKB_GSO_DODGY;
15046         skb_shinfo(skb[0])->gso_segs = 0;
15047         skb_shinfo(skb[0])->frag_list = skb[1];
15048
15049         /* adjust skb[0]'s len */
15050         skb[0]->len += skb[1]->len;
15051         skb[0]->data_len += skb[1]->len;
15052         skb[0]->truesize += skb[1]->truesize;
15053
15054         return skb[0];
15055
15056 err_skb1:
15057         kfree_skb(skb[0]);
15058 err_skb0:
15059         return NULL;
15060 }
15061
15062 struct skb_segment_test {
15063         const char *descr;
15064         struct sk_buff *(*build_skb)(void);
15065         netdev_features_t features;
15066 };
15067
15068 static struct skb_segment_test skb_segment_tests[] __initconst = {
15069         {
15070                 .descr = "gso_with_rx_frags",
15071                 .build_skb = build_test_skb,
15072                 .features = NETIF_F_SG | NETIF_F_GSO_PARTIAL | NETIF_F_IP_CSUM |
15073                             NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM
15074         },
15075         {
15076                 .descr = "gso_linear_no_head_frag",
15077                 .build_skb = build_test_skb_linear_no_head_frag,
15078                 .features = NETIF_F_SG | NETIF_F_FRAGLIST |
15079                             NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_GSO |
15080                             NETIF_F_LLTX | NETIF_F_GRO |
15081                             NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM |
15082                             NETIF_F_HW_VLAN_STAG_TX
15083         }
15084 };
15085
15086 static __init int test_skb_segment_single(const struct skb_segment_test *test)
15087 {
15088         struct sk_buff *skb, *segs;
15089         int ret = -1;
15090
15091         skb = test->build_skb();
15092         if (!skb) {
15093                 pr_info("%s: failed to build_test_skb", __func__);
15094                 goto done;
15095         }
15096
15097         segs = skb_segment(skb, test->features);
15098         if (!IS_ERR(segs)) {
15099                 kfree_skb_list(segs);
15100                 ret = 0;
15101         }
15102         kfree_skb(skb);
15103 done:
15104         return ret;
15105 }
15106
15107 static __init int test_skb_segment(void)
15108 {
15109         int i, err_cnt = 0, pass_cnt = 0;
15110
15111         for (i = 0; i < ARRAY_SIZE(skb_segment_tests); i++) {
15112                 const struct skb_segment_test *test = &skb_segment_tests[i];
15113
15114                 cond_resched();
15115                 if (exclude_test(i))
15116                         continue;
15117
15118                 pr_info("#%d %s ", i, test->descr);
15119
15120                 if (test_skb_segment_single(test)) {
15121                         pr_cont("FAIL\n");
15122                         err_cnt++;
15123                 } else {
15124                         pr_cont("PASS\n");
15125                         pass_cnt++;
15126                 }
15127         }
15128
15129         pr_info("%s: Summary: %d PASSED, %d FAILED\n", __func__,
15130                 pass_cnt, err_cnt);
15131         return err_cnt ? -EINVAL : 0;
15132 }
15133
15134 static __init int test_bpf(void)
15135 {
15136         int i, err_cnt = 0, pass_cnt = 0;
15137         int jit_cnt = 0, run_cnt = 0;
15138
15139         for (i = 0; i < ARRAY_SIZE(tests); i++) {
15140                 struct bpf_prog *fp;
15141                 int err;
15142
15143                 cond_resched();
15144                 if (exclude_test(i))
15145                         continue;
15146
15147                 pr_info("#%d %s ", i, tests[i].descr);
15148
15149                 if (tests[i].fill_helper &&
15150                     tests[i].fill_helper(&tests[i]) < 0) {
15151                         pr_cont("FAIL to prog_fill\n");
15152                         continue;
15153                 }
15154
15155                 fp = generate_filter(i, &err);
15156
15157                 if (tests[i].fill_helper) {
15158                         kfree(tests[i].u.ptr.insns);
15159                         tests[i].u.ptr.insns = NULL;
15160                 }
15161
15162                 if (fp == NULL) {
15163                         if (err == 0) {
15164                                 pass_cnt++;
15165                                 continue;
15166                         }
15167                         err_cnt++;
15168                         continue;
15169                 }
15170
15171                 pr_cont("jited:%u ", fp->jited);
15172
15173                 run_cnt++;
15174                 if (fp->jited)
15175                         jit_cnt++;
15176
15177                 err = run_one(fp, &tests[i]);
15178                 release_filter(fp, i);
15179
15180                 if (err) {
15181                         pr_cont("FAIL (%d times)\n", err);
15182                         err_cnt++;
15183                 } else {
15184                         pr_cont("PASS\n");
15185                         pass_cnt++;
15186                 }
15187         }
15188
15189         pr_info("Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n",
15190                 pass_cnt, err_cnt, jit_cnt, run_cnt);
15191
15192         return err_cnt ? -EINVAL : 0;
15193 }
15194
15195 struct tail_call_test {
15196         const char *descr;
15197         struct bpf_insn insns[MAX_INSNS];
15198         int flags;
15199         int result;
15200         int stack_depth;
15201 };
15202
15203 /* Flags that can be passed to tail call test cases */
15204 #define FLAG_NEED_STATE         BIT(0)
15205 #define FLAG_RESULT_IN_STATE    BIT(1)
15206
15207 /*
15208  * Magic marker used in test snippets for tail calls below.
15209  * BPF_LD/MOV to R2 and R2 with this immediate value is replaced
15210  * with the proper values by the test runner.
15211  */
15212 #define TAIL_CALL_MARKER 0x7a11ca11
15213
15214 /* Special offset to indicate a NULL call target */
15215 #define TAIL_CALL_NULL 0x7fff
15216
15217 /* Special offset to indicate an out-of-range index */
15218 #define TAIL_CALL_INVALID 0x7ffe
15219
15220 #define TAIL_CALL(offset)                              \
15221         BPF_LD_IMM64(R2, TAIL_CALL_MARKER),            \
15222         BPF_RAW_INSN(BPF_ALU | BPF_MOV | BPF_K, R3, 0, \
15223                      offset, TAIL_CALL_MARKER),        \
15224         BPF_JMP_IMM(BPF_TAIL_CALL, 0, 0, 0)
15225
15226 /*
15227  * A test function to be called from a BPF program, clobbering a lot of
15228  * CPU registers in the process. A JITed BPF program calling this function
15229  * must save and restore any caller-saved registers it uses for internal
15230  * state, for example the current tail call count.
15231  */
15232 BPF_CALL_1(bpf_test_func, u64, arg)
15233 {
15234         char buf[64];
15235         long a = 0;
15236         long b = 1;
15237         long c = 2;
15238         long d = 3;
15239         long e = 4;
15240         long f = 5;
15241         long g = 6;
15242         long h = 7;
15243
15244         return snprintf(buf, sizeof(buf),
15245                         "%ld %lu %lx %ld %lu %lx %ld %lu %x",
15246                         a, b, c, d, e, f, g, h, (int)arg);
15247 }
15248 #define BPF_FUNC_test_func __BPF_FUNC_MAX_ID
15249
15250 /*
15251  * Tail call tests. Each test case may call any other test in the table,
15252  * including itself, specified as a relative index offset from the calling
15253  * test. The index TAIL_CALL_NULL can be used to specify a NULL target
15254  * function to test the JIT error path. Similarly, the index TAIL_CALL_INVALID
15255  * results in a target index that is out of range.
15256  */
15257 static struct tail_call_test tail_call_tests[] = {
15258         {
15259                 "Tail call leaf",
15260                 .insns = {
15261                         BPF_ALU64_REG(BPF_MOV, R0, R1),
15262                         BPF_ALU64_IMM(BPF_ADD, R0, 1),
15263                         BPF_EXIT_INSN(),
15264                 },
15265                 .result = 1,
15266         },
15267         {
15268                 "Tail call 2",
15269                 .insns = {
15270                         BPF_ALU64_IMM(BPF_ADD, R1, 2),
15271                         TAIL_CALL(-1),
15272                         BPF_ALU64_IMM(BPF_MOV, R0, -1),
15273                         BPF_EXIT_INSN(),
15274                 },
15275                 .result = 3,
15276         },
15277         {
15278                 "Tail call 3",
15279                 .insns = {
15280                         BPF_ALU64_IMM(BPF_ADD, R1, 3),
15281                         TAIL_CALL(-1),
15282                         BPF_ALU64_IMM(BPF_MOV, R0, -1),
15283                         BPF_EXIT_INSN(),
15284                 },
15285                 .result = 6,
15286         },
15287         {
15288                 "Tail call 4",
15289                 .insns = {
15290                         BPF_ALU64_IMM(BPF_ADD, R1, 4),
15291                         TAIL_CALL(-1),
15292                         BPF_ALU64_IMM(BPF_MOV, R0, -1),
15293                         BPF_EXIT_INSN(),
15294                 },
15295                 .result = 10,
15296         },
15297         {
15298                 "Tail call load/store leaf",
15299                 .insns = {
15300                         BPF_ALU64_IMM(BPF_MOV, R1, 1),
15301                         BPF_ALU64_IMM(BPF_MOV, R2, 2),
15302                         BPF_ALU64_REG(BPF_MOV, R3, BPF_REG_FP),
15303                         BPF_STX_MEM(BPF_DW, R3, R1, -8),
15304                         BPF_STX_MEM(BPF_DW, R3, R2, -16),
15305                         BPF_LDX_MEM(BPF_DW, R0, BPF_REG_FP, -8),
15306                         BPF_JMP_REG(BPF_JNE, R0, R1, 3),
15307                         BPF_LDX_MEM(BPF_DW, R0, BPF_REG_FP, -16),
15308                         BPF_JMP_REG(BPF_JNE, R0, R2, 1),
15309                         BPF_ALU64_IMM(BPF_MOV, R0, 0),
15310                         BPF_EXIT_INSN(),
15311                 },
15312                 .result = 0,
15313                 .stack_depth = 32,
15314         },
15315         {
15316                 "Tail call load/store",
15317                 .insns = {
15318                         BPF_ALU64_IMM(BPF_MOV, R0, 3),
15319                         BPF_STX_MEM(BPF_DW, BPF_REG_FP, R0, -8),
15320                         TAIL_CALL(-1),
15321                         BPF_ALU64_IMM(BPF_MOV, R0, -1),
15322                         BPF_EXIT_INSN(),
15323                 },
15324                 .result = 0,
15325                 .stack_depth = 16,
15326         },
15327         {
15328                 "Tail call error path, max count reached",
15329                 .insns = {
15330                         BPF_LDX_MEM(BPF_W, R2, R1, 0),
15331                         BPF_ALU64_IMM(BPF_ADD, R2, 1),
15332                         BPF_STX_MEM(BPF_W, R1, R2, 0),
15333                         TAIL_CALL(0),
15334                         BPF_EXIT_INSN(),
15335                 },
15336                 .flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE,
15337                 .result = (MAX_TAIL_CALL_CNT + 1) * MAX_TESTRUNS,
15338         },
15339         {
15340                 "Tail call count preserved across function calls",
15341                 .insns = {
15342                         BPF_LDX_MEM(BPF_W, R2, R1, 0),
15343                         BPF_ALU64_IMM(BPF_ADD, R2, 1),
15344                         BPF_STX_MEM(BPF_W, R1, R2, 0),
15345                         BPF_STX_MEM(BPF_DW, R10, R1, -8),
15346                         BPF_CALL_REL(BPF_FUNC_get_numa_node_id),
15347                         BPF_CALL_REL(BPF_FUNC_ktime_get_ns),
15348                         BPF_CALL_REL(BPF_FUNC_ktime_get_boot_ns),
15349                         BPF_CALL_REL(BPF_FUNC_ktime_get_coarse_ns),
15350                         BPF_CALL_REL(BPF_FUNC_jiffies64),
15351                         BPF_CALL_REL(BPF_FUNC_test_func),
15352                         BPF_LDX_MEM(BPF_DW, R1, R10, -8),
15353                         BPF_ALU32_REG(BPF_MOV, R0, R1),
15354                         TAIL_CALL(0),
15355                         BPF_EXIT_INSN(),
15356                 },
15357                 .stack_depth = 8,
15358                 .flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE,
15359                 .result = (MAX_TAIL_CALL_CNT + 1) * MAX_TESTRUNS,
15360         },
15361         {
15362                 "Tail call error path, NULL target",
15363                 .insns = {
15364                         BPF_LDX_MEM(BPF_W, R2, R1, 0),
15365                         BPF_ALU64_IMM(BPF_ADD, R2, 1),
15366                         BPF_STX_MEM(BPF_W, R1, R2, 0),
15367                         TAIL_CALL(TAIL_CALL_NULL),
15368                         BPF_EXIT_INSN(),
15369                 },
15370                 .flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE,
15371                 .result = MAX_TESTRUNS,
15372         },
15373         {
15374                 "Tail call error path, index out of range",
15375                 .insns = {
15376                         BPF_LDX_MEM(BPF_W, R2, R1, 0),
15377                         BPF_ALU64_IMM(BPF_ADD, R2, 1),
15378                         BPF_STX_MEM(BPF_W, R1, R2, 0),
15379                         TAIL_CALL(TAIL_CALL_INVALID),
15380                         BPF_EXIT_INSN(),
15381                 },
15382                 .flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE,
15383                 .result = MAX_TESTRUNS,
15384         },
15385 };
15386
15387 static void __init destroy_tail_call_tests(struct bpf_array *progs)
15388 {
15389         int i;
15390
15391         for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++)
15392                 if (progs->ptrs[i])
15393                         bpf_prog_free(progs->ptrs[i]);
15394         kfree(progs);
15395 }
15396
15397 static __init int prepare_tail_call_tests(struct bpf_array **pprogs)
15398 {
15399         int ntests = ARRAY_SIZE(tail_call_tests);
15400         struct bpf_array *progs;
15401         int which, err;
15402
15403         /* Allocate the table of programs to be used for tail calls */
15404         progs = kzalloc(struct_size(progs, ptrs, ntests + 1), GFP_KERNEL);
15405         if (!progs)
15406                 goto out_nomem;
15407
15408         /* Create all eBPF programs and populate the table */
15409         for (which = 0; which < ntests; which++) {
15410                 struct tail_call_test *test = &tail_call_tests[which];
15411                 struct bpf_prog *fp;
15412                 int len, i;
15413
15414                 /* Compute the number of program instructions */
15415                 for (len = 0; len < MAX_INSNS; len++) {
15416                         struct bpf_insn *insn = &test->insns[len];
15417
15418                         if (len < MAX_INSNS - 1 &&
15419                             insn->code == (BPF_LD | BPF_DW | BPF_IMM))
15420                                 len++;
15421                         if (insn->code == 0)
15422                                 break;
15423                 }
15424
15425                 /* Allocate and initialize the program */
15426                 fp = bpf_prog_alloc(bpf_prog_size(len), 0);
15427                 if (!fp)
15428                         goto out_nomem;
15429
15430                 fp->len = len;
15431                 fp->type = BPF_PROG_TYPE_SOCKET_FILTER;
15432                 fp->aux->stack_depth = test->stack_depth;
15433                 memcpy(fp->insnsi, test->insns, len * sizeof(struct bpf_insn));
15434
15435                 /* Relocate runtime tail call offsets and addresses */
15436                 for (i = 0; i < len; i++) {
15437                         struct bpf_insn *insn = &fp->insnsi[i];
15438                         long addr = 0;
15439
15440                         switch (insn->code) {
15441                         case BPF_LD | BPF_DW | BPF_IMM:
15442                                 if (insn->imm != TAIL_CALL_MARKER)
15443                                         break;
15444                                 insn[0].imm = (u32)(long)progs;
15445                                 insn[1].imm = ((u64)(long)progs) >> 32;
15446                                 break;
15447
15448                         case BPF_ALU | BPF_MOV | BPF_K:
15449                                 if (insn->imm != TAIL_CALL_MARKER)
15450                                         break;
15451                                 if (insn->off == TAIL_CALL_NULL)
15452                                         insn->imm = ntests;
15453                                 else if (insn->off == TAIL_CALL_INVALID)
15454                                         insn->imm = ntests + 1;
15455                                 else
15456                                         insn->imm = which + insn->off;
15457                                 insn->off = 0;
15458                                 break;
15459
15460                         case BPF_JMP | BPF_CALL:
15461                                 if (insn->src_reg != BPF_PSEUDO_CALL)
15462                                         break;
15463                                 switch (insn->imm) {
15464                                 case BPF_FUNC_get_numa_node_id:
15465                                         addr = (long)&numa_node_id;
15466                                         break;
15467                                 case BPF_FUNC_ktime_get_ns:
15468                                         addr = (long)&ktime_get_ns;
15469                                         break;
15470                                 case BPF_FUNC_ktime_get_boot_ns:
15471                                         addr = (long)&ktime_get_boot_fast_ns;
15472                                         break;
15473                                 case BPF_FUNC_ktime_get_coarse_ns:
15474                                         addr = (long)&ktime_get_coarse_ns;
15475                                         break;
15476                                 case BPF_FUNC_jiffies64:
15477                                         addr = (long)&get_jiffies_64;
15478                                         break;
15479                                 case BPF_FUNC_test_func:
15480                                         addr = (long)&bpf_test_func;
15481                                         break;
15482                                 default:
15483                                         err = -EFAULT;
15484                                         goto out_err;
15485                                 }
15486                                 *insn = BPF_EMIT_CALL(addr);
15487                                 if ((long)__bpf_call_base + insn->imm != addr)
15488                                         *insn = BPF_JMP_A(0); /* Skip: NOP */
15489                                 break;
15490                         }
15491                 }
15492
15493                 fp = bpf_prog_select_runtime(fp, &err);
15494                 if (err)
15495                         goto out_err;
15496
15497                 progs->ptrs[which] = fp;
15498         }
15499
15500         /* The last entry contains a NULL program pointer */
15501         progs->map.max_entries = ntests + 1;
15502         *pprogs = progs;
15503         return 0;
15504
15505 out_nomem:
15506         err = -ENOMEM;
15507
15508 out_err:
15509         if (progs)
15510                 destroy_tail_call_tests(progs);
15511         return err;
15512 }
15513
15514 static __init int test_tail_calls(struct bpf_array *progs)
15515 {
15516         int i, err_cnt = 0, pass_cnt = 0;
15517         int jit_cnt = 0, run_cnt = 0;
15518
15519         for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++) {
15520                 struct tail_call_test *test = &tail_call_tests[i];
15521                 struct bpf_prog *fp = progs->ptrs[i];
15522                 int *data = NULL;
15523                 int state = 0;
15524                 u64 duration;
15525                 int ret;
15526
15527                 cond_resched();
15528                 if (exclude_test(i))
15529                         continue;
15530
15531                 pr_info("#%d %s ", i, test->descr);
15532                 if (!fp) {
15533                         err_cnt++;
15534                         continue;
15535                 }
15536                 pr_cont("jited:%u ", fp->jited);
15537
15538                 run_cnt++;
15539                 if (fp->jited)
15540                         jit_cnt++;
15541
15542                 if (test->flags & FLAG_NEED_STATE)
15543                         data = &state;
15544                 ret = __run_one(fp, data, MAX_TESTRUNS, &duration);
15545                 if (test->flags & FLAG_RESULT_IN_STATE)
15546                         ret = state;
15547                 if (ret == test->result) {
15548                         pr_cont("%lld PASS", duration);
15549                         pass_cnt++;
15550                 } else {
15551                         pr_cont("ret %d != %d FAIL", ret, test->result);
15552                         err_cnt++;
15553                 }
15554         }
15555
15556         pr_info("%s: Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n",
15557                 __func__, pass_cnt, err_cnt, jit_cnt, run_cnt);
15558
15559         return err_cnt ? -EINVAL : 0;
15560 }
15561
15562 static char test_suite[32];
15563 module_param_string(test_suite, test_suite, sizeof(test_suite), 0);
15564
15565 static __init int find_test_index(const char *test_name)
15566 {
15567         int i;
15568
15569         if (!strcmp(test_suite, "test_bpf")) {
15570                 for (i = 0; i < ARRAY_SIZE(tests); i++) {
15571                         if (!strcmp(tests[i].descr, test_name))
15572                                 return i;
15573                 }
15574         }
15575
15576         if (!strcmp(test_suite, "test_tail_calls")) {
15577                 for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++) {
15578                         if (!strcmp(tail_call_tests[i].descr, test_name))
15579                                 return i;
15580                 }
15581         }
15582
15583         if (!strcmp(test_suite, "test_skb_segment")) {
15584                 for (i = 0; i < ARRAY_SIZE(skb_segment_tests); i++) {
15585                         if (!strcmp(skb_segment_tests[i].descr, test_name))
15586                                 return i;
15587                 }
15588         }
15589
15590         return -1;
15591 }
15592
15593 static __init int prepare_test_range(void)
15594 {
15595         int valid_range;
15596
15597         if (!strcmp(test_suite, "test_bpf"))
15598                 valid_range = ARRAY_SIZE(tests);
15599         else if (!strcmp(test_suite, "test_tail_calls"))
15600                 valid_range = ARRAY_SIZE(tail_call_tests);
15601         else if (!strcmp(test_suite, "test_skb_segment"))
15602                 valid_range = ARRAY_SIZE(skb_segment_tests);
15603         else
15604                 return 0;
15605
15606         if (test_id >= 0) {
15607                 /*
15608                  * if a test_id was specified, use test_range to
15609                  * cover only that test.
15610                  */
15611                 if (test_id >= valid_range) {
15612                         pr_err("test_bpf: invalid test_id specified for '%s' suite.\n",
15613                                test_suite);
15614                         return -EINVAL;
15615                 }
15616
15617                 test_range[0] = test_id;
15618                 test_range[1] = test_id;
15619         } else if (*test_name) {
15620                 /*
15621                  * if a test_name was specified, find it and setup
15622                  * test_range to cover only that test.
15623                  */
15624                 int idx = find_test_index(test_name);
15625
15626                 if (idx < 0) {
15627                         pr_err("test_bpf: no test named '%s' found for '%s' suite.\n",
15628                                test_name, test_suite);
15629                         return -EINVAL;
15630                 }
15631                 test_range[0] = idx;
15632                 test_range[1] = idx;
15633         } else if (test_range[0] != 0 || test_range[1] != INT_MAX) {
15634                 /*
15635                  * check that the supplied test_range is valid.
15636                  */
15637                 if (test_range[0] < 0 || test_range[1] >= valid_range) {
15638                         pr_err("test_bpf: test_range is out of bound for '%s' suite.\n",
15639                                test_suite);
15640                         return -EINVAL;
15641                 }
15642
15643                 if (test_range[1] < test_range[0]) {
15644                         pr_err("test_bpf: test_range is ending before it starts.\n");
15645                         return -EINVAL;
15646                 }
15647         }
15648
15649         return 0;
15650 }
15651
15652 static int __init test_bpf_init(void)
15653 {
15654         struct bpf_array *progs = NULL;
15655         int ret;
15656
15657         if (strlen(test_suite) &&
15658             strcmp(test_suite, "test_bpf") &&
15659             strcmp(test_suite, "test_tail_calls") &&
15660             strcmp(test_suite, "test_skb_segment")) {
15661                 pr_err("test_bpf: invalid test_suite '%s' specified.\n", test_suite);
15662                 return -EINVAL;
15663         }
15664
15665         /*
15666          * if test_suite is not specified, but test_id, test_name or test_range
15667          * is specified, set 'test_bpf' as the default test suite.
15668          */
15669         if (!strlen(test_suite) &&
15670             (test_id != -1 || strlen(test_name) ||
15671             (test_range[0] != 0 || test_range[1] != INT_MAX))) {
15672                 pr_info("test_bpf: set 'test_bpf' as the default test_suite.\n");
15673                 strscpy(test_suite, "test_bpf", sizeof(test_suite));
15674         }
15675
15676         ret = prepare_test_range();
15677         if (ret < 0)
15678                 return ret;
15679
15680         if (!strlen(test_suite) || !strcmp(test_suite, "test_bpf")) {
15681                 ret = test_bpf();
15682                 if (ret)
15683                         return ret;
15684         }
15685
15686         if (!strlen(test_suite) || !strcmp(test_suite, "test_tail_calls")) {
15687                 ret = prepare_tail_call_tests(&progs);
15688                 if (ret)
15689                         return ret;
15690                 ret = test_tail_calls(progs);
15691                 destroy_tail_call_tests(progs);
15692                 if (ret)
15693                         return ret;
15694         }
15695
15696         if (!strlen(test_suite) || !strcmp(test_suite, "test_skb_segment"))
15697                 return test_skb_segment();
15698
15699         return 0;
15700 }
15701
15702 static void __exit test_bpf_exit(void)
15703 {
15704 }
15705
15706 module_init(test_bpf_init);
15707 module_exit(test_bpf_exit);
15708
15709 MODULE_LICENSE("GPL");