lib/test_bpf.c

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