1 /* btest.c -- Test for libbacktrace library 2 Copyright (C) 2012-2013 Free Software Foundation, Inc. 3 Written by Ian Lance Taylor, Google. 4 5 Redistribution and use in source and binary forms, with or without 6 modification, are permitted provided that the following conditions are 7 met: 8 9 (1) Redistributions of source code must retain the above copyright 10 notice, this list of conditions and the following disclaimer. 11 12 (2) Redistributions in binary form must reproduce the above copyright 13 notice, this list of conditions and the following disclaimer in 14 the documentation and/or other materials provided with the 15 distribution. 16 17 (3) The name of the author may not be used to 18 endorse or promote products derived from this software without 19 specific prior written permission. 20 21 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 22 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 23 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 24 DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, 25 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 26 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 27 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 29 STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 30 IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 31 POSSIBILITY OF SUCH DAMAGE. */ 32 33 /* This program tests the externally visible interfaces of the 34 libbacktrace library. */ 35 36 #include <assert.h> 37 #include <stdio.h> 38 #include <stdlib.h> 39 #include <string.h> 40 41 #include "filenames.h" 42 43 #include "backtrace.h" 44 #include "backtrace-supported.h" 45 46 /* Portable attribute syntax. Actually some of these tests probably 47 won't work if the attributes are not recognized. */ 48 49 #ifndef GCC_VERSION 50 # define GCC_VERSION (__GNUC__ * 1000 + __GNUC_MINOR__) 51 #endif 52 53 #if (GCC_VERSION < 2007) 54 # define __attribute__(x) 55 #endif 56 57 #ifndef ATTRIBUTE_UNUSED 58 # define ATTRIBUTE_UNUSED __attribute__ ((__unused__)) 59 #endif 60 61 /* Used to collect backtrace info. */ 62 63 struct info 64 { 65 char *filename; 66 int lineno; 67 char *function; 68 }; 69 70 /* Passed to backtrace callback function. */ 71 72 struct bdata 73 { 74 struct info *all; 75 size_t index; 76 size_t max; 77 int failed; 78 }; 79 80 /* Passed to backtrace_simple callback function. */ 81 82 struct sdata 83 { 84 uintptr_t *addrs; 85 size_t index; 86 size_t max; 87 int failed; 88 }; 89 90 /* Passed to backtrace_syminfo callback function. */ 91 92 struct symdata 93 { 94 const char *name; 95 uintptr_t val; 96 int failed; 97 }; 98 99 /* The backtrace state. */ 100 101 static void *state; 102 103 /* The number of failures. */ 104 105 static int failures; 106 107 /* Return the base name in a path. */ 108 109 static const char * 110 base (const char *p) 111 { 112 const char *last; 113 const char *s; 114 115 last = NULL; 116 for (s = p; *s != '\0'; ++s) 117 { 118 if (IS_DIR_SEPARATOR (*s)) 119 last = s + 1; 120 } 121 return last != NULL ? last : p; 122 } 123 124 /* Check an entry in a struct info array. */ 125 126 static void 127 check (const char *name, int index, const struct info *all, int want_lineno, 128 const char *want_function, int *failed) 129 { 130 if (*failed) 131 return; 132 if (strcmp (base (all[index].filename), "btest.c") != 0) 133 { 134 fprintf (stderr, "%s: [%d]: got %s expected test.c\n", name, index, 135 all[index].filename); 136 *failed = 1; 137 } 138 if (all[index].lineno != want_lineno) 139 { 140 fprintf (stderr, "%s: [%d]: got %d expected %d\n", name, index, 141 all[index].lineno, want_lineno); 142 *failed = 1; 143 } 144 if (strcmp (all[index].function, want_function) != 0) 145 { 146 fprintf (stderr, "%s: [%d]: got %s expected %s\n", name, index, 147 all[index].function, want_function); 148 *failed = 1; 149 } 150 } 151 152 /* The backtrace callback function. */ 153 154 static int 155 callback_one (void *vdata, uintptr_t pc ATTRIBUTE_UNUSED, 156 const char *filename, int lineno, const char *function) 157 { 158 struct bdata *data = (struct bdata *) vdata; 159 struct info *p; 160 161 if (data->index >= data->max) 162 { 163 fprintf (stderr, "callback_one: callback called too many times\n"); 164 data->failed = 1; 165 return 1; 166 } 167 168 p = &data->all[data->index]; 169 if (filename == NULL) 170 p->filename = NULL; 171 else 172 { 173 p->filename = strdup (filename); 174 assert (p->filename != NULL); 175 } 176 p->lineno = lineno; 177 if (function == NULL) 178 p->function = NULL; 179 else 180 { 181 p->function = strdup (function); 182 assert (p->function != NULL); 183 } 184 ++data->index; 185 186 return 0; 187 } 188 189 /* An error callback passed to backtrace. */ 190 191 static void 192 error_callback_one (void *vdata, const char *msg, int errnum) 193 { 194 struct bdata *data = (struct bdata *) vdata; 195 196 fprintf (stderr, "%s", msg); 197 if (errnum > 0) 198 fprintf (stderr, ": %s", strerror (errnum)); 199 fprintf (stderr, "\n"); 200 data->failed = 1; 201 } 202 203 /* The backtrace_simple callback function. */ 204 205 static int 206 callback_two (void *vdata, uintptr_t pc) 207 { 208 struct sdata *data = (struct sdata *) vdata; 209 210 if (data->index >= data->max) 211 { 212 fprintf (stderr, "callback_two: callback called too many times\n"); 213 data->failed = 1; 214 return 1; 215 } 216 217 data->addrs[data->index] = pc; 218 ++data->index; 219 220 return 0; 221 } 222 223 /* An error callback passed to backtrace_simple. */ 224 225 static void 226 error_callback_two (void *vdata, const char *msg, int errnum) 227 { 228 struct sdata *data = (struct sdata *) vdata; 229 230 fprintf (stderr, "%s", msg); 231 if (errnum > 0) 232 fprintf (stderr, ": %s", strerror (errnum)); 233 fprintf (stderr, "\n"); 234 data->failed = 1; 235 } 236 237 /* The backtrace_syminfo callback function. */ 238 239 static void 240 callback_three (void *vdata, uintptr_t pc ATTRIBUTE_UNUSED, 241 const char *symname, uintptr_t symval) 242 { 243 struct symdata *data = (struct symdata *) vdata; 244 245 if (symname == NULL) 246 data->name = NULL; 247 else 248 { 249 data->name = strdup (symname); 250 assert (data->name != NULL); 251 } 252 data->val = symval; 253 } 254 255 /* The backtrace_syminfo error callback function. */ 256 257 static void 258 error_callback_three (void *vdata, const char *msg, int errnum) 259 { 260 struct symdata *data = (struct symdata *) vdata; 261 262 fprintf (stderr, "%s", msg); 263 if (errnum > 0) 264 fprintf (stderr, ": %s", strerror (errnum)); 265 fprintf (stderr, "\n"); 266 data->failed = 1; 267 } 268 269 /* Test the backtrace function with non-inlined functions. */ 270 271 static int test1 (void) __attribute__ ((noinline, unused)); 272 static int f2 (int) __attribute__ ((noinline)); 273 static int f3 (int, int) __attribute__ ((noinline)); 274 275 static int 276 test1 (void) 277 { 278 /* Returning a value here and elsewhere avoids a tailcall which 279 would mess up the backtrace. */ 280 return f2 (__LINE__) + 1; 281 } 282 283 static int 284 f2 (int f1line) 285 { 286 return f3 (f1line, __LINE__) + 2; 287 } 288 289 static int 290 f3 (int f1line, int f2line) 291 { 292 struct info all[20]; 293 struct bdata data; 294 int f3line; 295 int i; 296 297 data.all = &all[0]; 298 data.index = 0; 299 data.max = 20; 300 data.failed = 0; 301 302 f3line = __LINE__ + 1; 303 i = backtrace_full (state, 0, callback_one, error_callback_one, &data); 304 305 if (i != 0) 306 { 307 fprintf (stderr, "test1: unexpected return value %d\n", i); 308 data.failed = 1; 309 } 310 311 check ("test1", 0, all, f3line, "f3", &data.failed); 312 check ("test1", 1, all, f2line, "f2", &data.failed); 313 check ("test1", 2, all, f1line, "test1", &data.failed); 314 315 printf ("%s: backtrace_full noinline\n", data.failed ? "FAIL" : "PASS"); 316 317 if (data.failed) 318 ++failures; 319 320 return failures; 321 } 322 323 /* Test the backtrace function with inlined functions. */ 324 325 static inline int test2 (void) __attribute__ ((always_inline, unused)); 326 static inline int f12 (int) __attribute__ ((always_inline)); 327 static inline int f13 (int, int) __attribute__ ((always_inline)); 328 329 static inline int 330 test2 (void) 331 { 332 return f12 (__LINE__) + 1; 333 } 334 335 static inline int 336 f12 (int f1line) 337 { 338 return f13 (f1line, __LINE__) + 2; 339 } 340 341 static inline int 342 f13 (int f1line, int f2line) 343 { 344 struct info all[20]; 345 struct bdata data; 346 int f3line; 347 int i; 348 349 data.all = &all[0]; 350 data.index = 0; 351 data.max = 20; 352 data.failed = 0; 353 354 f3line = __LINE__ + 1; 355 i = backtrace_full (state, 0, callback_one, error_callback_one, &data); 356 357 if (i != 0) 358 { 359 fprintf (stderr, "test2: unexpected return value %d\n", i); 360 data.failed = 1; 361 } 362 363 check ("test2", 0, all, f3line, "f13", &data.failed); 364 check ("test2", 1, all, f2line, "f12", &data.failed); 365 check ("test2", 2, all, f1line, "test2", &data.failed); 366 367 printf ("%s: backtrace_full inline\n", data.failed ? "FAIL" : "PASS"); 368 369 if (data.failed) 370 ++failures; 371 372 return failures; 373 } 374 375 /* Test the backtrace_simple function with non-inlined functions. */ 376 377 static int test3 (void) __attribute__ ((noinline, unused)); 378 static int f22 (int) __attribute__ ((noinline)); 379 static int f23 (int, int) __attribute__ ((noinline)); 380 381 static int 382 test3 (void) 383 { 384 return f22 (__LINE__) + 1; 385 } 386 387 static int 388 f22 (int f1line) 389 { 390 return f23 (f1line, __LINE__) + 2; 391 } 392 393 static int 394 f23 (int f1line, int f2line) 395 { 396 uintptr_t addrs[20]; 397 struct sdata data; 398 int f3line; 399 int i; 400 401 data.addrs = &addrs[0]; 402 data.index = 0; 403 data.max = 20; 404 data.failed = 0; 405 406 f3line = __LINE__ + 1; 407 i = backtrace_simple (state, 0, callback_two, error_callback_two, &data); 408 409 if (i != 0) 410 { 411 fprintf (stderr, "test3: unexpected return value %d\n", i); 412 data.failed = 1; 413 } 414 415 if (!data.failed) 416 { 417 struct info all[20]; 418 struct bdata bdata; 419 int j; 420 421 bdata.all = &all[0]; 422 bdata.index = 0; 423 bdata.max = 20; 424 bdata.failed = 0; 425 426 for (j = 0; j < 3; ++j) 427 { 428 i = backtrace_pcinfo (state, addrs[j], callback_one, 429 error_callback_one, &bdata); 430 if (i != 0) 431 { 432 fprintf (stderr, 433 ("test3: unexpected return value " 434 "from backtrace_pcinfo %d\n"), 435 i); 436 bdata.failed = 1; 437 } 438 if (!bdata.failed && bdata.index != (size_t) (j + 1)) 439 { 440 fprintf (stderr, 441 ("wrong number of calls from backtrace_pcinfo " 442 "got %u expected %d\n"), 443 (unsigned int) bdata.index, j + 1); 444 bdata.failed = 1; 445 } 446 } 447 448 check ("test3", 0, all, f3line, "f23", &bdata.failed); 449 check ("test3", 1, all, f2line, "f22", &bdata.failed); 450 check ("test3", 2, all, f1line, "test3", &bdata.failed); 451 452 if (bdata.failed) 453 data.failed = 1; 454 455 for (j = 0; j < 3; ++j) 456 { 457 struct symdata symdata; 458 459 symdata.name = NULL; 460 symdata.val = 0; 461 symdata.failed = 0; 462 463 i = backtrace_syminfo (state, addrs[j], callback_three, 464 error_callback_three, &symdata); 465 if (i == 0) 466 { 467 fprintf (stderr, 468 ("test3: [%d]: unexpected return value " 469 "from backtrace_syminfo %d\n"), 470 j, i); 471 symdata.failed = 1; 472 } 473 474 if (!symdata.failed) 475 { 476 const char *expected; 477 478 switch (j) 479 { 480 case 0: 481 expected = "f23"; 482 break; 483 case 1: 484 expected = "f22"; 485 break; 486 case 2: 487 expected = "test3"; 488 break; 489 default: 490 assert (0); 491 } 492 493 if (symdata.name == NULL) 494 { 495 fprintf (stderr, "test3: [%d]: NULL syminfo name\n", j); 496 symdata.failed = 1; 497 } 498 /* Use strncmp, not strcmp, because GCC might create a 499 clone. */ 500 else if (strncmp (symdata.name, expected, strlen (expected)) 501 != 0) 502 { 503 fprintf (stderr, 504 ("test3: [%d]: unexpected syminfo name " 505 "got %s expected %s\n"), 506 j, symdata.name, expected); 507 symdata.failed = 1; 508 } 509 } 510 511 if (symdata.failed) 512 data.failed = 1; 513 } 514 } 515 516 printf ("%s: backtrace_simple noinline\n", data.failed ? "FAIL" : "PASS"); 517 518 if (data.failed) 519 ++failures; 520 521 return failures; 522 } 523 524 /* Test the backtrace_simple function with inlined functions. */ 525 526 static inline int test4 (void) __attribute__ ((always_inline, unused)); 527 static inline int f32 (int) __attribute__ ((always_inline)); 528 static inline int f33 (int, int) __attribute__ ((always_inline)); 529 530 static inline int 531 test4 (void) 532 { 533 return f32 (__LINE__) + 1; 534 } 535 536 static inline int 537 f32 (int f1line) 538 { 539 return f33 (f1line, __LINE__) + 2; 540 } 541 542 static inline int 543 f33 (int f1line, int f2line) 544 { 545 uintptr_t addrs[20]; 546 struct sdata data; 547 int f3line; 548 int i; 549 550 data.addrs = &addrs[0]; 551 data.index = 0; 552 data.max = 20; 553 data.failed = 0; 554 555 f3line = __LINE__ + 1; 556 i = backtrace_simple (state, 0, callback_two, error_callback_two, &data); 557 558 if (i != 0) 559 { 560 fprintf (stderr, "test3: unexpected return value %d\n", i); 561 data.failed = 1; 562 } 563 564 if (!data.failed) 565 { 566 struct info all[20]; 567 struct bdata bdata; 568 569 bdata.all = &all[0]; 570 bdata.index = 0; 571 bdata.max = 20; 572 bdata.failed = 0; 573 574 i = backtrace_pcinfo (state, addrs[0], callback_one, error_callback_one, 575 &bdata); 576 if (i != 0) 577 { 578 fprintf (stderr, 579 ("test4: unexpected return value " 580 "from backtrace_pcinfo %d\n"), 581 i); 582 bdata.failed = 1; 583 } 584 585 check ("test4", 0, all, f3line, "f33", &bdata.failed); 586 check ("test4", 1, all, f2line, "f32", &bdata.failed); 587 check ("test4", 2, all, f1line, "test4", &bdata.failed); 588 589 if (bdata.failed) 590 data.failed = 1; 591 } 592 593 printf ("%s: backtrace_simple inline\n", data.failed ? "FAIL" : "PASS"); 594 595 if (data.failed) 596 ++failures; 597 598 return failures; 599 } 600 601 static void 602 error_callback_create (void *data ATTRIBUTE_UNUSED, const char *msg, 603 int errnum) 604 { 605 fprintf (stderr, "%s", msg); 606 if (errnum > 0) 607 fprintf (stderr, ": %s", strerror (errnum)); 608 fprintf (stderr, "\n"); 609 exit (EXIT_FAILURE); 610 } 611 612 /* Run all the tests. */ 613 614 int 615 main (int argc ATTRIBUTE_UNUSED, char **argv) 616 { 617 state = backtrace_create_state (argv[0], BACKTRACE_SUPPORTS_THREADS, 618 error_callback_create, NULL); 619 620 #if BACKTRACE_SUPPORTED 621 test1 (); 622 test2 (); 623 test3 (); 624 test4 (); 625 #endif 626 627 exit (failures ? EXIT_FAILURE : EXIT_SUCCESS); 628 } 629