Lines Matching refs:insns
83 static struct bpf_insn insns[] = {
90 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
92 ATF_CHECK(bpf_validate(insns, insn_count));
94 code = bpfjit_generate_code(NULL, insns, insn_count);
111 static struct bpf_insn insns[] = {
118 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
124 const uint16_t rcode = insns[0].code;
128 ATF_CHECK(!bpf_validate(insns, insn_count));
131 code = bpfjit_generate_code(NULL, insns, insn_count);
148 static struct bpf_insn insns[] = {
157 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
159 ATF_CHECK(bpf_validate(insns, insn_count));
161 code = bpfjit_generate_code(NULL, insns, insn_count);
178 static struct bpf_insn insns[] = {
187 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
189 ATF_CHECK(bpf_validate(insns, insn_count));
191 code = bpfjit_generate_code(NULL, insns, insn_count);
208 static struct bpf_insn insns[] = {
217 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
219 ATF_CHECK(bpf_validate(insns, insn_count));
221 code = bpfjit_generate_code(NULL, insns, insn_count);
238 static struct bpf_insn insns[] = {
246 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
248 //ATF_CHECK(bpf_validate(insns, insn_count));
250 code = bpfjit_generate_code(NULL, insns, insn_count);
267 static struct bpf_insn insns[] = {
276 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
278 ATF_CHECK(bpf_validate(insns, insn_count));
280 code = bpfjit_generate_code(NULL, insns, insn_count);
297 static struct bpf_insn insns[] = {
306 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
308 ATF_CHECK(bpf_validate(insns, insn_count));
310 code = bpfjit_generate_code(NULL, insns, insn_count);
327 static struct bpf_insn insns[] = {
336 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
338 ATF_CHECK(bpf_validate(insns, insn_count));
340 code = bpfjit_generate_code(NULL, insns, insn_count);
357 static struct bpf_insn insns[] = {
366 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
368 ATF_CHECK(bpf_validate(insns, insn_count));
370 code = bpfjit_generate_code(NULL, insns, insn_count);
387 static struct bpf_insn insns[] = {
396 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
398 ATF_CHECK(bpf_validate(insns, insn_count));
400 code = bpfjit_generate_code(NULL, insns, insn_count);
417 static struct bpf_insn insns[] = {
426 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
428 ATF_CHECK(bpf_validate(insns, insn_count));
430 code = bpfjit_generate_code(NULL, insns, insn_count);
447 static struct bpf_insn insns[] = {
456 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
458 ATF_CHECK(bpf_validate(insns, insn_count));
460 code = bpfjit_generate_code(NULL, insns, insn_count);
477 static struct bpf_insn insns[] = {
485 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
487 //ATF_CHECK(bpf_validate(insns, insn_count));
489 code = bpfjit_generate_code(NULL, insns, insn_count);
506 static struct bpf_insn insns[] = {
515 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
517 ATF_CHECK(bpf_validate(insns, insn_count));
519 code = bpfjit_generate_code(NULL, insns, insn_count);
536 static struct bpf_insn insns[] = {
545 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
547 ATF_CHECK(bpf_validate(insns, insn_count));
549 code = bpfjit_generate_code(NULL, insns, insn_count);
566 static struct bpf_insn insns[] = {
575 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
577 ATF_CHECK(bpf_validate(insns, insn_count));
579 code = bpfjit_generate_code(NULL, insns, insn_count);
596 static struct bpf_insn insns[] = {
605 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
607 ATF_CHECK(bpf_validate(insns, insn_count));
609 code = bpfjit_generate_code(NULL, insns, insn_count);
626 static struct bpf_insn insns[] = {
635 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
637 ATF_CHECK(bpf_validate(insns, insn_count));
639 code = bpfjit_generate_code(NULL, insns, insn_count);
656 static struct bpf_insn insns[] = {
665 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
667 ATF_CHECK(bpf_validate(insns, insn_count));
669 code = bpfjit_generate_code(NULL, insns, insn_count);
686 static struct bpf_insn insns[] = {
695 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
697 ATF_CHECK(bpf_validate(insns, insn_count));
699 code = bpfjit_generate_code(NULL, insns, insn_count);
716 static struct bpf_insn insns[] = {
725 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
727 ATF_CHECK(bpf_validate(insns, insn_count));
729 code = bpfjit_generate_code(NULL, insns, insn_count);
746 static struct bpf_insn insns[] = {
755 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
757 ATF_CHECK(bpf_validate(insns, insn_count));
759 code = bpfjit_generate_code(NULL, insns, insn_count);
776 static struct bpf_insn insns[] = {
785 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
787 ATF_CHECK(bpf_validate(insns, insn_count));
789 code = bpfjit_generate_code(NULL, insns, insn_count);
806 static struct bpf_insn insns[] = {
815 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
817 ATF_CHECK(bpf_validate(insns, insn_count));
819 code = bpfjit_generate_code(NULL, insns, insn_count);
836 static struct bpf_insn insns[] = {
845 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
847 ATF_CHECK(bpf_validate(insns, insn_count));
849 code = bpfjit_generate_code(NULL, insns, insn_count);
866 static struct bpf_insn insns[] = {
875 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
877 ATF_CHECK(bpf_validate(insns, insn_count));
879 code = bpfjit_generate_code(NULL, insns, insn_count);
896 static struct bpf_insn insns[] = {
905 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
907 ATF_CHECK(bpf_validate(insns, insn_count));
909 code = bpfjit_generate_code(NULL, insns, insn_count);
926 static struct bpf_insn insns[] = {
967 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
969 ATF_CHECK(bpf_validate(insns, insn_count));
971 code = bpfjit_generate_code(NULL, insns, insn_count);
990 static struct bpf_insn insns[] = {
1000 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1002 ATF_CHECK(bpf_validate(insns, insn_count));
1004 code = bpfjit_generate_code(NULL, insns, insn_count);
1021 static struct bpf_insn insns[] = {
1031 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1033 ATF_CHECK(bpf_validate(insns, insn_count));
1035 code = bpfjit_generate_code(NULL, insns, insn_count);
1052 static struct bpf_insn insns[] = {
1062 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1064 ATF_CHECK(bpf_validate(insns, insn_count));
1066 code = bpfjit_generate_code(NULL, insns, insn_count);
1083 static struct bpf_insn insns[] = {
1092 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1094 ATF_CHECK(bpf_validate(insns, insn_count));
1096 code = bpfjit_generate_code(NULL, insns, insn_count);
1113 static struct bpf_insn insns[] = {
1123 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1125 ATF_CHECK(bpf_validate(insns, insn_count));
1127 code = bpfjit_generate_code(NULL, insns, insn_count);
1144 static struct bpf_insn insns[] = {
1154 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1156 ATF_CHECK(bpf_validate(insns, insn_count));
1158 code = bpfjit_generate_code(NULL, insns, insn_count);
1175 static struct bpf_insn insns[] = {
1185 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1187 ATF_CHECK(bpf_validate(insns, insn_count));
1189 code = bpfjit_generate_code(NULL, insns, insn_count);
1206 static struct bpf_insn insns[] = {
1216 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1218 ATF_CHECK(bpf_validate(insns, insn_count));
1220 code = bpfjit_generate_code(NULL, insns, insn_count);
1237 static struct bpf_insn insns[] = {
1247 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1249 ATF_CHECK(bpf_validate(insns, insn_count));
1251 code = bpfjit_generate_code(NULL, insns, insn_count);
1268 static struct bpf_insn insns[] = {
1278 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1280 ATF_CHECK(bpf_validate(insns, insn_count));
1282 code = bpfjit_generate_code(NULL, insns, insn_count);
1299 static struct bpf_insn insns[] = {
1309 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1311 ATF_CHECK(bpf_validate(insns, insn_count));
1313 code = bpfjit_generate_code(NULL, insns, insn_count);
1330 static struct bpf_insn insns[] = {
1339 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1341 ATF_CHECK(bpf_validate(insns, insn_count));
1343 code = bpfjit_generate_code(NULL, insns, insn_count);
1360 static struct bpf_insn insns[] = {
1370 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1372 ATF_CHECK(bpf_validate(insns, insn_count));
1374 code = bpfjit_generate_code(NULL, insns, insn_count);
1391 static struct bpf_insn insns[] = {
1401 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1403 ATF_CHECK(bpf_validate(insns, insn_count));
1405 code = bpfjit_generate_code(NULL, insns, insn_count);
1422 static struct bpf_insn insns[] = {
1432 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1434 ATF_CHECK(bpf_validate(insns, insn_count));
1436 code = bpfjit_generate_code(NULL, insns, insn_count);
1453 static struct bpf_insn insns[] = {
1463 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1465 ATF_CHECK(bpf_validate(insns, insn_count));
1467 code = bpfjit_generate_code(NULL, insns, insn_count);
1484 static struct bpf_insn insns[] = {
1494 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1496 ATF_CHECK(bpf_validate(insns, insn_count));
1498 code = bpfjit_generate_code(NULL, insns, insn_count);
1515 static struct bpf_insn insns[] = {
1525 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1527 ATF_CHECK(bpf_validate(insns, insn_count));
1529 code = bpfjit_generate_code(NULL, insns, insn_count);
1546 static struct bpf_insn insns[] = {
1556 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1558 ATF_CHECK(bpf_validate(insns, insn_count));
1560 code = bpfjit_generate_code(NULL, insns, insn_count);
1577 static struct bpf_insn insns[] = {
1587 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1589 ATF_CHECK(bpf_validate(insns, insn_count));
1591 code = bpfjit_generate_code(NULL, insns, insn_count);
1608 static struct bpf_insn insns[] = {
1618 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1620 ATF_CHECK(bpf_validate(insns, insn_count));
1622 code = bpfjit_generate_code(NULL, insns, insn_count);
1639 static struct bpf_insn insns[] = {
1649 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1651 ATF_CHECK(bpf_validate(insns, insn_count));
1653 code = bpfjit_generate_code(NULL, insns, insn_count);
1670 static struct bpf_insn insns[] = {
1680 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1682 ATF_CHECK(bpf_validate(insns, insn_count));
1684 code = bpfjit_generate_code(NULL, insns, insn_count);
1701 static struct bpf_insn insns[] = {
1711 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1713 ATF_CHECK(bpf_validate(insns, insn_count));
1715 code = bpfjit_generate_code(NULL, insns, insn_count);
1732 static struct bpf_insn insns[] = {
1742 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1744 ATF_CHECK(bpf_validate(insns, insn_count));
1746 code = bpfjit_generate_code(NULL, insns, insn_count);
1763 static struct bpf_insn insns[] = {
1773 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1775 ATF_CHECK(bpf_validate(insns, insn_count));
1777 code = bpfjit_generate_code(NULL, insns, insn_count);
1794 static struct bpf_insn insns[] = {
1844 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1846 ATF_CHECK(bpf_validate(insns, insn_count));
1848 code = bpfjit_generate_code(NULL, insns, insn_count);
1867 static struct bpf_insn insns[] = {
1876 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1878 ATF_CHECK(bpf_validate(insns, insn_count));
1880 code = bpfjit_generate_code(NULL, insns, insn_count);
1897 static struct bpf_insn insns[] = {
1909 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1911 ATF_CHECK(bpf_validate(insns, insn_count));
1913 code = bpfjit_generate_code(NULL, insns, insn_count);
1930 static struct bpf_insn insns[] = {
1938 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1940 ATF_CHECK(!bpf_validate(insns, insn_count));
1941 ATF_CHECK(bpfjit_generate_code(NULL, insns, insn_count) == NULL);
1953 static struct bpf_insn insns[] = {
1960 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
1963 ATF_CHECK(bpf_validate(insns, insn_count));
1966 ATF_CHECK(bpfjit_generate_code(NULL, insns, insn_count) == NULL);
1978 static struct bpf_insn insns[] = {
2001 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2003 ATF_CHECK(bpf_validate(insns, insn_count));
2005 code = bpfjit_generate_code(NULL, insns, insn_count);
2029 static struct bpf_insn insns[] = {
2052 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2054 ATF_CHECK(bpf_validate(insns, insn_count));
2056 code = bpfjit_generate_code(NULL, insns, insn_count);
2080 static struct bpf_insn insns[] = {
2103 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2105 ATF_CHECK(bpf_validate(insns, insn_count));
2107 code = bpfjit_generate_code(NULL, insns, insn_count);
2131 static struct bpf_insn insns[] = {
2154 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2156 ATF_CHECK(bpf_validate(insns, insn_count));
2158 code = bpfjit_generate_code(NULL, insns, insn_count);
2182 static struct bpf_insn insns[] = {
2216 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2218 ATF_CHECK(bpf_validate(insns, insn_count));
2220 code = bpfjit_generate_code(NULL, insns, insn_count);
2237 static struct bpf_insn insns[] = {
2267 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2269 ATF_CHECK(bpf_validate(insns, insn_count));
2271 code = bpfjit_generate_code(NULL, insns, insn_count);
2295 static struct bpf_insn insns[] = {
2325 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2327 ATF_CHECK(bpf_validate(insns, insn_count));
2329 code = bpfjit_generate_code(NULL, insns, insn_count);
2353 static struct bpf_insn insns[] = {
2382 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2384 ATF_CHECK(bpf_validate(insns, insn_count));
2386 code = bpfjit_generate_code(NULL, insns, insn_count);
2410 static struct bpf_insn insns[] = {
2439 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2441 ATF_CHECK(bpf_validate(insns, insn_count));
2443 code = bpfjit_generate_code(NULL, insns, insn_count);
2467 static struct bpf_insn insns[] = {
2476 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2478 ATF_CHECK(bpf_validate(insns, insn_count));
2480 code = bpfjit_generate_code(NULL, insns, insn_count);
2497 static struct bpf_insn insns[] = {
2507 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2509 ATF_CHECK(bpf_validate(insns, insn_count));
2511 code = bpfjit_generate_code(NULL, insns, insn_count);
2528 static struct bpf_insn insns[] = {
2538 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2540 ATF_CHECK(bpf_validate(insns, insn_count));
2542 code = bpfjit_generate_code(NULL, insns, insn_count);
2559 static struct bpf_insn insns[] = {
2603 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2605 ATF_CHECK(bpf_validate(insns, insn_count));
2607 code = bpfjit_generate_code(NULL, insns, insn_count);
2624 static struct bpf_insn insns[3][2] = {
2646 size_t insn_count = sizeof(insns[0]) / sizeof(insns[0][0]);
2651 ATF_CHECK(bpf_validate(insns[i], insn_count));
2653 code = bpfjit_generate_code(NULL, insns[i], insn_count);
2681 static struct bpf_insn insns[12][3] = {
2747 size_t insn_count = sizeof(insns[0]) / sizeof(insns[0][0]);
2752 ATF_CHECK(bpf_validate(insns[i], insn_count));
2754 code = bpfjit_generate_code(NULL, insns[i], insn_count);
2772 static struct bpf_insn insns[6][3] = {
2816 size_t insn_count = sizeof(insns[0]) / sizeof(insns[0][0]);
2821 ATF_CHECK(bpf_validate(insns[i], insn_count));
2823 code = bpfjit_generate_code(NULL, insns[i], insn_count);
2851 static struct bpf_insn insns[12][3] = {
2917 size_t insn_count = sizeof(insns[0]) / sizeof(insns[0][0]);
2922 ATF_CHECK(bpf_validate(insns[i], insn_count));
2924 code = bpfjit_generate_code(NULL, insns[i], insn_count);
2942 static struct bpf_insn insns[] = {
2954 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2956 ATF_CHECK(bpf_validate(insns, insn_count));
2958 code = bpfjit_generate_code(NULL, insns, insn_count);
2962 ATF_CHECK(bpf_filter(insns, pkt, i, i) == 10 * i);
2978 static struct bpf_insn insns[] = {
2991 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
2993 ATF_CHECK(bpf_validate(insns, insn_count));
2995 code = bpfjit_generate_code(NULL, insns, insn_count);
2999 ATF_CHECK(bpf_filter(insns, pkt, i, i) == 10 * i);
3015 static struct bpf_insn insns[] = {
3024 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3026 ATF_CHECK(bpf_validate(insns, insn_count));
3028 code = bpfjit_generate_code(NULL, insns, insn_count);
3046 static struct bpf_insn insns[] = {
3054 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3056 ATF_CHECK(bpf_validate(insns, insn_count));
3058 code = bpfjit_generate_code(NULL, insns, insn_count);
3075 static struct bpf_insn insns[] = {
3084 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3086 ATF_CHECK(bpf_validate(insns, insn_count));
3088 code = bpfjit_generate_code(NULL, insns, insn_count);
3105 static struct bpf_insn insns[] = {
3116 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3118 ATF_CHECK(bpf_validate(insns, insn_count));
3120 code = bpfjit_generate_code(NULL, insns, insn_count);
3137 static struct bpf_insn insns[] = {
3147 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3149 ATF_CHECK(bpf_validate(insns, insn_count));
3151 code = bpfjit_generate_code(NULL, insns, insn_count);
3171 static struct bpf_insn insns[] = {
3182 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3184 ATF_CHECK(bpf_validate(insns, insn_count));
3186 code = bpfjit_generate_code(NULL, insns, insn_count);
3204 static struct bpf_insn insns[] = {
3213 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3215 ATF_CHECK(bpf_validate(insns, insn_count));
3217 code = bpfjit_generate_code(NULL, insns, insn_count);
3234 static struct bpf_insn insns[] = {
3244 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3246 ATF_CHECK(bpf_validate(insns, insn_count));
3248 code = bpfjit_generate_code(NULL, insns, insn_count);
3265 static struct bpf_insn insns[] = {
3274 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3276 ATF_CHECK(bpf_validate(insns, insn_count));
3278 code = bpfjit_generate_code(NULL, insns, insn_count);
3295 static struct bpf_insn insns[] = {
3307 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3309 ATF_CHECK(bpf_validate(insns, insn_count));
3311 code = bpfjit_generate_code(NULL, insns, insn_count);
3329 static struct bpf_insn insns[] = {
3339 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3341 ATF_CHECK(bpf_validate(insns, insn_count));
3343 code = bpfjit_generate_code(NULL, insns, insn_count);
3360 static struct bpf_insn insns[] = {
3376 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3380 ATF_CHECK(bpf_validate(insns, insn_count));
3382 code = bpfjit_generate_code(NULL, insns, insn_count);
3400 static struct bpf_insn insns[] = {
3416 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3420 ATF_CHECK(bpf_validate(insns, insn_count));
3422 code = bpfjit_generate_code(NULL, insns, insn_count);
3440 struct bpf_insn insns[5*BPF_MEMWORDS+2];
3441 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3447 memset(insns, 0, sizeof(insns));
3451 insns[2*k].code = BPF_LD+BPF_IMM;
3452 insns[2*k].k = 3*k;
3453 insns[2*k+1].code = BPF_ST;
3454 insns[2*k+1].k = k;
3458 insns[2*BPF_MEMWORDS].code = BPF_LD+BPF_W+BPF_LEN;
3462 insns[2*BPF_MEMWORDS+3*k+1].code = BPF_JMP+BPF_JEQ+BPF_K;
3463 insns[2*BPF_MEMWORDS+3*k+1].k = k+1;
3464 insns[2*BPF_MEMWORDS+3*k+1].jt = 0;
3465 insns[2*BPF_MEMWORDS+3*k+1].jf = 2;
3466 insns[2*BPF_MEMWORDS+3*k+2].code = BPF_LD+BPF_MEM;
3467 insns[2*BPF_MEMWORDS+3*k+2].k = k;
3468 insns[2*BPF_MEMWORDS+3*k+3].code = BPF_RET+BPF_A;
3469 insns[2*BPF_MEMWORDS+3*k+3].k = 0;
3472 insns[5*BPF_MEMWORDS+1].code = BPF_RET+BPF_K;
3473 insns[5*BPF_MEMWORDS+1].k = UINT32_MAX;
3475 ATF_CHECK(bpf_validate(insns, insn_count));
3477 code = bpfjit_generate_code(NULL, insns, insn_count);
3495 static struct bpf_insn insns[] = {
3507 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3509 ATF_CHECK(bpf_validate(insns, insn_count));
3511 code = bpfjit_generate_code(NULL, insns, insn_count);
3529 static struct bpf_insn insns[] = {
3540 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3542 ATF_CHECK(bpf_validate(insns, insn_count));
3544 code = bpfjit_generate_code(NULL, insns, insn_count);
3561 static struct bpf_insn insns[] = {
3583 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3585 ATF_CHECK(bpf_validate(insns, insn_count));
3587 code = bpfjit_generate_code(NULL, insns, insn_count);
3605 struct bpf_insn insns[5*BPF_MEMWORDS+2];
3606 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3612 memset(insns, 0, sizeof(insns));
3616 insns[2*k].code = BPF_LDX+BPF_W+BPF_IMM;
3617 insns[2*k].k = 3*k;
3618 insns[2*k+1].code = BPF_STX;
3619 insns[2*k+1].k = k;
3623 insns[2*BPF_MEMWORDS].code = BPF_LD+BPF_W+BPF_LEN;
3627 insns[2*BPF_MEMWORDS+3*k+1].code = BPF_JMP+BPF_JEQ+BPF_K;
3628 insns[2*BPF_MEMWORDS+3*k+1].k = k+1;
3629 insns[2*BPF_MEMWORDS+3*k+1].jt = 0;
3630 insns[2*BPF_MEMWORDS+3*k+1].jf = 2;
3631 insns[2*BPF_MEMWORDS+3*k+2].code = BPF_LD+BPF_MEM;
3632 insns[2*BPF_MEMWORDS+3*k+2].k = k;
3633 insns[2*BPF_MEMWORDS+3*k+3].code = BPF_RET+BPF_A;
3634 insns[2*BPF_MEMWORDS+3*k+3].k = 0;
3637 insns[5*BPF_MEMWORDS+1].code = BPF_RET+BPF_K;
3638 insns[5*BPF_MEMWORDS+1].k = UINT32_MAX;
3640 ATF_CHECK(bpf_validate(insns, insn_count));
3642 code = bpfjit_generate_code(NULL, insns, insn_count);
3661 static struct bpf_insn insns[] = {
3692 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3694 ATF_CHECK(bpf_validate(insns, insn_count));
3696 code = bpfjit_generate_code(NULL, insns, insn_count);
3718 static struct bpf_insn insns[] = {
3749 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3751 ATF_CHECK(bpf_validate(insns, insn_count));
3753 code = bpfjit_generate_code(NULL, insns, insn_count);
3775 static struct bpf_insn insns[] = {
3806 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3808 ATF_CHECK(bpf_validate(insns, insn_count));
3810 code = bpfjit_generate_code(NULL, insns, insn_count);
3832 static struct bpf_insn insns[] = {
3864 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3866 ATF_CHECK(bpf_validate(insns, insn_count));
3868 code = bpfjit_generate_code(NULL, insns, insn_count);
3890 static struct bpf_insn insns[] = {
3922 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3924 ATF_CHECK(bpf_validate(insns, insn_count));
3926 code = bpfjit_generate_code(NULL, insns, insn_count);
3948 static struct bpf_insn insns[] = {
3981 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
3983 ATF_CHECK(bpf_validate(insns, insn_count));
3985 code = bpfjit_generate_code(NULL, insns, insn_count);
4007 static struct bpf_insn insns[] = {
4040 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
4042 ATF_CHECK(bpf_validate(insns, insn_count));
4044 code = bpfjit_generate_code(NULL, insns, insn_count);
4065 static struct bpf_insn insns[] = {
4082 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
4084 ATF_CHECK(bpf_validate(insns, insn_count));
4086 code = bpfjit_generate_code(NULL, insns, insn_count);
4108 static struct bpf_insn insns[] = {
4124 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
4126 ATF_CHECK(bpf_validate(insns, insn_count));
4128 code = bpfjit_generate_code(NULL, insns, insn_count);
4146 static struct bpf_insn insns[] = {
4160 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
4162 ATF_CHECK(bpf_validate(insns, insn_count));
4164 code = bpfjit_generate_code(NULL, insns, insn_count);
4233 struct bpf_insn insns[] = {
4245 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
4247 ATF_CHECK(bpf_validate(insns, insn_count));
4249 code = bpfjit_generate_code(NULL, insns, insn_count);
4330 static struct bpf_insn insns[] = {
4347 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
4349 ATF_CHECK(bpf_validate(insns, insn_count));
4351 code = bpfjit_generate_code(NULL, insns, insn_count);
4464 struct bpf_insn insns[] = {
4486 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
4488 ATF_CHECK(bpf_validate(insns, insn_count));
4490 code = bpfjit_generate_code(NULL, insns, insn_count);
4598 static struct bpf_insn insns[] = {
4603 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
4605 ATF_CHECK(!bpf_validate(insns, insn_count));
4607 ATF_CHECK(bpfjit_generate_code(NULL, insns, insn_count) == NULL);
4619 static struct bpf_insn insns[] = {
4624 size_t insn_count = sizeof(insns) / sizeof(insns[0]);
4626 ATF_CHECK(!bpf_validate(insns, insn_count));
4628 ATF_CHECK(bpfjit_generate_code(NULL, insns, insn_count) == NULL);