lib/test_bpf.c

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