Lines Matching refs:insns
104 static struct bpf_insn insns[] = {
110 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
114 ATF_CHECK(prog_validate(insns, insn_count));
115 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 17);
127 static struct bpf_insn insns[] = {
131 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
139 const uint16_t rcode = insns[0].code;
145 ATF_CHECK(!prog_validate(insns, insn_count));
148 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 13);
160 static struct bpf_insn insns[] = {
168 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
172 ATF_CHECK(prog_validate(insns, insn_count));
173 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 5);
185 static struct bpf_insn insns[] = {
193 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
197 ATF_CHECK(prog_validate(insns, insn_count));
198 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == UINT32_MAX);
210 static struct bpf_insn insns[] = {
218 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
222 ATF_CHECK(prog_validate(insns, insn_count));
223 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 0xfffffffd);
235 static struct bpf_insn insns[] = {
242 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
246 //ATF_CHECK(prog_validate(insns, insn_count));
247 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 0);
259 static struct bpf_insn insns[] = {
267 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
271 ATF_CHECK(prog_validate(insns, insn_count));
272 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 7);
284 static struct bpf_insn insns[] = {
292 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
296 ATF_CHECK(prog_validate(insns, insn_count));
297 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 3);
309 static struct bpf_insn insns[] = {
317 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
321 ATF_CHECK(prog_validate(insns, insn_count));
322 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 0x3fffffff);
334 static struct bpf_insn insns[] = {
342 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
346 ATF_CHECK(prog_validate(insns, insn_count));
347 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 429484384);
359 static struct bpf_insn insns[] = {
367 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
371 ATF_CHECK(prog_validate(insns, insn_count));
372 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 429484);
384 static struct bpf_insn insns[] = {
392 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
396 ATF_CHECK(prog_validate(insns, insn_count));
397 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 564);
409 static struct bpf_insn insns[] = {
417 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
421 ATF_CHECK(prog_validate(insns, insn_count));
422 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 1);
434 static struct bpf_insn insns[] = {
441 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
445 //ATF_CHECK(prog_validate(insns, insn_count));
446 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 0);
458 static struct bpf_insn insns[] = {
466 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
470 ATF_CHECK(prog_validate(insns, insn_count));
471 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 0);
483 static struct bpf_insn insns[] = {
491 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
495 ATF_CHECK(prog_validate(insns, insn_count));
496 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 1);
508 static struct bpf_insn insns[] = {
516 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
520 ATF_CHECK(prog_validate(insns, insn_count));
521 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 3);
533 static struct bpf_insn insns[] = {
541 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
545 ATF_CHECK(prog_validate(insns, insn_count));
546 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 9);
558 static struct bpf_insn insns[] = {
566 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
570 ATF_CHECK(prog_validate(insns, insn_count));
571 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 3849);
583 static struct bpf_insn insns[] = {
591 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
595 ATF_CHECK(prog_validate(insns, insn_count));
596 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 3039531);
608 static struct bpf_insn insns[] = {
616 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
620 ATF_CHECK(prog_validate(insns, insn_count));
621 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == UINT32_C(0x7fffffde));
633 static struct bpf_insn insns[] = {
641 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
645 ATF_CHECK(prog_validate(insns, insn_count));
646 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == (0xdead&0xbeef));
658 static struct bpf_insn insns[] = {
666 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
670 ATF_CHECK(prog_validate(insns, insn_count));
671 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 0xdeadbeef);
683 static struct bpf_insn insns[] = {
691 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
695 ATF_CHECK(prog_validate(insns, insn_count));
696 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 0xdeadbeef);
708 static struct bpf_insn insns[] = {
716 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
720 ATF_CHECK(prog_validate(insns, insn_count));
721 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 0xbeef0000);
733 static struct bpf_insn insns[] = {
741 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
745 ATF_CHECK(prog_validate(insns, insn_count));
746 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 0xdeadbeef);
758 static struct bpf_insn insns[] = {
766 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
770 ATF_CHECK(prog_validate(insns, insn_count));
771 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 0x0000dead);
783 static struct bpf_insn insns[] = {
791 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
795 ATF_CHECK(prog_validate(insns, insn_count));
796 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 0xdeadbeef);
808 static struct bpf_insn insns[] = {
849 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
853 ATF_CHECK(prog_validate(insns, insn_count));
856 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
877 static struct bpf_insn insns[] = {
886 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
890 ATF_CHECK(prog_validate(insns, insn_count));
891 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 5);
903 static struct bpf_insn insns[] = {
912 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
916 ATF_CHECK(prog_validate(insns, insn_count));
917 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == UINT32_MAX);
929 static struct bpf_insn insns[] = {
938 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
942 ATF_CHECK(prog_validate(insns, insn_count));
943 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 0xfffffffd);
955 static struct bpf_insn insns[] = {
963 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
967 ATF_CHECK(prog_validate(insns, insn_count));
968 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 0);
980 static struct bpf_insn insns[] = {
989 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
993 ATF_CHECK(prog_validate(insns, insn_count));
994 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 7);
1006 static struct bpf_insn insns[] = {
1015 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1019 ATF_CHECK(prog_validate(insns, insn_count));
1020 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 3);
1032 static struct bpf_insn insns[] = {
1041 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1045 ATF_CHECK(prog_validate(insns, insn_count));
1046 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 0x3fffffff);
1058 static struct bpf_insn insns[] = {
1067 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1071 ATF_CHECK(prog_validate(insns, insn_count));
1072 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 429484384);
1084 static struct bpf_insn insns[] = {
1093 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1097 ATF_CHECK(prog_validate(insns, insn_count));
1098 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 429484);
1110 static struct bpf_insn insns[] = {
1119 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1123 ATF_CHECK(prog_validate(insns, insn_count));
1124 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 564);
1136 static struct bpf_insn insns[] = {
1145 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1149 ATF_CHECK(prog_validate(insns, insn_count));
1150 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 1);
1162 static struct bpf_insn insns[] = {
1170 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1174 ATF_CHECK(prog_validate(insns, insn_count));
1175 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 0);
1187 static struct bpf_insn insns[] = {
1196 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1200 ATF_CHECK(prog_validate(insns, insn_count));
1201 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 0);
1213 static struct bpf_insn insns[] = {
1222 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1226 ATF_CHECK(prog_validate(insns, insn_count));
1227 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 1);
1239 static struct bpf_insn insns[] = {
1248 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1252 ATF_CHECK(prog_validate(insns, insn_count));
1253 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 3);
1265 static struct bpf_insn insns[] = {
1274 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1278 ATF_CHECK(prog_validate(insns, insn_count));
1279 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 9);
1291 static struct bpf_insn insns[] = {
1300 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1304 ATF_CHECK(prog_validate(insns, insn_count));
1305 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 3849);
1317 static struct bpf_insn insns[] = {
1326 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1330 ATF_CHECK(prog_validate(insns, insn_count));
1331 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 3039531);
1343 static struct bpf_insn insns[] = {
1352 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1356 ATF_CHECK(prog_validate(insns, insn_count));
1357 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == UINT32_C(0x7fffffde));
1369 static struct bpf_insn insns[] = {
1378 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1382 ATF_CHECK(prog_validate(insns, insn_count));
1383 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == (0xdead&0xbeef));
1395 static struct bpf_insn insns[] = {
1404 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1408 ATF_CHECK(prog_validate(insns, insn_count));
1409 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 0xdeadbeef);
1421 static struct bpf_insn insns[] = {
1430 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1434 ATF_CHECK(prog_validate(insns, insn_count));
1435 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 0xdeadbeef);
1447 static struct bpf_insn insns[] = {
1456 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1460 ATF_CHECK(prog_validate(insns, insn_count));
1461 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 0xbeef0000);
1473 static struct bpf_insn insns[] = {
1482 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1486 ATF_CHECK(prog_validate(insns, insn_count));
1487 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 0xdeadbeef);
1499 static struct bpf_insn insns[] = {
1508 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1512 ATF_CHECK(prog_validate(insns, insn_count));
1513 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 0x0000dead);
1525 static struct bpf_insn insns[] = {
1534 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1538 ATF_CHECK(prog_validate(insns, insn_count));
1539 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 0xdeadbeef);
1551 static struct bpf_insn insns[] = {
1601 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1605 ATF_CHECK(prog_validate(insns, insn_count));
1608 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
1629 static struct bpf_insn insns[] = {
1637 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1641 ATF_CHECK(prog_validate(insns, insn_count));
1642 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 0u-777u);
1654 static struct bpf_insn insns[] = {
1665 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1669 ATF_CHECK(prog_validate(insns, insn_count));
1670 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == UINT32_MAX);
1682 static struct bpf_insn insns[] = {
1691 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1695 ATF_CHECK(!prog_validate(insns, insn_count));
1698 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
1712 static struct bpf_insn insns[] = {
1720 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1725 ATF_CHECK(!prog_validate(insns, insn_count));
1728 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
1742 static struct bpf_insn insns[] = {
1765 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1769 ATF_CHECK(prog_validate(insns, insn_count));
1772 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
1799 static struct bpf_insn insns[] = {
1822 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1826 ATF_CHECK(prog_validate(insns, insn_count));
1829 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
1856 static struct bpf_insn insns[] = {
1879 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1883 ATF_CHECK(prog_validate(insns, insn_count));
1886 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
1913 static struct bpf_insn insns[] = {
1936 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1940 ATF_CHECK(prog_validate(insns, insn_count));
1943 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
1970 static struct bpf_insn insns[] = {
2003 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2007 ATF_CHECK(prog_validate(insns, insn_count));
2008 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == UINT32_MAX);
2020 static struct bpf_insn insns[] = {
2050 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2054 ATF_CHECK(prog_validate(insns, insn_count));
2057 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
2084 static struct bpf_insn insns[] = {
2114 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2118 ATF_CHECK(prog_validate(insns, insn_count));
2121 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
2148 static struct bpf_insn insns[] = {
2177 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2181 ATF_CHECK(prog_validate(insns, insn_count));
2184 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
2211 static struct bpf_insn insns[] = {
2240 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2244 ATF_CHECK(prog_validate(insns, insn_count));
2247 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
2274 static struct bpf_insn insns[] = {
2283 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2287 ATF_CHECK(prog_validate(insns, insn_count));
2290 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
2310 static struct bpf_insn insns[] = {
2320 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2324 ATF_CHECK(prog_validate(insns, insn_count));
2327 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
2347 static struct bpf_insn insns[] = {
2357 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2361 ATF_CHECK(prog_validate(insns, insn_count));
2364 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
2384 static struct bpf_insn insns[] = {
2427 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2431 ATF_CHECK(prog_validate(insns, insn_count));
2432 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == UINT32_MAX);
2444 static struct bpf_insn insns[3][2] = {
2466 size_t insn_count = sizeof(insns[0]) / sizeof(insns[0][0]);
2473 ATF_CHECK(prog_validate(insns[i], insn_count));
2476 code = rumpns_bpfjit_generate_code(NULL, insns[i], insn_count);
2507 static struct bpf_insn insns[12][3] = {
2573 size_t insn_count = sizeof(insns[0]) / sizeof(insns[0][0]);
2578 ATF_CHECK(prog_validate(insns[i], insn_count));
2579 ATF_CHECK(exec_prog(insns[i], insn_count, pkt, 8) == 0);
2592 static struct bpf_insn insns[6][3] = {
2636 size_t insn_count = sizeof(insns[0]) / sizeof(insns[0][0]);
2643 ATF_CHECK(prog_validate(insns[i], insn_count));
2646 code = rumpns_bpfjit_generate_code(NULL, insns[i], insn_count);
2677 static struct bpf_insn insns[12][3] = {
2743 size_t insn_count = sizeof(insns[0]) / sizeof(insns[0][0]);
2749 ATF_CHECK(prog_validate(insns[i], insn_count));
2750 ATF_CHECK(exec_prog(insns[i], insn_count, pkt, 8) == 0);
2763 static struct bpf_insn insns[] = {
2775 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2779 ATF_CHECK(prog_validate(insns, insn_count));
2782 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
2787 //ATF_CHECK(bpf_filter(insns, pkt, i, i) == 10 * i);
2805 static struct bpf_insn insns[] = {
2818 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2822 ATF_CHECK(prog_validate(insns, insn_count));
2825 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
2830 //ATF_CHECK(bpf_filter(insns, pkt, i, i) == 10 * i);
2848 static struct bpf_insn insns[] = {
2857 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2861 ATF_CHECK(prog_validate(insns, insn_count));
2864 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
2885 static struct bpf_insn insns[] = {
2892 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2896 ATF_CHECK(prog_validate(insns, insn_count));
2897 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == UINT32_MAX);
2909 static struct bpf_insn insns[] = {
2917 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2921 ATF_CHECK(prog_validate(insns, insn_count));
2922 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == UINT32_MAX - 5);
2934 static struct bpf_insn insns[] = {
2944 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2948 ATF_CHECK(prog_validate(insns, insn_count));
2949 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == UINT32_MAX);
2961 static struct bpf_insn insns[] = {
2971 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2975 ATF_CHECK(prog_validate(insns, insn_count));
2978 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
3001 static struct bpf_insn insns[] = {
3012 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3016 ATF_CHECK(prog_validate(insns, insn_count));
3019 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
3040 static struct bpf_insn insns[] = {
3048 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3052 ATF_CHECK(prog_validate(insns, insn_count));
3053 ATF_CHECK(exec_prog(insns, insn_count, pkt, 2) == 40);
3065 static struct bpf_insn insns[] = {
3074 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3078 ATF_CHECK(prog_validate(insns, insn_count));
3079 ATF_CHECK(exec_prog(insns, insn_count, pkt, 6) == 55);
3091 static struct bpf_insn insns[] = {
3099 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3103 ATF_CHECK(prog_validate(insns, insn_count));
3104 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 391);
3116 static struct bpf_insn insns[] = {
3128 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3132 ATF_CHECK(prog_validate(insns, insn_count));
3135 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
3156 static struct bpf_insn insns[] = {
3166 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3170 ATF_CHECK(prog_validate(insns, insn_count));
3171 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 0);
3183 static struct bpf_insn insns[] = {
3199 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3205 ATF_CHECK(prog_validate(insns, insn_count));
3208 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
3229 static struct bpf_insn insns[] = {
3245 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3251 ATF_CHECK(prog_validate(insns, insn_count));
3254 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
3275 struct bpf_insn insns[5*BPF_MEMWORDS+2];
3276 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3282 memset(insns, 0, sizeof(insns));
3286 insns[2*k].code = BPF_LD+BPF_IMM;
3287 insns[2*k].k = 3*k;
3288 insns[2*k+1].code = BPF_ST;
3289 insns[2*k+1].k = k;
3293 insns[2*BPF_MEMWORDS].code = BPF_LD+BPF_W+BPF_LEN;
3297 insns[2*BPF_MEMWORDS+3*k+1].code = BPF_JMP+BPF_JEQ+BPF_K;
3298 insns[2*BPF_MEMWORDS+3*k+1].k = k+1;
3299 insns[2*BPF_MEMWORDS+3*k+1].jt = 0;
3300 insns[2*BPF_MEMWORDS+3*k+1].jf = 2;
3301 insns[2*BPF_MEMWORDS+3*k+2].code = BPF_LD+BPF_MEM;
3302 insns[2*BPF_MEMWORDS+3*k+2].k = k;
3303 insns[2*BPF_MEMWORDS+3*k+3].code = BPF_RET+BPF_A;
3304 insns[2*BPF_MEMWORDS+3*k+3].k = 0;
3307 insns[5*BPF_MEMWORDS+1].code = BPF_RET+BPF_K;
3308 insns[5*BPF_MEMWORDS+1].k = UINT32_MAX;
3312 ATF_CHECK(prog_validate(insns, insn_count));
3315 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
3336 static struct bpf_insn insns[] = {
3348 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3352 ATF_CHECK(prog_validate(insns, insn_count));
3355 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
3376 static struct bpf_insn insns[] = {
3387 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3391 ATF_CHECK(prog_validate(insns, insn_count));
3392 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == 0);
3404 static struct bpf_insn insns[] = {
3428 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3432 ATF_CHECK(prog_validate(insns, insn_count));
3435 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
3456 struct bpf_insn insns[5*BPF_MEMWORDS+2];
3457 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3463 memset(insns, 0, sizeof(insns));
3467 insns[2*k].code = BPF_LDX+BPF_W+BPF_IMM;
3468 insns[2*k].k = 3*k;
3469 insns[2*k+1].code = BPF_STX;
3470 insns[2*k+1].k = k;
3474 insns[2*BPF_MEMWORDS].code = BPF_LD+BPF_W+BPF_LEN;
3478 insns[2*BPF_MEMWORDS+3*k+1].code = BPF_JMP+BPF_JEQ+BPF_K;
3479 insns[2*BPF_MEMWORDS+3*k+1].k = k+1;
3480 insns[2*BPF_MEMWORDS+3*k+1].jt = 0;
3481 insns[2*BPF_MEMWORDS+3*k+1].jf = 2;
3482 insns[2*BPF_MEMWORDS+3*k+2].code = BPF_LD+BPF_MEM;
3483 insns[2*BPF_MEMWORDS+3*k+2].k = k;
3484 insns[2*BPF_MEMWORDS+3*k+3].code = BPF_RET+BPF_A;
3485 insns[2*BPF_MEMWORDS+3*k+3].k = 0;
3488 insns[5*BPF_MEMWORDS+1].code = BPF_RET+BPF_K;
3489 insns[5*BPF_MEMWORDS+1].k = UINT32_MAX;
3493 ATF_CHECK(prog_validate(insns, insn_count));
3496 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
3518 static struct bpf_insn insns[] = {
3549 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3553 ATF_CHECK(prog_validate(insns, insn_count));
3556 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
3581 static struct bpf_insn insns[] = {
3612 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3616 ATF_CHECK(prog_validate(insns, insn_count));
3619 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
3644 static struct bpf_insn insns[] = {
3675 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3679 ATF_CHECK(prog_validate(insns, insn_count));
3682 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
3707 static struct bpf_insn insns[] = {
3739 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3743 ATF_CHECK(prog_validate(insns, insn_count));
3746 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
3771 static struct bpf_insn insns[] = {
3803 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3807 ATF_CHECK(prog_validate(insns, insn_count));
3810 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
3835 static struct bpf_insn insns[] = {
3868 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3872 ATF_CHECK(prog_validate(insns, insn_count));
3875 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
3900 static struct bpf_insn insns[] = {
3933 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3937 ATF_CHECK(prog_validate(insns, insn_count));
3940 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
3964 static struct bpf_insn insns[] = {
3981 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3985 ATF_CHECK(prog_validate(insns, insn_count));
3988 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
4013 static struct bpf_insn insns[] = {
4028 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
4032 ATF_CHECK(prog_validate(insns, insn_count));
4033 ATF_CHECK(exec_prog(insns, insn_count, pkt, 1) == UINT32_MAX);
4046 static struct bpf_insn insns[] = {
4060 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
4064 ATF_CHECK(prog_validate(insns, insn_count));
4067 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
4139 struct bpf_insn insns[] = {
4151 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
4155 ATF_CHECK(prog_validate(insns, insn_count));
4158 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
4242 static struct bpf_insn insns[] = {
4259 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
4263 ATF_CHECK(prog_validate(insns, insn_count));
4266 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
4382 struct bpf_insn insns[] = {
4404 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
4408 ATF_CHECK(prog_validate(insns, insn_count));
4411 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
4522 static struct bpf_insn insns[] = {
4528 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
4532 ATF_CHECK(!prog_validate(insns, insn_count));
4535 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);
4549 static struct bpf_insn insns[] = {
4555 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
4559 ATF_CHECK(!prog_validate(insns, insn_count));
4562 code = rumpns_bpfjit_generate_code(NULL, insns, insn_count);