Debian Codegraph @

libdrgn/tests/parse_addr2line.c.in

raw
1 // Copyright (c) Meta Platforms, Inc. and affiliates.
2 // SPDX-License-Identifier: LGPL-2.1-or-later
3
4 #include "test_util.h"
5 #include "../error.h"
6 #include "../stack_trace.h"
7
8 #suite parse_addr2line
9
10 #test symbol_name
11 {
12 const char *sym_name;
13 size_t sym_name_len;
14 unsigned long long offset;
15 drgn_ck_no_err(drgn_parse_addr2line("my_symbol", &sym_name,
16 &sym_name_len, &offset));
17 ck_assert_uint_eq(sym_name_len, strlen("my_symbol"));
18 ck_assert_mem_eq(sym_name, "my_symbol", strlen("my_symbol"));
19 ck_assert_uint_eq(offset, 0);
20 }
21
22 #test symbol_name_with_punctuation
23 {
24 const char *sym_name;
25 size_t sym_name_len;
26 unsigned long long offset;
27 drgn_ck_no_err(drgn_parse_addr2line("my_symbol.cold", &sym_name,
28 &sym_name_len, &offset));
29 ck_assert_uint_eq(sym_name_len, strlen("my_symbol.cold"));
30 ck_assert_mem_eq(sym_name, "my_symbol.cold", strlen("my_symbol.cold"));
31 ck_assert_uint_eq(offset, 0);
32 }
33
34 #test symbol_name_with_whitespace
35 {
36 const char *sym_name;
37 size_t sym_name_len;
38 unsigned long long offset;
39 drgn_ck_no_err(drgn_parse_addr2line(" my_symbol\t", &sym_name,
40 &sym_name_len, &offset));
41 ck_assert_uint_eq(sym_name_len, strlen("my_symbol"));
42 ck_assert_mem_eq(sym_name, "my_symbol", strlen("my_symbol"));
43 ck_assert_uint_eq(offset, 0);
44 }
45
46 #test symbol_name_starting_with_0x
47 {
48 const char *sym_name;
49 size_t sym_name_len;
50 unsigned long long offset;
51 drgn_ck_no_err(drgn_parse_addr2line("0xfoobar", &sym_name,
52 &sym_name_len, &offset));
53 ck_assert_uint_eq(sym_name_len, strlen("0xfoobar"));
54 ck_assert_mem_eq(sym_name, "0xfoobar", strlen("0xfoobar"));
55 ck_assert_uint_eq(offset, 0);
56
57 drgn_ck_no_err(drgn_parse_addr2line("0Xnotaddress", &sym_name,
58 &sym_name_len, &offset));
59 ck_assert_uint_eq(sym_name_len, strlen("0Xnotaddress"));
60 ck_assert_mem_eq(sym_name, "0Xnotaddress", strlen("0Xnotaddress"));
61 ck_assert_uint_eq(offset, 0);
62 }
63
64 #test symbol_name_with_hex_offset
65 {
66 const char *sym_name;
67 size_t sym_name_len;
68 unsigned long long offset;
69 drgn_ck_no_err(drgn_parse_addr2line("my_symbol+0x10", &sym_name,
70 &sym_name_len, &offset));
71 ck_assert_uint_eq(sym_name_len, strlen("my_symbol"));
72 ck_assert_mem_eq(sym_name, "my_symbol", strlen("my_symbol"));
73 ck_assert_uint_eq(offset, 16);
74 }
75
76 #test symbol_name_with_hex_offset_and_whitespace
77 {
78 const char *sym_name;
79 size_t sym_name_len;
80 unsigned long long offset;
81 drgn_ck_no_err(drgn_parse_addr2line(" my_symbol + 0X10 ", &sym_name,
82 &sym_name_len, &offset));
83 ck_assert_uint_eq(sym_name_len, strlen("my_symbol"));
84 ck_assert_mem_eq(sym_name, "my_symbol", strlen("my_symbol"));
85 ck_assert_uint_eq(offset, 16);
86 }
87
88 #test symbol_name_with_hex_offset_overflow
89 {
90 const char *sym_name;
91 size_t sym_name_len;
92 unsigned long long offset;
93 drgn_ck_err(drgn_parse_addr2line("my_symbol+0x10000000000000000", &sym_name,
94 &sym_name_len, &offset),
95 DRGN_ERROR_OVERFLOW, "symbol offset out of range");
96 }
97
98 #test symbol_name_with_decimal_offset
99 {
100 const char *sym_name;
101 size_t sym_name_len;
102 unsigned long long offset;
103 drgn_ck_no_err(drgn_parse_addr2line("my_symbol+10", &sym_name,
104 &sym_name_len, &offset));
105 ck_assert_uint_eq(sym_name_len, strlen("my_symbol"));
106 ck_assert_mem_eq(sym_name, "my_symbol", strlen("my_symbol"));
107 ck_assert_uint_eq(offset, 10);
108 }
109
110 #test symbol_name_with_decimal_offset_leading_zero
111 {
112 const char *sym_name;
113 size_t sym_name_len;
114 unsigned long long offset;
115 drgn_ck_no_err(drgn_parse_addr2line("my_symbol+010", &sym_name,
116 &sym_name_len, &offset));
117 ck_assert_uint_eq(sym_name_len, strlen("my_symbol"));
118 ck_assert_mem_eq(sym_name, "my_symbol", strlen("my_symbol"));
119 ck_assert_uint_eq(offset, 10); // NB: not octal.
120 }
121
122 #test symbol_name_with_decimal_offset_overflow
123 {
124 const char *sym_name;
125 size_t sym_name_len;
126 unsigned long long offset;
127 drgn_ck_err(drgn_parse_addr2line("my_symbol+18446744073709551616", &sym_name,
128 &sym_name_len, &offset),
129 DRGN_ERROR_OVERFLOW, "symbol offset out of range");
130 }
131
132 #test symbol_name_with_decimal_offset_and_whitespace
133 {
134 const char *sym_name;
135 size_t sym_name_len;
136 unsigned long long offset;
137 drgn_ck_no_err(drgn_parse_addr2line(" my_symbol + 10 ", &sym_name,
138 &sym_name_len, &offset));
139 ck_assert_uint_eq(sym_name_len, strlen("my_symbol"));
140 ck_assert_mem_eq(sym_name, "my_symbol", strlen("my_symbol"));
141 ck_assert_uint_eq(offset, 10);
142 }
143
144 #test symbol_name_with_garbage
145 {
146 const char *sym_name;
147 size_t sym_name_len;
148 unsigned long long offset;
149 drgn_ck_err(drgn_parse_addr2line("my_symbol foo", &sym_name,
150 &sym_name_len, &offset),
151 DRGN_ERROR_INVALID_ARGUMENT,
152 "unexpected input after symbol name or address");
153 }
154
155 #test symbol_name_with_only_plus
156 {
157 const char *sym_name;
158 size_t sym_name_len;
159 unsigned long long offset;
160 drgn_ck_err(drgn_parse_addr2line("my_symbol+", &sym_name,
161 &sym_name_len, &offset),
162 DRGN_ERROR_INVALID_ARGUMENT, "expected symbol offset");
163 }
164
165 #test symbol_name_with_plus_and_non_numeric
166 {
167 const char *sym_name;
168 size_t sym_name_len;
169 unsigned long long offset;
170 drgn_ck_err(drgn_parse_addr2line("my_symbol+foo", &sym_name,
171 &sym_name_len, &offset),
172 DRGN_ERROR_INVALID_ARGUMENT, "expected symbol offset");
173 }
174
175 #test symbol_name_with_plus_and_0x
176 {
177 const char *sym_name;
178 size_t sym_name_len;
179 unsigned long long offset;
180 drgn_ck_err(drgn_parse_addr2line("my_symbol+0x", &sym_name,
181 &sym_name_len, &offset),
182 DRGN_ERROR_INVALID_ARGUMENT, "expected symbol offset");
183 drgn_ck_err(drgn_parse_addr2line("my_symbol+0X", &sym_name,
184 &sym_name_len, &offset),
185 DRGN_ERROR_INVALID_ARGUMENT, "expected symbol offset");
186 }
187
188 #test symbol_name_with_garbage_hex_offset
189 {
190 const char *sym_name;
191 size_t sym_name_len;
192 unsigned long long offset;
193 drgn_ck_err(drgn_parse_addr2line("my_symbol+0xz", &sym_name,
194 &sym_name_len, &offset),
195 DRGN_ERROR_INVALID_ARGUMENT, "expected symbol offset");
196 drgn_ck_err(drgn_parse_addr2line("my_symbol+0Xz", &sym_name,
197 &sym_name_len, &offset),
198 DRGN_ERROR_INVALID_ARGUMENT, "expected symbol offset");
199 }
200
201 #test symbol_name_with_garbage_after_offset
202 {
203 const char *sym_name;
204 size_t sym_name_len;
205 unsigned long long offset;
206 drgn_ck_err(drgn_parse_addr2line("my_symbol+1foo", &sym_name,
207 &sym_name_len, &offset),
208 DRGN_ERROR_INVALID_ARGUMENT,
209 "unexpected input after symbol offset");
210 }
211
212 #test symbol_name_with_whitespace_and_garbage_after_offset
213 {
214 const char *sym_name;
215 size_t sym_name_len;
216 unsigned long long offset;
217 drgn_ck_err(drgn_parse_addr2line("my_symbol+1 foo", &sym_name,
218 &sym_name_len, &offset),
219 DRGN_ERROR_INVALID_ARGUMENT,
220 "unexpected input after symbol offset");
221 }
222
223 #test address
224 {
225 const char *sym_name;
226 size_t sym_name_len;
227 unsigned long long offset;
228 drgn_ck_no_err(drgn_parse_addr2line("0x1234", &sym_name,
229 &sym_name_len, &offset));
230 ck_assert_uint_eq(sym_name_len, 0);
231 ck_assert_uint_eq(offset, 0x1234);
232 }
233
234 #test address_with_whitespace
235 {
236 const char *sym_name;
237 size_t sym_name_len;
238 unsigned long long offset;
239 drgn_ck_no_err(drgn_parse_addr2line("\t0x1234 ", &sym_name,
240 &sym_name_len, &offset));
241 ck_assert_uint_eq(sym_name_len, 0);
242 ck_assert_uint_eq(offset, 0x1234);
243 }
244
245 #test address_with_hex_offset
246 {
247 const char *sym_name;
248 size_t sym_name_len;
249 unsigned long long offset;
250 drgn_ck_no_err(drgn_parse_addr2line("0x1234+0x10", &sym_name,
251 &sym_name_len, &offset));
252 ck_assert_uint_eq(sym_name_len, 0);
253 ck_assert_uint_eq(offset, 0x1244);
254 }
255
256 #test address_with_decimal_offset
257 {
258 const char *sym_name;
259 size_t sym_name_len;
260 unsigned long long offset;
261 drgn_ck_no_err(drgn_parse_addr2line("0x1234+10", &sym_name,
262 &sym_name_len, &offset));
263 ck_assert_uint_eq(sym_name_len, 0);
264 ck_assert_uint_eq(offset, 0x123e);
265 }
266
267 #test address_overflow
268 {
269 const char *sym_name;
270 size_t sym_name_len;
271 unsigned long long offset;
272 drgn_ck_err(drgn_parse_addr2line("0x10000000000000000", &sym_name,
273 &sym_name_len, &offset),
274 DRGN_ERROR_OVERFLOW, "address out of range");
275 }
276
277 #test address_with_garbage
278 {
279 const char *sym_name;
280 size_t sym_name_len;
281 unsigned long long offset;
282 drgn_ck_err(drgn_parse_addr2line("0x1234 foo", &sym_name, &sym_name_len,
283 &offset),
284 DRGN_ERROR_INVALID_ARGUMENT,
285 "unexpected input after symbol name or address");
286 }
287
288 #test empty
289 {
290 const char *sym_name;
291 size_t sym_name_len;
292 unsigned long long offset;
293 drgn_ck_err(drgn_parse_addr2line("", &sym_name, &sym_name_len, &offset),
294 DRGN_ERROR_INVALID_ARGUMENT,
295 "expected symbol name or address");
296 }
297
298 #test all_whitespace
299 {
300 const char *sym_name;
301 size_t sym_name_len;
302 unsigned long long offset;
303 drgn_ck_err(drgn_parse_addr2line(" ", &sym_name, &sym_name_len, &offset),
304 DRGN_ERROR_INVALID_ARGUMENT,
305 "expected symbol name or address");
306 }