tests: Build new x86_64-linux-gnu debug-info artifacts
[babeltrace.git] / tests / plugins / test_bin_info.c
1 /*
2 * test_bin_info.c
3 *
4 * Babeltrace SO info tests
5 *
6 * Copyright (c) 2015 EfficiOS Inc. and Linux Foundation
7 * Copyright (c) 2015 Antoine Busque <abusque@efficios.com>
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; under version 2 of the License.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License along
19 * with this program; if not, write to the Free Software Foundation, Inc.,
20 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21 */
22
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26
27 #include <babeltrace/assert-internal.h>
28 #include <lttng-utils/debug-info/bin-info.h>
29
30 #include "tap/tap.h"
31
32 #define NR_TESTS 36
33 #define SO_NAME "libhello_so"
34
35 #define DWARF_DIR_NAME "dwarf_full"
36 #define ELF_DIR_NAME "elf_only"
37 #define BUILDID_DIR_NAME "build_id"
38 #define DEBUGLINK_DIR_NAME "debug_link"
39
40 #define SO_LOW_ADDR 0x400000
41 #define SO_MEMSZ 0x400000
42 #define FUNC_FOO_ADDR 0x402367
43 #define FUNC_FOO_LINE_NO 36
44 #define FUNC_FOO_FILENAME "./libhello.c"
45 #define FUNC_FOO_TP_ADDR 0x402300
46 #define FUNC_FOO_TP_LINE_NO 35
47 #define FUNC_FOO_TP_FILENAME "./libhello.c"
48 #define FUNC_FOO_ADDR_ELF 0x402367
49 #define FUNC_FOO_ADDR_DBG_LINK 0x402367
50 #define FUNC_FOO_NAME "foo+0xf0"
51 #define FUNC_FOO_NAME_ELF "foo+0xf0"
52 #define BUILD_ID_LEN 20
53
54 char *opt_debug_info_dir;
55 char *opt_debug_info_target_prefix;
56
57 static
58 void test_bin_info_build_id(const char *bin_info_dir)
59 {
60 int ret;
61 char *data_dir, *bin_path;
62 char *func_name = NULL;
63 struct bin_info *bin = NULL;
64 struct source_location *src_loc = NULL;
65 struct bt_fd_cache fdc;
66 uint8_t build_id[BUILD_ID_LEN] = {
67 0xcd, 0xd9, 0x8c, 0xdd, 0x87, 0xf7, 0xfe, 0x64, 0xc1, 0x3b,
68 0x6d, 0xaa, 0xd5, 0x53, 0x98, 0x7e, 0xaf, 0xd4, 0x0c, 0xbb
69 };
70
71 diag("bin-info tests - separate DWARF via build ID");
72
73 data_dir = g_build_filename(bin_info_dir, BUILDID_DIR_NAME, NULL);
74 bin_path = g_build_filename(bin_info_dir, BUILDID_DIR_NAME, SO_NAME, NULL);
75
76 if (data_dir == NULL || bin_path == NULL) {
77 exit(EXIT_FAILURE);
78 }
79
80 ret = bt_fd_cache_init(&fdc);
81 BT_ASSERT(ret == 0);
82 bin = bin_info_create(&fdc, bin_path, SO_LOW_ADDR, SO_MEMSZ, true, data_dir, NULL);
83 ok(bin != NULL, "bin_info_create successful");
84
85 /* Test setting build_id */
86 ret = bin_info_set_build_id(bin, build_id, BUILD_ID_LEN);
87 ok(ret == 0, "bin_info_set_build_id successful");
88
89 /* Test function name lookup (with DWARF) */
90 ret = bin_info_lookup_function_name(bin, FUNC_FOO_ADDR, &func_name);
91 ok(ret == 0, "bin_info_lookup_function_name successful");
92 if (func_name) {
93 ok(strcmp(func_name, FUNC_FOO_NAME) == 0,
94 "bin_info_lookup_function_name - correct func_name value");
95 free(func_name);
96 } else {
97 skip(1, "bin_info_lookup_function_name - func_name is NULL");
98 }
99
100 /* Test source location lookup */
101 ret = bin_info_lookup_source_location(bin, FUNC_FOO_ADDR, &src_loc);
102 ok(ret == 0, "bin_info_lookup_source_location successful");
103 if (src_loc) {
104 ok(src_loc->line_no == FUNC_FOO_LINE_NO,
105 "bin_info_lookup_source_location - correct line_no");
106 ok(strcmp(src_loc->filename, FUNC_FOO_FILENAME) == 0,
107 "bin_info_lookup_source_location - correct filename");
108 source_location_destroy(src_loc);
109 } else {
110 skip(2, "bin_info_lookup_source_location - src_loc is NULL");
111 }
112
113 bin_info_destroy(bin);
114 bt_fd_cache_fini(&fdc);
115 g_free(data_dir);
116 g_free(bin_path);
117 }
118
119 static
120 void test_bin_info_debug_link(const char *bin_info_dir)
121 {
122 int ret;
123 char *data_dir, *bin_path;
124 char *func_name = NULL;
125 struct bin_info *bin = NULL;
126 struct source_location *src_loc = NULL;
127 char *dbg_filename = "libhello_so.debug";
128 uint32_t crc = 0x289a8fdc;
129 struct bt_fd_cache fdc;
130
131 diag("bin-info tests - separate DWARF via debug link");
132
133 data_dir = g_build_filename(bin_info_dir, DEBUGLINK_DIR_NAME, NULL);
134 bin_path = g_build_filename(bin_info_dir, DEBUGLINK_DIR_NAME, SO_NAME, NULL);
135
136 if (data_dir == NULL || bin_path == NULL) {
137 exit(EXIT_FAILURE);
138 }
139
140 ret = bt_fd_cache_init(&fdc);
141 BT_ASSERT(ret == 0);
142 bin = bin_info_create(&fdc, bin_path, SO_LOW_ADDR, SO_MEMSZ, true, data_dir,
143 NULL);
144 ok(bin != NULL, "bin_info_create successful");
145
146 /* Test setting debug link */
147 ret = bin_info_set_debug_link(bin, dbg_filename, crc);
148 ok(ret == 0, "bin_info_set_debug_link successful");
149
150 /* Test function name lookup (with DWARF) */
151 ret = bin_info_lookup_function_name(bin, FUNC_FOO_ADDR_DBG_LINK,
152 &func_name);
153 ok(ret == 0, "bin_info_lookup_function_name successful");
154 if (func_name) {
155 ok(strcmp(func_name, FUNC_FOO_NAME) == 0,
156 "bin_info_lookup_function_name - correct func_name value");
157 free(func_name);
158 } else {
159 skip(1, "bin_info_lookup_function_name - func_name is NULL");
160 }
161
162 /* Test source location lookup */
163 ret = bin_info_lookup_source_location(bin, FUNC_FOO_ADDR_DBG_LINK,
164 &src_loc);
165 ok(ret == 0, "bin_info_lookup_source_location successful");
166 if (src_loc) {
167 ok(src_loc->line_no == FUNC_FOO_LINE_NO,
168 "bin_info_lookup_source_location - correct line_no");
169 ok(strcmp(src_loc->filename, FUNC_FOO_FILENAME) == 0,
170 "bin_info_lookup_source_location - correct filename");
171 source_location_destroy(src_loc);
172 } else {
173 skip(2, "bin_info_lookup_source_location - src_loc is NULL");
174 }
175
176 bin_info_destroy(bin);
177 bt_fd_cache_fini(&fdc);
178 g_free(data_dir);
179 g_free(bin_path);
180 }
181
182 static
183 void test_bin_info_elf(const char *bin_info_dir)
184 {
185 int ret;
186 char *data_dir, *bin_path;
187 char *func_name = NULL;
188 struct bin_info *bin = NULL;
189 struct source_location *src_loc = NULL;
190 struct bt_fd_cache fdc;
191
192 diag("bin-info tests - ELF only");
193
194 data_dir = g_build_filename(bin_info_dir, ELF_DIR_NAME, NULL);
195 bin_path = g_build_filename(bin_info_dir, ELF_DIR_NAME, SO_NAME, NULL);
196
197 if (data_dir == NULL || bin_path == NULL) {
198 exit(EXIT_FAILURE);
199 }
200
201 ret = bt_fd_cache_init(&fdc);
202 BT_ASSERT(ret == 0);
203 bin = bin_info_create(&fdc, bin_path, SO_LOW_ADDR, SO_MEMSZ, true, data_dir, NULL);
204 ok(bin != NULL, "bin_info_create successful");
205
206 /* Test function name lookup (with ELF) */
207 ret = bin_info_lookup_function_name(bin, FUNC_FOO_ADDR_ELF, &func_name);
208 ok(ret == 0, "bin_info_lookup_function_name successful");
209 if (func_name) {
210 ok(strcmp(func_name, FUNC_FOO_NAME_ELF) == 0,
211 "bin_info_lookup_function_name - correct func_name value");
212 free(func_name);
213 func_name = NULL;
214 } else {
215 skip(1, "bin_info_lookup_function_name - func_name is NULL");
216 }
217
218 /* Test function name lookup - erroneous address */
219 ret = bin_info_lookup_function_name(bin, 0, &func_name);
220 ok(ret == -1 && func_name == NULL,
221 "bin_info_lookup_function_name - fail on addr not found");
222
223 /* Test source location location - should fail on ELF only file */
224 ret = bin_info_lookup_source_location(bin, FUNC_FOO_ADDR_ELF, &src_loc);
225 ok(ret == -1, "bin_info_lookup_source_location - fail on ELF only file");
226
227 source_location_destroy(src_loc);
228 bin_info_destroy(bin);
229 bt_fd_cache_fini(&fdc);
230 g_free(data_dir);
231 g_free(bin_path);
232 }
233
234 static
235 void test_bin_info(const char *bin_info_dir)
236 {
237 int ret;
238 char *data_dir, *bin_path;
239 char *func_name = NULL;
240 struct bin_info *bin = NULL;
241 struct source_location *src_loc = NULL;
242 struct bt_fd_cache fdc;
243
244 diag("bin-info tests - DWARF bundled with SO file");
245
246
247 data_dir = g_build_filename(bin_info_dir, DWARF_DIR_NAME, NULL);
248 bin_path = g_build_filename(bin_info_dir, DWARF_DIR_NAME, SO_NAME, NULL);
249
250 if (data_dir == NULL || bin_path == NULL) {
251 exit(EXIT_FAILURE);
252 }
253
254 ret = bt_fd_cache_init(&fdc);
255 BT_ASSERT(ret == 0);
256 bin = bin_info_create(&fdc, bin_path, SO_LOW_ADDR, SO_MEMSZ, true, data_dir, NULL);
257 ok(bin != NULL, "bin_info_create successful");
258
259 /* Test bin_info_has_address */
260 ret = bin_info_has_address(bin, 0);
261 ok(ret == 0, "bin_info_has_address - address under so's range");
262 ret = bin_info_has_address(bin, SO_LOW_ADDR);
263 ok(ret == 1, "bin_info_has_address - lower bound of so's range");
264 ret = bin_info_has_address(bin, FUNC_FOO_ADDR);
265 ok(ret == 1, "bin_info_has_address - address in so's range");
266 ret = bin_info_has_address(bin, SO_LOW_ADDR + SO_MEMSZ - 1);
267 ok(ret == 1, "bin_info_has_address - upper bound of so's range");
268 ret = bin_info_has_address(bin, SO_LOW_ADDR + SO_MEMSZ);
269 ok(ret == 0, "bin_info_has_address - address above so's range");
270
271 /* Test function name lookup (with DWARF) */
272 ret = bin_info_lookup_function_name(bin, FUNC_FOO_ADDR, &func_name);
273 ok(ret == 0, "bin_info_lookup_function_name successful");
274 if (func_name) {
275 ok(strcmp(func_name, FUNC_FOO_NAME) == 0,
276 "bin_info_lookup_function_name - correct func_name value");
277 free(func_name);
278 func_name = NULL;
279 } else {
280 skip(1, "bin_info_lookup_function_name - func_name is NULL");
281 }
282
283 /* Test function name lookup - erroneous address */
284 ret = bin_info_lookup_function_name(bin, 0, &func_name);
285 ok(ret == -1 && func_name == NULL,
286 "bin_info_lookup_function_name - fail on addr not found");
287
288 /* Test source location lookup */
289 ret = bin_info_lookup_source_location(bin, FUNC_FOO_ADDR, &src_loc);
290 ok(ret == 0, "bin_info_lookup_source_location successful");
291 if (src_loc) {
292 ok(src_loc->line_no == FUNC_FOO_LINE_NO,
293 "bin_info_lookup_source_location - correct line_no");
294 ok(strcmp(src_loc->filename, FUNC_FOO_FILENAME) == 0,
295 "bin_info_lookup_source_location - correct filename");
296 source_location_destroy(src_loc);
297 src_loc = NULL;
298 } else {
299 skip(2, "bin_info_lookup_source_location - src_loc is NULL");
300 }
301
302 /* Test source location lookup - inlined function */
303 ret = bin_info_lookup_source_location(bin, FUNC_FOO_TP_ADDR, &src_loc);
304 ok(ret == 0,
305 "bin_info_lookup_source_location (inlined func) successful");
306 if (src_loc) {
307 ok(src_loc->line_no == FUNC_FOO_TP_LINE_NO,
308 "bin_info_lookup_source_location (inlined func) - correct line_no");
309 ok(strcmp(src_loc->filename, FUNC_FOO_TP_FILENAME) == 0,
310 "bin_info_lookup_source_location (inlined func) - correct filename");
311 source_location_destroy(src_loc);
312 src_loc = NULL;
313 } else {
314 skip(2, "bin_info_lookup_source_location (inlined func) - src_loc is NULL");
315 }
316
317 /* Test source location lookup - erroneous address */
318 ret = bin_info_lookup_source_location(bin, 0, &src_loc);
319 ok(ret == -1 && src_loc == NULL,
320 "bin_info_lookup_source_location - fail on addr not found");
321
322 bin_info_destroy(bin);
323 bt_fd_cache_fini(&fdc);
324 g_free(data_dir);
325 g_free(bin_path);
326 }
327
328 int main(int argc, char **argv)
329 {
330 int ret;
331
332 plan_tests(NR_TESTS);
333
334 if (argc != 2) {
335 return EXIT_FAILURE;
336 } else {
337 opt_debug_info_dir = argv[1];
338 }
339
340 ret = bin_info_init();
341 ok(ret == 0, "bin_info_init successful");
342
343 test_bin_info(opt_debug_info_dir);
344 test_bin_info_elf(opt_debug_info_dir);
345 test_bin_info_build_id(opt_debug_info_dir);
346 test_bin_info_debug_link(opt_debug_info_dir);
347
348 return EXIT_SUCCESS;
349 }
This page took 0.043057 seconds and 4 git commands to generate.