1 /* btest.c -- Test for libbacktrace library 2 Copyright (C) 2012-2015 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, size; 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 (all[index].filename == NULL || all[index].function == NULL) 133 { 134 fprintf (stderr, "%s: [%d]: missing file name or function name\n", 135 name, index); 136 *failed = 1; 137 return; 138 } 139 if (strcmp (base (all[index].filename), "btest.c") != 0) 140 { 141 fprintf (stderr, "%s: [%d]: got %s expected test.c\n", name, index, 142 all[index].filename); 143 *failed = 1; 144 } 145 if (all[index].lineno != want_lineno) 146 { 147 fprintf (stderr, "%s: [%d]: got %d expected %d\n", name, index, 148 all[index].lineno, want_lineno); 149 *failed = 1; 150 } 151 if (strcmp (all[index].function, want_function) != 0) 152 { 153 fprintf (stderr, "%s: [%d]: got %s expected %s\n", name, index, 154 all[index].function, want_function); 155 *failed = 1; 156 } 157 } 158 159 /* The backtrace callback function. */ 160 161 static int 162 callback_one (void *vdata, uintptr_t pc ATTRIBUTE_UNUSED, 163 const char *filename, int lineno, const char *function) 164 { 165 struct bdata *data = (struct bdata *) vdata; 166 struct info *p; 167 168 if (data->index >= data->max) 169 { 170 fprintf (stderr, "callback_one: callback called too many times\n"); 171 data->failed = 1; 172 return 1; 173 } 174 175 p = &data->all[data->index]; 176 if (filename == NULL) 177 p->filename = NULL; 178 else 179 { 180 p->filename = strdup (filename); 181 assert (p->filename != NULL); 182 } 183 p->lineno = lineno; 184 if (function == NULL) 185 p->function = NULL; 186 else 187 { 188 p->function = strdup (function); 189 assert (p->function != NULL); 190 } 191 ++data->index; 192 193 return 0; 194 } 195 196 /* An error callback passed to backtrace. */ 197 198 static void 199 error_callback_one (void *vdata, const char *msg, int errnum) 200 { 201 struct bdata *data = (struct bdata *) vdata; 202 203 fprintf (stderr, "%s", msg); 204 if (errnum > 0) 205 fprintf (stderr, ": %s", strerror (errnum)); 206 fprintf (stderr, "\n"); 207 data->failed = 1; 208 } 209 210 /* The backtrace_simple callback function. */ 211 212 static int 213 callback_two (void *vdata, uintptr_t pc) 214 { 215 struct sdata *data = (struct sdata *) vdata; 216 217 if (data->index >= data->max) 218 { 219 fprintf (stderr, "callback_two: callback called too many times\n"); 220 data->failed = 1; 221 return 1; 222 } 223 224 data->addrs[data->index] = pc; 225 ++data->index; 226 227 return 0; 228 } 229 230 /* An error callback passed to backtrace_simple. */ 231 232 static void 233 error_callback_two (void *vdata, const char *msg, int errnum) 234 { 235 struct sdata *data = (struct sdata *) vdata; 236 237 fprintf (stderr, "%s", msg); 238 if (errnum > 0) 239 fprintf (stderr, ": %s", strerror (errnum)); 240 fprintf (stderr, "\n"); 241 data->failed = 1; 242 } 243 244 /* The backtrace_syminfo callback function. */ 245 246 static void 247 callback_three (void *vdata, uintptr_t pc ATTRIBUTE_UNUSED, 248 const char *symname, uintptr_t symval, 249 uintptr_t symsize) 250 { 251 struct symdata *data = (struct symdata *) vdata; 252 253 if (symname == NULL) 254 data->name = NULL; 255 else 256 { 257 data->name = strdup (symname); 258 assert (data->name != NULL); 259 } 260 data->val = symval; 261 data->size = symsize; 262 } 263 264 /* The backtrace_syminfo error callback function. */ 265 266 static void 267 error_callback_three (void *vdata, const char *msg, int errnum) 268 { 269 struct symdata *data = (struct symdata *) vdata; 270 271 fprintf (stderr, "%s", msg); 272 if (errnum > 0) 273 fprintf (stderr, ": %s", strerror (errnum)); 274 fprintf (stderr, "\n"); 275 data->failed = 1; 276 } 277 278 /* Test the backtrace function with non-inlined functions. */ 279 280 static int test1 (void) __attribute__ ((noinline, unused)); 281 static int f2 (int) __attribute__ ((noinline)); 282 static int f3 (int, int) __attribute__ ((noinline)); 283 284 static int 285 test1 (void) 286 { 287 /* Returning a value here and elsewhere avoids a tailcall which 288 would mess up the backtrace. */ 289 return f2 (__LINE__) + 1; 290 } 291 292 static int 293 f2 (int f1line) 294 { 295 return f3 (f1line, __LINE__) + 2; 296 } 297 298 static int 299 f3 (int f1line, int f2line) 300 { 301 struct info all[20]; 302 struct bdata data; 303 int f3line; 304 int i; 305 306 data.all = &all[0]; 307 data.index = 0; 308 data.max = 20; 309 data.failed = 0; 310 311 f3line = __LINE__ + 1; 312 i = backtrace_full (state, 0, callback_one, error_callback_one, &data); 313 314 if (i != 0) 315 { 316 fprintf (stderr, "test1: unexpected return value %d\n", i); 317 data.failed = 1; 318 } 319 320 if (data.index < 3) 321 { 322 fprintf (stderr, 323 "test1: not enough frames; got %zu, expected at least 3\n", 324 data.index); 325 data.failed = 1; 326 } 327 328 check ("test1", 0, all, f3line, "f3", &data.failed); 329 check ("test1", 1, all, f2line, "f2", &data.failed); 330 check ("test1", 2, all, f1line, "test1", &data.failed); 331 332 printf ("%s: backtrace_full noinline\n", data.failed ? "FAIL" : "PASS"); 333 334 if (data.failed) 335 ++failures; 336 337 return failures; 338 } 339 340 /* Test the backtrace function with inlined functions. */ 341 342 static inline int test2 (void) __attribute__ ((always_inline, unused)); 343 static inline int f12 (int) __attribute__ ((always_inline)); 344 static inline int f13 (int, int) __attribute__ ((always_inline)); 345 346 static inline int 347 test2 (void) 348 { 349 return f12 (__LINE__) + 1; 350 } 351 352 static inline int 353 f12 (int f1line) 354 { 355 return f13 (f1line, __LINE__) + 2; 356 } 357 358 static inline int 359 f13 (int f1line, int f2line) 360 { 361 struct info all[20]; 362 struct bdata data; 363 int f3line; 364 int i; 365 366 data.all = &all[0]; 367 data.index = 0; 368 data.max = 20; 369 data.failed = 0; 370 371 f3line = __LINE__ + 1; 372 i = backtrace_full (state, 0, callback_one, error_callback_one, &data); 373 374 if (i != 0) 375 { 376 fprintf (stderr, "test2: unexpected return value %d\n", i); 377 data.failed = 1; 378 } 379 380 check ("test2", 0, all, f3line, "f13", &data.failed); 381 check ("test2", 1, all, f2line, "f12", &data.failed); 382 check ("test2", 2, all, f1line, "test2", &data.failed); 383 384 printf ("%s: backtrace_full inline\n", data.failed ? "FAIL" : "PASS"); 385 386 if (data.failed) 387 ++failures; 388 389 return failures; 390 } 391 392 /* Test the backtrace_simple function with non-inlined functions. */ 393 394 static int test3 (void) __attribute__ ((noinline, unused)); 395 static int f22 (int) __attribute__ ((noinline)); 396 static int f23 (int, int) __attribute__ ((noinline)); 397 398 static int 399 test3 (void) 400 { 401 return f22 (__LINE__) + 1; 402 } 403 404 static int 405 f22 (int f1line) 406 { 407 return f23 (f1line, __LINE__) + 2; 408 } 409 410 static int 411 f23 (int f1line, int f2line) 412 { 413 uintptr_t addrs[20]; 414 struct sdata data; 415 int f3line; 416 int i; 417 418 data.addrs = &addrs[0]; 419 data.index = 0; 420 data.max = 20; 421 data.failed = 0; 422 423 f3line = __LINE__ + 1; 424 i = backtrace_simple (state, 0, callback_two, error_callback_two, &data); 425 426 if (i != 0) 427 { 428 fprintf (stderr, "test3: unexpected return value %d\n", i); 429 data.failed = 1; 430 } 431 432 if (!data.failed) 433 { 434 struct info all[20]; 435 struct bdata bdata; 436 int j; 437 438 bdata.all = &all[0]; 439 bdata.index = 0; 440 bdata.max = 20; 441 bdata.failed = 0; 442 443 for (j = 0; j < 3; ++j) 444 { 445 i = backtrace_pcinfo (state, addrs[j], callback_one, 446 error_callback_one, &bdata); 447 if (i != 0) 448 { 449 fprintf (stderr, 450 ("test3: unexpected return value " 451 "from backtrace_pcinfo %d\n"), 452 i); 453 bdata.failed = 1; 454 } 455 if (!bdata.failed && bdata.index != (size_t) (j + 1)) 456 { 457 fprintf (stderr, 458 ("wrong number of calls from backtrace_pcinfo " 459 "got %u expected %d\n"), 460 (unsigned int) bdata.index, j + 1); 461 bdata.failed = 1; 462 } 463 } 464 465 check ("test3", 0, all, f3line, "f23", &bdata.failed); 466 check ("test3", 1, all, f2line, "f22", &bdata.failed); 467 check ("test3", 2, all, f1line, "test3", &bdata.failed); 468 469 if (bdata.failed) 470 data.failed = 1; 471 472 for (j = 0; j < 3; ++j) 473 { 474 struct symdata symdata; 475 476 symdata.name = NULL; 477 symdata.val = 0; 478 symdata.size = 0; 479 symdata.failed = 0; 480 481 i = backtrace_syminfo (state, addrs[j], callback_three, 482 error_callback_three, &symdata); 483 if (i == 0) 484 { 485 fprintf (stderr, 486 ("test3: [%d]: unexpected return value " 487 "from backtrace_syminfo %d\n"), 488 j, i); 489 symdata.failed = 1; 490 } 491 492 if (!symdata.failed) 493 { 494 const char *expected; 495 496 switch (j) 497 { 498 case 0: 499 expected = "f23"; 500 break; 501 case 1: 502 expected = "f22"; 503 break; 504 case 2: 505 expected = "test3"; 506 break; 507 default: 508 assert (0); 509 } 510 511 if (symdata.name == NULL) 512 { 513 fprintf (stderr, "test3: [%d]: NULL syminfo name\n", j); 514 symdata.failed = 1; 515 } 516 /* Use strncmp, not strcmp, because GCC might create a 517 clone. */ 518 else if (strncmp (symdata.name, expected, strlen (expected)) 519 != 0) 520 { 521 fprintf (stderr, 522 ("test3: [%d]: unexpected syminfo name " 523 "got %s expected %s\n"), 524 j, symdata.name, expected); 525 symdata.failed = 1; 526 } 527 } 528 529 if (symdata.failed) 530 data.failed = 1; 531 } 532 } 533 534 printf ("%s: backtrace_simple noinline\n", data.failed ? "FAIL" : "PASS"); 535 536 if (data.failed) 537 ++failures; 538 539 return failures; 540 } 541 542 /* Test the backtrace_simple function with inlined functions. */ 543 544 static inline int test4 (void) __attribute__ ((always_inline, unused)); 545 static inline int f32 (int) __attribute__ ((always_inline)); 546 static inline int f33 (int, int) __attribute__ ((always_inline)); 547 548 static inline int 549 test4 (void) 550 { 551 return f32 (__LINE__) + 1; 552 } 553 554 static inline int 555 f32 (int f1line) 556 { 557 return f33 (f1line, __LINE__) + 2; 558 } 559 560 static inline int 561 f33 (int f1line, int f2line) 562 { 563 uintptr_t addrs[20]; 564 struct sdata data; 565 int f3line; 566 int i; 567 568 data.addrs = &addrs[0]; 569 data.index = 0; 570 data.max = 20; 571 data.failed = 0; 572 573 f3line = __LINE__ + 1; 574 i = backtrace_simple (state, 0, callback_two, error_callback_two, &data); 575 576 if (i != 0) 577 { 578 fprintf (stderr, "test3: unexpected return value %d\n", i); 579 data.failed = 1; 580 } 581 582 if (!data.failed) 583 { 584 struct info all[20]; 585 struct bdata bdata; 586 587 bdata.all = &all[0]; 588 bdata.index = 0; 589 bdata.max = 20; 590 bdata.failed = 0; 591 592 i = backtrace_pcinfo (state, addrs[0], callback_one, error_callback_one, 593 &bdata); 594 if (i != 0) 595 { 596 fprintf (stderr, 597 ("test4: unexpected return value " 598 "from backtrace_pcinfo %d\n"), 599 i); 600 bdata.failed = 1; 601 } 602 603 check ("test4", 0, all, f3line, "f33", &bdata.failed); 604 check ("test4", 1, all, f2line, "f32", &bdata.failed); 605 check ("test4", 2, all, f1line, "test4", &bdata.failed); 606 607 if (bdata.failed) 608 data.failed = 1; 609 } 610 611 printf ("%s: backtrace_simple inline\n", data.failed ? "FAIL" : "PASS"); 612 613 if (data.failed) 614 ++failures; 615 616 return failures; 617 } 618 619 int global = 1; 620 621 static int 622 test5 (void) 623 { 624 struct symdata symdata; 625 int i; 626 uintptr_t addr = (uintptr_t) &global; 627 628 if (sizeof (global) > 1) 629 addr += 1; 630 631 symdata.name = NULL; 632 symdata.val = 0; 633 symdata.size = 0; 634 symdata.failed = 0; 635 636 i = backtrace_syminfo (state, addr, callback_three, 637 error_callback_three, &symdata); 638 if (i == 0) 639 { 640 fprintf (stderr, 641 "test5: unexpected return value from backtrace_syminfo %d\n", 642 i); 643 symdata.failed = 1; 644 } 645 646 if (!symdata.failed) 647 { 648 if (symdata.name == NULL) 649 { 650 fprintf (stderr, "test5: NULL syminfo name\n"); 651 symdata.failed = 1; 652 } 653 else if (strcmp (symdata.name, "global") != 0) 654 { 655 fprintf (stderr, 656 "test5: unexpected syminfo name got %s expected %s\n", 657 symdata.name, "global"); 658 symdata.failed = 1; 659 } 660 else if (symdata.val != (uintptr_t) &global) 661 { 662 fprintf (stderr, 663 "test5: unexpected syminfo value got %lx expected %lx\n", 664 (unsigned long) symdata.val, 665 (unsigned long) (uintptr_t) &global); 666 symdata.failed = 1; 667 } 668 else if (symdata.size != sizeof (global)) 669 { 670 fprintf (stderr, 671 "test5: unexpected syminfo size got %lx expected %lx\n", 672 (unsigned long) symdata.size, 673 (unsigned long) sizeof (global)); 674 symdata.failed = 1; 675 } 676 } 677 678 printf ("%s: backtrace_syminfo variable\n", 679 symdata.failed ? "FAIL" : "PASS"); 680 681 if (symdata.failed) 682 ++failures; 683 684 return failures; 685 } 686 687 static void 688 error_callback_create (void *data ATTRIBUTE_UNUSED, const char *msg, 689 int errnum) 690 { 691 fprintf (stderr, "%s", msg); 692 if (errnum > 0) 693 fprintf (stderr, ": %s", strerror (errnum)); 694 fprintf (stderr, "\n"); 695 exit (EXIT_FAILURE); 696 } 697 698 /* Run all the tests. */ 699 700 int 701 main (int argc ATTRIBUTE_UNUSED, char **argv) 702 { 703 state = backtrace_create_state (argv[0], BACKTRACE_SUPPORTS_THREADS, 704 error_callback_create, NULL); 705 706 #if BACKTRACE_SUPPORTED 707 test1 (); 708 test2 (); 709 test3 (); 710 test4 (); 711 test5 (); 712 #endif 713 714 exit (failures ? EXIT_FAILURE : EXIT_SUCCESS); 715 } 716