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