contrib/netbsd-tests/lib/libbpfjit/t_bpfjit.c

   1 /*      $NetBSD: t_bpfjit.c,v 1.6 2014/07/08 21:07:52 alnsn Exp $ */
   2
   3 /*-
   4  * Copyright (c) 2011-2012, 2014 Alexander Nasonov.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in
  15  *    the documentation and/or other materials provided with the
  16  *    distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  21  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  22  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  23  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  24  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  25  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  26  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  27  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  28  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __RCSID("$NetBSD: t_bpfjit.c,v 1.6 2014/07/08 21:07:52 alnsn Exp $");
  34
  35 #include <atf-c.h>
  36 #include <stdint.h>
  37 #include <string.h>
  38
  39 #include <net/bpf.h>
  40 #include <net/bpfjit.h>
  41
  42 static uint8_t deadbeef_at_5[16] = {
  43         0, 0xf1, 2, 0xf3, 4, 0xde, 0xad, 0xbe, 0xef, 0xff
  44 };
  45
  46 static inline
  47 unsigned int jitcall(bpfjit_func_t fn,
  48     const uint8_t *pkt, unsigned int wirelen, unsigned int buflen)
  49 {
  50         bpf_args_t args;
  51
  52         args.pkt = pkt;
  53         args.wirelen = wirelen;
  54         args.buflen = buflen;
  55
  56         return fn(NULL, &args);
  57 }
  58
  59 ATF_TC(libbpfjit_empty);
  60 ATF_TC_HEAD(libbpfjit_empty, tc)
  61 {
  62         atf_tc_set_md_var(tc, "descr",
  63             "Test that JIT compilation of an empty bpf program fails");
  64 }
  65
  66 ATF_TC_BODY(libbpfjit_empty, tc)
  67 {
  68         struct bpf_insn dummy;
  69
  70         ATF_CHECK(bpfjit_generate_code(NULL, &dummy, 0) == NULL);
  71 }
  72
  73 ATF_TC(libbpfjit_alu_add_k);
  74 ATF_TC_HEAD(libbpfjit_alu_add_k, tc)
  75 {
  76         atf_tc_set_md_var(tc, "descr",
  77             "Test JIT compilation of BPF_ALU+BPF_ADD+BPF_K");
  78 }
  79
  80 ATF_TC_BODY(libbpfjit_alu_add_k, tc)
  81 {
  82         static struct bpf_insn insns[] = {
  83                 BPF_STMT(BPF_LD+BPF_IMM, 3),
  84                 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 2),
  85                 BPF_STMT(BPF_RET+BPF_A, 0)
  86         };
  87
  88         bpfjit_func_t code;
  89         uint8_t pkt[1]; /* the program doesn't read any data */
  90
  91         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
  92
  93         ATF_CHECK(bpf_validate(insns, insn_count));
  94
  95         code = bpfjit_generate_code(NULL, insns, insn_count);
  96         ATF_REQUIRE(code != NULL);
  97
  98         ATF_CHECK(jitcall(code, pkt, 1, 1) == 5);
  99
 100         bpfjit_free_code(code);
 101 }
 102
 103 ATF_TC(libbpfjit_alu_sub_k);
 104 ATF_TC_HEAD(libbpfjit_alu_sub_k, tc)
 105 {
 106         atf_tc_set_md_var(tc, "descr",
 107             "Test JIT compilation of BPF_ALU+BPF_SUB+BPF_K");
 108 }
 109
 110 ATF_TC_BODY(libbpfjit_alu_sub_k, tc)
 111 {
 112         static struct bpf_insn insns[] = {
 113                 BPF_STMT(BPF_LD+BPF_IMM, 1),
 114                 BPF_STMT(BPF_ALU+BPF_SUB+BPF_K, 2),
 115                 BPF_STMT(BPF_RET+BPF_A, 0)
 116         };
 117
 118         bpfjit_func_t code;
 119         uint8_t pkt[1]; /* the program doesn't read any data */
 120
 121         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
 122
 123         ATF_CHECK(bpf_validate(insns, insn_count));
 124
 125         code = bpfjit_generate_code(NULL, insns, insn_count);
 126         ATF_REQUIRE(code != NULL);
 127
 128         ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_MAX);
 129
 130         bpfjit_free_code(code);
 131 }
 132
 133 ATF_TC(libbpfjit_alu_mul_k);
 134 ATF_TC_HEAD(libbpfjit_alu_mul_k, tc)
 135 {
 136         atf_tc_set_md_var(tc, "descr",
 137             "Test JIT compilation of BPF_ALU+BPF_MUL+BPF_K");
 138 }
 139
 140 ATF_TC_BODY(libbpfjit_alu_mul_k, tc)
 141 {
 142         static struct bpf_insn insns[] = {
 143                 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0xffffffff)),
 144                 BPF_STMT(BPF_ALU+BPF_MUL+BPF_K, 3),
 145                 BPF_STMT(BPF_RET+BPF_A, 0)
 146         };
 147
 148         bpfjit_func_t code;
 149         uint8_t pkt[1]; /* the program doesn't read any data */
 150
 151         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
 152
 153         ATF_CHECK(bpf_validate(insns, insn_count));
 154
 155         code = bpfjit_generate_code(NULL, insns, insn_count);
 156         ATF_REQUIRE(code != NULL);
 157
 158         ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_C(0xfffffffd));
 159
 160         bpfjit_free_code(code);
 161 }
 162
 163 ATF_TC(libbpfjit_alu_div0_k);
 164 ATF_TC_HEAD(libbpfjit_alu_div0_k, tc)
 165 {
 166         atf_tc_set_md_var(tc, "descr",
 167             "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=0");
 168 }
 169
 170 ATF_TC_BODY(libbpfjit_alu_div0_k, tc)
 171 {
 172         static struct bpf_insn insns[] = {
 173                 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 0),
 174                 BPF_STMT(BPF_RET+BPF_A, 0)
 175         };
 176
 177         bpfjit_func_t code;
 178         uint8_t pkt[1]; /* the program doesn't read any data */
 179
 180         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
 181
 182         //ATF_CHECK(bpf_validate(insns, insn_count));
 183
 184         code = bpfjit_generate_code(NULL, insns, insn_count);
 185         ATF_REQUIRE(code != NULL);
 186
 187         ATF_CHECK(jitcall(code, pkt, 1, 1) == 0);
 188
 189         bpfjit_free_code(code);
 190 }
 191
 192 ATF_TC(libbpfjit_alu_div1_k);
 193 ATF_TC_HEAD(libbpfjit_alu_div1_k, tc)
 194 {
 195         atf_tc_set_md_var(tc, "descr",
 196             "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=1");
 197 }
 198
 199 ATF_TC_BODY(libbpfjit_alu_div1_k, tc)
 200 {
 201         static struct bpf_insn insns[] = {
 202                 BPF_STMT(BPF_LD+BPF_IMM, 7),
 203                 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 1),
 204                 BPF_STMT(BPF_RET+BPF_A, 0)
 205         };
 206
 207         bpfjit_func_t code;
 208         uint8_t pkt[1]; /* the program doesn't read any data */
 209
 210         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
 211
 212         ATF_CHECK(bpf_validate(insns, insn_count));
 213
 214         code = bpfjit_generate_code(NULL, insns, insn_count);
 215         ATF_REQUIRE(code != NULL);
 216
 217         ATF_CHECK(jitcall(code, pkt, 1, 1) == 7);
 218
 219         bpfjit_free_code(code);
 220 }
 221
 222 ATF_TC(libbpfjit_alu_div2_k);
 223 ATF_TC_HEAD(libbpfjit_alu_div2_k, tc)
 224 {
 225         atf_tc_set_md_var(tc, "descr",
 226             "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=2");
 227 }
 228
 229 ATF_TC_BODY(libbpfjit_alu_div2_k, tc)
 230 {
 231         static struct bpf_insn insns[] = {
 232                 BPF_STMT(BPF_LD+BPF_IMM, 7),
 233                 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 2),
 234                 BPF_STMT(BPF_RET+BPF_A, 0)
 235         };
 236
 237         bpfjit_func_t code;
 238         uint8_t pkt[1]; /* the program doesn't read any data */
 239
 240         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
 241
 242         ATF_CHECK(bpf_validate(insns, insn_count));
 243
 244         code = bpfjit_generate_code(NULL, insns, insn_count);
 245         ATF_REQUIRE(code != NULL);
 246
 247         ATF_CHECK(jitcall(code, pkt, 1, 1) == 3);
 248
 249         bpfjit_free_code(code);
 250 }
 251
 252 ATF_TC(libbpfjit_alu_div4_k);
 253 ATF_TC_HEAD(libbpfjit_alu_div4_k, tc)
 254 {
 255         atf_tc_set_md_var(tc, "descr",
 256             "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=4");
 257 }
 258
 259 ATF_TC_BODY(libbpfjit_alu_div4_k, tc)
 260 {
 261         static struct bpf_insn insns[] = {
 262                 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0xffffffff)),
 263                 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 4),
 264                 BPF_STMT(BPF_RET+BPF_A, 0)
 265         };
 266
 267         bpfjit_func_t code;
 268         uint8_t pkt[1]; /* the program doesn't read any data */
 269
 270         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
 271
 272         ATF_CHECK(bpf_validate(insns, insn_count));
 273
 274         code = bpfjit_generate_code(NULL, insns, insn_count);
 275         ATF_REQUIRE(code != NULL);
 276
 277         ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_C(0x3fffffff));
 278
 279         bpfjit_free_code(code);
 280 }
 281
 282 ATF_TC(libbpfjit_alu_div10_k);
 283 ATF_TC_HEAD(libbpfjit_alu_div10_k, tc)
 284 {
 285         atf_tc_set_md_var(tc, "descr",
 286             "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=10");
 287 }
 288
 289 ATF_TC_BODY(libbpfjit_alu_div10_k, tc)
 290 {
 291         static struct bpf_insn insns[] = {
 292                 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(4294843849)),
 293                 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 10),
 294                 BPF_STMT(BPF_RET+BPF_A, 0)
 295         };
 296
 297         bpfjit_func_t code;
 298         uint8_t pkt[1]; /* the program doesn't read any data */
 299
 300         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
 301
 302         ATF_CHECK(bpf_validate(insns, insn_count));
 303
 304         code = bpfjit_generate_code(NULL, insns, insn_count);
 305         ATF_REQUIRE(code != NULL);
 306
 307         ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_C(429484384));
 308
 309         bpfjit_free_code(code);
 310 }
 311
 312 ATF_TC(libbpfjit_alu_div10000_k);
 313 ATF_TC_HEAD(libbpfjit_alu_div10000_k, tc)
 314 {
 315         atf_tc_set_md_var(tc, "descr",
 316             "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=10000");
 317 }
 318
 319 ATF_TC_BODY(libbpfjit_alu_div10000_k, tc)
 320 {
 321         static struct bpf_insn insns[] = {
 322                 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(4294843849)),
 323                 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 10000),
 324                 BPF_STMT(BPF_RET+BPF_A, 0)
 325         };
 326
 327         bpfjit_func_t code;
 328         uint8_t pkt[1]; /* the program doesn't read any data */
 329
 330         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
 331
 332         ATF_CHECK(bpf_validate(insns, insn_count));
 333
 334         code = bpfjit_generate_code(NULL, insns, insn_count);
 335         ATF_REQUIRE(code != NULL);
 336
 337         ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_C(429484));
 338
 339         bpfjit_free_code(code);
 340 }
 341
 342 ATF_TC(libbpfjit_alu_div7609801_k);
 343 ATF_TC_HEAD(libbpfjit_alu_div7609801_k, tc)
 344 {
 345         atf_tc_set_md_var(tc, "descr",
 346             "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=7609801");
 347 }
 348
 349 ATF_TC_BODY(libbpfjit_alu_div7609801_k, tc)
 350 {
 351         static struct bpf_insn insns[] = {
 352                 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(4294967295)),
 353                 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, UINT32_C(7609801)),
 354                 BPF_STMT(BPF_RET+BPF_A, 0)
 355         };
 356
 357         bpfjit_func_t code;
 358         uint8_t pkt[1]; /* the program doesn't read any data */
 359
 360         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
 361
 362         ATF_CHECK(bpf_validate(insns, insn_count));
 363
 364         code = bpfjit_generate_code(NULL, insns, insn_count);
 365         ATF_REQUIRE(code != NULL);
 366
 367         ATF_CHECK(jitcall(code, pkt, 1, 1) == 564);
 368
 369         bpfjit_free_code(code);
 370 }
 371
 372 ATF_TC(libbpfjit_alu_div80000000_k);
 373 ATF_TC_HEAD(libbpfjit_alu_div80000000_k, tc)
 374 {
 375         atf_tc_set_md_var(tc, "descr",
 376             "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=0x80000000");
 377 }
 378
 379 ATF_TC_BODY(libbpfjit_alu_div80000000_k, tc)
 380 {
 381         static struct bpf_insn insns[] = {
 382                 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0xffffffde)),
 383                 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, UINT32_C(0x80000000)),
 384                 BPF_STMT(BPF_RET+BPF_A, 0)
 385         };
 386
 387         bpfjit_func_t code;
 388         uint8_t pkt[1]; /* the program doesn't read any data */
 389
 390         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
 391
 392         ATF_CHECK(bpf_validate(insns, insn_count));
 393
 394         code = bpfjit_generate_code(NULL, insns, insn_count);
 395         ATF_REQUIRE(code != NULL);
 396
 397         ATF_CHECK(jitcall(code, pkt, 1, 1) == 1);
 398
 399         bpfjit_free_code(code);
 400 }
 401
 402 ATF_TC(libbpfjit_alu_and_k);
 403 ATF_TC_HEAD(libbpfjit_alu_and_k, tc)
 404 {
 405         atf_tc_set_md_var(tc, "descr",
 406             "Test JIT compilation of BPF_ALU+BPF_AND+BPF_K");
 407 }
 408
 409 ATF_TC_BODY(libbpfjit_alu_and_k, tc)
 410 {
 411         static struct bpf_insn insns[] = {
 412                 BPF_STMT(BPF_LD+BPF_IMM, 0xdead),
 413                 BPF_STMT(BPF_ALU+BPF_AND+BPF_K, 0xbeef),
 414                 BPF_STMT(BPF_RET+BPF_A, 0)
 415         };
 416
 417         bpfjit_func_t code;
 418         uint8_t pkt[1]; /* the program doesn't read any data */
 419
 420         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
 421
 422         ATF_CHECK(bpf_validate(insns, insn_count));
 423
 424         code = bpfjit_generate_code(NULL, insns, insn_count);
 425         ATF_REQUIRE(code != NULL);
 426
 427         ATF_CHECK(jitcall(code, pkt, 1, 1) == (0xdead&0xbeef));
 428
 429         bpfjit_free_code(code);
 430 }
 431
 432 ATF_TC(libbpfjit_alu_or_k);
 433 ATF_TC_HEAD(libbpfjit_alu_or_k, tc)
 434 {
 435         atf_tc_set_md_var(tc, "descr",
 436             "Test JIT compilation of BPF_ALU+BPF_OR+BPF_K");
 437 }
 438
 439 ATF_TC_BODY(libbpfjit_alu_or_k, tc)
 440 {
 441         static struct bpf_insn insns[] = {
 442                 BPF_STMT(BPF_LD+BPF_IMM, 0xdead0000),
 443                 BPF_STMT(BPF_ALU+BPF_OR+BPF_K, 0x0000beef),
 444                 BPF_STMT(BPF_RET+BPF_A, 0)
 445         };
 446
 447         bpfjit_func_t code;
 448         uint8_t pkt[1]; /* the program doesn't read any data */
 449
 450         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
 451
 452         ATF_CHECK(bpf_validate(insns, insn_count));
 453
 454         code = bpfjit_generate_code(NULL, insns, insn_count);
 455         ATF_REQUIRE(code != NULL);
 456
 457         ATF_CHECK(jitcall(code, pkt, 1, 1) == 0xdeadbeef);
 458
 459         bpfjit_free_code(code);
 460 }
 461
 462 ATF_TC(libbpfjit_alu_lsh_k);
 463 ATF_TC_HEAD(libbpfjit_alu_lsh_k, tc)
 464 {
 465         atf_tc_set_md_var(tc, "descr",
 466             "Test JIT compilation of BPF_ALU+BPF_LSH+BPF_K");
 467 }
 468
 469 ATF_TC_BODY(libbpfjit_alu_lsh_k, tc)
 470 {
 471         static struct bpf_insn insns[] = {
 472                 BPF_STMT(BPF_LD+BPF_IMM, 0xdeadbeef),
 473                 BPF_STMT(BPF_ALU+BPF_LSH+BPF_K, 16),
 474                 BPF_STMT(BPF_RET+BPF_A, 0)
 475         };
 476
 477         bpfjit_func_t code;
 478         uint8_t pkt[1]; /* the program doesn't read any data */
 479
 480         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
 481
 482         ATF_CHECK(bpf_validate(insns, insn_count));
 483
 484         code = bpfjit_generate_code(NULL, insns, insn_count);
 485         ATF_REQUIRE(code != NULL);
 486
 487         ATF_CHECK(jitcall(code, pkt, 1, 1) == 0xbeef0000);
 488
 489         bpfjit_free_code(code);
 490 }
 491
 492 ATF_TC(libbpfjit_alu_lsh0_k);
 493 ATF_TC_HEAD(libbpfjit_alu_lsh0_k, tc)
 494 {
 495         atf_tc_set_md_var(tc, "descr",
 496             "Test JIT compilation of BPF_ALU+BPF_LSH+BPF_K with k=0");
 497 }
 498
 499 ATF_TC_BODY(libbpfjit_alu_lsh0_k, tc)
 500 {
 501         static struct bpf_insn insns[] = {
 502                 BPF_STMT(BPF_LD+BPF_IMM, 0xdeadbeef),
 503                 BPF_STMT(BPF_ALU+BPF_LSH+BPF_K, 0),
 504                 BPF_STMT(BPF_RET+BPF_A, 0)
 505         };
 506
 507         bpfjit_func_t code;
 508         uint8_t pkt[1]; /* the program doesn't read any data */
 509
 510         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
 511
 512         ATF_CHECK(bpf_validate(insns, insn_count));
 513
 514         code = bpfjit_generate_code(NULL, insns, insn_count);
 515         ATF_REQUIRE(code != NULL);
 516
 517         ATF_CHECK(jitcall(code, pkt, 1, 1) == 0xdeadbeef);
 518
 519         bpfjit_free_code(code);
 520 }
 521
 522 ATF_TC(libbpfjit_alu_rsh_k);
 523 ATF_TC_HEAD(libbpfjit_alu_rsh_k, tc)
 524 {
 525         atf_tc_set_md_var(tc, "descr",
 526             "Test JIT compilation of BPF_ALU+BPF_RSH+BPF_K");
 527 }
 528
 529 ATF_TC_BODY(libbpfjit_alu_rsh_k, tc)
 530 {
 531         static struct bpf_insn insns[] = {
 532                 BPF_STMT(BPF_LD+BPF_IMM, 0xdeadbeef),
 533                 BPF_STMT(BPF_ALU+BPF_RSH+BPF_K, 16),
 534                 BPF_STMT(BPF_RET+BPF_A, 0)
 535         };
 536
 537         bpfjit_func_t code;
 538         uint8_t pkt[1]; /* the program doesn't read any data */
 539
 540         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
 541
 542         ATF_CHECK(bpf_validate(insns, insn_count));
 543
 544         code = bpfjit_generate_code(NULL, insns, insn_count);
 545         ATF_REQUIRE(code != NULL);
 546
 547         ATF_CHECK(jitcall(code, pkt, 1, 1) == 0x0000dead);
 548
 549         bpfjit_free_code(code);
 550 }
 551
 552 ATF_TC(libbpfjit_alu_rsh0_k);
 553 ATF_TC_HEAD(libbpfjit_alu_rsh0_k, tc)
 554 {
 555         atf_tc_set_md_var(tc, "descr",
 556             "Test JIT compilation of BPF_ALU+BPF_RSH+BPF_K with k=0");
 557 }
 558
 559 ATF_TC_BODY(libbpfjit_alu_rsh0_k, tc)
 560 {
 561         static struct bpf_insn insns[] = {
 562                 BPF_STMT(BPF_LD+BPF_IMM, 0xdeadbeef),
 563                 BPF_STMT(BPF_ALU+BPF_RSH+BPF_K, 0),
 564                 BPF_STMT(BPF_RET+BPF_A, 0)
 565         };
 566
 567         bpfjit_func_t code;
 568         uint8_t pkt[1]; /* the program doesn't read any data */
 569
 570         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
 571
 572         ATF_CHECK(bpf_validate(insns, insn_count));
 573
 574         code = bpfjit_generate_code(NULL, insns, insn_count);
 575         ATF_REQUIRE(code != NULL);
 576
 577         ATF_CHECK(jitcall(code, pkt, 1, 1) == 0xdeadbeef);
 578
 579         bpfjit_free_code(code);
 580 }
 581
 582 ATF_TC(libbpfjit_alu_modulo_k);
 583 ATF_TC_HEAD(libbpfjit_alu_modulo_k, tc)
 584 {
 585         atf_tc_set_md_var(tc, "descr",
 586             "Test JIT compilation of modulo logic of BPF_ALU+BPF_K operations");
 587 }
 588
 589 ATF_TC_BODY(libbpfjit_alu_modulo_k, tc)
 590 {
 591         static struct bpf_insn insns[] = {
 592                 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0x7fffff77)),
 593
 594                 /* (7FFFFF77 * 0FFFFF77) = 07FFFFB2,F0004951 */
 595                 BPF_STMT(BPF_ALU+BPF_MUL+BPF_K, UINT32_C(0x0fffff77)),
 596
 597                 /* 07FFFFB2,F0004951 << 1 = 0FFFFF65,E00092A2 */
 598                 BPF_STMT(BPF_ALU+BPF_LSH+BPF_K, 1),
 599
 600                 /* 0FFFFF65,E00092A2 + DDDDDDDD = 0FFFFF66,BDDE707F */
 601                 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, UINT32_C(0xdddddddd)),
 602
 603                 /* 0FFFFF66,BDDE707F - FFFFFFFF = 0FFFFF65,BDDE7080 */
 604                 BPF_STMT(BPF_ALU+BPF_SUB+BPF_K, UINT32_C(0xffffffff)),
 605
 606                 /* 0FFFFF65,BDDE7080 | 0000030C = 0FFFFF65,BDDE738C */
 607                 BPF_STMT(BPF_ALU+BPF_OR+BPF_K, UINT32_C(0x0000030c)),
 608
 609                 /* -0FFFFF65,BDDE738C mod(2^64) = F000009A,42218C74 */
 610                 BPF_STMT(BPF_ALU+BPF_NEG, 0),
 611
 612                 /* F000009A,42218C74 & FFFFFF0F = F000009A,42218C04 */
 613                 BPF_STMT(BPF_ALU+BPF_AND+BPF_K, UINT32_C(0xffffff0f)),
 614
 615                 /* F000009A,42218C74 >> 3 = 1E000013,48443180 */
 616                 /* 00000000,42218C74 >> 3 = 00000000,08443180 */
 617                 BPF_STMT(BPF_ALU+BPF_RSH+BPF_K, 3),
 618
 619                 /* 00000000,08443180 * 7FFFFF77 = 042218BB,93818280 */
 620                 BPF_STMT(BPF_ALU+BPF_MUL+BPF_K, UINT32_C(0x7fffff77)),
 621
 622                 /* 042218BB,93818280 / DEAD = 000004C0,71CBBBC3 */
 623                 /* 00000000,93818280 / DEAD = 00000000,0000A994 */
 624                 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, UINT32_C(0xdead)),
 625
 626                 BPF_STMT(BPF_RET+BPF_A, 0)
 627         };
 628
 629         bpfjit_func_t code;
 630         uint8_t pkt[1]; /* the program doesn't read any data */
 631
 632         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
 633
 634         ATF_CHECK(bpf_validate(insns, insn_count));
 635
 636         code = bpfjit_generate_code(NULL, insns, insn_count);
 637         ATF_REQUIRE(code != NULL);
 638
 639         ATF_CHECK(jitcall(code, pkt, 1, 1) != UINT32_C(0x71cbbbc3));
 640         ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_C(0x0000a994));
 641
 642
 643         bpfjit_free_code(code);
 644 }
 645
 646 ATF_TC(libbpfjit_alu_add_x);
 647 ATF_TC_HEAD(libbpfjit_alu_add_x, tc)
 648 {
 649         atf_tc_set_md_var(tc, "descr",
 650             "Test JIT compilation of BPF_ALU+BPF_ADD+BPF_X");
 651 }
 652
 653 ATF_TC_BODY(libbpfjit_alu_add_x, tc)
 654 {
 655         static struct bpf_insn insns[] = {
 656                 BPF_STMT(BPF_LD+BPF_IMM, 3),
 657                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 2),
 658                 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0),
 659                 BPF_STMT(BPF_RET+BPF_A, 0)
 660         };
 661
 662         bpfjit_func_t code;
 663         uint8_t pkt[1]; /* the program doesn't read any data */
 664
 665         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
 666
 667         ATF_CHECK(bpf_validate(insns, insn_count));
 668
 669         code = bpfjit_generate_code(NULL, insns, insn_count);
 670         ATF_REQUIRE(code != NULL);
 671
 672         ATF_CHECK(jitcall(code, pkt, 1, 1) == 5);
 673
 674         bpfjit_free_code(code);
 675 }
 676
 677 ATF_TC(libbpfjit_alu_sub_x);
 678 ATF_TC_HEAD(libbpfjit_alu_sub_x, tc)
 679 {
 680         atf_tc_set_md_var(tc, "descr",
 681             "Test JIT compilation of BPF_ALU+BPF_SUB+BPF_X");
 682 }
 683
 684 ATF_TC_BODY(libbpfjit_alu_sub_x, tc)
 685 {
 686         static struct bpf_insn insns[] = {
 687                 BPF_STMT(BPF_LD+BPF_IMM, 1),
 688                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 2),
 689                 BPF_STMT(BPF_ALU+BPF_SUB+BPF_X, 0),
 690                 BPF_STMT(BPF_RET+BPF_A, 0)
 691         };
 692
 693         bpfjit_func_t code;
 694         uint8_t pkt[1]; /* the program doesn't read any data */
 695
 696         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
 697
 698         ATF_CHECK(bpf_validate(insns, insn_count));
 699
 700         code = bpfjit_generate_code(NULL, insns, insn_count);
 701         ATF_REQUIRE(code != NULL);
 702
 703         ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_MAX);
 704
 705         bpfjit_free_code(code);
 706 }
 707
 708 ATF_TC(libbpfjit_alu_mul_x);
 709 ATF_TC_HEAD(libbpfjit_alu_mul_x, tc)
 710 {
 711         atf_tc_set_md_var(tc, "descr",
 712             "Test JIT compilation of BPF_ALU+BPF_MUL+BPF_X");
 713 }
 714
 715 ATF_TC_BODY(libbpfjit_alu_mul_x, tc)
 716 {
 717         static struct bpf_insn insns[] = {
 718                 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0xffffffff)),
 719                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 3),
 720                 BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0),
 721                 BPF_STMT(BPF_RET+BPF_A, 0)
 722         };
 723
 724         bpfjit_func_t code;
 725         uint8_t pkt[1]; /* the program doesn't read any data */
 726
 727         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
 728
 729         ATF_CHECK(bpf_validate(insns, insn_count));
 730
 731         code = bpfjit_generate_code(NULL, insns, insn_count);
 732         ATF_REQUIRE(code != NULL);
 733
 734         ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_C(0xfffffffd));
 735
 736         bpfjit_free_code(code);
 737 }
 738
 739 ATF_TC(libbpfjit_alu_div0_x);
 740 ATF_TC_HEAD(libbpfjit_alu_div0_x, tc)
 741 {
 742         atf_tc_set_md_var(tc, "descr",
 743             "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=0");
 744 }
 745
 746 ATF_TC_BODY(libbpfjit_alu_div0_x, tc)
 747 {
 748         static struct bpf_insn insns[] = {
 749                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0),
 750                 BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0),
 751                 BPF_STMT(BPF_RET+BPF_A, 0)
 752         };
 753
 754         bpfjit_func_t code;
 755         uint8_t pkt[1]; /* the program doesn't read any data */
 756
 757         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
 758
 759         ATF_CHECK(bpf_validate(insns, insn_count));
 760
 761         code = bpfjit_generate_code(NULL, insns, insn_count);
 762         ATF_REQUIRE(code != NULL);
 763
 764         ATF_CHECK(jitcall(code, pkt, 1, 1) == 0);
 765
 766         bpfjit_free_code(code);
 767 }
 768
 769 ATF_TC(libbpfjit_alu_div1_x);
 770 ATF_TC_HEAD(libbpfjit_alu_div1_x, tc)
 771 {
 772         atf_tc_set_md_var(tc, "descr",
 773             "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=1");
 774 }
 775
 776 ATF_TC_BODY(libbpfjit_alu_div1_x, tc)
 777 {
 778         static struct bpf_insn insns[] = {
 779                 BPF_STMT(BPF_LD+BPF_IMM, 7),
 780                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1),
 781                 BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0),
 782                 BPF_STMT(BPF_RET+BPF_A, 0)
 783         };
 784
 785         bpfjit_func_t code;
 786         uint8_t pkt[1]; /* the program doesn't read any data */
 787
 788         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
 789
 790         ATF_CHECK(bpf_validate(insns, insn_count));
 791
 792         code = bpfjit_generate_code(NULL, insns, insn_count);
 793         ATF_REQUIRE(code != NULL);
 794
 795         ATF_CHECK(jitcall(code, pkt, 1, 1) == 7);
 796
 797         bpfjit_free_code(code);
 798 }
 799
 800 ATF_TC(libbpfjit_alu_div2_x);
 801 ATF_TC_HEAD(libbpfjit_alu_div2_x, tc)
 802 {
 803         atf_tc_set_md_var(tc, "descr",
 804             "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=2");
 805 }
 806
 807 ATF_TC_BODY(libbpfjit_alu_div2_x, tc)
 808 {
 809         static struct bpf_insn insns[] = {
 810                 BPF_STMT(BPF_LD+BPF_IMM, 7),
 811                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 2),
 812                 BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0),
 813                 BPF_STMT(BPF_RET+BPF_A, 0)
 814         };
 815
 816         bpfjit_func_t code;
 817         uint8_t pkt[1]; /* the program doesn't read any data */
 818
 819         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
 820
 821         ATF_CHECK(bpf_validate(insns, insn_count));
 822
 823         code = bpfjit_generate_code(NULL, insns, insn_count);
 824         ATF_REQUIRE(code != NULL);
 825
 826         ATF_CHECK(jitcall(code, pkt, 1, 1) == 3);
 827
 828         bpfjit_free_code(code);
 829 }
 830
 831 ATF_TC(libbpfjit_alu_div4_x);
 832 ATF_TC_HEAD(libbpfjit_alu_div4_x, tc)
 833 {
 834         atf_tc_set_md_var(tc, "descr",
 835             "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=4");
 836 }
 837
 838 ATF_TC_BODY(libbpfjit_alu_div4_x, tc)
 839 {
 840         static struct bpf_insn insns[] = {
 841                 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0xffffffff)),
 842                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 4),
 843                 BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0),
 844                 BPF_STMT(BPF_RET+BPF_A, 0)
 845         };
 846
 847         bpfjit_func_t code;
 848         uint8_t pkt[1]; /* the program doesn't read any data */
 849
 850         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
 851
 852         ATF_CHECK(bpf_validate(insns, insn_count));
 853
 854         code = bpfjit_generate_code(NULL, insns, insn_count);
 855         ATF_REQUIRE(code != NULL);
 856
 857         ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_C(0x3fffffff));
 858
 859         bpfjit_free_code(code);
 860 }
 861
 862 ATF_TC(libbpfjit_alu_div10_x);
 863 ATF_TC_HEAD(libbpfjit_alu_div10_x, tc)
 864 {
 865         atf_tc_set_md_var(tc, "descr",
 866             "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=10");
 867 }
 868
 869 ATF_TC_BODY(libbpfjit_alu_div10_x, tc)
 870 {
 871         static struct bpf_insn insns[] = {
 872                 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(4294843849)),
 873                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 10),
 874                 BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0),
 875                 BPF_STMT(BPF_RET+BPF_A, 0)
 876         };
 877
 878         bpfjit_func_t code;
 879         uint8_t pkt[1]; /* the program doesn't read any data */
 880
 881         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
 882
 883         ATF_CHECK(bpf_validate(insns, insn_count));
 884
 885         code = bpfjit_generate_code(NULL, insns, insn_count);
 886         ATF_REQUIRE(code != NULL);
 887
 888         ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_C(429484384));
 889
 890         bpfjit_free_code(code);
 891 }
 892
 893 ATF_TC(libbpfjit_alu_div10000_x);
 894 ATF_TC_HEAD(libbpfjit_alu_div10000_x, tc)
 895 {
 896         atf_tc_set_md_var(tc, "descr",
 897             "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=10000");
 898 }
 899
 900 ATF_TC_BODY(libbpfjit_alu_div10000_x, tc)
 901 {
 902         static struct bpf_insn insns[] = {
 903                 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(4294843849)),
 904                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 10000),
 905                 BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0),
 906                 BPF_STMT(BPF_RET+BPF_A, 0)
 907         };
 908
 909         bpfjit_func_t code;
 910         uint8_t pkt[1]; /* the program doesn't read any data */
 911
 912         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
 913
 914         ATF_CHECK(bpf_validate(insns, insn_count));
 915
 916         code = bpfjit_generate_code(NULL, insns, insn_count);
 917         ATF_REQUIRE(code != NULL);
 918
 919         ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_C(429484));
 920
 921         bpfjit_free_code(code);
 922 }
 923
 924 ATF_TC(libbpfjit_alu_div7609801_x);
 925 ATF_TC_HEAD(libbpfjit_alu_div7609801_x, tc)
 926 {
 927         atf_tc_set_md_var(tc, "descr",
 928             "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=7609801");
 929 }
 930
 931 ATF_TC_BODY(libbpfjit_alu_div7609801_x, tc)
 932 {
 933         static struct bpf_insn insns[] = {
 934                 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(4294967295)),
 935                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(7609801)),
 936                 BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0),
 937                 BPF_STMT(BPF_RET+BPF_A, 0)
 938         };
 939
 940         bpfjit_func_t code;
 941         uint8_t pkt[1]; /* the program doesn't read any data */
 942
 943         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
 944
 945         ATF_CHECK(bpf_validate(insns, insn_count));
 946
 947         code = bpfjit_generate_code(NULL, insns, insn_count);
 948         ATF_REQUIRE(code != NULL);
 949
 950         ATF_CHECK(jitcall(code, pkt, 1, 1) == 564);
 951
 952         bpfjit_free_code(code);
 953 }
 954
 955 ATF_TC(libbpfjit_alu_div80000000_x);
 956 ATF_TC_HEAD(libbpfjit_alu_div80000000_x, tc)
 957 {
 958         atf_tc_set_md_var(tc, "descr",
 959             "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=0x80000000");
 960 }
 961
 962 ATF_TC_BODY(libbpfjit_alu_div80000000_x, tc)
 963 {
 964         static struct bpf_insn insns[] = {
 965                 BPF_STMT(BPF_LD+BPF_IMM, UINT32_MAX - 33),
 966                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0x80000000)),
 967                 BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0),
 968                 BPF_STMT(BPF_RET+BPF_A, 0)
 969         };
 970
 971         bpfjit_func_t code;
 972         uint8_t pkt[1]; /* the program doesn't read any data */
 973
 974         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
 975
 976         ATF_CHECK(bpf_validate(insns, insn_count));
 977
 978         code = bpfjit_generate_code(NULL, insns, insn_count);
 979         ATF_REQUIRE(code != NULL);
 980
 981         ATF_CHECK(jitcall(code, pkt, 1, 1) == 1);
 982
 983         bpfjit_free_code(code);
 984 }
 985
 986 ATF_TC(libbpfjit_alu_and_x);
 987 ATF_TC_HEAD(libbpfjit_alu_and_x, tc)
 988 {
 989         atf_tc_set_md_var(tc, "descr",
 990             "Test JIT compilation of BPF_ALU+BPF_AND+BPF_X");
 991 }
 992
 993 ATF_TC_BODY(libbpfjit_alu_and_x, tc)
 994 {
 995         static struct bpf_insn insns[] = {
 996                 BPF_STMT(BPF_LD+BPF_IMM, 0xdead),
 997                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0xbeef),
 998                 BPF_STMT(BPF_ALU+BPF_AND+BPF_X, 0),
 999                 BPF_STMT(BPF_RET+BPF_A, 0)
1000         };
1001
1002         bpfjit_func_t code;
1003         uint8_t pkt[1]; /* the program doesn't read any data */
1004
1005         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1006
1007         ATF_CHECK(bpf_validate(insns, insn_count));
1008
1009         code = bpfjit_generate_code(NULL, insns, insn_count);
1010         ATF_REQUIRE(code != NULL);
1011
1012         ATF_CHECK(jitcall(code, pkt, 1, 1) == (0xdead&0xbeef));
1013
1014         bpfjit_free_code(code);
1015 }
1016
1017 ATF_TC(libbpfjit_alu_or_x);
1018 ATF_TC_HEAD(libbpfjit_alu_or_x, tc)
1019 {
1020         atf_tc_set_md_var(tc, "descr",
1021             "Test JIT compilation of BPF_ALU+BPF_OR+BPF_X");
1022 }
1023
1024 ATF_TC_BODY(libbpfjit_alu_or_x, tc)
1025 {
1026         static struct bpf_insn insns[] = {
1027                 BPF_STMT(BPF_LD+BPF_IMM, 0xdead0000),
1028                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0x0000beef),
1029                 BPF_STMT(BPF_ALU+BPF_OR+BPF_X, 0),
1030                 BPF_STMT(BPF_RET+BPF_A, 0)
1031         };
1032
1033         bpfjit_func_t code;
1034         uint8_t pkt[1]; /* the program doesn't read any data */
1035
1036         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1037
1038         ATF_CHECK(bpf_validate(insns, insn_count));
1039
1040         code = bpfjit_generate_code(NULL, insns, insn_count);
1041         ATF_REQUIRE(code != NULL);
1042
1043         ATF_CHECK(jitcall(code, pkt, 1, 1) == 0xdeadbeef);
1044
1045         bpfjit_free_code(code);
1046 }
1047
1048 ATF_TC(libbpfjit_alu_lsh_x);
1049 ATF_TC_HEAD(libbpfjit_alu_lsh_x, tc)
1050 {
1051         atf_tc_set_md_var(tc, "descr",
1052             "Test JIT compilation of BPF_ALU+BPF_LSH+BPF_X");
1053 }
1054
1055 ATF_TC_BODY(libbpfjit_alu_lsh_x, tc)
1056 {
1057         static struct bpf_insn insns[] = {
1058                 BPF_STMT(BPF_LD+BPF_IMM, 0xdeadbeef),
1059                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 16),
1060                 BPF_STMT(BPF_ALU+BPF_LSH+BPF_X, 0),
1061                 BPF_STMT(BPF_RET+BPF_A, 0)
1062         };
1063
1064         bpfjit_func_t code;
1065         uint8_t pkt[1]; /* the program doesn't read any data */
1066
1067         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1068
1069         ATF_CHECK(bpf_validate(insns, insn_count));
1070
1071         code = bpfjit_generate_code(NULL, insns, insn_count);
1072         ATF_REQUIRE(code != NULL);
1073
1074         ATF_CHECK(jitcall(code, pkt, 1, 1) == 0xbeef0000);
1075
1076         bpfjit_free_code(code);
1077 }
1078
1079 ATF_TC(libbpfjit_alu_lsh0_x);
1080 ATF_TC_HEAD(libbpfjit_alu_lsh0_x, tc)
1081 {
1082         atf_tc_set_md_var(tc, "descr",
1083             "Test JIT compilation of BPF_ALU+BPF_LSH+BPF_X with k=0");
1084 }
1085
1086 ATF_TC_BODY(libbpfjit_alu_lsh0_x, tc)
1087 {
1088         static struct bpf_insn insns[] = {
1089                 BPF_STMT(BPF_LD+BPF_IMM, 0xdeadbeef),
1090                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0),
1091                 BPF_STMT(BPF_ALU+BPF_LSH+BPF_X, 0),
1092                 BPF_STMT(BPF_RET+BPF_A, 0)
1093         };
1094
1095         bpfjit_func_t code;
1096         uint8_t pkt[1]; /* the program doesn't read any data */
1097
1098         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1099
1100         ATF_CHECK(bpf_validate(insns, insn_count));
1101
1102         code = bpfjit_generate_code(NULL, insns, insn_count);
1103         ATF_REQUIRE(code != NULL);
1104
1105         ATF_CHECK(jitcall(code, pkt, 1, 1) == 0xdeadbeef);
1106
1107         bpfjit_free_code(code);
1108 }
1109
1110 ATF_TC(libbpfjit_alu_rsh_x);
1111 ATF_TC_HEAD(libbpfjit_alu_rsh_x, tc)
1112 {
1113         atf_tc_set_md_var(tc, "descr",
1114             "Test JIT compilation of BPF_ALU+BPF_RSH+BPF_X");
1115 }
1116
1117 ATF_TC_BODY(libbpfjit_alu_rsh_x, tc)
1118 {
1119         static struct bpf_insn insns[] = {
1120                 BPF_STMT(BPF_LD+BPF_IMM, 0xdeadbeef),
1121                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 16),
1122                 BPF_STMT(BPF_ALU+BPF_RSH+BPF_X, 0),
1123                 BPF_STMT(BPF_RET+BPF_A, 0)
1124         };
1125
1126         bpfjit_func_t code;
1127         uint8_t pkt[1]; /* the program doesn't read any data */
1128
1129         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1130
1131         ATF_CHECK(bpf_validate(insns, insn_count));
1132
1133         code = bpfjit_generate_code(NULL, insns, insn_count);
1134         ATF_REQUIRE(code != NULL);
1135
1136         ATF_CHECK(jitcall(code, pkt, 1, 1) == 0x0000dead);
1137
1138         bpfjit_free_code(code);
1139 }
1140
1141 ATF_TC(libbpfjit_alu_rsh0_x);
1142 ATF_TC_HEAD(libbpfjit_alu_rsh0_x, tc)
1143 {
1144         atf_tc_set_md_var(tc, "descr",
1145             "Test JIT compilation of BPF_ALU+BPF_RSH+BPF_X with k=0");
1146 }
1147
1148 ATF_TC_BODY(libbpfjit_alu_rsh0_x, tc)
1149 {
1150         static struct bpf_insn insns[] = {
1151                 BPF_STMT(BPF_LD+BPF_IMM, 0xdeadbeef),
1152                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0),
1153                 BPF_STMT(BPF_ALU+BPF_RSH+BPF_X, 0),
1154                 BPF_STMT(BPF_RET+BPF_A, 0)
1155         };
1156
1157         bpfjit_func_t code;
1158         uint8_t pkt[1]; /* the program doesn't read any data */
1159
1160         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1161
1162         ATF_CHECK(bpf_validate(insns, insn_count));
1163
1164         code = bpfjit_generate_code(NULL, insns, insn_count);
1165         ATF_REQUIRE(code != NULL);
1166
1167         ATF_CHECK(jitcall(code, pkt, 1, 1) == 0xdeadbeef);
1168
1169         bpfjit_free_code(code);
1170 }
1171
1172 ATF_TC(libbpfjit_alu_modulo_x);
1173 ATF_TC_HEAD(libbpfjit_alu_modulo_x, tc)
1174 {
1175         atf_tc_set_md_var(tc, "descr",
1176             "Test JIT compilation of modulo logic of BPF_ALU+BPF_X operations");
1177 }
1178
1179 ATF_TC_BODY(libbpfjit_alu_modulo_x, tc)
1180 {
1181         static struct bpf_insn insns[] = {
1182                 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0x7fffff77)),
1183
1184                 /* (7FFFFF77 * 0FFFFF77) = 07FFFFB2,F0004951 */
1185                 BPF_STMT(BPF_LDX+BPF_W+BPF_K, UINT32_C(0x0fffff77)),
1186                 BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0),
1187
1188                 /* 07FFFFB2,F0004951 << 1 = 0FFFFF65,E00092A2 */
1189                 BPF_STMT(BPF_LDX+BPF_W+BPF_K, 1),
1190                 BPF_STMT(BPF_ALU+BPF_LSH+BPF_X, 0),
1191
1192                 /* 0FFFFF65,E00092A2 + DDDDDDDD = 0FFFFF66,BDDE707F */
1193                 BPF_STMT(BPF_LDX+BPF_W+BPF_K, UINT32_C(0xdddddddd)),
1194                 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0),
1195
1196                 /* 0FFFFF66,BDDE707F - FFFFFFFF = 0FFFFF65,BDDE7080 */
1197                 BPF_STMT(BPF_LDX+BPF_W+BPF_K, UINT32_C(0xffffffff)),
1198                 BPF_STMT(BPF_ALU+BPF_SUB+BPF_X, 0),
1199
1200                 /* 0FFFFF65,BDDE7080 | 0000030C = 0FFFFF65,BDDE738C */
1201                 BPF_STMT(BPF_LDX+BPF_W+BPF_K, UINT32_C(0x0000030c)),
1202                 BPF_STMT(BPF_ALU+BPF_OR+BPF_X, 0),
1203
1204                 /* -0FFFFF65,BDDE738C mod(2^64) = F000009A,42218C74 */
1205                 BPF_STMT(BPF_ALU+BPF_NEG, 0),
1206
1207                 /* F000009A,42218C74 & FFFFFF0F = F000009A,42218C04 */
1208                 BPF_STMT(BPF_LDX+BPF_W+BPF_K, UINT32_C(0xffffff0f)),
1209                 BPF_STMT(BPF_ALU+BPF_AND+BPF_X, 0),
1210
1211                 /* F000009A,42218C74 >> 3 = 1E000013,48443180 */
1212                 /* 00000000,42218C74 >> 3 = 00000000,08443180 */
1213                 BPF_STMT(BPF_LDX+BPF_W+BPF_K, 3),
1214                 BPF_STMT(BPF_ALU+BPF_RSH+BPF_X, 0),
1215
1216                 /* 00000000,08443180 * 7FFFFF77 = 042218BB,93818280 */
1217                 BPF_STMT(BPF_LDX+BPF_W+BPF_K, UINT32_C(0x7fffff77)),
1218                 BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0),
1219
1220                 /* 042218BB,93818280 / DEAD = 000004C0,71CBBBC3 */
1221                 /* 00000000,93818280 / DEAD = 00000000,0000A994 */
1222                 BPF_STMT(BPF_LDX+BPF_W+BPF_K, UINT32_C(0xdead)),
1223                 BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0),
1224
1225                 BPF_STMT(BPF_RET+BPF_A, 0)
1226         };
1227
1228         bpfjit_func_t code;
1229         uint8_t pkt[1]; /* the program doesn't read any data */
1230
1231         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1232
1233         ATF_CHECK(bpf_validate(insns, insn_count));
1234
1235         code = bpfjit_generate_code(NULL, insns, insn_count);
1236         ATF_REQUIRE(code != NULL);
1237
1238         ATF_CHECK(jitcall(code, pkt, 1, 1) != UINT32_C(0x71cbbbc3));
1239         ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_C(0x0000a994));
1240
1241
1242         bpfjit_free_code(code);
1243 }
1244
1245 ATF_TC(libbpfjit_alu_neg);
1246 ATF_TC_HEAD(libbpfjit_alu_neg, tc)
1247 {
1248         atf_tc_set_md_var(tc, "descr",
1249             "Test JIT compilation of BPF_ALU+BPF_NEG");
1250 }
1251
1252 ATF_TC_BODY(libbpfjit_alu_neg, tc)
1253 {
1254         static struct bpf_insn insns[] = {
1255                 BPF_STMT(BPF_LD+BPF_IMM, 777),
1256                 BPF_STMT(BPF_ALU+BPF_NEG, 0),
1257                 BPF_STMT(BPF_RET+BPF_A, 0)
1258         };
1259
1260         bpfjit_func_t code;
1261         uint8_t pkt[1]; /* the program doesn't read any data */
1262
1263         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1264
1265         ATF_CHECK(bpf_validate(insns, insn_count));
1266
1267         code = bpfjit_generate_code(NULL, insns, insn_count);
1268         ATF_REQUIRE(code != NULL);
1269
1270         ATF_CHECK(jitcall(code, pkt, 1, 1) == 0u-777u);
1271
1272         bpfjit_free_code(code);
1273 }
1274
1275 ATF_TC(libbpfjit_jmp_ja);
1276 ATF_TC_HEAD(libbpfjit_jmp_ja, tc)
1277 {
1278         atf_tc_set_md_var(tc, "descr",
1279             "Test JIT compilation of BPF_JMP+BPF_JA");
1280 }
1281
1282 ATF_TC_BODY(libbpfjit_jmp_ja, tc)
1283 {
1284         static struct bpf_insn insns[] = {
1285                 BPF_STMT(BPF_JMP+BPF_JA, 1),
1286                 BPF_STMT(BPF_RET+BPF_K, 0),
1287                 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX),
1288                 BPF_STMT(BPF_RET+BPF_K, 1),
1289                 BPF_STMT(BPF_RET+BPF_K, 2),
1290                 BPF_STMT(BPF_RET+BPF_K, 3),
1291         };
1292
1293         bpfjit_func_t code;
1294         uint8_t pkt[1]; /* the program doesn't read any data */
1295
1296         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1297
1298         ATF_CHECK(bpf_validate(insns, insn_count));
1299
1300         code = bpfjit_generate_code(NULL, insns, insn_count);
1301         ATF_REQUIRE(code != NULL);
1302
1303         ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_MAX);
1304
1305         bpfjit_free_code(code);
1306 }
1307
1308 ATF_TC(libbpfjit_jmp_jgt_k);
1309 ATF_TC_HEAD(libbpfjit_jmp_jgt_k, tc)
1310 {
1311         atf_tc_set_md_var(tc, "descr",
1312             "Test JIT compilation of BPF_JMP+BPF_JGT+BPF_K");
1313 }
1314
1315 ATF_TC_BODY(libbpfjit_jmp_jgt_k, tc)
1316 {
1317         static struct bpf_insn insns[] = {
1318                 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0),
1319                 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, 7, 0, 1),
1320                 BPF_STMT(BPF_RET+BPF_K, 0),
1321                 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, 2, 2, 0),
1322                 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, 9, 0, 0),
1323                 BPF_STMT(BPF_RET+BPF_K, 1),
1324                 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, 4, 1, 1),
1325                 BPF_STMT(BPF_RET+BPF_K, 2),
1326                 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, 6, 2, 3),
1327                 BPF_STMT(BPF_RET+BPF_K, 3),
1328                 BPF_STMT(BPF_RET+BPF_K, 4),
1329                 BPF_STMT(BPF_RET+BPF_K, 5),
1330                 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, 5, 3, 1),
1331                 BPF_STMT(BPF_RET+BPF_K, 6),
1332                 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, 0, 0, 0),
1333                 BPF_STMT(BPF_RET+BPF_K, 7),
1334                 BPF_STMT(BPF_RET+BPF_K, 8)
1335         };
1336
1337         bpfjit_func_t code;
1338         uint8_t pkt[8]; /* the program doesn't read any data */
1339
1340         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1341
1342         ATF_CHECK(bpf_validate(insns, insn_count));
1343
1344         code = bpfjit_generate_code(NULL, insns, insn_count);
1345         ATF_REQUIRE(code != NULL);
1346
1347         ATF_CHECK(jitcall(code, pkt, 1, 1) == 1);
1348         ATF_CHECK(jitcall(code, pkt, 2, 2) == 1);
1349         ATF_CHECK(jitcall(code, pkt, 3, 3) == 7);
1350         ATF_CHECK(jitcall(code, pkt, 4, 4) == 7);
1351         ATF_CHECK(jitcall(code, pkt, 5, 5) == 7);
1352         ATF_CHECK(jitcall(code, pkt, 6, 6) == 8);
1353         ATF_CHECK(jitcall(code, pkt, 7, 7) == 5);
1354         ATF_CHECK(jitcall(code, pkt, 8, 8) == 0);
1355
1356         bpfjit_free_code(code);
1357 }
1358
1359 ATF_TC(libbpfjit_jmp_jge_k);
1360 ATF_TC_HEAD(libbpfjit_jmp_jge_k, tc)
1361 {
1362         atf_tc_set_md_var(tc, "descr",
1363             "Test JIT compilation of BPF_JMP+BPF_JGE+BPF_K");
1364 }
1365
1366 ATF_TC_BODY(libbpfjit_jmp_jge_k, tc)
1367 {
1368         static struct bpf_insn insns[] = {
1369                 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0),
1370                 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, 8, 0, 1),
1371                 BPF_STMT(BPF_RET+BPF_K, 0),
1372                 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, 3, 2, 0),
1373                 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, 9, 0, 0),
1374                 BPF_STMT(BPF_RET+BPF_K, 1),
1375                 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, 5, 1, 1),
1376                 BPF_STMT(BPF_RET+BPF_K, 2),
1377                 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, 7, 2, 3),
1378                 BPF_STMT(BPF_RET+BPF_K, 3),
1379                 BPF_STMT(BPF_RET+BPF_K, 4),
1380                 BPF_STMT(BPF_RET+BPF_K, 5),
1381                 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, 6, 3, 1),
1382                 BPF_STMT(BPF_RET+BPF_K, 6),
1383                 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, 1, 0, 0),
1384                 BPF_STMT(BPF_RET+BPF_K, 7),
1385                 BPF_STMT(BPF_RET+BPF_K, 8)
1386         };
1387
1388         bpfjit_func_t code;
1389         uint8_t pkt[8]; /* the program doesn't read any data */
1390
1391         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1392
1393         ATF_CHECK(bpf_validate(insns, insn_count));
1394
1395         code = bpfjit_generate_code(NULL, insns, insn_count);
1396         ATF_REQUIRE(code != NULL);
1397
1398         ATF_CHECK(jitcall(code, pkt, 1, 1) == 1);
1399         ATF_CHECK(jitcall(code, pkt, 2, 2) == 1);
1400         ATF_CHECK(jitcall(code, pkt, 3, 3) == 7);
1401         ATF_CHECK(jitcall(code, pkt, 4, 4) == 7);
1402         ATF_CHECK(jitcall(code, pkt, 5, 5) == 7);
1403         ATF_CHECK(jitcall(code, pkt, 6, 6) == 8);
1404         ATF_CHECK(jitcall(code, pkt, 7, 7) == 5);
1405         ATF_CHECK(jitcall(code, pkt, 8, 8) == 0);
1406
1407         bpfjit_free_code(code);
1408 }
1409
1410 ATF_TC(libbpfjit_jmp_jeq_k);
1411 ATF_TC_HEAD(libbpfjit_jmp_jeq_k, tc)
1412 {
1413         atf_tc_set_md_var(tc, "descr",
1414             "Test JIT compilation of BPF_JMP+BPF_JEQ+BPF_K");
1415 }
1416
1417 ATF_TC_BODY(libbpfjit_jmp_jeq_k, tc)
1418 {
1419         static struct bpf_insn insns[] = {
1420                 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0),
1421                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 8, 0, 1),
1422                 BPF_STMT(BPF_RET+BPF_K, 0),
1423                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 3, 1, 0),
1424                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 9, 1, 1),
1425                 BPF_STMT(BPF_RET+BPF_K, 1),
1426                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 5, 1, 1),
1427                 BPF_STMT(BPF_RET+BPF_K, 2),
1428                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 7, 2, 3),
1429                 BPF_STMT(BPF_RET+BPF_K, 3),
1430                 BPF_STMT(BPF_RET+BPF_K, 4),
1431                 BPF_STMT(BPF_RET+BPF_K, 5),
1432                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 6, 3, 1),
1433                 BPF_STMT(BPF_RET+BPF_K, 6),
1434                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 1, 0, 0),
1435                 BPF_STMT(BPF_RET+BPF_K, 7),
1436                 BPF_STMT(BPF_RET+BPF_K, 8)
1437         };
1438
1439         bpfjit_func_t code;
1440         uint8_t pkt[8]; /* the program doesn't read any data */
1441
1442         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1443
1444         ATF_CHECK(bpf_validate(insns, insn_count));
1445
1446         code = bpfjit_generate_code(NULL, insns, insn_count);
1447         ATF_REQUIRE(code != NULL);
1448
1449         ATF_CHECK(jitcall(code, pkt, 1, 1) == 7);
1450         ATF_CHECK(jitcall(code, pkt, 2, 2) == 7);
1451         ATF_CHECK(jitcall(code, pkt, 3, 3) == 1);
1452         ATF_CHECK(jitcall(code, pkt, 4, 4) == 7);
1453         ATF_CHECK(jitcall(code, pkt, 5, 5) == 7);
1454         ATF_CHECK(jitcall(code, pkt, 6, 6) == 8);
1455         ATF_CHECK(jitcall(code, pkt, 7, 7) == 5);
1456         ATF_CHECK(jitcall(code, pkt, 8, 8) == 0);
1457
1458         bpfjit_free_code(code);
1459 }
1460
1461 ATF_TC(libbpfjit_jmp_jset_k);
1462 ATF_TC_HEAD(libbpfjit_jmp_jset_k, tc)
1463 {
1464         atf_tc_set_md_var(tc, "descr",
1465             "Test JIT compilation of BPF_JMP+BPF_JSET+BPF_K");
1466 }
1467
1468 ATF_TC_BODY(libbpfjit_jmp_jset_k, tc)
1469 {
1470         static struct bpf_insn insns[] = {
1471                 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0),
1472                 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, 8, 0, 1),
1473                 BPF_STMT(BPF_RET+BPF_K, 0),
1474                 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, 4, 2, 0),
1475                 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, 3, 0, 0),
1476                 BPF_STMT(BPF_RET+BPF_K, 1),
1477                 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, 2, 1, 1),
1478                 BPF_STMT(BPF_RET+BPF_K, 2),
1479                 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, 1, 2, 3),
1480                 BPF_STMT(BPF_RET+BPF_K, 3),
1481                 BPF_STMT(BPF_RET+BPF_K, 4),
1482                 BPF_STMT(BPF_RET+BPF_K, 5),
1483                 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, 2, 3, 1),
1484                 BPF_STMT(BPF_RET+BPF_K, 6),
1485                 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, 7, 0, 0),
1486                 BPF_STMT(BPF_RET+BPF_K, 7),
1487                 BPF_STMT(BPF_RET+BPF_K, 8)
1488         };
1489
1490         bpfjit_func_t code;
1491         uint8_t pkt[8]; /* the program doesn't read any data */
1492
1493         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1494
1495         ATF_CHECK(bpf_validate(insns, insn_count));
1496
1497         code = bpfjit_generate_code(NULL, insns, insn_count);
1498         ATF_REQUIRE(code != NULL);
1499
1500         ATF_CHECK(jitcall(code, pkt, 1, 1) == 1);
1501         ATF_CHECK(jitcall(code, pkt, 2, 2) == 1);
1502         ATF_CHECK(jitcall(code, pkt, 3, 3) == 1);
1503         ATF_CHECK(jitcall(code, pkt, 4, 4) == 7);
1504         ATF_CHECK(jitcall(code, pkt, 5, 5) == 5);
1505         ATF_CHECK(jitcall(code, pkt, 6, 6) == 8);
1506         ATF_CHECK(jitcall(code, pkt, 7, 7) == 5);
1507         ATF_CHECK(jitcall(code, pkt, 8, 8) == 0);
1508
1509         bpfjit_free_code(code);
1510 }
1511
1512 ATF_TC(libbpfjit_jmp_modulo_k);
1513 ATF_TC_HEAD(libbpfjit_jmp_modulo_k, tc)
1514 {
1515         atf_tc_set_md_var(tc, "descr",
1516             "Test JIT compilation of modulo logic of BPF_JMP+BPF_K operations");
1517 }
1518
1519 ATF_TC_BODY(libbpfjit_jmp_modulo_k, tc)
1520 {
1521         static struct bpf_insn insns[] = {
1522                 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0x7fffff77)),
1523                 BPF_STMT(BPF_ALU+BPF_LSH+BPF_K, 4),
1524                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, UINT32_C(0xfffff770), 1, 0),
1525                 BPF_STMT(BPF_RET+BPF_K, 0),
1526                 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, UINT32_C(0xfffff770), 0, 1),
1527                 BPF_STMT(BPF_RET+BPF_K, 1),
1528                 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, UINT32_C(0xfffff771), 0, 1),
1529                 BPF_STMT(BPF_RET+BPF_K, 2),
1530                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, UINT32_C(0xfffff770), 0, 3),
1531                 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, UINT32_C(0xfffff770), 2, 0),
1532                 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, UINT32_C(0xfffff771), 1, 0),
1533                 BPF_STMT(BPF_JMP+BPF_JA, 1),
1534                 BPF_STMT(BPF_RET+BPF_K, 3),
1535
1536                 /* FFFFF770+FFFFF770 = 00000001,FFFFEEE0 */
1537                 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, UINT32_C(0xfffff770)),
1538
1539                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, UINT32_C(0xffffeee0), 1, 0),
1540                 BPF_STMT(BPF_RET+BPF_K, 4),
1541                 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, UINT32_C(0xffffeee0), 0, 1),
1542                 BPF_STMT(BPF_RET+BPF_K, 5),
1543                 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, UINT32_C(0xffffeee1), 0, 1),
1544                 BPF_STMT(BPF_RET+BPF_K, 6),
1545                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, UINT32_C(0xffffeee0), 0, 3),
1546                 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, UINT32_C(0xffffeee0), 2, 0),
1547                 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, UINT32_C(0xffffeee1), 1, 0),
1548                 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX),
1549                 BPF_STMT(BPF_RET+BPF_K, 7)
1550         };
1551
1552         bpfjit_func_t code;
1553         uint8_t pkt[1]; /* the program doesn't read any data */
1554
1555         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1556
1557         ATF_CHECK(bpf_validate(insns, insn_count));
1558
1559         code = bpfjit_generate_code(NULL, insns, insn_count);
1560         ATF_REQUIRE(code != NULL);
1561
1562         ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_MAX);
1563
1564         bpfjit_free_code(code);
1565 }
1566
1567 ATF_TC(libbpfjit_jmp_jgt_x);
1568 ATF_TC_HEAD(libbpfjit_jmp_jgt_x, tc)
1569 {
1570         atf_tc_set_md_var(tc, "descr",
1571             "Test JIT compilation of BPF_JMP+BPF_JGT+BPF_X");
1572 }
1573
1574 ATF_TC_BODY(libbpfjit_jmp_jgt_x, tc)
1575 {
1576         static struct bpf_insn insns[] = {
1577                 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0),
1578                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 7),
1579                 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 0, 1),
1580                 BPF_STMT(BPF_RET+BPF_K, 0),
1581                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 2),
1582                 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 3, 0),
1583                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 9),
1584                 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 0, 0),
1585                 BPF_STMT(BPF_RET+BPF_K, 1),
1586                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 4),
1587                 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 1, 1),
1588                 BPF_STMT(BPF_RET+BPF_K, 2),
1589                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 6),
1590                 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 2, 3),
1591                 BPF_STMT(BPF_RET+BPF_K, 3),
1592                 BPF_STMT(BPF_RET+BPF_K, 4),
1593                 BPF_STMT(BPF_RET+BPF_K, 5),
1594                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 5),
1595                 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 4, 1),
1596                 BPF_STMT(BPF_RET+BPF_K, 6),
1597                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0),
1598                 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 0, 0),
1599                 BPF_STMT(BPF_RET+BPF_K, 7),
1600                 BPF_STMT(BPF_RET+BPF_K, 8)
1601         };
1602
1603         bpfjit_func_t code;
1604         uint8_t pkt[8]; /* the program doesn't read any data */
1605
1606         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1607
1608         ATF_CHECK(bpf_validate(insns, insn_count));
1609
1610         code = bpfjit_generate_code(NULL, insns, insn_count);
1611         ATF_REQUIRE(code != NULL);
1612
1613         ATF_CHECK(jitcall(code, pkt, 1, 1) == 1);
1614         ATF_CHECK(jitcall(code, pkt, 2, 2) == 1);
1615         ATF_CHECK(jitcall(code, pkt, 3, 3) == 7);
1616         ATF_CHECK(jitcall(code, pkt, 4, 4) == 7);
1617         ATF_CHECK(jitcall(code, pkt, 5, 5) == 7);
1618         ATF_CHECK(jitcall(code, pkt, 6, 6) == 8);
1619         ATF_CHECK(jitcall(code, pkt, 7, 7) == 5);
1620         ATF_CHECK(jitcall(code, pkt, 8, 8) == 0);
1621
1622         bpfjit_free_code(code);
1623 }
1624
1625 ATF_TC(libbpfjit_jmp_jge_x);
1626 ATF_TC_HEAD(libbpfjit_jmp_jge_x, tc)
1627 {
1628         atf_tc_set_md_var(tc, "descr",
1629             "Test JIT compilation of BPF_JMP+BPF_JGE+BPF_X");
1630 }
1631
1632 ATF_TC_BODY(libbpfjit_jmp_jge_x, tc)
1633 {
1634         static struct bpf_insn insns[] = {
1635                 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0),
1636                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 8),
1637                 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 0, 1),
1638                 BPF_STMT(BPF_RET+BPF_K, 0),
1639                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 3),
1640                 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 3, 0),
1641                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 9),
1642                 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 0, 0),
1643                 BPF_STMT(BPF_RET+BPF_K, 1),
1644                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 5),
1645                 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 1, 1),
1646                 BPF_STMT(BPF_RET+BPF_K, 2),
1647                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 7),
1648                 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 2, 3),
1649                 BPF_STMT(BPF_RET+BPF_K, 3),
1650                 BPF_STMT(BPF_RET+BPF_K, 4),
1651                 BPF_STMT(BPF_RET+BPF_K, 5),
1652                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 6),
1653                 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 4, 1),
1654                 BPF_STMT(BPF_RET+BPF_K, 6),
1655                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1),
1656                 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 0, 0),
1657                 BPF_STMT(BPF_RET+BPF_K, 7),
1658                 BPF_STMT(BPF_RET+BPF_K, 8)
1659         };
1660
1661         bpfjit_func_t code;
1662         uint8_t pkt[8]; /* the program doesn't read any data */
1663
1664         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1665
1666         ATF_CHECK(bpf_validate(insns, insn_count));
1667
1668         code = bpfjit_generate_code(NULL, insns, insn_count);
1669         ATF_REQUIRE(code != NULL);
1670
1671         ATF_CHECK(jitcall(code, pkt, 1, 1) == 1);
1672         ATF_CHECK(jitcall(code, pkt, 2, 2) == 1);
1673         ATF_CHECK(jitcall(code, pkt, 3, 3) == 7);
1674         ATF_CHECK(jitcall(code, pkt, 4, 4) == 7);
1675         ATF_CHECK(jitcall(code, pkt, 5, 5) == 7);
1676         ATF_CHECK(jitcall(code, pkt, 6, 6) == 8);
1677         ATF_CHECK(jitcall(code, pkt, 7, 7) == 5);
1678         ATF_CHECK(jitcall(code, pkt, 8, 8) == 0);
1679
1680         bpfjit_free_code(code);
1681 }
1682
1683 ATF_TC(libbpfjit_jmp_jeq_x);
1684 ATF_TC_HEAD(libbpfjit_jmp_jeq_x, tc)
1685 {
1686         atf_tc_set_md_var(tc, "descr",
1687             "Test JIT compilation of BPF_JMP+BPF_JEQ+BPF_X");
1688 }
1689
1690 ATF_TC_BODY(libbpfjit_jmp_jeq_x, tc)
1691 {
1692         static struct bpf_insn insns[] = {
1693                 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0),
1694                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 8),
1695                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 0, 1),
1696                 BPF_STMT(BPF_RET+BPF_K, 0),
1697                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 3),
1698                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 2, 0),
1699                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 9),
1700                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 1, 1),
1701                 BPF_STMT(BPF_RET+BPF_K, 1),
1702                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 5),
1703                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 1, 1),
1704                 BPF_STMT(BPF_RET+BPF_K, 2),
1705                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 7),
1706                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 2, 3),
1707                 BPF_STMT(BPF_RET+BPF_K, 3),
1708                 BPF_STMT(BPF_RET+BPF_K, 4),
1709                 BPF_STMT(BPF_RET+BPF_K, 5),
1710                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 6),
1711                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 3, 1),
1712                 BPF_STMT(BPF_RET+BPF_K, 6),
1713                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 1, 0, 0),
1714                 BPF_STMT(BPF_RET+BPF_K, 7),
1715                 BPF_STMT(BPF_RET+BPF_K, 8)
1716         };
1717
1718         bpfjit_func_t code;
1719         uint8_t pkt[8]; /* the program doesn't read any data */
1720
1721         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1722
1723         ATF_CHECK(bpf_validate(insns, insn_count));
1724
1725         code = bpfjit_generate_code(NULL, insns, insn_count);
1726         ATF_REQUIRE(code != NULL);
1727
1728         ATF_CHECK(jitcall(code, pkt, 1, 1) == 7);
1729         ATF_CHECK(jitcall(code, pkt, 2, 2) == 7);
1730         ATF_CHECK(jitcall(code, pkt, 3, 3) == 1);
1731         ATF_CHECK(jitcall(code, pkt, 4, 4) == 7);
1732         ATF_CHECK(jitcall(code, pkt, 5, 5) == 7);
1733         ATF_CHECK(jitcall(code, pkt, 6, 6) == 8);
1734         ATF_CHECK(jitcall(code, pkt, 7, 7) == 5);
1735         ATF_CHECK(jitcall(code, pkt, 8, 8) == 0);
1736
1737         bpfjit_free_code(code);
1738 }
1739
1740 ATF_TC(libbpfjit_jmp_jset_x);
1741 ATF_TC_HEAD(libbpfjit_jmp_jset_x, tc)
1742 {
1743         atf_tc_set_md_var(tc, "descr",
1744             "Test JIT compilation of BPF_JMP+BPF_JSET+BPF_X");
1745 }
1746
1747 ATF_TC_BODY(libbpfjit_jmp_jset_x, tc)
1748 {
1749         static struct bpf_insn insns[] = {
1750                 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0),
1751                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 8),
1752                 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_X, 0, 0, 1),
1753                 BPF_STMT(BPF_RET+BPF_K, 0),
1754                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 4),
1755                 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_X, 0, 2, 0),
1756                 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_X, 3, 0, 0),
1757                 BPF_STMT(BPF_RET+BPF_K, 1),
1758                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 2),
1759                 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_X, 0, 1, 1),
1760                 BPF_STMT(BPF_RET+BPF_K, 2),
1761                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1),
1762                 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_X, 0, 2, 3),
1763                 BPF_STMT(BPF_RET+BPF_K, 3),
1764                 BPF_STMT(BPF_RET+BPF_K, 4),
1765                 BPF_STMT(BPF_RET+BPF_K, 5),
1766                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 2),
1767                 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_X, 0, 4, 1),
1768                 BPF_STMT(BPF_RET+BPF_K, 6),
1769                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 7),
1770                 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_X, 0, 0, 0),
1771                 BPF_STMT(BPF_RET+BPF_K, 7),
1772                 BPF_STMT(BPF_RET+BPF_K, 8)
1773         };
1774
1775         bpfjit_func_t code;
1776         uint8_t pkt[8]; /* the program doesn't read any data */
1777
1778         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1779
1780         ATF_CHECK(bpf_validate(insns, insn_count));
1781
1782         code = bpfjit_generate_code(NULL, insns, insn_count);
1783         ATF_REQUIRE(code != NULL);
1784
1785         ATF_CHECK(jitcall(code, pkt, 1, 1) == 1);
1786         ATF_CHECK(jitcall(code, pkt, 2, 2) == 1);
1787         ATF_CHECK(jitcall(code, pkt, 3, 3) == 1);
1788         ATF_CHECK(jitcall(code, pkt, 4, 4) == 7);
1789         ATF_CHECK(jitcall(code, pkt, 5, 5) == 5);
1790         ATF_CHECK(jitcall(code, pkt, 6, 6) == 8);
1791         ATF_CHECK(jitcall(code, pkt, 7, 7) == 5);
1792         ATF_CHECK(jitcall(code, pkt, 8, 8) == 0);
1793
1794         bpfjit_free_code(code);
1795 }
1796
1797 ATF_TC(libbpfjit_jmp_modulo_x);
1798 ATF_TC_HEAD(libbpfjit_jmp_modulo_x, tc)
1799 {
1800         atf_tc_set_md_var(tc, "descr",
1801             "Test JIT compilation of modulo logic of BPF_JMP+BPF_X operations");
1802 }
1803
1804 ATF_TC_BODY(libbpfjit_jmp_modulo_x, tc)
1805 {
1806         static struct bpf_insn insns[] = {
1807                 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0x7fffff77)),
1808                 /* FFFFF770 << 4 = FFFFF770 */
1809                 BPF_STMT(BPF_ALU+BPF_LSH+BPF_K, 4),
1810
1811                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xfffff770)),
1812                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 1, 0),
1813                 BPF_STMT(BPF_RET+BPF_K, 0),
1814                 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 0, 1),
1815                 BPF_STMT(BPF_RET+BPF_K, 1),
1816                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xfffff771)),
1817                 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 0, 1),
1818                 BPF_STMT(BPF_RET+BPF_K, 2),
1819                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xfffff770)),
1820                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 0, 4),
1821                 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 3, 0),
1822                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xfffff771)),
1823                 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 1, 0),
1824                 BPF_STMT(BPF_JMP+BPF_JA, 1),
1825                 BPF_STMT(BPF_RET+BPF_K, 3),
1826
1827                 /* FFFFF770+FFFFF770 = 00000001,FFFFEEE0 */
1828                 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, UINT32_C(0xfffff770)),
1829
1830                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xffffeee0)),
1831                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 1, 0),
1832                 BPF_STMT(BPF_RET+BPF_K, 4),
1833                 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 0, 1),
1834                 BPF_STMT(BPF_RET+BPF_K, 5),
1835                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xffffeee1)),
1836                 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 0, 1),
1837                 BPF_STMT(BPF_RET+BPF_K, 6),
1838                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xffffeee0)),
1839                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 0, 4),
1840                 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 3, 0),
1841                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xffffeee1)),
1842                 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 1, 0),
1843                 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX),
1844                 BPF_STMT(BPF_RET+BPF_K, 7)
1845         };
1846
1847         bpfjit_func_t code;
1848         uint8_t pkt[1]; /* the program doesn't read any data */
1849
1850         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1851
1852         ATF_CHECK(bpf_validate(insns, insn_count));
1853
1854         code = bpfjit_generate_code(NULL, insns, insn_count);
1855         ATF_REQUIRE(code != NULL);
1856
1857         ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_MAX);
1858
1859         bpfjit_free_code(code);
1860 }
1861
1862 ATF_TC(libbpfjit_ld_abs);
1863 ATF_TC_HEAD(libbpfjit_ld_abs, tc)
1864 {
1865         atf_tc_set_md_var(tc, "descr",
1866             "Test JIT compilation of BPF_LD+BPF_ABS");
1867 }
1868
1869 ATF_TC_BODY(libbpfjit_ld_abs, tc)
1870 {
1871         static struct bpf_insn insns[3][2] = {
1872                 {
1873                         BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 5),
1874                         BPF_STMT(BPF_RET+BPF_A, 0)
1875                 },
1876                 {
1877                         BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 5),
1878                         BPF_STMT(BPF_RET+BPF_A, 0)
1879                 },
1880                 {
1881                         BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 5),
1882                         BPF_STMT(BPF_RET+BPF_A, 0)
1883                 }
1884         };
1885
1886         static size_t lengths[3] = { 1, 2, 4 };
1887         static unsigned int expected[3] = { 0xde, 0xdead, 0xdeadbeef };
1888
1889         size_t i, l;
1890         uint8_t *pkt = deadbeef_at_5;
1891         size_t pktsize = sizeof(deadbeef_at_5);
1892
1893         size_t insn_count = sizeof(insns[0]) / sizeof(insns[0][0]);
1894
1895         for (i = 0; i < 3; i++) {
1896                 bpfjit_func_t code;
1897
1898                 ATF_CHECK(bpf_validate(insns[i], insn_count));
1899
1900                 code = bpfjit_generate_code(NULL, insns[i], insn_count);
1901                 ATF_REQUIRE(code != NULL);
1902
1903                 for (l = 1; l < 5 + lengths[i]; l++) {
1904                         ATF_CHECK(jitcall(code, pkt, l, l) == 0);
1905                         ATF_CHECK(jitcall(code, pkt, pktsize, l) == 0);
1906                 }
1907
1908                 l = 5 + lengths[i];
1909                 ATF_CHECK(jitcall(code, pkt, l, l) == expected[i]);
1910                 ATF_CHECK(jitcall(code, pkt, pktsize, l) == expected[i]);
1911
1912                 l = pktsize;
1913                 ATF_CHECK(jitcall(code, pkt, l, l) == expected[i]);
1914
1915                 bpfjit_free_code(code);
1916         }
1917 }
1918
1919 ATF_TC(libbpfjit_ld_abs_k_overflow);
1920 ATF_TC_HEAD(libbpfjit_ld_abs_k_overflow, tc)
1921 {
1922         atf_tc_set_md_var(tc, "descr",
1923             "Test JIT compilation of BPF_LD+BPF_ABS with overflow in k+4");
1924 }
1925
1926 ATF_TC_BODY(libbpfjit_ld_abs_k_overflow, tc)
1927 {
1928         static struct bpf_insn insns[12][3] = {
1929                 {
1930                         BPF_STMT(BPF_LD+BPF_H+BPF_ABS, UINT32_MAX),
1931                         BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7),
1932                         BPF_STMT(BPF_RET+BPF_K, 1)
1933                 },
1934                 {
1935                         BPF_STMT(BPF_LD+BPF_H+BPF_ABS, UINT32_MAX - 1),
1936                         BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7),
1937                         BPF_STMT(BPF_RET+BPF_K, 1)
1938                 },
1939                 {
1940                         BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX),
1941                         BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7),
1942                         BPF_STMT(BPF_RET+BPF_K, 1)
1943                 },
1944                 {
1945                         BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX - 1),
1946                         BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7),
1947                         BPF_STMT(BPF_RET+BPF_K, 1)
1948                 },
1949                 {
1950                         BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX - 2),
1951                         BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7),
1952                         BPF_STMT(BPF_RET+BPF_K, 1)
1953                 },
1954                 {
1955                         BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX - 3),
1956                         BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7),
1957                         BPF_STMT(BPF_RET+BPF_K, 1)
1958                 },
1959                 {
1960                         BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7),
1961                         BPF_STMT(BPF_LD+BPF_H+BPF_ABS, UINT32_MAX),
1962                         BPF_STMT(BPF_RET+BPF_K, 1)
1963                 },
1964                 {
1965                         BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7),
1966                         BPF_STMT(BPF_LD+BPF_H+BPF_ABS, UINT32_MAX - 1),
1967                         BPF_STMT(BPF_RET+BPF_K, 1)
1968                 },
1969                 {
1970                         BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7),
1971                         BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX),
1972                         BPF_STMT(BPF_RET+BPF_K, 1)
1973                 },
1974                 {
1975                         BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7),
1976                         BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX - 1),
1977                         BPF_STMT(BPF_RET+BPF_K, 1)
1978                 },
1979                 {
1980                         BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7),
1981                         BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX - 2),
1982                         BPF_STMT(BPF_RET+BPF_K, 1)
1983                 },
1984                 {
1985                         BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7),
1986                         BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX - 3),
1987                         BPF_STMT(BPF_RET+BPF_K, 1)
1988                 }
1989         };
1990
1991         int i;
1992         uint8_t pkt[8] = { 0 };
1993
1994         size_t insn_count = sizeof(insns[0]) / sizeof(insns[0][0]);
1995
1996         for (i = 0; i < 3; i++) {
1997                 bpfjit_func_t code;
1998
1999                 ATF_CHECK(bpf_validate(insns[i], insn_count));
2000
2001                 code = bpfjit_generate_code(NULL, insns[i], insn_count);
2002                 ATF_REQUIRE(code != NULL);
2003
2004                 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0);
2005
2006                 bpfjit_free_code(code);
2007         }
2008 }
2009
2010 ATF_TC(libbpfjit_ld_ind);
2011 ATF_TC_HEAD(libbpfjit_ld_ind, tc)
2012 {
2013         atf_tc_set_md_var(tc, "descr",
2014             "Test JIT compilation of BPF_LD+BPF_IND");
2015 }
2016
2017 ATF_TC_BODY(libbpfjit_ld_ind, tc)
2018 {
2019         static struct bpf_insn insns[6][3] = {
2020                 {
2021                         BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 3),
2022                         BPF_STMT(BPF_LD+BPF_B+BPF_IND, 2),
2023                         BPF_STMT(BPF_RET+BPF_A, 0)
2024                 },
2025                 {
2026                         BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 3),
2027                         BPF_STMT(BPF_LD+BPF_H+BPF_IND, 2),
2028                         BPF_STMT(BPF_RET+BPF_A, 0)
2029                 },
2030                 {
2031                         BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 3),
2032                         BPF_STMT(BPF_LD+BPF_W+BPF_IND, 2),
2033                         BPF_STMT(BPF_RET+BPF_A, 0)
2034                 },
2035                 {
2036                         BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 5),
2037                         BPF_STMT(BPF_LD+BPF_B+BPF_IND, 0),
2038                         BPF_STMT(BPF_RET+BPF_A, 0)
2039                 },
2040                 {
2041                         BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 5),
2042                         BPF_STMT(BPF_LD+BPF_H+BPF_IND, 0),
2043                         BPF_STMT(BPF_RET+BPF_A, 0)
2044                 },
2045                 {
2046                         BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 5),
2047                         BPF_STMT(BPF_LD+BPF_W+BPF_IND, 0),
2048                         BPF_STMT(BPF_RET+BPF_A, 0)
2049                 }
2050         };
2051
2052         static size_t lengths[6] = { 1, 2, 4, 1, 2, 4 };
2053
2054         static unsigned int expected[6] = {
2055                 0xde, 0xdead, 0xdeadbeef,
2056                 0xde, 0xdead, 0xdeadbeef
2057         };
2058
2059         size_t i, l;
2060         uint8_t *pkt = deadbeef_at_5;
2061         size_t pktsize = sizeof(deadbeef_at_5);
2062
2063         size_t insn_count = sizeof(insns[0]) / sizeof(insns[0][0]);
2064
2065         for (i = 0; i < 3; i++) {
2066                 bpfjit_func_t code;
2067
2068                 ATF_CHECK(bpf_validate(insns[i], insn_count));
2069
2070                 code = bpfjit_generate_code(NULL, insns[i], insn_count);
2071                 ATF_REQUIRE(code != NULL);
2072
2073                 for (l = 1; l < 5 + lengths[i]; l++) {
2074                         ATF_CHECK(jitcall(code, pkt, l, l) == 0);
2075                         ATF_CHECK(jitcall(code, pkt, pktsize, l) == 0);
2076                 }
2077
2078                 l = 5 + lengths[i];
2079                 ATF_CHECK(jitcall(code, pkt, l, l) == expected[i]);
2080                 ATF_CHECK(jitcall(code, pkt, pktsize, l) == expected[i]);
2081
2082                 l = pktsize;
2083                 ATF_CHECK(jitcall(code, pkt, l, l) == expected[i]);
2084
2085                 bpfjit_free_code(code);
2086         }
2087 }
2088
2089 ATF_TC(libbpfjit_ld_ind_k_overflow);
2090 ATF_TC_HEAD(libbpfjit_ld_ind_k_overflow, tc)
2091 {
2092         atf_tc_set_md_var(tc, "descr",
2093             "Test JIT compilation of BPF_LD+BPF_IND with overflow in k+4");
2094 }
2095
2096 ATF_TC_BODY(libbpfjit_ld_ind_k_overflow, tc)
2097 {
2098         static struct bpf_insn insns[12][3] = {
2099                 {
2100                         BPF_STMT(BPF_LD+BPF_H+BPF_IND, UINT32_MAX),
2101                         BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7),
2102                         BPF_STMT(BPF_RET+BPF_K, 1)
2103                 },
2104                 {
2105                         BPF_STMT(BPF_LD+BPF_H+BPF_IND, UINT32_MAX - 1),
2106                         BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7),
2107                         BPF_STMT(BPF_RET+BPF_K, 1)
2108                 },
2109                 {
2110                         BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX),
2111                         BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7),
2112                         BPF_STMT(BPF_RET+BPF_K, 1)
2113                 },
2114                 {
2115                         BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX - 1),
2116                         BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7),
2117                         BPF_STMT(BPF_RET+BPF_K, 1)
2118                 },
2119                 {
2120                         BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX - 2),
2121                         BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7),
2122                         BPF_STMT(BPF_RET+BPF_K, 1)
2123                 },
2124                 {
2125                         BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX - 3),
2126                         BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7),
2127                         BPF_STMT(BPF_RET+BPF_K, 1)
2128                 },
2129                 {
2130                         BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7),
2131                         BPF_STMT(BPF_LD+BPF_H+BPF_IND, UINT32_MAX),
2132                         BPF_STMT(BPF_RET+BPF_K, 1)
2133                 },
2134                 {
2135                         BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7),
2136                         BPF_STMT(BPF_LD+BPF_H+BPF_IND, UINT32_MAX - 1),
2137                         BPF_STMT(BPF_RET+BPF_K, 1)
2138                 },
2139                 {
2140                         BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7),
2141                         BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX),
2142                         BPF_STMT(BPF_RET+BPF_K, 1)
2143                 },
2144                 {
2145                         BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7),
2146                         BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX - 1),
2147                         BPF_STMT(BPF_RET+BPF_K, 1)
2148                 },
2149                 {
2150                         BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7),
2151                         BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX - 2),
2152                         BPF_STMT(BPF_RET+BPF_K, 1)
2153                 },
2154                 {
2155                         BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7),
2156                         BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX - 3),
2157                         BPF_STMT(BPF_RET+BPF_K, 1)
2158                 }
2159         };
2160
2161         int i;
2162         uint8_t pkt[8] = { 0 };
2163
2164         size_t insn_count = sizeof(insns[0]) / sizeof(insns[0][0]);
2165
2166         for (i = 0; i < 3; i++) {
2167                 bpfjit_func_t code;
2168
2169                 ATF_CHECK(bpf_validate(insns[i], insn_count));
2170
2171                 code = bpfjit_generate_code(NULL, insns[i], insn_count);
2172                 ATF_REQUIRE(code != NULL);
2173
2174                 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0);
2175
2176                 bpfjit_free_code(code);
2177         }
2178 }
2179
2180 ATF_TC(libbpfjit_ld_ind_x_overflow1);
2181 ATF_TC_HEAD(libbpfjit_ld_ind_x_overflow1, tc)
2182 {
2183         atf_tc_set_md_var(tc, "descr",
2184             "Test JIT compilation of BPF_LD+BPF_IND with overflow in X+4");
2185 }
2186
2187 ATF_TC_BODY(libbpfjit_ld_ind_x_overflow1, tc)
2188 {
2189         static struct bpf_insn insns[] = {
2190                 BPF_STMT(BPF_LD+BPF_LEN, 0),
2191                 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, UINT32_C(0xffffffff)),
2192                 BPF_STMT(BPF_MISC+BPF_TAX, 0),
2193                 BPF_STMT(BPF_LD+BPF_B+BPF_IND, 0),
2194                 BPF_STMT(BPF_RET+BPF_A, 0)
2195         };
2196
2197         size_t i;
2198         bpfjit_func_t code;
2199         uint8_t pkt[8] = { 10, 20, 30, 40, 50, 60, 70, 80 };
2200
2201         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2202
2203         ATF_CHECK(bpf_validate(insns, insn_count));
2204
2205         code = bpfjit_generate_code(NULL, insns, insn_count);
2206         ATF_REQUIRE(code != NULL);
2207
2208         for (i = 1; i <= sizeof(pkt); i++) {
2209                 ATF_CHECK(bpf_filter(insns, pkt, i, i) == 10 * i);
2210                 ATF_CHECK(jitcall(code, pkt, i, i) == 10 * i);
2211         }
2212
2213         bpfjit_free_code(code);
2214 }
2215
2216 ATF_TC(libbpfjit_ld_ind_x_overflow2);
2217 ATF_TC_HEAD(libbpfjit_ld_ind_x_overflow2, tc)
2218 {
2219         atf_tc_set_md_var(tc, "descr",
2220             "Test JIT compilation of BPF_LD+BPF_IND with overflow in X+4");
2221 }
2222
2223 ATF_TC_BODY(libbpfjit_ld_ind_x_overflow2, tc)
2224 {
2225         static struct bpf_insn insns[] = {
2226                 BPF_STMT(BPF_LD+BPF_LEN, 0),
2227                 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, UINT32_C(0xffffffff)),
2228                 BPF_STMT(BPF_ST, 3),
2229                 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 3),
2230                 BPF_STMT(BPF_LD+BPF_B+BPF_IND, 0),
2231                 BPF_STMT(BPF_RET+BPF_A, 0)
2232         };
2233
2234         size_t i;
2235         bpfjit_func_t code;
2236         uint8_t pkt[8] = { 10, 20, 30, 40, 50, 60, 70, 80 };
2237
2238         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2239
2240         ATF_CHECK(bpf_validate(insns, insn_count));
2241
2242         code = bpfjit_generate_code(NULL, insns, insn_count);
2243         ATF_REQUIRE(code != NULL);
2244
2245         for (i = 1; i <= sizeof(pkt); i++) {
2246                 ATF_CHECK(bpf_filter(insns, pkt, i, i) == 10 * i);
2247                 ATF_CHECK(jitcall(code, pkt, i, i) == 10 * i);
2248         }
2249
2250         bpfjit_free_code(code);
2251 }
2252
2253 ATF_TC(libbpfjit_ld_len);
2254 ATF_TC_HEAD(libbpfjit_ld_len, tc)
2255 {
2256         atf_tc_set_md_var(tc, "descr",
2257             "Test JIT compilation of BPF_LD+BPF_W+BPF_LEN");
2258 }
2259
2260 ATF_TC_BODY(libbpfjit_ld_len, tc)
2261 {
2262         static struct bpf_insn insns[] = {
2263                 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0),
2264                 BPF_STMT(BPF_RET+BPF_A, 0)
2265         };
2266
2267         size_t i;
2268         bpfjit_func_t code;
2269         uint8_t pkt[32]; /* the program doesn't read any data */
2270
2271         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2272
2273         ATF_CHECK(bpf_validate(insns, insn_count));
2274
2275         code = bpfjit_generate_code(NULL, insns, insn_count);
2276         ATF_REQUIRE(code != NULL);
2277
2278         for (i = 0; i < sizeof(pkt); i++)
2279                 ATF_CHECK(jitcall(code, pkt, i, 1) == i);
2280
2281         bpfjit_free_code(code);
2282 }
2283
2284 ATF_TC(libbpfjit_ld_imm);
2285 ATF_TC_HEAD(libbpfjit_ld_imm, tc)
2286 {
2287         atf_tc_set_md_var(tc, "descr",
2288             "Test JIT compilation of BPF_LD+BPF_IMM");
2289 }
2290
2291 ATF_TC_BODY(libbpfjit_ld_imm, tc)
2292 {
2293         static struct bpf_insn insns[] = {
2294                 BPF_STMT(BPF_LD+BPF_IMM, UINT32_MAX),
2295                 BPF_STMT(BPF_RET+BPF_A, 0)
2296         };
2297
2298         bpfjit_func_t code;
2299         uint8_t pkt[1]; /* the program doesn't read any data */
2300
2301         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2302
2303         ATF_CHECK(bpf_validate(insns, insn_count));
2304
2305         code = bpfjit_generate_code(NULL, insns, insn_count);
2306         ATF_REQUIRE(code != NULL);
2307
2308         ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_MAX);
2309
2310         bpfjit_free_code(code);
2311 }
2312
2313 ATF_TC(libbpfjit_ldx_imm1);
2314 ATF_TC_HEAD(libbpfjit_ldx_imm1, tc)
2315 {
2316         atf_tc_set_md_var(tc, "descr",
2317             "Test JIT compilation of BPF_LDX+BPF_IMM");
2318 }
2319
2320 ATF_TC_BODY(libbpfjit_ldx_imm1, tc)
2321 {
2322         static struct bpf_insn insns[] = {
2323                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_MAX - 5),
2324                 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0),
2325                 BPF_STMT(BPF_RET+BPF_A, 0)
2326         };
2327
2328         bpfjit_func_t code;
2329         uint8_t pkt[1]; /* the program doesn't read any data */
2330
2331         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2332
2333         ATF_CHECK(bpf_validate(insns, insn_count));
2334
2335         code = bpfjit_generate_code(NULL, insns, insn_count);
2336         ATF_REQUIRE(code != NULL);
2337
2338         ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_MAX - 5);
2339
2340         bpfjit_free_code(code);
2341 }
2342
2343 ATF_TC(libbpfjit_ldx_imm2);
2344 ATF_TC_HEAD(libbpfjit_ldx_imm2, tc)
2345 {
2346         atf_tc_set_md_var(tc, "descr",
2347             "Test JIT compilation of BPF_LDX+BPF_IMM");
2348 }
2349
2350 ATF_TC_BODY(libbpfjit_ldx_imm2, tc)
2351 {
2352         static struct bpf_insn insns[] = {
2353                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 5),
2354                 BPF_STMT(BPF_LD+BPF_IMM, 5),
2355                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 1, 0),
2356                 BPF_STMT(BPF_RET+BPF_K, 7),
2357                 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX)
2358         };
2359
2360         bpfjit_func_t code;
2361         uint8_t pkt[1]; /* the program doesn't read any data */
2362
2363         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2364
2365         ATF_CHECK(bpf_validate(insns, insn_count));
2366
2367         code = bpfjit_generate_code(NULL, insns, insn_count);
2368         ATF_REQUIRE(code != NULL);
2369
2370         ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_MAX);
2371
2372         bpfjit_free_code(code);
2373 }
2374
2375 ATF_TC(libbpfjit_ldx_len1);
2376 ATF_TC_HEAD(libbpfjit_ldx_len1, tc)
2377 {
2378         atf_tc_set_md_var(tc, "descr",
2379             "Test JIT compilation of BPF_LDX+BPF_LEN");
2380 }
2381
2382 ATF_TC_BODY(libbpfjit_ldx_len1, tc)
2383 {
2384         static struct bpf_insn insns[] = {
2385                 BPF_STMT(BPF_LDX+BPF_W+BPF_LEN, 0),
2386                 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0),
2387                 BPF_STMT(BPF_RET+BPF_A, 0)
2388         };
2389
2390         size_t i;
2391         bpfjit_func_t code;
2392         uint8_t pkt[5]; /* the program doesn't read any data */
2393
2394         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2395
2396         ATF_CHECK(bpf_validate(insns, insn_count));
2397
2398         code = bpfjit_generate_code(NULL, insns, insn_count);
2399         ATF_REQUIRE(code != NULL);
2400
2401         for (i = 1; i < sizeof(pkt); i++) {
2402                 ATF_CHECK(jitcall(code, pkt, i, 1) == i);
2403                 ATF_CHECK(jitcall(code, pkt, i + 1, i) == i + 1);
2404         }
2405
2406         bpfjit_free_code(code);
2407 }
2408
2409 ATF_TC(libbpfjit_ldx_len2);
2410 ATF_TC_HEAD(libbpfjit_ldx_len2, tc)
2411 {
2412         atf_tc_set_md_var(tc, "descr",
2413             "Test JIT compilation of BPF_LDX+BPF_LEN");
2414 }
2415
2416 ATF_TC_BODY(libbpfjit_ldx_len2, tc)
2417 {
2418         static struct bpf_insn insns[] = {
2419                 BPF_STMT(BPF_LDX+BPF_W+BPF_LEN, 0),
2420                 BPF_STMT(BPF_LD+BPF_IMM, 5),
2421                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 1, 0),
2422                 BPF_STMT(BPF_RET+BPF_K, 7),
2423                 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX)
2424         };
2425
2426         bpfjit_func_t code;
2427         uint8_t pkt[5]; /* the program doesn't read any data */
2428
2429         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2430
2431         ATF_CHECK(bpf_validate(insns, insn_count));
2432
2433         code = bpfjit_generate_code(NULL, insns, insn_count);
2434         ATF_REQUIRE(code != NULL);
2435
2436         ATF_CHECK(jitcall(code, pkt, 5, 1) == UINT32_MAX);
2437         ATF_CHECK(jitcall(code, pkt, 6, 5) == 7);
2438
2439         bpfjit_free_code(code);
2440 }
2441
2442 ATF_TC(libbpfjit_ldx_msh);
2443 ATF_TC_HEAD(libbpfjit_ldx_msh, tc)
2444 {
2445         atf_tc_set_md_var(tc, "descr",
2446             "Test JIT compilation of BPF_LDX+BPF_MSH");
2447 }
2448
2449 ATF_TC_BODY(libbpfjit_ldx_msh, tc)
2450 {
2451         static struct bpf_insn insns[] = {
2452                 BPF_STMT(BPF_LDX+BPF_B+BPF_MSH, 1),
2453                 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0),
2454                 BPF_STMT(BPF_RET+BPF_A, 0)
2455         };
2456
2457         bpfjit_func_t code;
2458         uint8_t pkt[2] = { 0, 0x7a };
2459
2460         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2461
2462         ATF_CHECK(bpf_validate(insns, insn_count));
2463
2464         code = bpfjit_generate_code(NULL, insns, insn_count);
2465         ATF_REQUIRE(code != NULL);
2466
2467         ATF_CHECK(jitcall(code, pkt, 2, 2) == 40);
2468
2469         bpfjit_free_code(code);
2470 }
2471
2472 ATF_TC(libbpfjit_misc_tax);
2473 ATF_TC_HEAD(libbpfjit_misc_tax, tc)
2474 {
2475         atf_tc_set_md_var(tc, "descr",
2476             "Test JIT compilation of BPF_MISC+BPF_TAX");
2477 }
2478
2479 ATF_TC_BODY(libbpfjit_misc_tax, tc)
2480 {
2481         static struct bpf_insn insns[] = {
2482                 BPF_STMT(BPF_LD+BPF_IMM, 3),
2483                 BPF_STMT(BPF_MISC+BPF_TAX, 0),
2484                 BPF_STMT(BPF_LD+BPF_B+BPF_IND, 2),
2485                 BPF_STMT(BPF_RET+BPF_A, 0)
2486         };
2487
2488         bpfjit_func_t code;
2489         uint8_t pkt[] = { 0, 11, 22, 33, 44, 55 };
2490
2491         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2492
2493         ATF_CHECK(bpf_validate(insns, insn_count));
2494
2495         code = bpfjit_generate_code(NULL, insns, insn_count);
2496         ATF_REQUIRE(code != NULL);
2497
2498         ATF_CHECK(jitcall(code, pkt, sizeof(pkt), sizeof(pkt)) == 55);
2499
2500         bpfjit_free_code(code);
2501 }
2502
2503 ATF_TC(libbpfjit_misc_txa);
2504 ATF_TC_HEAD(libbpfjit_misc_txa, tc)
2505 {
2506         atf_tc_set_md_var(tc, "descr",
2507             "Test JIT compilation of BPF_MISC+BPF_TXA");
2508 }
2509
2510 ATF_TC_BODY(libbpfjit_misc_txa, tc)
2511 {
2512         static struct bpf_insn insns[] = {
2513                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 391),
2514                 BPF_STMT(BPF_MISC+BPF_TXA, 0),
2515                 BPF_STMT(BPF_RET+BPF_A, 0)
2516         };
2517
2518         bpfjit_func_t code;
2519         uint8_t pkt[1]; /* the program doesn't read any data */
2520
2521         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2522
2523         ATF_CHECK(bpf_validate(insns, insn_count));
2524
2525         code = bpfjit_generate_code(NULL, insns, insn_count);
2526         ATF_REQUIRE(code != NULL);
2527
2528         ATF_CHECK(jitcall(code, pkt, 1, 1) == 391);
2529
2530         bpfjit_free_code(code);
2531 }
2532
2533 ATF_TC(libbpfjit_st1);
2534 ATF_TC_HEAD(libbpfjit_st1, tc)
2535 {
2536         atf_tc_set_md_var(tc, "descr",
2537             "Test JIT compilation of BPF_ST");
2538 }
2539
2540 ATF_TC_BODY(libbpfjit_st1, tc)
2541 {
2542         static struct bpf_insn insns[] = {
2543                 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0),
2544                 BPF_STMT(BPF_ST, 0),
2545                 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 1),
2546                 BPF_STMT(BPF_LD+BPF_MEM, 0),
2547                 BPF_STMT(BPF_RET+BPF_A, 0)
2548         };
2549
2550         size_t i;
2551         bpfjit_func_t code;
2552         uint8_t pkt[16]; /* the program doesn't read any data */
2553
2554         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2555
2556         ATF_CHECK(bpf_validate(insns, insn_count));
2557
2558         code = bpfjit_generate_code(NULL, insns, insn_count);
2559         ATF_REQUIRE(code != NULL);
2560
2561         for (i = 1; i <= sizeof(pkt); i++)
2562                 ATF_CHECK(jitcall(code, pkt, i, sizeof(pkt)) == i);
2563
2564         bpfjit_free_code(code);
2565 }
2566
2567 ATF_TC(libbpfjit_st2);
2568 ATF_TC_HEAD(libbpfjit_st2, tc)
2569 {
2570         atf_tc_set_md_var(tc, "descr",
2571             "Test JIT compilation of BPF_ST");
2572 }
2573
2574 ATF_TC_BODY(libbpfjit_st2, tc)
2575 {
2576         static struct bpf_insn insns[] = {
2577                 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0),
2578                 BPF_STMT(BPF_ST, BPF_MEMWORDS-1),
2579                 BPF_STMT(BPF_LD+BPF_MEM, 0),
2580                 BPF_STMT(BPF_RET+BPF_A, 0)
2581         };
2582
2583         bpfjit_func_t code;
2584         uint8_t pkt[1]; /* the program doesn't read any data */
2585
2586         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2587
2588         ATF_CHECK(bpf_validate(insns, insn_count));
2589
2590         code = bpfjit_generate_code(NULL, insns, insn_count);
2591         ATF_REQUIRE(code != NULL);
2592
2593         ATF_CHECK(jitcall(code, pkt, 1, 1) == 0);
2594
2595         bpfjit_free_code(code);
2596 }
2597
2598 ATF_TC(libbpfjit_st3);
2599 ATF_TC_HEAD(libbpfjit_st3, tc)
2600 {
2601         atf_tc_set_md_var(tc, "descr",
2602             "Test JIT compilation of BPF_ST");
2603 }
2604
2605 ATF_TC_BODY(libbpfjit_st3, tc)
2606 {
2607         static struct bpf_insn insns[] = {
2608                 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0),
2609                 BPF_STMT(BPF_ST, 0),
2610                 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 100),
2611                 BPF_STMT(BPF_ST, BPF_MEMWORDS-1),
2612                 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 200),
2613                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 301, 2, 0),
2614                 BPF_STMT(BPF_LD+BPF_MEM, BPF_MEMWORDS-1),
2615                 BPF_STMT(BPF_RET+BPF_A, 0),
2616                 BPF_STMT(BPF_LD+BPF_MEM, 0),
2617                 BPF_STMT(BPF_RET+BPF_A, 0)
2618         };
2619
2620         bpfjit_func_t code;
2621         uint8_t pkt[2]; /* the program doesn't read any data */
2622
2623         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2624
2625         ATF_REQUIRE(BPF_MEMWORDS > 1);
2626
2627         ATF_CHECK(bpf_validate(insns, insn_count));
2628
2629         code = bpfjit_generate_code(NULL, insns, insn_count);
2630         ATF_REQUIRE(code != NULL);
2631
2632         ATF_CHECK(jitcall(code, pkt, 1, 1) == 1);
2633         ATF_CHECK(jitcall(code, pkt, 2, 2) == 102);
2634
2635         bpfjit_free_code(code);
2636 }
2637
2638 ATF_TC(libbpfjit_st4);
2639 ATF_TC_HEAD(libbpfjit_st4, tc)
2640 {
2641         atf_tc_set_md_var(tc, "descr",
2642             "Test JIT compilation of BPF_ST");
2643 }
2644
2645 ATF_TC_BODY(libbpfjit_st4, tc)
2646 {
2647         static struct bpf_insn insns[] = {
2648                 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0),
2649                 BPF_STMT(BPF_ST, 5),
2650                 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 100),
2651                 BPF_STMT(BPF_ST, BPF_MEMWORDS-1),
2652                 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 200),
2653                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 301, 2, 0),
2654                 BPF_STMT(BPF_LD+BPF_MEM, BPF_MEMWORDS-1),
2655                 BPF_STMT(BPF_RET+BPF_A, 0),
2656                 BPF_STMT(BPF_LD+BPF_MEM, 5),
2657                 BPF_STMT(BPF_RET+BPF_A, 0)
2658         };
2659
2660         bpfjit_func_t code;
2661         uint8_t pkt[2]; /* the program doesn't read any data */
2662
2663         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2664
2665         ATF_REQUIRE(BPF_MEMWORDS > 6);
2666
2667         ATF_CHECK(bpf_validate(insns, insn_count));
2668
2669         code = bpfjit_generate_code(NULL, insns, insn_count);
2670         ATF_REQUIRE(code != NULL);
2671
2672         ATF_CHECK(jitcall(code, pkt, 1, 1) == 1);
2673         ATF_CHECK(jitcall(code, pkt, 2, 2) == 102);
2674
2675         bpfjit_free_code(code);
2676 }
2677
2678 ATF_TC(libbpfjit_st5);
2679 ATF_TC_HEAD(libbpfjit_st5, tc)
2680 {
2681         atf_tc_set_md_var(tc, "descr",
2682             "Test JIT compilation of BPF_ST");
2683 }
2684
2685 ATF_TC_BODY(libbpfjit_st5, tc)
2686 {
2687         struct bpf_insn insns[5*BPF_MEMWORDS+2];
2688         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2689
2690         size_t k;
2691         bpfjit_func_t code;
2692         uint8_t pkt[BPF_MEMWORDS]; /* the program doesn't read any data */
2693
2694         memset(insns, 0, sizeof(insns));
2695
2696         /* for each k do M[k] = k */
2697         for (k = 0; k < BPF_MEMWORDS; k++) {
2698                 insns[2*k].code   = BPF_LD+BPF_IMM;
2699                 insns[2*k].k      = 3*k;
2700                 insns[2*k+1].code = BPF_ST;
2701                 insns[2*k+1].k    = k;
2702         }
2703
2704         /* load wirelen into A */
2705         insns[2*BPF_MEMWORDS].code = BPF_LD+BPF_W+BPF_LEN;
2706
2707         /* for each k, if (A == k + 1) return M[k] */
2708         for (k = 0; k < BPF_MEMWORDS; k++) {
2709                 insns[2*BPF_MEMWORDS+3*k+1].code = BPF_JMP+BPF_JEQ+BPF_K;
2710                 insns[2*BPF_MEMWORDS+3*k+1].k    = k+1;
2711                 insns[2*BPF_MEMWORDS+3*k+1].jt   = 0;
2712                 insns[2*BPF_MEMWORDS+3*k+1].jf   = 2;
2713                 insns[2*BPF_MEMWORDS+3*k+2].code = BPF_LD+BPF_MEM;
2714                 insns[2*BPF_MEMWORDS+3*k+2].k    = k;
2715                 insns[2*BPF_MEMWORDS+3*k+3].code = BPF_RET+BPF_A;
2716                 insns[2*BPF_MEMWORDS+3*k+3].k    = 0;
2717         }
2718
2719         insns[5*BPF_MEMWORDS+1].code = BPF_RET+BPF_K;
2720         insns[5*BPF_MEMWORDS+1].k    = UINT32_MAX;
2721
2722         ATF_CHECK(bpf_validate(insns, insn_count));
2723
2724         code = bpfjit_generate_code(NULL, insns, insn_count);
2725         ATF_REQUIRE(code != NULL);
2726
2727         for (k = 1; k <= sizeof(pkt); k++)
2728                 ATF_CHECK(jitcall(code, pkt, k, k) == 3*(k-1));
2729
2730         bpfjit_free_code(code);
2731 }
2732
2733 ATF_TC(libbpfjit_stx1);
2734 ATF_TC_HEAD(libbpfjit_stx1, tc)
2735 {
2736         atf_tc_set_md_var(tc, "descr",
2737             "Test JIT compilation of BPF_STX");
2738 }
2739
2740 ATF_TC_BODY(libbpfjit_stx1, tc)
2741 {
2742         static struct bpf_insn insns[] = {
2743                 BPF_STMT(BPF_LDX+BPF_W+BPF_LEN, 0),
2744                 BPF_STMT(BPF_STX, 0),
2745                 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0),
2746                 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0),
2747                 BPF_STMT(BPF_RET+BPF_A, 0)
2748         };
2749
2750         size_t i;
2751         bpfjit_func_t code;
2752         uint8_t pkt[16]; /* the program doesn't read any data */
2753
2754         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2755
2756         ATF_CHECK(bpf_validate(insns, insn_count));
2757
2758         code = bpfjit_generate_code(NULL, insns, insn_count);
2759         ATF_REQUIRE(code != NULL);
2760
2761         for (i = 1; i <= sizeof(pkt); i++)
2762                 ATF_CHECK(jitcall(code, pkt, i, sizeof(pkt)) == i);
2763
2764         bpfjit_free_code(code);
2765 }
2766
2767 ATF_TC(libbpfjit_stx2);
2768 ATF_TC_HEAD(libbpfjit_stx2, tc)
2769 {
2770         atf_tc_set_md_var(tc, "descr",
2771             "Test JIT compilation of BPF_STX");
2772 }
2773
2774 ATF_TC_BODY(libbpfjit_stx2, tc)
2775 {
2776         static struct bpf_insn insns[] = {
2777                 BPF_STMT(BPF_LDX+BPF_W+BPF_LEN, 0),
2778                 BPF_STMT(BPF_STX, BPF_MEMWORDS-1),
2779                 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0),
2780                 BPF_STMT(BPF_MISC+BPF_TXA, 0),
2781                 BPF_STMT(BPF_RET+BPF_A, 0)
2782         };
2783
2784         bpfjit_func_t code;
2785         uint8_t pkt[1]; /* the program doesn't read any data */
2786
2787         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2788
2789         ATF_CHECK(bpf_validate(insns, insn_count));
2790
2791         code = bpfjit_generate_code(NULL, insns, insn_count);
2792         ATF_REQUIRE(code != NULL);
2793
2794         ATF_CHECK(jitcall(code, pkt, 1, 1) == 0);
2795
2796         bpfjit_free_code(code);
2797 }
2798
2799 ATF_TC(libbpfjit_stx3);
2800 ATF_TC_HEAD(libbpfjit_stx3, tc)
2801 {
2802         atf_tc_set_md_var(tc, "descr",
2803             "Test JIT compilation of BPF_STX");
2804 }
2805
2806 ATF_TC_BODY(libbpfjit_stx3, tc)
2807 {
2808         static struct bpf_insn insns[] = {
2809                 BPF_STMT(BPF_LDX+BPF_W+BPF_LEN, 0),
2810                 BPF_STMT(BPF_STX, 5),
2811                 BPF_STMT(BPF_STX, 2),
2812                 BPF_STMT(BPF_STX, 3),
2813                 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 1),
2814                 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0),
2815                 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 2),
2816                 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0),
2817                 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 3),
2818                 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0),
2819                 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 5),
2820                 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0),
2821                 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 6),
2822                 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0),
2823                 BPF_STMT(BPF_RET+BPF_A, 0)
2824         };
2825
2826         size_t i;
2827         bpfjit_func_t code;
2828         uint8_t pkt[16]; /* the program doesn't read any data */
2829
2830         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2831
2832         ATF_CHECK(bpf_validate(insns, insn_count));
2833
2834         code = bpfjit_generate_code(NULL, insns, insn_count);
2835         ATF_REQUIRE(code != NULL);
2836
2837         for (i = 1; i <= sizeof(pkt); i++)
2838                 ATF_CHECK(jitcall(code, pkt, i, sizeof(pkt)) == 3 * i);
2839
2840         bpfjit_free_code(code);
2841 }
2842
2843 ATF_TC(libbpfjit_stx4);
2844 ATF_TC_HEAD(libbpfjit_stx4, tc)
2845 {
2846         atf_tc_set_md_var(tc, "descr",
2847             "Test JIT compilation of BPF_STX");
2848 }
2849
2850 ATF_TC_BODY(libbpfjit_stx4, tc)
2851 {
2852         struct bpf_insn insns[5*BPF_MEMWORDS+2];
2853         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2854
2855         size_t k;
2856         bpfjit_func_t code;
2857         uint8_t pkt[BPF_MEMWORDS]; /* the program doesn't read any data */
2858
2859         memset(insns, 0, sizeof(insns));
2860
2861         /* for each k do M[k] = k */
2862         for (k = 0; k < BPF_MEMWORDS; k++) {
2863                 insns[2*k].code   = BPF_LDX+BPF_W+BPF_IMM;
2864                 insns[2*k].k      = 3*k;
2865                 insns[2*k+1].code = BPF_STX;
2866                 insns[2*k+1].k    = k;
2867         }
2868
2869         /* load wirelen into A */
2870         insns[2*BPF_MEMWORDS].code = BPF_LD+BPF_W+BPF_LEN;
2871
2872         /* for each k, if (A == k + 1) return M[k] */
2873         for (k = 0; k < BPF_MEMWORDS; k++) {
2874                 insns[2*BPF_MEMWORDS+3*k+1].code = BPF_JMP+BPF_JEQ+BPF_K;
2875                 insns[2*BPF_MEMWORDS+3*k+1].k    = k+1;
2876                 insns[2*BPF_MEMWORDS+3*k+1].jt   = 0;
2877                 insns[2*BPF_MEMWORDS+3*k+1].jf   = 2;
2878                 insns[2*BPF_MEMWORDS+3*k+2].code = BPF_LD+BPF_MEM;
2879                 insns[2*BPF_MEMWORDS+3*k+2].k    = k;
2880                 insns[2*BPF_MEMWORDS+3*k+3].code = BPF_RET+BPF_A;
2881                 insns[2*BPF_MEMWORDS+3*k+3].k    = 0;
2882         }
2883
2884         insns[5*BPF_MEMWORDS+1].code = BPF_RET+BPF_K;
2885         insns[5*BPF_MEMWORDS+1].k    = UINT32_MAX;
2886
2887         ATF_CHECK(bpf_validate(insns, insn_count));
2888
2889         code = bpfjit_generate_code(NULL, insns, insn_count);
2890         ATF_REQUIRE(code != NULL);
2891
2892         for (k = 1; k <= sizeof(pkt); k++)
2893                 ATF_CHECK(jitcall(code, pkt, k, k) == 3*(k-1));
2894
2895         bpfjit_free_code(code);
2896 }
2897
2898 ATF_TC(libbpfjit_opt_ld_abs_1);
2899 ATF_TC_HEAD(libbpfjit_opt_ld_abs_1, tc)
2900 {
2901         atf_tc_set_md_var(tc, "descr",
2902             "Test JIT compilation with length optimization "
2903             "applied to BPF_LD+BPF_ABS");
2904 }
2905
2906 ATF_TC_BODY(libbpfjit_opt_ld_abs_1, tc)
2907 {
2908         static struct bpf_insn insns[] = {
2909                 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 12),
2910                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x800, 0, 8),
2911                 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 26),
2912                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 2),
2913                 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 30),
2914                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 3, 4),
2915                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 3),
2916                 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 30),
2917                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 1),
2918                 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX),
2919                 BPF_STMT(BPF_RET+BPF_K, 0),
2920         };
2921
2922         size_t i, j;
2923         bpfjit_func_t code;
2924         uint8_t pkt[2][34] = {
2925                 {
2926                         0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00,
2927                         14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
2928                         0x80, 0x03, 0x70, 0x0f,
2929                         0x80, 0x03, 0x70, 0x23
2930                 },
2931                 {
2932                         0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00,
2933                         14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
2934                         0x80, 0x03, 0x70, 0x23,
2935                         0x80, 0x03, 0x70, 0x0f
2936                 }
2937         };
2938
2939         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2940
2941         ATF_CHECK(bpf_validate(insns, insn_count));
2942
2943         code = bpfjit_generate_code(NULL, insns, insn_count);
2944         ATF_REQUIRE(code != NULL);
2945
2946         for (i = 0; i < 2; i++) {
2947                 for (j = 1; j < sizeof(pkt[i]); j++)
2948                         ATF_CHECK(jitcall(code, pkt[i], j, j) == 0);
2949                 ATF_CHECK(jitcall(code, pkt[i], j, j) == UINT32_MAX);
2950         }
2951
2952         bpfjit_free_code(code);
2953 }
2954
2955 ATF_TC(libbpfjit_opt_ld_abs_2);
2956 ATF_TC_HEAD(libbpfjit_opt_ld_abs_2, tc)
2957 {
2958         atf_tc_set_md_var(tc, "descr",
2959             "Test JIT compilation with length optimization "
2960             "applied to BPF_LD+BPF_ABS");
2961 }
2962
2963 ATF_TC_BODY(libbpfjit_opt_ld_abs_2, tc)
2964 {
2965         static struct bpf_insn insns[] = {
2966                 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 26),
2967                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 2),
2968                 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 30),
2969                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 3, 6),
2970                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 5),
2971                 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 30),
2972                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 3),
2973                 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 12),
2974                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x800, 0, 1),
2975                 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX),
2976                 BPF_STMT(BPF_RET+BPF_K, 0),
2977         };
2978
2979         size_t i, j;
2980         bpfjit_func_t code;
2981         uint8_t pkt[2][34] = {
2982                 {
2983                         0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00,
2984                         14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
2985                         0x80, 0x03, 0x70, 0x0f,
2986                         0x80, 0x03, 0x70, 0x23
2987                 },
2988                 {
2989                         0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00,
2990                         14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
2991                         0x80, 0x03, 0x70, 0x23,
2992                         0x80, 0x03, 0x70, 0x0f
2993                 }
2994         };
2995
2996         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2997
2998         ATF_CHECK(bpf_validate(insns, insn_count));
2999
3000         code = bpfjit_generate_code(NULL, insns, insn_count);
3001         ATF_REQUIRE(code != NULL);
3002
3003         for (i = 0; i < 2; i++) {
3004                 for (j = 1; j < sizeof(pkt[i]); j++)
3005                         ATF_CHECK(jitcall(code, pkt[i], j, j) == 0);
3006                 ATF_CHECK(jitcall(code, pkt[i], j, j) == UINT32_MAX);
3007         }
3008
3009         bpfjit_free_code(code);
3010 }
3011
3012 ATF_TC(libbpfjit_opt_ld_abs_3);
3013 ATF_TC_HEAD(libbpfjit_opt_ld_abs_3, tc)
3014 {
3015         atf_tc_set_md_var(tc, "descr",
3016             "Test JIT compilation with length optimization "
3017             "applied to BPF_LD+BPF_ABS");
3018 }
3019
3020 ATF_TC_BODY(libbpfjit_opt_ld_abs_3, tc)
3021 {
3022         static struct bpf_insn insns[] = {
3023                 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 30),
3024                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 2),
3025                 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 26),
3026                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 3, 6),
3027                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 5),
3028                 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 26),
3029                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 3),
3030                 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 12),
3031                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x800, 0, 1),
3032                 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX),
3033                 BPF_STMT(BPF_RET+BPF_K, 0),
3034         };
3035
3036         size_t i, j;
3037         bpfjit_func_t code;
3038         uint8_t pkt[2][34] = {
3039                 {
3040                         0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00,
3041                         14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
3042                         0x80, 0x03, 0x70, 0x0f,
3043                         0x80, 0x03, 0x70, 0x23
3044                 },
3045                 {
3046                         0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00,
3047                         14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
3048                         0x80, 0x03, 0x70, 0x23,
3049                         0x80, 0x03, 0x70, 0x0f
3050                 }
3051         };
3052
3053         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3054
3055         ATF_CHECK(bpf_validate(insns, insn_count));
3056
3057         code = bpfjit_generate_code(NULL, insns, insn_count);
3058         ATF_REQUIRE(code != NULL);
3059
3060         for (i = 0; i < 2; i++) {
3061                 for (j = 1; j < sizeof(pkt[i]); j++)
3062                         ATF_CHECK(jitcall(code, pkt[i], j, j) == 0);
3063                 ATF_CHECK(jitcall(code, pkt[i], j, j) == UINT32_MAX);
3064         }
3065
3066         bpfjit_free_code(code);
3067 }
3068
3069 ATF_TC(libbpfjit_opt_ld_ind_1);
3070 ATF_TC_HEAD(libbpfjit_opt_ld_ind_1, tc)
3071 {
3072         atf_tc_set_md_var(tc, "descr",
3073             "Test JIT compilation with length optimization "
3074             "applied to BPF_LD+BPF_IND");
3075 }
3076
3077 ATF_TC_BODY(libbpfjit_opt_ld_ind_1, tc)
3078 {
3079         static struct bpf_insn insns[] = {
3080                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 12),
3081                 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 0),
3082                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x800, 0, 8),
3083                 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 14),
3084                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 2),
3085                 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 18),
3086                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 3, 4),
3087                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 3),
3088                 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 18),
3089                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 1),
3090                 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX),
3091                 BPF_STMT(BPF_RET+BPF_K, 0),
3092         };
3093
3094         size_t i, j;
3095         bpfjit_func_t code;
3096         uint8_t pkt[2][34] = {
3097                 {
3098                         0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00,
3099                         14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
3100                         0x80, 0x03, 0x70, 0x0f,
3101                         0x80, 0x03, 0x70, 0x23
3102                 },
3103                 {
3104                         0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00,
3105                         14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
3106                         0x80, 0x03, 0x70, 0x23,
3107                         0x80, 0x03, 0x70, 0x0f
3108                 }
3109         };
3110
3111         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3112
3113         ATF_CHECK(bpf_validate(insns, insn_count));
3114
3115         code = bpfjit_generate_code(NULL, insns, insn_count);
3116         ATF_REQUIRE(code != NULL);
3117
3118         for (i = 0; i < 2; i++) {
3119                 for (j = 1; j < sizeof(pkt[i]); j++)
3120                         ATF_CHECK(jitcall(code, pkt[i], j, j) == 0);
3121                 ATF_CHECK(jitcall(code, pkt[i], j, j) == UINT32_MAX);
3122         }
3123
3124         bpfjit_free_code(code);
3125 }
3126
3127 ATF_TC(libbpfjit_opt_ld_ind_2);
3128 ATF_TC_HEAD(libbpfjit_opt_ld_ind_2, tc)
3129 {
3130         atf_tc_set_md_var(tc, "descr",
3131             "Test JIT compilation with length optimization "
3132             "applied to BPF_LD+BPF_IND");
3133 }
3134
3135 ATF_TC_BODY(libbpfjit_opt_ld_ind_2, tc)
3136 {
3137         static struct bpf_insn insns[] = {
3138                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0),
3139                 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 26),
3140                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 2),
3141                 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 30),
3142                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 3, 6),
3143                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 5),
3144                 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 30),
3145                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 3),
3146                 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 12),
3147                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x800, 0, 1),
3148                 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX),
3149                 BPF_STMT(BPF_RET+BPF_K, 0),
3150         };
3151
3152         size_t i, j;
3153         bpfjit_func_t code;
3154         uint8_t pkt[2][34] = {
3155                 {
3156                         0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00,
3157                         14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
3158                         0x80, 0x03, 0x70, 0x0f,
3159                         0x80, 0x03, 0x70, 0x23
3160                 },
3161                 {
3162                         0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00,
3163                         14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
3164                         0x80, 0x03, 0x70, 0x23,
3165                         0x80, 0x03, 0x70, 0x0f
3166                 }
3167         };
3168
3169         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3170
3171         ATF_CHECK(bpf_validate(insns, insn_count));
3172
3173         code = bpfjit_generate_code(NULL, insns, insn_count);
3174         ATF_REQUIRE(code != NULL);
3175
3176         for (i = 0; i < 2; i++) {
3177                 for (j = 1; j < sizeof(pkt[i]); j++)
3178                         ATF_CHECK(jitcall(code, pkt[i], j, j) == 0);
3179                 ATF_CHECK(jitcall(code, pkt[i], j, j) == UINT32_MAX);
3180         }
3181
3182         bpfjit_free_code(code);
3183 }
3184
3185 ATF_TC(libbpfjit_opt_ld_ind_3);
3186 ATF_TC_HEAD(libbpfjit_opt_ld_ind_3, tc)
3187 {
3188         atf_tc_set_md_var(tc, "descr",
3189             "Test JIT compilation with length optimization "
3190             "applied to BPF_LD+BPF_IND");
3191 }
3192
3193 ATF_TC_BODY(libbpfjit_opt_ld_ind_3, tc)
3194 {
3195         static struct bpf_insn insns[] = {
3196                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 15),
3197                 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 15),
3198                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 2),
3199                 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 11),
3200                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 3, 7),
3201                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 6),
3202                 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 11),
3203                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 4),
3204                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0),
3205                 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 12),
3206                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x800, 0, 1),
3207                 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX),
3208                 BPF_STMT(BPF_RET+BPF_K, 0),
3209         };
3210
3211         size_t i, j;
3212         bpfjit_func_t code;
3213         uint8_t pkt[2][34] = {
3214                 {
3215                         0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00,
3216                         14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
3217                         0x80, 0x03, 0x70, 0x0f,
3218                         0x80, 0x03, 0x70, 0x23
3219                 },
3220                 {
3221                         0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00,
3222                         14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
3223                         0x80, 0x03, 0x70, 0x23,
3224                         0x80, 0x03, 0x70, 0x0f
3225                 }
3226         };
3227
3228         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3229
3230         ATF_CHECK(bpf_validate(insns, insn_count));
3231
3232         code = bpfjit_generate_code(NULL, insns, insn_count);
3233         ATF_REQUIRE(code != NULL);
3234
3235         for (i = 0; i < 2; i++) {
3236                 for (j = 1; j < sizeof(pkt[i]); j++)
3237                         ATF_CHECK(jitcall(code, pkt[i], j, j) == 0);
3238                 ATF_CHECK(jitcall(code, pkt[i], j, j) == UINT32_MAX);
3239         }
3240
3241         bpfjit_free_code(code);
3242 }
3243
3244 ATF_TC(libbpfjit_opt_ld_ind_4);
3245 ATF_TC_HEAD(libbpfjit_opt_ld_ind_4, tc)
3246 {
3247         atf_tc_set_md_var(tc, "descr",
3248             "Test JIT compilation with length optimization "
3249             "applied to BPF_LD+BPF_IND");
3250 }
3251
3252 ATF_TC_BODY(libbpfjit_opt_ld_ind_4, tc)
3253 {
3254         static struct bpf_insn insns[] = {
3255                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 11),
3256                 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 19),
3257                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 2),
3258                 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 15),
3259                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 3, 7),
3260                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 6),
3261                 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 15),
3262                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 4),
3263                 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0),
3264                 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 12),
3265                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x800, 0, 1),
3266                 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX),
3267                 BPF_STMT(BPF_RET+BPF_K, 0),
3268         };
3269
3270         size_t i, j;
3271         bpfjit_func_t code;
3272         uint8_t pkt[2][34] = {
3273                 {
3274                         0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00,
3275                         14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
3276                         0x80, 0x03, 0x70, 0x0f,
3277                         0x80, 0x03, 0x70, 0x23
3278                 },
3279                 {
3280                         0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00,
3281                         14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
3282                         0x80, 0x03, 0x70, 0x23,
3283                         0x80, 0x03, 0x70, 0x0f
3284                 }
3285         };
3286
3287         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3288
3289         ATF_CHECK(bpf_validate(insns, insn_count));
3290
3291         code = bpfjit_generate_code(NULL, insns, insn_count);
3292         ATF_REQUIRE(code != NULL);
3293
3294         for (i = 0; i < 2; i++) {
3295                 for (j = 1; j < sizeof(pkt[i]); j++)
3296                         ATF_CHECK(jitcall(code, pkt[i], j, j) == 0);
3297                 ATF_CHECK(jitcall(code, pkt[i], j, j) == UINT32_MAX);
3298         }
3299
3300         bpfjit_free_code(code);
3301 }
3302
3303 ATF_TC(libbpfjit_abc_ja);
3304 ATF_TC_HEAD(libbpfjit_abc_ja, tc)
3305 {
3306         atf_tc_set_md_var(tc, "descr",
3307             "Test ABC optimization with a single BPF_JMP+BPF_JA");
3308 }
3309
3310 ATF_TC_BODY(libbpfjit_abc_ja, tc)
3311 {
3312         static struct bpf_insn insns[] = {
3313                 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 3), /* min. length 4 */
3314                 BPF_STMT(BPF_JMP+BPF_JA, 2),
3315                 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, UINT32_MAX - 1),
3316                 BPF_STMT(BPF_RET+BPF_K, 0),
3317                 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 2), /* min. length 6 */
3318                 BPF_STMT(BPF_RET+BPF_A, 0),
3319                 BPF_STMT(BPF_RET+BPF_K, 1),
3320                 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 6),
3321                 BPF_STMT(BPF_RET+BPF_K, 2),
3322                 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7),
3323                 BPF_STMT(BPF_RET+BPF_K, 3),
3324         };
3325
3326         bpfjit_func_t code;
3327         uint8_t pkt[6] = {0, 0, /* UINT32_MAX: */ 255, 255, 255, 255};
3328
3329         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3330
3331         ATF_CHECK(bpf_validate(insns, insn_count));
3332
3333         code = bpfjit_generate_code(NULL, insns, insn_count);
3334         ATF_REQUIRE(code != NULL);
3335
3336         ATF_CHECK(jitcall(code, pkt, 1, 1) == 0);
3337         ATF_CHECK(jitcall(code, pkt, 2, 2) == 0);
3338         ATF_CHECK(jitcall(code, pkt, 3, 3) == 0);
3339         ATF_CHECK(jitcall(code, pkt, 4, 4) == 0);
3340         ATF_CHECK(jitcall(code, pkt, 5, 5) == 0);
3341         ATF_CHECK(jitcall(code, pkt, 6, 6) == UINT32_MAX);
3342
3343         bpfjit_free_code(code);
3344 }
3345
3346 ATF_TC(libbpfjit_abc_ja_over);
3347 ATF_TC_HEAD(libbpfjit_abc_ja_over, tc)
3348 {
3349         atf_tc_set_md_var(tc, "descr",
3350             "Test ABC optimization when BPF_JMP+BPF_JA jumps over all loads");
3351 }
3352
3353 ATF_TC_BODY(libbpfjit_abc_ja_over, tc)
3354 {
3355         static struct bpf_insn insns[] = {
3356                 BPF_STMT(BPF_JMP+BPF_JA, 2),
3357                 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 3),
3358                 BPF_STMT(BPF_RET+BPF_K, 0),
3359                 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX),
3360                 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 4),
3361                 BPF_STMT(BPF_RET+BPF_K, 1),
3362                 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 5),
3363                 BPF_STMT(BPF_RET+BPF_K, 2),
3364                 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 6),
3365                 BPF_STMT(BPF_RET+BPF_K, 3),
3366         };
3367
3368         bpfjit_func_t code;
3369         uint8_t pkt[1]; /* the program doesn't read any data */
3370
3371         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3372
3373         ATF_CHECK(bpf_validate(insns, insn_count));
3374
3375         code = bpfjit_generate_code(NULL, insns, insn_count);
3376         ATF_REQUIRE(code != NULL);
3377
3378         ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_MAX);
3379
3380         bpfjit_free_code(code);
3381 }
3382
3383 ATF_TC(libbpfjit_abc_ld_chain);
3384 ATF_TC_HEAD(libbpfjit_abc_ld_chain, tc)
3385 {
3386         atf_tc_set_md_var(tc, "descr",
3387             "Test ABC optimization of a chain of BPF_LD instructions "
3388             "with exits leading to a single BPF_RET");
3389 }
3390
3391 ATF_TC_BODY(libbpfjit_abc_ld_chain, tc)
3392 {
3393         static struct bpf_insn insns[] = {
3394                 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 3), /* min. length 4 */
3395                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 8, 0, 4),
3396                 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 4), /* min. length 6 */
3397                 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, 7, 0, 2),
3398                 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 6), /* min. length 10 */
3399                 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, 6, 0, 1),
3400                 BPF_STMT(BPF_RET+BPF_K, 123456789),
3401                 BPF_STMT(BPF_RET+BPF_K, 987654321),
3402         };
3403
3404         bpfjit_func_t code;
3405         uint8_t pkt[10] = {};
3406
3407         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3408
3409         ATF_CHECK(bpf_validate(insns, insn_count));
3410
3411         code = bpfjit_generate_code(NULL, insns, insn_count);
3412         ATF_REQUIRE(code != NULL);
3413
3414         /* Packet is too short. */
3415         ATF_CHECK(jitcall(code, pkt, 1, 1) == 0);
3416         ATF_CHECK(jitcall(code, pkt, 2, 2) == 0);
3417         ATF_CHECK(jitcall(code, pkt, 3, 3) == 0);
3418
3419         /* !(pkt[3] == 8) => return 123456789 */
3420         ATF_CHECK(jitcall(code, pkt, 4, 4) == 123456789);
3421         ATF_CHECK(jitcall(code, pkt, 5, 5) == 123456789);
3422         ATF_CHECK(jitcall(code, pkt, 6, 6) == 123456789);
3423         ATF_CHECK(jitcall(code, pkt, 7, 7) == 123456789);
3424         ATF_CHECK(jitcall(code, pkt, 8, 8) == 123456789);
3425         ATF_CHECK(jitcall(code, pkt, 9, 9) == 123456789);
3426
3427         /* !(pkt[4:2] >= 7) => too short or return 123456789 */
3428         pkt[3] = 8;
3429         ATF_CHECK(jitcall(code, pkt, 1, 1) == 0);
3430         ATF_CHECK(jitcall(code, pkt, 2, 2) == 0);
3431         ATF_CHECK(jitcall(code, pkt, 3, 3) == 0);
3432         ATF_CHECK(jitcall(code, pkt, 4, 4) == 0);
3433         ATF_CHECK(jitcall(code, pkt, 5, 5) == 0);
3434         ATF_CHECK(jitcall(code, pkt, 6, 6) == 123456789);
3435         ATF_CHECK(jitcall(code, pkt, 9, 9) == 123456789);
3436
3437         /* !(pkt[6:4] > 6) => too short or return 987654321 */
3438         pkt[4] = pkt[5] = 1;
3439         ATF_CHECK(jitcall(code, pkt, 1, 1) == 0);
3440         ATF_CHECK(jitcall(code, pkt, 2, 2) == 0);
3441         ATF_CHECK(jitcall(code, pkt, 3, 3) == 0);
3442         ATF_CHECK(jitcall(code, pkt, 4, 4) == 0);
3443         ATF_CHECK(jitcall(code, pkt, 5, 5) == 0);
3444         ATF_CHECK(jitcall(code, pkt, 6, 6) == 0);
3445         ATF_CHECK(jitcall(code, pkt, 7, 7) == 0);
3446         ATF_CHECK(jitcall(code, pkt, 8, 8) == 0);
3447         ATF_CHECK(jitcall(code, pkt, 9, 9) == 0);
3448         ATF_CHECK(jitcall(code, pkt, 10, 10) == 987654321);
3449
3450         /* (pkt[6:4] > 6) => too short or return 123456789 */
3451         pkt[6] = pkt[7] = pkt[8] = pkt[9] = 1;
3452         ATF_CHECK(jitcall(code, pkt, 1, 1) == 0);
3453         ATF_CHECK(jitcall(code, pkt, 2, 2) == 0);
3454         ATF_CHECK(jitcall(code, pkt, 3, 3) == 0);
3455         ATF_CHECK(jitcall(code, pkt, 4, 4) == 0);
3456         ATF_CHECK(jitcall(code, pkt, 5, 5) == 0);
3457         ATF_CHECK(jitcall(code, pkt, 6, 6) == 0);
3458         ATF_CHECK(jitcall(code, pkt, 7, 7) == 0);
3459         ATF_CHECK(jitcall(code, pkt, 8, 8) == 0);
3460         ATF_CHECK(jitcall(code, pkt, 9, 9) == 0);
3461         ATF_CHECK(jitcall(code, pkt, 10, 10) == 123456789);
3462
3463         bpfjit_free_code(code);
3464 }
3465
3466 ATF_TC(libbpfjit_examples_1);
3467 ATF_TC_HEAD(libbpfjit_examples_1, tc)
3468 {
3469         atf_tc_set_md_var(tc, "descr",
3470             "Test the first example from bpf(4) - "
3471             "accept Reverse ARP requests");
3472 }
3473
3474 ATF_TC_BODY(libbpfjit_examples_1, tc)
3475 {
3476         /*
3477          * The following filter is taken from the Reverse ARP
3478          * Daemon. It accepts only Reverse ARP requests.
3479          */
3480         struct bpf_insn insns[] = {
3481                 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 12),
3482                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8035, 0, 3),
3483                 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 20),
3484                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 3, 0, 1),
3485                 BPF_STMT(BPF_RET+BPF_K, 42),
3486                 BPF_STMT(BPF_RET+BPF_K, 0),
3487         };
3488
3489         bpfjit_func_t code;
3490         uint8_t pkt[22] = {};
3491
3492         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3493
3494         ATF_CHECK(bpf_validate(insns, insn_count));
3495
3496         code = bpfjit_generate_code(NULL, insns, insn_count);
3497         ATF_REQUIRE(code != NULL);
3498
3499         /* Packet is too short. */
3500         ATF_CHECK(jitcall(code, pkt, 1, 1) == 0);
3501         ATF_CHECK(jitcall(code, pkt, 2, 2) == 0);
3502         ATF_CHECK(jitcall(code, pkt, 3, 3) == 0);
3503         ATF_CHECK(jitcall(code, pkt, 4, 4) == 0);
3504         ATF_CHECK(jitcall(code, pkt, 5, 5) == 0);
3505         ATF_CHECK(jitcall(code, pkt, 6, 6) == 0);
3506         ATF_CHECK(jitcall(code, pkt, 7, 7) == 0);
3507         ATF_CHECK(jitcall(code, pkt, 8, 8) == 0);
3508         ATF_CHECK(jitcall(code, pkt, 9, 9) == 0);
3509         ATF_CHECK(jitcall(code, pkt, 10, 10) == 0);
3510         ATF_CHECK(jitcall(code, pkt, 11, 11) == 0);
3511         ATF_CHECK(jitcall(code, pkt, 12, 12) == 0);
3512         ATF_CHECK(jitcall(code, pkt, 13, 13) == 0);
3513         ATF_CHECK(jitcall(code, pkt, 14, 14) == 0);
3514         ATF_CHECK(jitcall(code, pkt, 15, 15) == 0);
3515         ATF_CHECK(jitcall(code, pkt, 16, 16) == 0);
3516         ATF_CHECK(jitcall(code, pkt, 17, 17) == 0);
3517         ATF_CHECK(jitcall(code, pkt, 18, 18) == 0);
3518         ATF_CHECK(jitcall(code, pkt, 19, 19) == 0);
3519         ATF_CHECK(jitcall(code, pkt, 20, 20) == 0);
3520         ATF_CHECK(jitcall(code, pkt, 21, 21) == 0);
3521
3522         /* The packet doesn't match. */
3523         ATF_CHECK(jitcall(code, pkt, 22, 22) == 0);
3524
3525         /* Still no match after setting the protocol field. */
3526         pkt[12] = 0x80; pkt[13] = 0x35;
3527         ATF_CHECK(jitcall(code, pkt, 22, 22) == 0);
3528
3529         /* Set RARP message type. */
3530         pkt[21] = 3;
3531         ATF_CHECK(jitcall(code, pkt, 22, 22) == 42);
3532
3533         /* Packet is too short. */
3534         ATF_CHECK(jitcall(code, pkt, 1, 1) == 0);
3535         ATF_CHECK(jitcall(code, pkt, 2, 2) == 0);
3536         ATF_CHECK(jitcall(code, pkt, 3, 3) == 0);
3537         ATF_CHECK(jitcall(code, pkt, 4, 4) == 0);
3538         ATF_CHECK(jitcall(code, pkt, 5, 5) == 0);
3539         ATF_CHECK(jitcall(code, pkt, 6, 6) == 0);
3540         ATF_CHECK(jitcall(code, pkt, 7, 7) == 0);
3541         ATF_CHECK(jitcall(code, pkt, 8, 8) == 0);
3542         ATF_CHECK(jitcall(code, pkt, 9, 9) == 0);
3543         ATF_CHECK(jitcall(code, pkt, 10, 10) == 0);
3544         ATF_CHECK(jitcall(code, pkt, 11, 11) == 0);
3545         ATF_CHECK(jitcall(code, pkt, 12, 12) == 0);
3546         ATF_CHECK(jitcall(code, pkt, 13, 13) == 0);
3547         ATF_CHECK(jitcall(code, pkt, 14, 14) == 0);
3548         ATF_CHECK(jitcall(code, pkt, 15, 15) == 0);
3549         ATF_CHECK(jitcall(code, pkt, 16, 16) == 0);
3550         ATF_CHECK(jitcall(code, pkt, 17, 17) == 0);
3551         ATF_CHECK(jitcall(code, pkt, 18, 18) == 0);
3552         ATF_CHECK(jitcall(code, pkt, 19, 19) == 0);
3553         ATF_CHECK(jitcall(code, pkt, 20, 20) == 0);
3554         ATF_CHECK(jitcall(code, pkt, 21, 21) == 0);
3555
3556         /* Change RARP message type. */
3557         pkt[20] = 3;
3558         ATF_CHECK(jitcall(code, pkt, 22, 22) == 0);
3559
3560         bpfjit_free_code(code);
3561 }
3562
3563 ATF_TC(libbpfjit_examples_2);
3564 ATF_TC_HEAD(libbpfjit_examples_2, tc)
3565 {
3566         atf_tc_set_md_var(tc, "descr",
3567             "Test the second example from bpf(4) - "
3568             "accept IP packets between two specified hosts");
3569 }
3570
3571 ATF_TC_BODY(libbpfjit_examples_2, tc)
3572 {
3573         /*
3574          * This filter accepts only IP packets between host 128.3.112.15
3575          * and 128.3.112.35.
3576          */
3577         static struct bpf_insn insns[] = {
3578                 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 12),
3579                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x0800, 0, 8),
3580                 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 26),
3581                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 2),
3582                 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 30),
3583                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 3, 4),
3584                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 3),
3585                 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 30),
3586                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 1),
3587                 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX),
3588                 BPF_STMT(BPF_RET+BPF_K, 0),
3589         };
3590
3591         bpfjit_func_t code;
3592         uint8_t pkt[34] = {};
3593
3594         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3595
3596         ATF_CHECK(bpf_validate(insns, insn_count));
3597
3598         code = bpfjit_generate_code(NULL, insns, insn_count);
3599         ATF_REQUIRE(code != NULL);
3600
3601         /* Packet is too short. */
3602         ATF_CHECK(jitcall(code, pkt, 1, 1) == 0);
3603         ATF_CHECK(jitcall(code, pkt, 2, 2) == 0);
3604         ATF_CHECK(jitcall(code, pkt, 3, 3) == 0);
3605         ATF_CHECK(jitcall(code, pkt, 4, 4) == 0);
3606         ATF_CHECK(jitcall(code, pkt, 5, 5) == 0);
3607         ATF_CHECK(jitcall(code, pkt, 6, 6) == 0);
3608         ATF_CHECK(jitcall(code, pkt, 7, 7) == 0);
3609         ATF_CHECK(jitcall(code, pkt, 8, 8) == 0);
3610         ATF_CHECK(jitcall(code, pkt, 9, 9) == 0);
3611         ATF_CHECK(jitcall(code, pkt, 10, 10) == 0);
3612         ATF_CHECK(jitcall(code, pkt, 11, 11) == 0);
3613         ATF_CHECK(jitcall(code, pkt, 12, 12) == 0);
3614         ATF_CHECK(jitcall(code, pkt, 13, 13) == 0);
3615         ATF_CHECK(jitcall(code, pkt, 14, 14) == 0);
3616         ATF_CHECK(jitcall(code, pkt, 15, 15) == 0);
3617         ATF_CHECK(jitcall(code, pkt, 16, 16) == 0);
3618         ATF_CHECK(jitcall(code, pkt, 17, 17) == 0);
3619         ATF_CHECK(jitcall(code, pkt, 18, 18) == 0);
3620         ATF_CHECK(jitcall(code, pkt, 19, 19) == 0);
3621         ATF_CHECK(jitcall(code, pkt, 20, 20) == 0);
3622         ATF_CHECK(jitcall(code, pkt, 21, 21) == 0);
3623         ATF_CHECK(jitcall(code, pkt, 22, 22) == 0);
3624         ATF_CHECK(jitcall(code, pkt, 23, 23) == 0);
3625         ATF_CHECK(jitcall(code, pkt, 24, 24) == 0);
3626         ATF_CHECK(jitcall(code, pkt, 25, 25) == 0);
3627         ATF_CHECK(jitcall(code, pkt, 26, 26) == 0);
3628         ATF_CHECK(jitcall(code, pkt, 27, 27) == 0);
3629         ATF_CHECK(jitcall(code, pkt, 28, 28) == 0);
3630         ATF_CHECK(jitcall(code, pkt, 29, 29) == 0);
3631         ATF_CHECK(jitcall(code, pkt, 30, 30) == 0);
3632         ATF_CHECK(jitcall(code, pkt, 31, 31) == 0);
3633         ATF_CHECK(jitcall(code, pkt, 32, 32) == 0);
3634         ATF_CHECK(jitcall(code, pkt, 33, 33) == 0);
3635
3636         /* The packet doesn't match. */
3637         ATF_CHECK(jitcall(code, pkt, 34, 34) == 0);
3638
3639         /* Still no match after setting the protocol field. */
3640         pkt[12] = 8;
3641         ATF_CHECK(jitcall(code, pkt, 34, 34) == 0);
3642
3643         pkt[26] = 128; pkt[27] = 3; pkt[28] = 112; pkt[29] = 15;
3644         ATF_CHECK(jitcall(code, pkt, 34, 34) == 0);
3645
3646         pkt[30] = 128; pkt[31] = 3; pkt[32] = 112; pkt[33] = 35;
3647         ATF_CHECK(jitcall(code, pkt, 34, 34) == UINT32_MAX);
3648
3649         /* Swap the ip addresses. */
3650         pkt[26] = 128; pkt[27] = 3; pkt[28] = 112; pkt[29] = 35;
3651         ATF_CHECK(jitcall(code, pkt, 34, 34) == 0);
3652
3653         pkt[30] = 128; pkt[31] = 3; pkt[32] = 112; pkt[33] = 15;
3654         ATF_CHECK(jitcall(code, pkt, 34, 34) == UINT32_MAX);
3655
3656         /* Packet is too short. */
3657         ATF_CHECK(jitcall(code, pkt, 1, 1) == 0);
3658         ATF_CHECK(jitcall(code, pkt, 2, 2) == 0);
3659         ATF_CHECK(jitcall(code, pkt, 3, 3) == 0);
3660         ATF_CHECK(jitcall(code, pkt, 4, 4) == 0);
3661         ATF_CHECK(jitcall(code, pkt, 5, 5) == 0);
3662         ATF_CHECK(jitcall(code, pkt, 6, 6) == 0);
3663         ATF_CHECK(jitcall(code, pkt, 7, 7) == 0);
3664         ATF_CHECK(jitcall(code, pkt, 8, 8) == 0);
3665         ATF_CHECK(jitcall(code, pkt, 9, 9) == 0);
3666         ATF_CHECK(jitcall(code, pkt, 10, 10) == 0);
3667         ATF_CHECK(jitcall(code, pkt, 11, 11) == 0);
3668         ATF_CHECK(jitcall(code, pkt, 12, 12) == 0);
3669         ATF_CHECK(jitcall(code, pkt, 13, 13) == 0);
3670         ATF_CHECK(jitcall(code, pkt, 14, 14) == 0);
3671         ATF_CHECK(jitcall(code, pkt, 15, 15) == 0);
3672         ATF_CHECK(jitcall(code, pkt, 16, 16) == 0);
3673         ATF_CHECK(jitcall(code, pkt, 17, 17) == 0);
3674         ATF_CHECK(jitcall(code, pkt, 18, 18) == 0);
3675         ATF_CHECK(jitcall(code, pkt, 19, 19) == 0);
3676         ATF_CHECK(jitcall(code, pkt, 20, 20) == 0);
3677         ATF_CHECK(jitcall(code, pkt, 21, 21) == 0);
3678         ATF_CHECK(jitcall(code, pkt, 22, 22) == 0);
3679         ATF_CHECK(jitcall(code, pkt, 23, 23) == 0);
3680         ATF_CHECK(jitcall(code, pkt, 24, 24) == 0);
3681         ATF_CHECK(jitcall(code, pkt, 25, 25) == 0);
3682         ATF_CHECK(jitcall(code, pkt, 26, 26) == 0);
3683         ATF_CHECK(jitcall(code, pkt, 27, 27) == 0);
3684         ATF_CHECK(jitcall(code, pkt, 28, 28) == 0);
3685         ATF_CHECK(jitcall(code, pkt, 29, 29) == 0);
3686         ATF_CHECK(jitcall(code, pkt, 30, 30) == 0);
3687         ATF_CHECK(jitcall(code, pkt, 31, 31) == 0);
3688         ATF_CHECK(jitcall(code, pkt, 32, 32) == 0);
3689         ATF_CHECK(jitcall(code, pkt, 33, 33) == 0);
3690
3691         /* Change the protocol field. */
3692         pkt[13] = 8;
3693         ATF_CHECK(jitcall(code, pkt, 34, 34) == 0);
3694
3695         bpfjit_free_code(code);
3696 }
3697
3698 ATF_TC(libbpfjit_examples_3);
3699 ATF_TC_HEAD(libbpfjit_examples_3, tc)
3700 {
3701         atf_tc_set_md_var(tc, "descr",
3702             "Test the third example from bpf(4) - "
3703             "accept TCP finger packets");
3704 }
3705
3706 ATF_TC_BODY(libbpfjit_examples_3, tc)
3707 {
3708         /*
3709          * This filter returns only TCP finger packets.
3710          */
3711         struct bpf_insn insns[] = {
3712                 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 12),
3713                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x0800, 0, 10),
3714                 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 23),
3715                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 6, 0, 8),
3716                 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 20),
3717                 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, 0x1fff, 6, 0),
3718                 BPF_STMT(BPF_LDX+BPF_B+BPF_MSH, 14),
3719                 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 14),
3720                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 79, 2, 0),
3721                 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 16),
3722                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 79, 0, 1),
3723                 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX),
3724                 BPF_STMT(BPF_RET+BPF_K, 0),
3725         };
3726
3727         bpfjit_func_t code;
3728         uint8_t pkt[30] = {};
3729
3730         /* Set IP fragment offset to non-zero. */
3731         pkt[20] = 1; pkt[21] = 1;
3732
3733         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3734
3735         ATF_CHECK(bpf_validate(insns, insn_count));
3736
3737         code = bpfjit_generate_code(NULL, insns, insn_count);
3738         ATF_REQUIRE(code != NULL);
3739
3740         /* Packet is too short. */
3741         ATF_CHECK(jitcall(code, pkt, 1, 1) == 0);
3742         ATF_CHECK(jitcall(code, pkt, 2, 2) == 0);
3743         ATF_CHECK(jitcall(code, pkt, 3, 3) == 0);
3744         ATF_CHECK(jitcall(code, pkt, 4, 4) == 0);
3745         ATF_CHECK(jitcall(code, pkt, 5, 5) == 0);
3746         ATF_CHECK(jitcall(code, pkt, 6, 6) == 0);
3747         ATF_CHECK(jitcall(code, pkt, 7, 7) == 0);
3748         ATF_CHECK(jitcall(code, pkt, 8, 8) == 0);
3749         ATF_CHECK(jitcall(code, pkt, 9, 9) == 0);
3750         ATF_CHECK(jitcall(code, pkt, 10, 10) == 0);
3751         ATF_CHECK(jitcall(code, pkt, 11, 11) == 0);
3752         ATF_CHECK(jitcall(code, pkt, 12, 12) == 0);
3753         ATF_CHECK(jitcall(code, pkt, 13, 13) == 0);
3754         ATF_CHECK(jitcall(code, pkt, 14, 14) == 0);
3755         ATF_CHECK(jitcall(code, pkt, 15, 15) == 0);
3756         ATF_CHECK(jitcall(code, pkt, 16, 16) == 0);
3757         ATF_CHECK(jitcall(code, pkt, 17, 17) == 0);
3758         ATF_CHECK(jitcall(code, pkt, 18, 18) == 0);
3759         ATF_CHECK(jitcall(code, pkt, 19, 19) == 0);
3760         ATF_CHECK(jitcall(code, pkt, 20, 20) == 0);
3761         ATF_CHECK(jitcall(code, pkt, 21, 21) == 0);
3762         ATF_CHECK(jitcall(code, pkt, 22, 22) == 0);
3763         ATF_CHECK(jitcall(code, pkt, 23, 23) == 0);
3764         ATF_CHECK(jitcall(code, pkt, 24, 24) == 0);
3765         ATF_CHECK(jitcall(code, pkt, 25, 25) == 0);
3766         ATF_CHECK(jitcall(code, pkt, 26, 26) == 0);
3767         ATF_CHECK(jitcall(code, pkt, 27, 27) == 0);
3768         ATF_CHECK(jitcall(code, pkt, 28, 28) == 0);
3769         ATF_CHECK(jitcall(code, pkt, 29, 29) == 0);
3770
3771         /* The packet doesn't match. */
3772         ATF_CHECK(jitcall(code, pkt, 30, 30) == 0);
3773
3774         /* Still no match after setting the protocol field. */
3775         pkt[12] = 8;
3776         ATF_CHECK(jitcall(code, pkt, 30, 30) == 0);
3777
3778         /* Get one step closer to the match. */
3779         pkt[23] = 6;
3780         ATF_CHECK(jitcall(code, pkt, 30, 30) == 0);
3781
3782         /* Set IP fragment offset to zero. */
3783         pkt[20] = 0x20; pkt[21] = 0;
3784         ATF_CHECK(jitcall(code, pkt, 30, 30) == 0);
3785
3786         /* Set IP header length to 12. */
3787         pkt[14] = 0xd3;
3788         ATF_CHECK(jitcall(code, pkt, 30, 30) == 0);
3789
3790         /* Match one branch of the program. */
3791         pkt[27] = 79;
3792         ATF_CHECK(jitcall(code, pkt, 30, 30) == UINT32_MAX);
3793
3794         /* Match the other branch of the program. */
3795         pkt[29] = 79; pkt[27] = 0;
3796         ATF_CHECK(jitcall(code, pkt, 30, 30) == UINT32_MAX);
3797
3798         /* Packet is too short. */
3799         ATF_CHECK(jitcall(code, pkt, 1, 1) == 0);
3800         ATF_CHECK(jitcall(code, pkt, 2, 2) == 0);
3801         ATF_CHECK(jitcall(code, pkt, 3, 3) == 0);
3802         ATF_CHECK(jitcall(code, pkt, 4, 4) == 0);
3803         ATF_CHECK(jitcall(code, pkt, 5, 5) == 0);
3804         ATF_CHECK(jitcall(code, pkt, 6, 6) == 0);
3805         ATF_CHECK(jitcall(code, pkt, 7, 7) == 0);
3806         ATF_CHECK(jitcall(code, pkt, 8, 8) == 0);
3807         ATF_CHECK(jitcall(code, pkt, 9, 9) == 0);
3808         ATF_CHECK(jitcall(code, pkt, 10, 10) == 0);
3809         ATF_CHECK(jitcall(code, pkt, 11, 11) == 0);
3810         ATF_CHECK(jitcall(code, pkt, 12, 12) == 0);
3811         ATF_CHECK(jitcall(code, pkt, 13, 13) == 0);
3812         ATF_CHECK(jitcall(code, pkt, 14, 14) == 0);
3813         ATF_CHECK(jitcall(code, pkt, 15, 15) == 0);
3814         ATF_CHECK(jitcall(code, pkt, 16, 16) == 0);
3815         ATF_CHECK(jitcall(code, pkt, 17, 17) == 0);
3816         ATF_CHECK(jitcall(code, pkt, 18, 18) == 0);
3817         ATF_CHECK(jitcall(code, pkt, 19, 19) == 0);
3818         ATF_CHECK(jitcall(code, pkt, 20, 20) == 0);
3819         ATF_CHECK(jitcall(code, pkt, 21, 21) == 0);
3820         ATF_CHECK(jitcall(code, pkt, 22, 22) == 0);
3821         ATF_CHECK(jitcall(code, pkt, 23, 23) == 0);
3822         ATF_CHECK(jitcall(code, pkt, 24, 24) == 0);
3823         ATF_CHECK(jitcall(code, pkt, 25, 25) == 0);
3824         ATF_CHECK(jitcall(code, pkt, 26, 26) == 0);
3825         ATF_CHECK(jitcall(code, pkt, 27, 27) == 0);
3826         ATF_CHECK(jitcall(code, pkt, 28, 28) == 0);
3827         ATF_CHECK(jitcall(code, pkt, 29, 29) == 0);
3828
3829         /* Set IP header length to 16. Packet is too short. */
3830         pkt[14] = 4;
3831         ATF_CHECK(jitcall(code, pkt, 30, 30) == 0);
3832
3833         bpfjit_free_code(code);
3834 }
3835
3836 ATF_TC(libbpfjit_cop_no_ctx);
3837 ATF_TC_HEAD(libbpfjit_cop_no_ctx, tc)
3838 {
3839         atf_tc_set_md_var(tc, "descr", "Test that BPF_MISC|BPF_COP "
3840             "instruction can't be accepted without a context");
3841 }
3842
3843 ATF_TC_BODY(libbpfjit_cop_no_ctx, tc)
3844 {
3845         static struct bpf_insn insns[] = {
3846                 BPF_STMT(BPF_MISC+BPF_COP, 0),
3847                 BPF_STMT(BPF_RET+BPF_K, 7)
3848         };
3849
3850         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3851
3852         ATF_CHECK(!bpf_validate(insns, insn_count));
3853
3854         ATF_CHECK(bpfjit_generate_code(NULL, insns, insn_count) == NULL);
3855 }
3856
3857 ATF_TC(libbpfjit_copx_no_ctx);
3858 ATF_TC_HEAD(libbpfjit_copx_no_ctx, tc)
3859 {
3860         atf_tc_set_md_var(tc, "descr", "Test that BPF_MISC|BPF_COPX "
3861             "instruction can't be accepted without a context");
3862 }
3863
3864 ATF_TC_BODY(libbpfjit_copx_no_ctx, tc)
3865 {
3866         static struct bpf_insn insns[] = {
3867                 BPF_STMT(BPF_MISC+BPF_COPX, 0),
3868                 BPF_STMT(BPF_RET+BPF_K, 7)
3869         };
3870
3871         size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3872
3873         ATF_CHECK(!bpf_validate(insns, insn_count));
3874
3875         ATF_CHECK(bpfjit_generate_code(NULL, insns, insn_count) == NULL);
3876 }
3877
3878 ATF_TP_ADD_TCS(tp)
3879 {
3880
3881         /*
3882          * For every new test please also add a similar test
3883          * to ../../net/bpfjit/t_bpfjit.c
3884          */
3885         ATF_TP_ADD_TC(tp, libbpfjit_empty);
3886         ATF_TP_ADD_TC(tp, libbpfjit_alu_add_k);
3887         ATF_TP_ADD_TC(tp, libbpfjit_alu_sub_k);
3888         ATF_TP_ADD_TC(tp, libbpfjit_alu_mul_k);
3889         ATF_TP_ADD_TC(tp, libbpfjit_alu_div0_k);
3890         ATF_TP_ADD_TC(tp, libbpfjit_alu_div1_k);
3891         ATF_TP_ADD_TC(tp, libbpfjit_alu_div2_k);
3892         ATF_TP_ADD_TC(tp, libbpfjit_alu_div4_k);
3893         ATF_TP_ADD_TC(tp, libbpfjit_alu_div10_k);
3894         ATF_TP_ADD_TC(tp, libbpfjit_alu_div10000_k);
3895         ATF_TP_ADD_TC(tp, libbpfjit_alu_div7609801_k);
3896         ATF_TP_ADD_TC(tp, libbpfjit_alu_div80000000_k);
3897         ATF_TP_ADD_TC(tp, libbpfjit_alu_and_k);
3898         ATF_TP_ADD_TC(tp, libbpfjit_alu_or_k);
3899         ATF_TP_ADD_TC(tp, libbpfjit_alu_lsh_k);
3900         ATF_TP_ADD_TC(tp, libbpfjit_alu_lsh0_k);
3901         ATF_TP_ADD_TC(tp, libbpfjit_alu_rsh_k);
3902         ATF_TP_ADD_TC(tp, libbpfjit_alu_rsh0_k);
3903         ATF_TP_ADD_TC(tp, libbpfjit_alu_modulo_k);
3904         ATF_TP_ADD_TC(tp, libbpfjit_alu_add_x);
3905         ATF_TP_ADD_TC(tp, libbpfjit_alu_sub_x);
3906         ATF_TP_ADD_TC(tp, libbpfjit_alu_mul_x);
3907         ATF_TP_ADD_TC(tp, libbpfjit_alu_div0_x);
3908         ATF_TP_ADD_TC(tp, libbpfjit_alu_div1_x);
3909         ATF_TP_ADD_TC(tp, libbpfjit_alu_div2_x);
3910         ATF_TP_ADD_TC(tp, libbpfjit_alu_div4_x);
3911         ATF_TP_ADD_TC(tp, libbpfjit_alu_div10_x);
3912         ATF_TP_ADD_TC(tp, libbpfjit_alu_div10000_x);
3913         ATF_TP_ADD_TC(tp, libbpfjit_alu_div7609801_x);
3914         ATF_TP_ADD_TC(tp, libbpfjit_alu_div80000000_x);
3915         ATF_TP_ADD_TC(tp, libbpfjit_alu_and_x);
3916         ATF_TP_ADD_TC(tp, libbpfjit_alu_or_x);
3917         ATF_TP_ADD_TC(tp, libbpfjit_alu_lsh_x);
3918         ATF_TP_ADD_TC(tp, libbpfjit_alu_lsh0_x);
3919         ATF_TP_ADD_TC(tp, libbpfjit_alu_rsh_x);
3920         ATF_TP_ADD_TC(tp, libbpfjit_alu_rsh0_x);
3921         ATF_TP_ADD_TC(tp, libbpfjit_alu_modulo_x);
3922         ATF_TP_ADD_TC(tp, libbpfjit_alu_neg);
3923         ATF_TP_ADD_TC(tp, libbpfjit_jmp_ja);
3924         ATF_TP_ADD_TC(tp, libbpfjit_jmp_jgt_k);
3925         ATF_TP_ADD_TC(tp, libbpfjit_jmp_jge_k);
3926         ATF_TP_ADD_TC(tp, libbpfjit_jmp_jeq_k);
3927         ATF_TP_ADD_TC(tp, libbpfjit_jmp_jset_k);
3928         ATF_TP_ADD_TC(tp, libbpfjit_jmp_modulo_k);
3929         ATF_TP_ADD_TC(tp, libbpfjit_jmp_jgt_x);
3930         ATF_TP_ADD_TC(tp, libbpfjit_jmp_jge_x);
3931         ATF_TP_ADD_TC(tp, libbpfjit_jmp_jeq_x);
3932         ATF_TP_ADD_TC(tp, libbpfjit_jmp_jset_x);
3933         ATF_TP_ADD_TC(tp, libbpfjit_jmp_modulo_x);
3934         ATF_TP_ADD_TC(tp, libbpfjit_ld_abs);
3935         ATF_TP_ADD_TC(tp, libbpfjit_ld_abs_k_overflow);
3936         ATF_TP_ADD_TC(tp, libbpfjit_ld_ind);
3937         ATF_TP_ADD_TC(tp, libbpfjit_ld_ind_k_overflow);
3938         ATF_TP_ADD_TC(tp, libbpfjit_ld_ind_x_overflow1);
3939         ATF_TP_ADD_TC(tp, libbpfjit_ld_ind_x_overflow2);
3940         ATF_TP_ADD_TC(tp, libbpfjit_ld_len);
3941         ATF_TP_ADD_TC(tp, libbpfjit_ld_imm);
3942         ATF_TP_ADD_TC(tp, libbpfjit_ldx_imm1);
3943         ATF_TP_ADD_TC(tp, libbpfjit_ldx_imm2);
3944         ATF_TP_ADD_TC(tp, libbpfjit_ldx_len1);
3945         ATF_TP_ADD_TC(tp, libbpfjit_ldx_len2);
3946         ATF_TP_ADD_TC(tp, libbpfjit_ldx_msh);
3947         ATF_TP_ADD_TC(tp, libbpfjit_misc_tax);
3948         ATF_TP_ADD_TC(tp, libbpfjit_misc_txa);
3949         ATF_TP_ADD_TC(tp, libbpfjit_st1);
3950         ATF_TP_ADD_TC(tp, libbpfjit_st2);
3951         ATF_TP_ADD_TC(tp, libbpfjit_st3);
3952         ATF_TP_ADD_TC(tp, libbpfjit_st4);
3953         ATF_TP_ADD_TC(tp, libbpfjit_st5);
3954         ATF_TP_ADD_TC(tp, libbpfjit_stx1);
3955         ATF_TP_ADD_TC(tp, libbpfjit_stx2);
3956         ATF_TP_ADD_TC(tp, libbpfjit_stx3);
3957         ATF_TP_ADD_TC(tp, libbpfjit_stx4);
3958         ATF_TP_ADD_TC(tp, libbpfjit_opt_ld_abs_1);
3959         ATF_TP_ADD_TC(tp, libbpfjit_opt_ld_abs_2);
3960         ATF_TP_ADD_TC(tp, libbpfjit_opt_ld_abs_3);
3961         ATF_TP_ADD_TC(tp, libbpfjit_opt_ld_ind_1);
3962         ATF_TP_ADD_TC(tp, libbpfjit_opt_ld_ind_2);
3963         ATF_TP_ADD_TC(tp, libbpfjit_opt_ld_ind_3);
3964         ATF_TP_ADD_TC(tp, libbpfjit_opt_ld_ind_4);
3965         ATF_TP_ADD_TC(tp, libbpfjit_abc_ja);
3966         ATF_TP_ADD_TC(tp, libbpfjit_abc_ja_over);
3967         ATF_TP_ADD_TC(tp, libbpfjit_abc_ld_chain);
3968         ATF_TP_ADD_TC(tp, libbpfjit_examples_1);
3969         ATF_TP_ADD_TC(tp, libbpfjit_examples_2);
3970         ATF_TP_ADD_TC(tp, libbpfjit_examples_3);
3971         ATF_TP_ADD_TC(tp, libbpfjit_cop_no_ctx);
3972         ATF_TP_ADD_TC(tp, libbpfjit_copx_no_ctx);
3973
3974         return atf_no_error();
3975 }