1 // SPDX-License-Identifier: GPL-2.0-only
2
3 #include <test_progs.h>
4
5 #include "arena_kfunc.skel.h"
6 #include "arena_kfunc_jit.skel.h"
7 #include "cap_helpers.h"
8 #include "verifier_align.skel.h"
9 #include "verifier_and.skel.h"
10 #include "verifier_arena.skel.h"
11 #include "verifier_arena_large.skel.h"
12 #include "verifier_arena_globals1.skel.h"
13 #include "verifier_arena_globals2.skel.h"
14 #include "verifier_array_access.skel.h"
15 #include "verifier_async_cb_context.skel.h"
16 #include "verifier_basic_stack.skel.h"
17 #include "verifier_bitfield_write.skel.h"
18 #include "verifier_bounds.skel.h"
19 #include "verifier_bounds_deduction.skel.h"
20 #include "verifier_bounds_deduction_non_const.skel.h"
21 #include "verifier_bounds_mix_sign_unsign.skel.h"
22 #include "verifier_bpf_get_stack.skel.h"
23 #include "verifier_bpf_trap.skel.h"
24 #include "verifier_bswap.skel.h"
25 #include "verifier_btf_ctx_access.skel.h"
26 #include "verifier_btf_unreliable_prog.skel.h"
27 #include "verifier_call_large_imm.skel.h"
28 #include "verifier_cfg.skel.h"
29 #include "verifier_cgroup_inv_retcode.skel.h"
30 #include "verifier_cgroup_skb.skel.h"
31 #include "verifier_cgroup_storage.skel.h"
32 #include "verifier_const.skel.h"
33 #include "verifier_const_or.skel.h"
34 #include "verifier_ctx.skel.h"
35 #include "verifier_ctx_sk_msg.skel.h"
36 #include "verifier_d_path.skel.h"
37 #include "verifier_default_trusted_ptr.skel.h"
38 #include "verifier_direct_packet_access.skel.h"
39 #include "verifier_direct_stack_access_wraparound.skel.h"
40 #include "verifier_div0.skel.h"
41 #include "verifier_div_mod_bounds.skel.h"
42 #include "verifier_div_overflow.skel.h"
43 #include "verifier_flow_keys.skel.h"
44 #include "verifier_global_subprogs.skel.h"
45 #include "verifier_global_ptr_args.skel.h"
46 #include "verifier_gotol.skel.h"
47 #include "verifier_gotox.skel.h"
48 #include "verifier_helper_access_var_len.skel.h"
49 #include "verifier_helper_packet_access.skel.h"
50 #include "verifier_helper_restricted.skel.h"
51 #include "verifier_helper_value_access.skel.h"
52 #include "verifier_int_ptr.skel.h"
53 #include "verifier_iterating_callbacks.skel.h"
54 #include "verifier_jeq_infer_not_null.skel.h"
55 #include "verifier_jit_convergence.skel.h"
56 #include "verifier_ld_ind.skel.h"
57 #include "verifier_ldsx.skel.h"
58 #include "verifier_leak_ptr.skel.h"
59 #include "verifier_linked_scalars.skel.h"
60 #include "verifier_live_stack.skel.h"
61 #include "verifier_liveness_exp.skel.h"
62 #include "verifier_load_acquire.skel.h"
63 #include "verifier_loops1.skel.h"
64 #include "verifier_lwt.skel.h"
65 #include "verifier_map_in_map.skel.h"
66 #include "verifier_map_lookup_refine.skel.h"
67 #include "verifier_map_ptr.skel.h"
68 #include "verifier_map_ptr_mixing.skel.h"
69 #include "verifier_map_ret_val.skel.h"
70 #include "verifier_masking.skel.h"
71 #include "verifier_may_goto_1.skel.h"
72 #include "verifier_may_goto_2.skel.h"
73 #include "verifier_mem_size_reg.skel.h"
74 #include "verifier_meta_access.skel.h"
75 #include "verifier_movsx.skel.h"
76 #include "verifier_mtu.skel.h"
77 #include "verifier_mul.skel.h"
78 #include "verifier_netfilter_ctx.skel.h"
79 #include "verifier_netfilter_retcode.skel.h"
80 #include "verifier_bpf_fastcall.skel.h"
81 #include "verifier_or_jmp32_k.skel.h"
82 #include "verifier_percpu_addr.skel.h"
83 #include "verifier_precision.skel.h"
84 #include "verifier_prevent_map_lookup.skel.h"
85 #include "verifier_private_stack.skel.h"
86 #include "verifier_ptr_to_buf.skel.h"
87 #include "verifier_raw_stack.skel.h"
88 #include "verifier_raw_tp_writable.skel.h"
89 #include "verifier_reg_equal.skel.h"
90 #include "verifier_ref_tracking.skel.h"
91 #include "verifier_regalloc.skel.h"
92 #include "verifier_ringbuf.skel.h"
93 #include "verifier_runtime_jit.skel.h"
94 #include "verifier_scalar_ids.skel.h"
95 #include "verifier_sdiv.skel.h"
96 #include "verifier_search_pruning.skel.h"
97 #include "verifier_sock.skel.h"
98 #include "verifier_sock_addr.skel.h"
99 #include "verifier_sockmap_mutate.skel.h"
100 #include "verifier_spill_fill.skel.h"
101 #include "verifier_spin_lock.skel.h"
102 #include "verifier_stack_arg.skel.h"
103 #include "verifier_stack_arg_order.skel.h"
104 #include "verifier_stack_ptr.skel.h"
105 #include "verifier_store_release.skel.h"
106 #include "verifier_subprog_insn_stats.skel.h"
107 #include "verifier_subprog_precision.skel.h"
108 #include "verifier_subprog_topo.skel.h"
109 #include "verifier_subreg.skel.h"
110 #include "verifier_tailcall.skel.h"
111 #include "verifier_tailcall_jit.skel.h"
112 #include "verifier_typedef.skel.h"
113 #include "verifier_uninit.skel.h"
114 #include "verifier_unpriv.skel.h"
115 #include "verifier_unpriv_perf.skel.h"
116 #include "verifier_value_adj_spill.skel.h"
117 #include "verifier_value.skel.h"
118 #include "verifier_value_illegal_alu.skel.h"
119 #include "verifier_value_or_null.skel.h"
120 #include "verifier_value_ptr_arith.skel.h"
121 #include "verifier_var_off.skel.h"
122 #include "verifier_vfs_accept.skel.h"
123 #include "verifier_vfs_reject.skel.h"
124 #include "verifier_xadd.skel.h"
125 #include "verifier_xdp.skel.h"
126 #include "verifier_xdp_direct_packet_access.skel.h"
127 #include "verifier_bits_iter.skel.h"
128 #include "verifier_set_retval.skel.h"
129 #include "verifier_lsm.skel.h"
130 #include "verifier_jit_inline.skel.h"
131 #include "irq.skel.h"
132 #include "verifier_ctx_ptr_param.skel.h"
133 #include "verifier_zext.skel.h"
134
135 #define MAX_ENTRIES 11
136
137 struct test_val {
138 unsigned int index;
139 int foo[MAX_ENTRIES];
140 };
141
142 __maybe_unused
run_tests_aux(const char * skel_name,skel_elf_bytes_fn elf_bytes_factory,pre_execution_cb pre_execution_cb)143 static void run_tests_aux(const char *skel_name,
144 skel_elf_bytes_fn elf_bytes_factory,
145 pre_execution_cb pre_execution_cb)
146 {
147 struct test_loader tester = {};
148 __u64 old_caps;
149 int err;
150
151 /* test_verifier tests are executed w/o CAP_SYS_ADMIN, do the same here */
152 err = cap_disable_effective(1ULL << CAP_SYS_ADMIN, &old_caps);
153 if (err) {
154 PRINT_FAIL("failed to drop CAP_SYS_ADMIN: %i, %s\n", err, strerror(-err));
155 return;
156 }
157
158 test_loader__set_pre_execution_cb(&tester, pre_execution_cb);
159 test_loader__run_subtests(&tester, skel_name, elf_bytes_factory);
160 test_loader_fini(&tester);
161
162 err = cap_enable_effective(old_caps, NULL);
163 if (err)
164 PRINT_FAIL("failed to restore CAP_SYS_ADMIN: %i, %s\n", err, strerror(-err));
165 }
166
167 #define RUN(skel) run_tests_aux(#skel, skel##__elf_bytes, NULL)
168
test_arena_kfunc(void)169 void test_arena_kfunc(void) { RUN_TESTS(arena_kfunc); }
170
test_arena_kfunc_jit(void)171 void test_arena_kfunc_jit(void) { RUN_TESTS(arena_kfunc_jit); }
172
test_verifier_align(void)173 void test_verifier_align(void) { RUN(verifier_align); }
test_verifier_and(void)174 void test_verifier_and(void) { RUN(verifier_and); }
test_verifier_arena(void)175 void test_verifier_arena(void) { RUN(verifier_arena); }
test_verifier_arena_large(void)176 void test_verifier_arena_large(void) { RUN(verifier_arena_large); }
test_verifier_arena_globals1(void)177 void test_verifier_arena_globals1(void) { RUN(verifier_arena_globals1); }
test_verifier_arena_globals2(void)178 void test_verifier_arena_globals2(void) { RUN(verifier_arena_globals2); }
test_verifier_basic_stack(void)179 void test_verifier_basic_stack(void) { RUN(verifier_basic_stack); }
test_verifier_bitfield_write(void)180 void test_verifier_bitfield_write(void) { RUN(verifier_bitfield_write); }
test_verifier_bounds(void)181 void test_verifier_bounds(void) { RUN(verifier_bounds); }
test_verifier_bounds_deduction(void)182 void test_verifier_bounds_deduction(void) { RUN(verifier_bounds_deduction); }
test_verifier_bounds_deduction_non_const(void)183 void test_verifier_bounds_deduction_non_const(void) { RUN(verifier_bounds_deduction_non_const); }
test_verifier_bounds_mix_sign_unsign(void)184 void test_verifier_bounds_mix_sign_unsign(void) { RUN(verifier_bounds_mix_sign_unsign); }
test_verifier_bpf_get_stack(void)185 void test_verifier_bpf_get_stack(void) { RUN(verifier_bpf_get_stack); }
test_verifier_bpf_trap(void)186 void test_verifier_bpf_trap(void) { RUN(verifier_bpf_trap); }
test_verifier_bswap(void)187 void test_verifier_bswap(void) { RUN(verifier_bswap); }
test_verifier_btf_ctx_access(void)188 void test_verifier_btf_ctx_access(void) { RUN(verifier_btf_ctx_access); }
test_verifier_btf_unreliable_prog(void)189 void test_verifier_btf_unreliable_prog(void) { RUN(verifier_btf_unreliable_prog); }
test_verifier_call_large_imm(void)190 void test_verifier_call_large_imm(void) { RUN(verifier_call_large_imm); }
test_verifier_cfg(void)191 void test_verifier_cfg(void) { RUN(verifier_cfg); }
test_verifier_cgroup_inv_retcode(void)192 void test_verifier_cgroup_inv_retcode(void) { RUN(verifier_cgroup_inv_retcode); }
test_verifier_cgroup_skb(void)193 void test_verifier_cgroup_skb(void) { RUN(verifier_cgroup_skb); }
test_verifier_cgroup_storage(void)194 void test_verifier_cgroup_storage(void) { RUN(verifier_cgroup_storage); }
test_verifier_const(void)195 void test_verifier_const(void) { RUN(verifier_const); }
test_verifier_const_or(void)196 void test_verifier_const_or(void) { RUN(verifier_const_or); }
test_verifier_ctx(void)197 void test_verifier_ctx(void) { RUN_TESTS(verifier_ctx); }
test_verifier_ctx_sk_msg(void)198 void test_verifier_ctx_sk_msg(void) { RUN(verifier_ctx_sk_msg); }
test_verifier_d_path(void)199 void test_verifier_d_path(void) { RUN(verifier_d_path); }
test_verifier_default_trusted_ptr(void)200 void test_verifier_default_trusted_ptr(void) { RUN_TESTS(verifier_default_trusted_ptr); }
test_verifier_direct_packet_access(void)201 void test_verifier_direct_packet_access(void) { RUN(verifier_direct_packet_access); }
test_verifier_direct_stack_access_wraparound(void)202 void test_verifier_direct_stack_access_wraparound(void) { RUN(verifier_direct_stack_access_wraparound); }
test_verifier_div0(void)203 void test_verifier_div0(void) { RUN(verifier_div0); }
test_verifier_div_mod_bounds(void)204 void test_verifier_div_mod_bounds(void) { RUN(verifier_div_mod_bounds); }
test_verifier_div_overflow(void)205 void test_verifier_div_overflow(void) { RUN(verifier_div_overflow); }
test_verifier_flow_keys(void)206 void test_verifier_flow_keys(void) { RUN(verifier_flow_keys); }
test_verifier_global_subprogs(void)207 void test_verifier_global_subprogs(void) { RUN(verifier_global_subprogs); }
test_verifier_global_ptr_args(void)208 void test_verifier_global_ptr_args(void) { RUN(verifier_global_ptr_args); }
test_verifier_gotol(void)209 void test_verifier_gotol(void) { RUN(verifier_gotol); }
test_verifier_gotox(void)210 void test_verifier_gotox(void) { RUN(verifier_gotox); }
test_verifier_helper_access_var_len(void)211 void test_verifier_helper_access_var_len(void) { RUN(verifier_helper_access_var_len); }
test_verifier_helper_packet_access(void)212 void test_verifier_helper_packet_access(void) { RUN(verifier_helper_packet_access); }
test_verifier_helper_restricted(void)213 void test_verifier_helper_restricted(void) { RUN(verifier_helper_restricted); }
test_verifier_helper_value_access(void)214 void test_verifier_helper_value_access(void) { RUN(verifier_helper_value_access); }
test_verifier_int_ptr(void)215 void test_verifier_int_ptr(void) { RUN(verifier_int_ptr); }
test_verifier_iterating_callbacks(void)216 void test_verifier_iterating_callbacks(void) { RUN(verifier_iterating_callbacks); }
test_verifier_jeq_infer_not_null(void)217 void test_verifier_jeq_infer_not_null(void) { RUN(verifier_jeq_infer_not_null); }
test_verifier_jit_convergence(void)218 void test_verifier_jit_convergence(void) { RUN(verifier_jit_convergence); }
test_verifier_load_acquire(void)219 void test_verifier_load_acquire(void) { RUN(verifier_load_acquire); }
test_verifier_ld_ind(void)220 void test_verifier_ld_ind(void) { RUN(verifier_ld_ind); }
test_verifier_ldsx(void)221 void test_verifier_ldsx(void) { RUN(verifier_ldsx); }
test_verifier_leak_ptr(void)222 void test_verifier_leak_ptr(void) { RUN(verifier_leak_ptr); }
test_verifier_linked_scalars(void)223 void test_verifier_linked_scalars(void) { RUN(verifier_linked_scalars); }
test_verifier_live_stack(void)224 void test_verifier_live_stack(void) { RUN(verifier_live_stack); }
test_verifier_liveness_exp(void)225 void test_verifier_liveness_exp(void) { RUN(verifier_liveness_exp); }
test_verifier_loops1(void)226 void test_verifier_loops1(void) { RUN(verifier_loops1); }
test_verifier_lwt(void)227 void test_verifier_lwt(void) { RUN(verifier_lwt); }
test_verifier_map_in_map(void)228 void test_verifier_map_in_map(void) { RUN(verifier_map_in_map); }
test_verifier_map_lookup_refine(void)229 void test_verifier_map_lookup_refine(void) { RUN(verifier_map_lookup_refine); }
test_verifier_map_ptr(void)230 void test_verifier_map_ptr(void) { RUN(verifier_map_ptr); }
test_verifier_map_ptr_mixing(void)231 void test_verifier_map_ptr_mixing(void) { RUN(verifier_map_ptr_mixing); }
test_verifier_map_ret_val(void)232 void test_verifier_map_ret_val(void) { RUN(verifier_map_ret_val); }
test_verifier_masking(void)233 void test_verifier_masking(void) { RUN(verifier_masking); }
test_verifier_may_goto_1(void)234 void test_verifier_may_goto_1(void) { RUN(verifier_may_goto_1); }
test_verifier_may_goto_2(void)235 void test_verifier_may_goto_2(void) { RUN(verifier_may_goto_2); }
test_verifier_mem_size_reg(void)236 void test_verifier_mem_size_reg(void) { RUN(verifier_mem_size_reg); }
test_verifier_meta_access(void)237 void test_verifier_meta_access(void) { RUN(verifier_meta_access); }
test_verifier_movsx(void)238 void test_verifier_movsx(void) { RUN(verifier_movsx); }
test_verifier_mul(void)239 void test_verifier_mul(void) { RUN(verifier_mul); }
test_verifier_netfilter_ctx(void)240 void test_verifier_netfilter_ctx(void) { RUN(verifier_netfilter_ctx); }
test_verifier_netfilter_retcode(void)241 void test_verifier_netfilter_retcode(void) { RUN(verifier_netfilter_retcode); }
test_verifier_bpf_fastcall(void)242 void test_verifier_bpf_fastcall(void) { RUN(verifier_bpf_fastcall); }
test_verifier_or_jmp32_k(void)243 void test_verifier_or_jmp32_k(void) { RUN(verifier_or_jmp32_k); }
test_verifier_percpu_addr(void)244 void test_verifier_percpu_addr(void) { RUN(verifier_percpu_addr); }
test_verifier_precision(void)245 void test_verifier_precision(void) { RUN(verifier_precision); }
test_verifier_prevent_map_lookup(void)246 void test_verifier_prevent_map_lookup(void) { RUN(verifier_prevent_map_lookup); }
test_verifier_private_stack(void)247 void test_verifier_private_stack(void) { RUN(verifier_private_stack); }
test_verifier_ptr_to_buf(void)248 void test_verifier_ptr_to_buf(void) { RUN(verifier_ptr_to_buf); }
test_verifier_raw_stack(void)249 void test_verifier_raw_stack(void) { RUN(verifier_raw_stack); }
test_verifier_raw_tp_writable(void)250 void test_verifier_raw_tp_writable(void) { RUN(verifier_raw_tp_writable); }
test_verifier_reg_equal(void)251 void test_verifier_reg_equal(void) { RUN(verifier_reg_equal); }
test_verifier_ref_tracking(void)252 void test_verifier_ref_tracking(void) { RUN(verifier_ref_tracking); }
test_verifier_regalloc(void)253 void test_verifier_regalloc(void) { RUN(verifier_regalloc); }
test_verifier_ringbuf(void)254 void test_verifier_ringbuf(void) { RUN(verifier_ringbuf); }
test_verifier_runtime_jit(void)255 void test_verifier_runtime_jit(void) { RUN(verifier_runtime_jit); }
test_verifier_scalar_ids(void)256 void test_verifier_scalar_ids(void) { RUN(verifier_scalar_ids); }
test_verifier_sdiv(void)257 void test_verifier_sdiv(void) { RUN(verifier_sdiv); }
test_verifier_search_pruning(void)258 void test_verifier_search_pruning(void) { RUN(verifier_search_pruning); }
test_verifier_sock(void)259 void test_verifier_sock(void) { RUN(verifier_sock); }
test_verifier_sock_addr(void)260 void test_verifier_sock_addr(void) { RUN(verifier_sock_addr); }
test_verifier_sockmap_mutate(void)261 void test_verifier_sockmap_mutate(void) { RUN(verifier_sockmap_mutate); }
test_verifier_spill_fill(void)262 void test_verifier_spill_fill(void) { RUN(verifier_spill_fill); }
test_verifier_spin_lock(void)263 void test_verifier_spin_lock(void) { RUN(verifier_spin_lock); }
test_verifier_stack_arg(void)264 void test_verifier_stack_arg(void) { RUN(verifier_stack_arg); }
test_verifier_stack_arg_order(void)265 void test_verifier_stack_arg_order(void) { RUN(verifier_stack_arg_order); }
test_verifier_stack_ptr(void)266 void test_verifier_stack_ptr(void) { RUN(verifier_stack_ptr); }
test_verifier_store_release(void)267 void test_verifier_store_release(void) { RUN(verifier_store_release); }
test_verifier_subprog_insn_stats(void)268 void test_verifier_subprog_insn_stats(void) { RUN(verifier_subprog_insn_stats); }
test_verifier_subprog_precision(void)269 void test_verifier_subprog_precision(void) { RUN(verifier_subprog_precision); }
test_verifier_subprog_topo(void)270 void test_verifier_subprog_topo(void) { RUN(verifier_subprog_topo); }
test_verifier_subreg(void)271 void test_verifier_subreg(void) { RUN(verifier_subreg); }
test_verifier_tailcall(void)272 void test_verifier_tailcall(void) { RUN(verifier_tailcall); }
test_verifier_tailcall_jit(void)273 void test_verifier_tailcall_jit(void) { RUN(verifier_tailcall_jit); }
test_verifier_typedef(void)274 void test_verifier_typedef(void) { RUN(verifier_typedef); }
test_verifier_uninit(void)275 void test_verifier_uninit(void) { RUN(verifier_uninit); }
test_verifier_unpriv(void)276 void test_verifier_unpriv(void) { RUN(verifier_unpriv); }
test_verifier_unpriv_perf(void)277 void test_verifier_unpriv_perf(void) { RUN(verifier_unpriv_perf); }
test_verifier_value_adj_spill(void)278 void test_verifier_value_adj_spill(void) { RUN(verifier_value_adj_spill); }
test_verifier_value(void)279 void test_verifier_value(void) { RUN(verifier_value); }
test_verifier_value_illegal_alu(void)280 void test_verifier_value_illegal_alu(void) { RUN(verifier_value_illegal_alu); }
test_verifier_value_or_null(void)281 void test_verifier_value_or_null(void) { RUN(verifier_value_or_null); }
test_verifier_var_off(void)282 void test_verifier_var_off(void) { RUN(verifier_var_off); }
test_verifier_vfs_accept(void)283 void test_verifier_vfs_accept(void) { RUN(verifier_vfs_accept); }
test_verifier_vfs_reject(void)284 void test_verifier_vfs_reject(void) { RUN(verifier_vfs_reject); }
test_verifier_xadd(void)285 void test_verifier_xadd(void) { RUN(verifier_xadd); }
test_verifier_xdp(void)286 void test_verifier_xdp(void) { RUN(verifier_xdp); }
test_verifier_xdp_direct_packet_access(void)287 void test_verifier_xdp_direct_packet_access(void) { RUN(verifier_xdp_direct_packet_access); }
test_verifier_bits_iter(void)288 void test_verifier_bits_iter(void) { RUN(verifier_bits_iter); }
test_verifier_set_retval(void)289 void test_verifier_set_retval(void) { RUN(verifier_set_retval); }
test_verifier_lsm(void)290 void test_verifier_lsm(void) { RUN(verifier_lsm); }
test_irq(void)291 void test_irq(void) { RUN(irq); }
test_verifier_mtu(void)292 void test_verifier_mtu(void) { RUN(verifier_mtu); }
test_verifier_jit_inline(void)293 void test_verifier_jit_inline(void) { RUN(verifier_jit_inline); }
test_verifier_ctx_ptr_param(void)294 void test_verifier_ctx_ptr_param(void) { RUN(verifier_ctx_ptr_param); }
test_verifier_zext(void)295 void test_verifier_zext(void) { RUN_TESTS(verifier_zext); }
296
init_test_val_map(struct bpf_object * obj,char * map_name)297 static int init_test_val_map(struct bpf_object *obj, char *map_name)
298 {
299 struct test_val value = {
300 .index = (6 + 1) * sizeof(int),
301 .foo[6] = 0xabcdef12,
302 };
303 struct bpf_map *map;
304 int err, key = 0;
305
306 map = bpf_object__find_map_by_name(obj, map_name);
307 if (!map) {
308 PRINT_FAIL("Can't find map '%s'\n", map_name);
309 return -EINVAL;
310 }
311
312 err = bpf_map_update_elem(bpf_map__fd(map), &key, &value, 0);
313 if (err) {
314 PRINT_FAIL("Error while updating map '%s': %d\n", map_name, err);
315 return err;
316 }
317
318 return 0;
319 }
320
init_array_access_maps(struct bpf_object * obj)321 static int init_array_access_maps(struct bpf_object *obj)
322 {
323 return init_test_val_map(obj, "map_array_ro");
324 }
325
test_verifier_array_access(void)326 void test_verifier_array_access(void)
327 {
328 run_tests_aux("verifier_array_access",
329 verifier_array_access__elf_bytes,
330 init_array_access_maps);
331 }
test_verifier_async_cb_context(void)332 void test_verifier_async_cb_context(void) { RUN(verifier_async_cb_context); }
333
init_value_ptr_arith_maps(struct bpf_object * obj)334 static int init_value_ptr_arith_maps(struct bpf_object *obj)
335 {
336 return init_test_val_map(obj, "map_array_48b");
337 }
338
test_verifier_value_ptr_arith(void)339 void test_verifier_value_ptr_arith(void)
340 {
341 run_tests_aux("verifier_value_ptr_arith",
342 verifier_value_ptr_arith__elf_bytes,
343 init_value_ptr_arith_maps);
344 }
345