1 /* General utility routines for GDB, the GNU debugger. 2 3 Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 4 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 5 2009, 2010, 2011 Free Software Foundation, Inc. 6 7 This file is part of GDB. 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; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22 #include "defs.h" 23 #include "gdb_assert.h" 24 #include <ctype.h> 25 #include "gdb_string.h" 26 #include "event-top.h" 27 #include "exceptions.h" 28 #include "gdbthread.h" 29 #ifdef HAVE_SYS_RESOURCE_H 30 #include <sys/resource.h> 31 #endif /* HAVE_SYS_RESOURCE_H */ 32 33 #ifdef TUI 34 #include "tui/tui.h" /* For tui_get_command_dimension. */ 35 #endif 36 37 #ifdef __GO32__ 38 #include <pc.h> 39 #endif 40 41 /* SunOS's curses.h has a '#define reg register' in it. Thank you Sun. */ 42 #ifdef reg 43 #undef reg 44 #endif 45 46 #include <signal.h> 47 #include "gdbcmd.h" 48 #include "serial.h" 49 #include "bfd.h" 50 #include "target.h" 51 #include "demangle.h" 52 #include "expression.h" 53 #include "language.h" 54 #include "charset.h" 55 #include "annotate.h" 56 #include "filenames.h" 57 #include "symfile.h" 58 #include "gdb_obstack.h" 59 #include "gdbcore.h" 60 #include "top.h" 61 #include "main.h" 62 63 #include "inferior.h" /* for signed_pointer_to_address */ 64 65 #include <sys/param.h> /* For MAXPATHLEN */ 66 67 #include "gdb_curses.h" 68 69 #include "readline/readline.h" 70 71 #include <sys/time.h> 72 #include <time.h> 73 74 #include "gdb_usleep.h" 75 #include "interps.h" 76 #include "gdb_regex.h" 77 78 #if !HAVE_DECL_MALLOC 79 extern PTR malloc (); /* ARI: PTR */ 80 #endif 81 #if !HAVE_DECL_REALLOC 82 extern PTR realloc (); /* ARI: PTR */ 83 #endif 84 #if !HAVE_DECL_FREE 85 extern void free (); 86 #endif 87 88 /* readline defines this. */ 89 #undef savestring 90 91 void (*deprecated_error_begin_hook) (void); 92 93 /* Prototypes for local functions */ 94 95 static void vfprintf_maybe_filtered (struct ui_file *, const char *, 96 va_list, int) ATTRIBUTE_PRINTF (2, 0); 97 98 static void fputs_maybe_filtered (const char *, struct ui_file *, int); 99 100 static void do_my_cleanups (struct cleanup **, struct cleanup *); 101 102 static void prompt_for_continue (void); 103 104 static void set_screen_size (void); 105 static void set_width (void); 106 107 /* A flag indicating whether to timestamp debugging messages. */ 108 109 static int debug_timestamp = 0; 110 111 /* Chain of cleanup actions established with make_cleanup, 112 to be executed if an error happens. */ 113 114 static struct cleanup *cleanup_chain; /* cleaned up after a failed command */ 115 static struct cleanup *final_cleanup_chain; /* cleaned up when gdb exits */ 116 117 /* Nonzero if we have job control. */ 118 119 int job_control; 120 121 /* Nonzero means a quit has been requested. */ 122 123 int quit_flag; 124 125 /* Nonzero means quit immediately if Control-C is typed now, rather 126 than waiting until QUIT is executed. Be careful in setting this; 127 code which executes with immediate_quit set has to be very careful 128 about being able to deal with being interrupted at any time. It is 129 almost always better to use QUIT; the only exception I can think of 130 is being able to quit out of a system call (using EINTR loses if 131 the SIGINT happens between the previous QUIT and the system call). 132 To immediately quit in the case in which a SIGINT happens between 133 the previous QUIT and setting immediate_quit (desirable anytime we 134 expect to block), call QUIT after setting immediate_quit. */ 135 136 int immediate_quit; 137 138 /* Nonzero means that encoded C++/ObjC names should be printed out in their 139 C++/ObjC form rather than raw. */ 140 141 int demangle = 1; 142 static void 143 show_demangle (struct ui_file *file, int from_tty, 144 struct cmd_list_element *c, const char *value) 145 { 146 fprintf_filtered (file, 147 _("Demangling of encoded C++/ObjC names " 148 "when displaying symbols is %s.\n"), 149 value); 150 } 151 152 /* Nonzero means that encoded C++/ObjC names should be printed out in their 153 C++/ObjC form even in assembler language displays. If this is set, but 154 DEMANGLE is zero, names are printed raw, i.e. DEMANGLE controls. */ 155 156 int asm_demangle = 0; 157 static void 158 show_asm_demangle (struct ui_file *file, int from_tty, 159 struct cmd_list_element *c, const char *value) 160 { 161 fprintf_filtered (file, 162 _("Demangling of C++/ObjC names in " 163 "disassembly listings is %s.\n"), 164 value); 165 } 166 167 /* Nonzero means that strings with character values >0x7F should be printed 168 as octal escapes. Zero means just print the value (e.g. it's an 169 international character, and the terminal or window can cope.) */ 170 171 int sevenbit_strings = 0; 172 static void 173 show_sevenbit_strings (struct ui_file *file, int from_tty, 174 struct cmd_list_element *c, const char *value) 175 { 176 fprintf_filtered (file, _("Printing of 8-bit characters " 177 "in strings as \\nnn is %s.\n"), 178 value); 179 } 180 181 /* String to be printed before error messages, if any. */ 182 183 char *error_pre_print; 184 185 /* String to be printed before quit messages, if any. */ 186 187 char *quit_pre_print; 188 189 /* String to be printed before warning messages, if any. */ 190 191 char *warning_pre_print = "\nwarning: "; 192 193 int pagination_enabled = 1; 194 static void 195 show_pagination_enabled (struct ui_file *file, int from_tty, 196 struct cmd_list_element *c, const char *value) 197 { 198 fprintf_filtered (file, _("State of pagination is %s.\n"), value); 199 } 200 201 202 203 /* Add a new cleanup to the cleanup_chain, 204 and return the previous chain pointer 205 to be passed later to do_cleanups or discard_cleanups. 206 Args are FUNCTION to clean up with, and ARG to pass to it. */ 207 208 struct cleanup * 209 make_cleanup (make_cleanup_ftype *function, void *arg) 210 { 211 return make_my_cleanup (&cleanup_chain, function, arg); 212 } 213 214 struct cleanup * 215 make_cleanup_dtor (make_cleanup_ftype *function, void *arg, 216 void (*dtor) (void *)) 217 { 218 return make_my_cleanup2 (&cleanup_chain, 219 function, arg, dtor); 220 } 221 222 struct cleanup * 223 make_final_cleanup (make_cleanup_ftype *function, void *arg) 224 { 225 return make_my_cleanup (&final_cleanup_chain, function, arg); 226 } 227 228 static void 229 do_freeargv (void *arg) 230 { 231 freeargv ((char **) arg); 232 } 233 234 struct cleanup * 235 make_cleanup_freeargv (char **arg) 236 { 237 return make_my_cleanup (&cleanup_chain, do_freeargv, arg); 238 } 239 240 static void 241 do_bfd_close_cleanup (void *arg) 242 { 243 bfd_close (arg); 244 } 245 246 struct cleanup * 247 make_cleanup_bfd_close (bfd *abfd) 248 { 249 return make_cleanup (do_bfd_close_cleanup, abfd); 250 } 251 252 static void 253 do_close_cleanup (void *arg) 254 { 255 int *fd = arg; 256 257 close (*fd); 258 } 259 260 struct cleanup * 261 make_cleanup_close (int fd) 262 { 263 int *saved_fd = xmalloc (sizeof (fd)); 264 265 *saved_fd = fd; 266 return make_cleanup_dtor (do_close_cleanup, saved_fd, xfree); 267 } 268 269 /* Helper function which does the work for make_cleanup_fclose. */ 270 271 static void 272 do_fclose_cleanup (void *arg) 273 { 274 FILE *file = arg; 275 276 fclose (file); 277 } 278 279 /* Return a new cleanup that closes FILE. */ 280 281 struct cleanup * 282 make_cleanup_fclose (FILE *file) 283 { 284 return make_cleanup (do_fclose_cleanup, file); 285 } 286 287 /* Helper function which does the work for make_cleanup_obstack_free. */ 288 289 static void 290 do_obstack_free (void *arg) 291 { 292 struct obstack *ob = arg; 293 294 obstack_free (ob, NULL); 295 } 296 297 /* Return a new cleanup that frees OBSTACK. */ 298 299 struct cleanup * 300 make_cleanup_obstack_free (struct obstack *obstack) 301 { 302 return make_cleanup (do_obstack_free, obstack); 303 } 304 305 static void 306 do_ui_file_delete (void *arg) 307 { 308 ui_file_delete (arg); 309 } 310 311 struct cleanup * 312 make_cleanup_ui_file_delete (struct ui_file *arg) 313 { 314 return make_my_cleanup (&cleanup_chain, do_ui_file_delete, arg); 315 } 316 317 /* Helper function for make_cleanup_ui_out_redirect_pop. */ 318 319 static void 320 do_ui_out_redirect_pop (void *arg) 321 { 322 struct ui_out *uiout = arg; 323 324 if (ui_out_redirect (uiout, NULL) < 0) 325 warning (_("Cannot restore redirection of the current output protocol")); 326 } 327 328 /* Return a new cleanup that pops the last redirection by ui_out_redirect 329 with NULL parameter. */ 330 331 struct cleanup * 332 make_cleanup_ui_out_redirect_pop (struct ui_out *uiout) 333 { 334 return make_my_cleanup (&cleanup_chain, do_ui_out_redirect_pop, uiout); 335 } 336 337 static void 338 do_free_section_addr_info (void *arg) 339 { 340 free_section_addr_info (arg); 341 } 342 343 struct cleanup * 344 make_cleanup_free_section_addr_info (struct section_addr_info *addrs) 345 { 346 return make_my_cleanup (&cleanup_chain, do_free_section_addr_info, addrs); 347 } 348 349 struct restore_integer_closure 350 { 351 int *variable; 352 int value; 353 }; 354 355 static void 356 restore_integer (void *p) 357 { 358 struct restore_integer_closure *closure = p; 359 360 *(closure->variable) = closure->value; 361 } 362 363 /* Remember the current value of *VARIABLE and make it restored when 364 the cleanup is run. */ 365 366 struct cleanup * 367 make_cleanup_restore_integer (int *variable) 368 { 369 struct restore_integer_closure *c = 370 xmalloc (sizeof (struct restore_integer_closure)); 371 372 c->variable = variable; 373 c->value = *variable; 374 375 return make_my_cleanup2 (&cleanup_chain, restore_integer, (void *)c, 376 xfree); 377 } 378 379 /* Remember the current value of *VARIABLE and make it restored when 380 the cleanup is run. */ 381 382 struct cleanup * 383 make_cleanup_restore_uinteger (unsigned int *variable) 384 { 385 return make_cleanup_restore_integer ((int *) variable); 386 } 387 388 /* Helper for make_cleanup_unpush_target. */ 389 390 static void 391 do_unpush_target (void *arg) 392 { 393 struct target_ops *ops = arg; 394 395 unpush_target (ops); 396 } 397 398 /* Return a new cleanup that unpushes OPS. */ 399 400 struct cleanup * 401 make_cleanup_unpush_target (struct target_ops *ops) 402 { 403 return make_my_cleanup (&cleanup_chain, do_unpush_target, ops); 404 } 405 406 struct restore_ui_file_closure 407 { 408 struct ui_file **variable; 409 struct ui_file *value; 410 }; 411 412 static void 413 do_restore_ui_file (void *p) 414 { 415 struct restore_ui_file_closure *closure = p; 416 417 *(closure->variable) = closure->value; 418 } 419 420 /* Remember the current value of *VARIABLE and make it restored when 421 the cleanup is run. */ 422 423 struct cleanup * 424 make_cleanup_restore_ui_file (struct ui_file **variable) 425 { 426 struct restore_ui_file_closure *c = XNEW (struct restore_ui_file_closure); 427 428 c->variable = variable; 429 c->value = *variable; 430 431 return make_cleanup_dtor (do_restore_ui_file, (void *) c, xfree); 432 } 433 434 struct cleanup * 435 make_my_cleanup2 (struct cleanup **pmy_chain, make_cleanup_ftype *function, 436 void *arg, void (*free_arg) (void *)) 437 { 438 struct cleanup *new 439 = (struct cleanup *) xmalloc (sizeof (struct cleanup)); 440 struct cleanup *old_chain = *pmy_chain; 441 442 new->next = *pmy_chain; 443 new->function = function; 444 new->free_arg = free_arg; 445 new->arg = arg; 446 *pmy_chain = new; 447 448 return old_chain; 449 } 450 451 struct cleanup * 452 make_my_cleanup (struct cleanup **pmy_chain, make_cleanup_ftype *function, 453 void *arg) 454 { 455 return make_my_cleanup2 (pmy_chain, function, arg, NULL); 456 } 457 458 /* Discard cleanups and do the actions they describe 459 until we get back to the point OLD_CHAIN in the cleanup_chain. */ 460 461 void 462 do_cleanups (struct cleanup *old_chain) 463 { 464 do_my_cleanups (&cleanup_chain, old_chain); 465 } 466 467 void 468 do_final_cleanups (struct cleanup *old_chain) 469 { 470 do_my_cleanups (&final_cleanup_chain, old_chain); 471 } 472 473 static void 474 do_my_cleanups (struct cleanup **pmy_chain, 475 struct cleanup *old_chain) 476 { 477 struct cleanup *ptr; 478 479 while ((ptr = *pmy_chain) != old_chain) 480 { 481 *pmy_chain = ptr->next; /* Do this first in case of recursion. */ 482 (*ptr->function) (ptr->arg); 483 if (ptr->free_arg) 484 (*ptr->free_arg) (ptr->arg); 485 xfree (ptr); 486 } 487 } 488 489 /* Discard cleanups, not doing the actions they describe, 490 until we get back to the point OLD_CHAIN in the cleanup_chain. */ 491 492 void 493 discard_cleanups (struct cleanup *old_chain) 494 { 495 discard_my_cleanups (&cleanup_chain, old_chain); 496 } 497 498 void 499 discard_final_cleanups (struct cleanup *old_chain) 500 { 501 discard_my_cleanups (&final_cleanup_chain, old_chain); 502 } 503 504 void 505 discard_my_cleanups (struct cleanup **pmy_chain, 506 struct cleanup *old_chain) 507 { 508 struct cleanup *ptr; 509 510 while ((ptr = *pmy_chain) != old_chain) 511 { 512 *pmy_chain = ptr->next; 513 if (ptr->free_arg) 514 (*ptr->free_arg) (ptr->arg); 515 xfree (ptr); 516 } 517 } 518 519 /* Set the cleanup_chain to 0, and return the old cleanup chain. */ 520 struct cleanup * 521 save_cleanups (void) 522 { 523 return save_my_cleanups (&cleanup_chain); 524 } 525 526 struct cleanup * 527 save_final_cleanups (void) 528 { 529 return save_my_cleanups (&final_cleanup_chain); 530 } 531 532 struct cleanup * 533 save_my_cleanups (struct cleanup **pmy_chain) 534 { 535 struct cleanup *old_chain = *pmy_chain; 536 537 *pmy_chain = 0; 538 return old_chain; 539 } 540 541 /* Restore the cleanup chain from a previously saved chain. */ 542 void 543 restore_cleanups (struct cleanup *chain) 544 { 545 restore_my_cleanups (&cleanup_chain, chain); 546 } 547 548 void 549 restore_final_cleanups (struct cleanup *chain) 550 { 551 restore_my_cleanups (&final_cleanup_chain, chain); 552 } 553 554 void 555 restore_my_cleanups (struct cleanup **pmy_chain, struct cleanup *chain) 556 { 557 *pmy_chain = chain; 558 } 559 560 /* This function is useful for cleanups. 561 Do 562 563 foo = xmalloc (...); 564 old_chain = make_cleanup (free_current_contents, &foo); 565 566 to arrange to free the object thus allocated. */ 567 568 void 569 free_current_contents (void *ptr) 570 { 571 void **location = ptr; 572 573 if (location == NULL) 574 internal_error (__FILE__, __LINE__, 575 _("free_current_contents: NULL pointer")); 576 if (*location != NULL) 577 { 578 xfree (*location); 579 *location = NULL; 580 } 581 } 582 583 /* Provide a known function that does nothing, to use as a base for 584 for a possibly long chain of cleanups. This is useful where we 585 use the cleanup chain for handling normal cleanups as well as dealing 586 with cleanups that need to be done as a result of a call to error(). 587 In such cases, we may not be certain where the first cleanup is, unless 588 we have a do-nothing one to always use as the base. */ 589 590 void 591 null_cleanup (void *arg) 592 { 593 } 594 595 /* If nonzero, display time usage both at startup and for each command. */ 596 597 static int display_time; 598 599 /* If nonzero, display space usage both at startup and for each command. */ 600 601 static int display_space; 602 603 /* Records a run time and space usage to be used as a base for 604 reporting elapsed time or change in space. In addition, 605 the msg_type field indicates whether the saved time is from the 606 beginning of GDB execution (0) or the beginning of an individual 607 command execution (1). */ 608 struct cmd_stats 609 { 610 int msg_type; 611 long start_time; 612 long start_space; 613 }; 614 615 /* Set whether to display time statistics to NEW_VALUE (non-zero 616 means true). */ 617 void 618 set_display_time (int new_value) 619 { 620 display_time = new_value; 621 } 622 623 /* Set whether to display space statistics to NEW_VALUE (non-zero 624 means true). */ 625 void 626 set_display_space (int new_value) 627 { 628 display_space = new_value; 629 } 630 631 /* As indicated by display_time and display_space, report GDB's elapsed time 632 and space usage from the base time and space provided in ARG, which 633 must be a pointer to a struct cmd_stat. This function is intended 634 to be called as a cleanup. */ 635 static void 636 report_command_stats (void *arg) 637 { 638 struct cmd_stats *start_stats = (struct cmd_stats *) arg; 639 int msg_type = start_stats->msg_type; 640 641 if (display_time) 642 { 643 long cmd_time = get_run_time () - start_stats->start_time; 644 645 printf_unfiltered (msg_type == 0 646 ? _("Startup time: %ld.%06ld\n") 647 : _("Command execution time: %ld.%06ld\n"), 648 cmd_time / 1000000, cmd_time % 1000000); 649 } 650 651 if (display_space) 652 { 653 #ifdef HAVE_SBRK 654 char *lim = (char *) sbrk (0); 655 656 long space_now = lim - lim_at_start; 657 long space_diff = space_now - start_stats->start_space; 658 659 printf_unfiltered (msg_type == 0 660 ? _("Space used: %ld (%s%ld during startup)\n") 661 : _("Space used: %ld (%s%ld for this command)\n"), 662 space_now, 663 (space_diff >= 0 ? "+" : ""), 664 space_diff); 665 #endif 666 } 667 } 668 669 /* Create a cleanup that reports time and space used since its 670 creation. Precise messages depend on MSG_TYPE: 671 0: Initial time/space 672 1: Individual command time/space. */ 673 struct cleanup * 674 make_command_stats_cleanup (int msg_type) 675 { 676 struct cmd_stats *new_stat = XMALLOC (struct cmd_stats); 677 678 #ifdef HAVE_SBRK 679 char *lim = (char *) sbrk (0); 680 new_stat->start_space = lim - lim_at_start; 681 #endif 682 683 new_stat->msg_type = msg_type; 684 new_stat->start_time = get_run_time (); 685 686 return make_cleanup_dtor (report_command_stats, new_stat, xfree); 687 } 688 689 /* Continuations are implemented as cleanups internally. Inherit from 690 cleanups. */ 691 struct continuation 692 { 693 struct cleanup base; 694 }; 695 696 /* Add a continuation to the continuation list of THREAD. The new 697 continuation will be added at the front. */ 698 void 699 add_continuation (struct thread_info *thread, 700 void (*continuation_hook) (void *), void *args, 701 void (*continuation_free_args) (void *)) 702 { 703 struct cleanup *as_cleanup = &thread->continuations->base; 704 make_cleanup_ftype *continuation_hook_fn = continuation_hook; 705 706 make_my_cleanup2 (&as_cleanup, 707 continuation_hook_fn, 708 args, 709 continuation_free_args); 710 711 thread->continuations = (struct continuation *) as_cleanup; 712 } 713 714 /* Add a continuation to the continuation list of INFERIOR. The new 715 continuation will be added at the front. */ 716 717 void 718 add_inferior_continuation (void (*continuation_hook) (void *), void *args, 719 void (*continuation_free_args) (void *)) 720 { 721 struct inferior *inf = current_inferior (); 722 struct cleanup *as_cleanup = &inf->continuations->base; 723 make_cleanup_ftype *continuation_hook_fn = continuation_hook; 724 725 make_my_cleanup2 (&as_cleanup, 726 continuation_hook_fn, 727 args, 728 continuation_free_args); 729 730 inf->continuations = (struct continuation *) as_cleanup; 731 } 732 733 /* Do all continuations of the current inferior. */ 734 735 void 736 do_all_inferior_continuations (void) 737 { 738 struct cleanup *as_cleanup; 739 struct inferior *inf = current_inferior (); 740 741 if (inf->continuations == NULL) 742 return; 743 744 /* Copy the list header into another pointer, and set the global 745 list header to null, so that the global list can change as a side 746 effect of invoking the continuations and the processing of the 747 preexisting continuations will not be affected. */ 748 749 as_cleanup = &inf->continuations->base; 750 inf->continuations = NULL; 751 752 /* Work now on the list we have set aside. */ 753 do_my_cleanups (&as_cleanup, NULL); 754 } 755 756 /* Get rid of all the inferior-wide continuations of INF. */ 757 758 void 759 discard_all_inferior_continuations (struct inferior *inf) 760 { 761 struct cleanup *continuation_ptr = &inf->continuations->base; 762 763 discard_my_cleanups (&continuation_ptr, NULL); 764 inf->continuations = NULL; 765 } 766 767 static void 768 restore_thread_cleanup (void *arg) 769 { 770 ptid_t *ptid_p = arg; 771 772 switch_to_thread (*ptid_p); 773 } 774 775 /* Walk down the continuation list of PTID, and execute all the 776 continuations. There is a problem though. In some cases new 777 continuations may be added while we are in the middle of this loop. 778 If this happens they will be added in the front, and done before we 779 have a chance of exhausting those that were already there. We need 780 to then save the beginning of the list in a pointer and do the 781 continuations from there on, instead of using the global beginning 782 of list as our iteration pointer. */ 783 static void 784 do_all_continuations_ptid (ptid_t ptid, 785 struct continuation **continuations_p) 786 { 787 struct cleanup *old_chain; 788 ptid_t current_thread; 789 struct cleanup *as_cleanup; 790 791 if (*continuations_p == NULL) 792 return; 793 794 current_thread = inferior_ptid; 795 796 /* Restore selected thread on exit. Don't try to restore the frame 797 as well, because: 798 799 - When running continuations, the selected frame is always #0. 800 801 - The continuations may trigger symbol file loads, which may 802 change the frame layout (frame ids change), which would trigger 803 a warning if we used make_cleanup_restore_current_thread. */ 804 805 old_chain = make_cleanup (restore_thread_cleanup, ¤t_thread); 806 807 /* Let the continuation see this thread as selected. */ 808 switch_to_thread (ptid); 809 810 /* Copy the list header into another pointer, and set the global 811 list header to null, so that the global list can change as a side 812 effect of invoking the continuations and the processing of the 813 preexisting continuations will not be affected. */ 814 815 as_cleanup = &(*continuations_p)->base; 816 *continuations_p = NULL; 817 818 /* Work now on the list we have set aside. */ 819 do_my_cleanups (&as_cleanup, NULL); 820 821 do_cleanups (old_chain); 822 } 823 824 /* Callback for iterate over threads. */ 825 static int 826 do_all_continuations_thread_callback (struct thread_info *thread, void *data) 827 { 828 do_all_continuations_ptid (thread->ptid, &thread->continuations); 829 return 0; 830 } 831 832 /* Do all continuations of thread THREAD. */ 833 void 834 do_all_continuations_thread (struct thread_info *thread) 835 { 836 do_all_continuations_thread_callback (thread, NULL); 837 } 838 839 /* Do all continuations of all threads. */ 840 void 841 do_all_continuations (void) 842 { 843 iterate_over_threads (do_all_continuations_thread_callback, NULL); 844 } 845 846 /* Callback for iterate over threads. */ 847 static int 848 discard_all_continuations_thread_callback (struct thread_info *thread, 849 void *data) 850 { 851 struct cleanup *continuation_ptr = &thread->continuations->base; 852 853 discard_my_cleanups (&continuation_ptr, NULL); 854 thread->continuations = NULL; 855 return 0; 856 } 857 858 /* Get rid of all the continuations of THREAD. */ 859 void 860 discard_all_continuations_thread (struct thread_info *thread) 861 { 862 discard_all_continuations_thread_callback (thread, NULL); 863 } 864 865 /* Get rid of all the continuations of all threads. */ 866 void 867 discard_all_continuations (void) 868 { 869 iterate_over_threads (discard_all_continuations_thread_callback, NULL); 870 } 871 872 873 /* Add a continuation to the intermediate continuation list of THREAD. 874 The new continuation will be added at the front. */ 875 void 876 add_intermediate_continuation (struct thread_info *thread, 877 void (*continuation_hook) 878 (void *), void *args, 879 void (*continuation_free_args) (void *)) 880 { 881 struct cleanup *as_cleanup = &thread->intermediate_continuations->base; 882 make_cleanup_ftype *continuation_hook_fn = continuation_hook; 883 884 make_my_cleanup2 (&as_cleanup, 885 continuation_hook_fn, 886 args, 887 continuation_free_args); 888 889 thread->intermediate_continuations = (struct continuation *) as_cleanup; 890 } 891 892 /* Walk down the cmd_continuation list, and execute all the 893 continuations. There is a problem though. In some cases new 894 continuations may be added while we are in the middle of this 895 loop. If this happens they will be added in the front, and done 896 before we have a chance of exhausting those that were already 897 there. We need to then save the beginning of the list in a pointer 898 and do the continuations from there on, instead of using the 899 global beginning of list as our iteration pointer. */ 900 static int 901 do_all_intermediate_continuations_thread_callback (struct thread_info *thread, 902 void *data) 903 { 904 do_all_continuations_ptid (thread->ptid, 905 &thread->intermediate_continuations); 906 return 0; 907 } 908 909 /* Do all intermediate continuations of thread THREAD. */ 910 void 911 do_all_intermediate_continuations_thread (struct thread_info *thread) 912 { 913 do_all_intermediate_continuations_thread_callback (thread, NULL); 914 } 915 916 /* Do all intermediate continuations of all threads. */ 917 void 918 do_all_intermediate_continuations (void) 919 { 920 iterate_over_threads (do_all_intermediate_continuations_thread_callback, 921 NULL); 922 } 923 924 /* Callback for iterate over threads. */ 925 static int 926 discard_all_intermediate_continuations_thread_callback (struct thread_info *thread, 927 void *data) 928 { 929 struct cleanup *continuation_ptr = &thread->intermediate_continuations->base; 930 931 discard_my_cleanups (&continuation_ptr, NULL); 932 thread->intermediate_continuations = NULL; 933 return 0; 934 } 935 936 /* Get rid of all the intermediate continuations of THREAD. */ 937 void 938 discard_all_intermediate_continuations_thread (struct thread_info *thread) 939 { 940 discard_all_intermediate_continuations_thread_callback (thread, NULL); 941 } 942 943 /* Get rid of all the intermediate continuations of all threads. */ 944 void 945 discard_all_intermediate_continuations (void) 946 { 947 iterate_over_threads (discard_all_intermediate_continuations_thread_callback, 948 NULL); 949 } 950 951 952 953 /* Print a warning message. The first argument STRING is the warning 954 message, used as an fprintf format string, the second is the 955 va_list of arguments for that string. A warning is unfiltered (not 956 paginated) so that the user does not need to page through each 957 screen full of warnings when there are lots of them. */ 958 959 void 960 vwarning (const char *string, va_list args) 961 { 962 if (deprecated_warning_hook) 963 (*deprecated_warning_hook) (string, args); 964 else 965 { 966 target_terminal_ours (); 967 wrap_here (""); /* Force out any buffered output. */ 968 gdb_flush (gdb_stdout); 969 if (warning_pre_print) 970 fputs_unfiltered (warning_pre_print, gdb_stderr); 971 vfprintf_unfiltered (gdb_stderr, string, args); 972 fprintf_unfiltered (gdb_stderr, "\n"); 973 va_end (args); 974 } 975 } 976 977 /* Print a warning message. 978 The first argument STRING is the warning message, used as a fprintf string, 979 and the remaining args are passed as arguments to it. 980 The primary difference between warnings and errors is that a warning 981 does not force the return to command level. */ 982 983 void 984 warning (const char *string, ...) 985 { 986 va_list args; 987 988 va_start (args, string); 989 vwarning (string, args); 990 va_end (args); 991 } 992 993 /* Print an error message and return to command level. 994 The first argument STRING is the error message, used as a fprintf string, 995 and the remaining args are passed as arguments to it. */ 996 997 void 998 verror (const char *string, va_list args) 999 { 1000 throw_verror (GENERIC_ERROR, string, args); 1001 } 1002 1003 void 1004 error (const char *string, ...) 1005 { 1006 va_list args; 1007 1008 va_start (args, string); 1009 throw_verror (GENERIC_ERROR, string, args); 1010 va_end (args); 1011 } 1012 1013 /* Print an error message and quit. 1014 The first argument STRING is the error message, used as a fprintf string, 1015 and the remaining args are passed as arguments to it. */ 1016 1017 void 1018 vfatal (const char *string, va_list args) 1019 { 1020 throw_vfatal (string, args); 1021 } 1022 1023 void 1024 fatal (const char *string, ...) 1025 { 1026 va_list args; 1027 1028 va_start (args, string); 1029 throw_vfatal (string, args); 1030 va_end (args); 1031 } 1032 1033 void 1034 error_stream (struct ui_file *stream) 1035 { 1036 char *message = ui_file_xstrdup (stream, NULL); 1037 1038 make_cleanup (xfree, message); 1039 error (("%s"), message); 1040 } 1041 1042 /* Dump core trying to increase the core soft limit to hard limit first. */ 1043 1044 static void 1045 dump_core (void) 1046 { 1047 #ifdef HAVE_SETRLIMIT 1048 struct rlimit rlim = { RLIM_INFINITY, RLIM_INFINITY }; 1049 1050 setrlimit (RLIMIT_CORE, &rlim); 1051 #endif /* HAVE_SETRLIMIT */ 1052 1053 abort (); /* NOTE: GDB has only three calls to abort(). */ 1054 } 1055 1056 /* Check whether GDB will be able to dump core using the dump_core 1057 function. */ 1058 1059 static int 1060 can_dump_core (const char *reason) 1061 { 1062 #ifdef HAVE_GETRLIMIT 1063 struct rlimit rlim; 1064 1065 /* Be quiet and assume we can dump if an error is returned. */ 1066 if (getrlimit (RLIMIT_CORE, &rlim) != 0) 1067 return 1; 1068 1069 if (rlim.rlim_max == 0) 1070 { 1071 fprintf_unfiltered (gdb_stderr, 1072 _("%s\nUnable to dump core, use `ulimit -c" 1073 " unlimited' before executing GDB next time.\n"), 1074 reason); 1075 return 0; 1076 } 1077 #endif /* HAVE_GETRLIMIT */ 1078 1079 return 1; 1080 } 1081 1082 /* Allow the user to configure the debugger behavior with respect to 1083 what to do when an internal problem is detected. */ 1084 1085 const char internal_problem_ask[] = "ask"; 1086 const char internal_problem_yes[] = "yes"; 1087 const char internal_problem_no[] = "no"; 1088 static const char *internal_problem_modes[] = 1089 { 1090 internal_problem_ask, 1091 internal_problem_yes, 1092 internal_problem_no, 1093 NULL 1094 }; 1095 1096 /* Print a message reporting an internal error/warning. Ask the user 1097 if they want to continue, dump core, or just exit. Return 1098 something to indicate a quit. */ 1099 1100 struct internal_problem 1101 { 1102 const char *name; 1103 const char *should_quit; 1104 const char *should_dump_core; 1105 }; 1106 1107 /* Report a problem, internal to GDB, to the user. Once the problem 1108 has been reported, and assuming GDB didn't quit, the caller can 1109 either allow execution to resume or throw an error. */ 1110 1111 static void ATTRIBUTE_PRINTF (4, 0) 1112 internal_vproblem (struct internal_problem *problem, 1113 const char *file, int line, const char *fmt, va_list ap) 1114 { 1115 static int dejavu; 1116 int quit_p; 1117 int dump_core_p; 1118 char *reason; 1119 1120 /* Don't allow infinite error/warning recursion. */ 1121 { 1122 static char msg[] = "Recursive internal problem.\n"; 1123 1124 switch (dejavu) 1125 { 1126 case 0: 1127 dejavu = 1; 1128 break; 1129 case 1: 1130 dejavu = 2; 1131 fputs_unfiltered (msg, gdb_stderr); 1132 abort (); /* NOTE: GDB has only three calls to abort(). */ 1133 default: 1134 dejavu = 3; 1135 /* Newer GLIBC versions put the warn_unused_result attribute 1136 on write, but this is one of those rare cases where 1137 ignoring the return value is correct. Casting to (void) 1138 does not fix this problem. This is the solution suggested 1139 at http://gcc.gnu.org/bugzilla/show_bug.cgi?id=25509. */ 1140 if (write (STDERR_FILENO, msg, sizeof (msg)) != sizeof (msg)) 1141 abort (); /* NOTE: GDB has only three calls to abort(). */ 1142 exit (1); 1143 } 1144 } 1145 1146 /* Try to get the message out and at the start of a new line. */ 1147 target_terminal_ours (); 1148 begin_line (); 1149 1150 /* Create a string containing the full error/warning message. Need 1151 to call query with this full string, as otherwize the reason 1152 (error/warning) and question become separated. Format using a 1153 style similar to a compiler error message. Include extra detail 1154 so that the user knows that they are living on the edge. */ 1155 { 1156 char *msg; 1157 1158 msg = xstrvprintf (fmt, ap); 1159 reason = xstrprintf ("%s:%d: %s: %s\n" 1160 "A problem internal to GDB has been detected,\n" 1161 "further debugging may prove unreliable.", 1162 file, line, problem->name, msg); 1163 xfree (msg); 1164 make_cleanup (xfree, reason); 1165 } 1166 1167 if (problem->should_quit == internal_problem_ask) 1168 { 1169 /* Default (yes/batch case) is to quit GDB. When in batch mode 1170 this lessens the likelihood of GDB going into an infinite 1171 loop. */ 1172 if (caution == 0) 1173 { 1174 /* Emit the message and quit. */ 1175 fputs_unfiltered (reason, gdb_stderr); 1176 fputs_unfiltered ("\n", gdb_stderr); 1177 quit_p = 1; 1178 } 1179 else 1180 quit_p = query (_("%s\nQuit this debugging session? "), reason); 1181 } 1182 else if (problem->should_quit == internal_problem_yes) 1183 quit_p = 1; 1184 else if (problem->should_quit == internal_problem_no) 1185 quit_p = 0; 1186 else 1187 internal_error (__FILE__, __LINE__, _("bad switch")); 1188 1189 if (problem->should_dump_core == internal_problem_ask) 1190 { 1191 if (!can_dump_core (reason)) 1192 dump_core_p = 0; 1193 else 1194 { 1195 /* Default (yes/batch case) is to dump core. This leaves a GDB 1196 `dropping' so that it is easier to see that something went 1197 wrong in GDB. */ 1198 dump_core_p = query (_("%s\nCreate a core file of GDB? "), reason); 1199 } 1200 } 1201 else if (problem->should_dump_core == internal_problem_yes) 1202 dump_core_p = can_dump_core (reason); 1203 else if (problem->should_dump_core == internal_problem_no) 1204 dump_core_p = 0; 1205 else 1206 internal_error (__FILE__, __LINE__, _("bad switch")); 1207 1208 if (quit_p) 1209 { 1210 if (dump_core_p) 1211 dump_core (); 1212 else 1213 exit (1); 1214 } 1215 else 1216 { 1217 if (dump_core_p) 1218 { 1219 #ifdef HAVE_WORKING_FORK 1220 if (fork () == 0) 1221 dump_core (); 1222 #endif 1223 } 1224 } 1225 1226 dejavu = 0; 1227 } 1228 1229 static struct internal_problem internal_error_problem = { 1230 "internal-error", internal_problem_ask, internal_problem_ask 1231 }; 1232 1233 void 1234 internal_verror (const char *file, int line, const char *fmt, va_list ap) 1235 { 1236 internal_vproblem (&internal_error_problem, file, line, fmt, ap); 1237 deprecated_throw_reason (RETURN_ERROR); 1238 } 1239 1240 void 1241 internal_error (const char *file, int line, const char *string, ...) 1242 { 1243 va_list ap; 1244 1245 va_start (ap, string); 1246 internal_verror (file, line, string, ap); 1247 va_end (ap); 1248 } 1249 1250 static struct internal_problem internal_warning_problem = { 1251 "internal-warning", internal_problem_ask, internal_problem_ask 1252 }; 1253 1254 void 1255 internal_vwarning (const char *file, int line, const char *fmt, va_list ap) 1256 { 1257 internal_vproblem (&internal_warning_problem, file, line, fmt, ap); 1258 } 1259 1260 void 1261 internal_warning (const char *file, int line, const char *string, ...) 1262 { 1263 va_list ap; 1264 1265 va_start (ap, string); 1266 internal_vwarning (file, line, string, ap); 1267 va_end (ap); 1268 } 1269 1270 /* Dummy functions to keep add_prefix_cmd happy. */ 1271 1272 static void 1273 set_internal_problem_cmd (char *args, int from_tty) 1274 { 1275 } 1276 1277 static void 1278 show_internal_problem_cmd (char *args, int from_tty) 1279 { 1280 } 1281 1282 /* When GDB reports an internal problem (error or warning) it gives 1283 the user the opportunity to quit GDB and/or create a core file of 1284 the current debug session. This function registers a few commands 1285 that make it possible to specify that GDB should always or never 1286 quit or create a core file, without asking. The commands look 1287 like: 1288 1289 maint set PROBLEM-NAME quit ask|yes|no 1290 maint show PROBLEM-NAME quit 1291 maint set PROBLEM-NAME corefile ask|yes|no 1292 maint show PROBLEM-NAME corefile 1293 1294 Where PROBLEM-NAME is currently "internal-error" or 1295 "internal-warning". */ 1296 1297 static void 1298 add_internal_problem_command (struct internal_problem *problem) 1299 { 1300 struct cmd_list_element **set_cmd_list; 1301 struct cmd_list_element **show_cmd_list; 1302 char *set_doc; 1303 char *show_doc; 1304 1305 set_cmd_list = xmalloc (sizeof (*set_cmd_list)); 1306 show_cmd_list = xmalloc (sizeof (*set_cmd_list)); 1307 *set_cmd_list = NULL; 1308 *show_cmd_list = NULL; 1309 1310 set_doc = xstrprintf (_("Configure what GDB does when %s is detected."), 1311 problem->name); 1312 1313 show_doc = xstrprintf (_("Show what GDB does when %s is detected."), 1314 problem->name); 1315 1316 add_prefix_cmd ((char*) problem->name, 1317 class_maintenance, set_internal_problem_cmd, set_doc, 1318 set_cmd_list, 1319 concat ("maintenance set ", problem->name, " ", 1320 (char *) NULL), 1321 0/*allow-unknown*/, &maintenance_set_cmdlist); 1322 1323 add_prefix_cmd ((char*) problem->name, 1324 class_maintenance, show_internal_problem_cmd, show_doc, 1325 show_cmd_list, 1326 concat ("maintenance show ", problem->name, " ", 1327 (char *) NULL), 1328 0/*allow-unknown*/, &maintenance_show_cmdlist); 1329 1330 set_doc = xstrprintf (_("Set whether GDB should quit " 1331 "when an %s is detected"), 1332 problem->name); 1333 show_doc = xstrprintf (_("Show whether GDB will quit " 1334 "when an %s is detected"), 1335 problem->name); 1336 add_setshow_enum_cmd ("quit", class_maintenance, 1337 internal_problem_modes, 1338 &problem->should_quit, 1339 set_doc, 1340 show_doc, 1341 NULL, /* help_doc */ 1342 NULL, /* setfunc */ 1343 NULL, /* showfunc */ 1344 set_cmd_list, 1345 show_cmd_list); 1346 1347 xfree (set_doc); 1348 xfree (show_doc); 1349 1350 set_doc = xstrprintf (_("Set whether GDB should create a core " 1351 "file of GDB when %s is detected"), 1352 problem->name); 1353 show_doc = xstrprintf (_("Show whether GDB will create a core " 1354 "file of GDB when %s is detected"), 1355 problem->name); 1356 add_setshow_enum_cmd ("corefile", class_maintenance, 1357 internal_problem_modes, 1358 &problem->should_dump_core, 1359 set_doc, 1360 show_doc, 1361 NULL, /* help_doc */ 1362 NULL, /* setfunc */ 1363 NULL, /* showfunc */ 1364 set_cmd_list, 1365 show_cmd_list); 1366 1367 xfree (set_doc); 1368 xfree (show_doc); 1369 } 1370 1371 /* Print the system error message for errno, and also mention STRING 1372 as the file name for which the error was encountered. 1373 Then return to command level. */ 1374 1375 void 1376 perror_with_name (const char *string) 1377 { 1378 char *err; 1379 char *combined; 1380 1381 err = safe_strerror (errno); 1382 combined = (char *) alloca (strlen (err) + strlen (string) + 3); 1383 strcpy (combined, string); 1384 strcat (combined, ": "); 1385 strcat (combined, err); 1386 1387 /* I understand setting these is a matter of taste. Still, some people 1388 may clear errno but not know about bfd_error. Doing this here is not 1389 unreasonable. */ 1390 bfd_set_error (bfd_error_no_error); 1391 errno = 0; 1392 1393 error (_("%s."), combined); 1394 } 1395 1396 /* Print the system error message for ERRCODE, and also mention STRING 1397 as the file name for which the error was encountered. */ 1398 1399 void 1400 print_sys_errmsg (const char *string, int errcode) 1401 { 1402 char *err; 1403 char *combined; 1404 1405 err = safe_strerror (errcode); 1406 combined = (char *) alloca (strlen (err) + strlen (string) + 3); 1407 strcpy (combined, string); 1408 strcat (combined, ": "); 1409 strcat (combined, err); 1410 1411 /* We want anything which was printed on stdout to come out first, before 1412 this message. */ 1413 gdb_flush (gdb_stdout); 1414 fprintf_unfiltered (gdb_stderr, "%s.\n", combined); 1415 } 1416 1417 /* Control C eventually causes this to be called, at a convenient time. */ 1418 1419 void 1420 quit (void) 1421 { 1422 #ifdef __MSDOS__ 1423 /* No steenking SIGINT will ever be coming our way when the 1424 program is resumed. Don't lie. */ 1425 fatal ("Quit"); 1426 #else 1427 if (job_control 1428 /* If there is no terminal switching for this target, then we can't 1429 possibly get screwed by the lack of job control. */ 1430 || current_target.to_terminal_ours == NULL) 1431 fatal ("Quit"); 1432 else 1433 fatal ("Quit (expect signal SIGINT when the program is resumed)"); 1434 #endif 1435 } 1436 1437 1438 /* Called when a memory allocation fails, with the number of bytes of 1439 memory requested in SIZE. */ 1440 1441 void 1442 nomem (long size) 1443 { 1444 if (size > 0) 1445 { 1446 internal_error (__FILE__, __LINE__, 1447 _("virtual memory exhausted: can't allocate %ld bytes."), 1448 size); 1449 } 1450 else 1451 { 1452 internal_error (__FILE__, __LINE__, _("virtual memory exhausted.")); 1453 } 1454 } 1455 1456 /* The xmalloc() (libiberty.h) family of memory management routines. 1457 1458 These are like the ISO-C malloc() family except that they implement 1459 consistent semantics and guard against typical memory management 1460 problems. */ 1461 1462 /* NOTE: These are declared using PTR to ensure consistency with 1463 "libiberty.h". xfree() is GDB local. */ 1464 1465 PTR /* ARI: PTR */ 1466 xmalloc (size_t size) 1467 { 1468 void *val; 1469 1470 /* See libiberty/xmalloc.c. This function need's to match that's 1471 semantics. It never returns NULL. */ 1472 if (size == 0) 1473 size = 1; 1474 1475 val = malloc (size); /* ARI: malloc */ 1476 if (val == NULL) 1477 nomem (size); 1478 1479 return (val); 1480 } 1481 1482 void * 1483 xzalloc (size_t size) 1484 { 1485 return xcalloc (1, size); 1486 } 1487 1488 PTR /* ARI: PTR */ 1489 xrealloc (PTR ptr, size_t size) /* ARI: PTR */ 1490 { 1491 void *val; 1492 1493 /* See libiberty/xmalloc.c. This function need's to match that's 1494 semantics. It never returns NULL. */ 1495 if (size == 0) 1496 size = 1; 1497 1498 if (ptr != NULL) 1499 val = realloc (ptr, size); /* ARI: realloc */ 1500 else 1501 val = malloc (size); /* ARI: malloc */ 1502 if (val == NULL) 1503 nomem (size); 1504 1505 return (val); 1506 } 1507 1508 PTR /* ARI: PTR */ 1509 xcalloc (size_t number, size_t size) 1510 { 1511 void *mem; 1512 1513 /* See libiberty/xmalloc.c. This function need's to match that's 1514 semantics. It never returns NULL. */ 1515 if (number == 0 || size == 0) 1516 { 1517 number = 1; 1518 size = 1; 1519 } 1520 1521 mem = calloc (number, size); /* ARI: xcalloc */ 1522 if (mem == NULL) 1523 nomem (number * size); 1524 1525 return mem; 1526 } 1527 1528 void 1529 xfree (void *ptr) 1530 { 1531 if (ptr != NULL) 1532 free (ptr); /* ARI: free */ 1533 } 1534 1535 1536 /* Like asprintf/vasprintf but get an internal_error if the call 1537 fails. */ 1538 1539 char * 1540 xstrprintf (const char *format, ...) 1541 { 1542 char *ret; 1543 va_list args; 1544 1545 va_start (args, format); 1546 ret = xstrvprintf (format, args); 1547 va_end (args); 1548 return ret; 1549 } 1550 1551 void 1552 xasprintf (char **ret, const char *format, ...) 1553 { 1554 va_list args; 1555 1556 va_start (args, format); 1557 (*ret) = xstrvprintf (format, args); 1558 va_end (args); 1559 } 1560 1561 void 1562 xvasprintf (char **ret, const char *format, va_list ap) 1563 { 1564 (*ret) = xstrvprintf (format, ap); 1565 } 1566 1567 char * 1568 xstrvprintf (const char *format, va_list ap) 1569 { 1570 char *ret = NULL; 1571 int status = vasprintf (&ret, format, ap); 1572 1573 /* NULL is returned when there was a memory allocation problem, or 1574 any other error (for instance, a bad format string). A negative 1575 status (the printed length) with a non-NULL buffer should never 1576 happen, but just to be sure. */ 1577 if (ret == NULL || status < 0) 1578 internal_error (__FILE__, __LINE__, _("vasprintf call failed")); 1579 return ret; 1580 } 1581 1582 int 1583 xsnprintf (char *str, size_t size, const char *format, ...) 1584 { 1585 va_list args; 1586 int ret; 1587 1588 va_start (args, format); 1589 ret = vsnprintf (str, size, format, args); 1590 gdb_assert (ret < size); 1591 va_end (args); 1592 1593 return ret; 1594 } 1595 1596 /* My replacement for the read system call. 1597 Used like `read' but keeps going if `read' returns too soon. */ 1598 1599 int 1600 myread (int desc, char *addr, int len) 1601 { 1602 int val; 1603 int orglen = len; 1604 1605 while (len > 0) 1606 { 1607 val = read (desc, addr, len); 1608 if (val < 0) 1609 return val; 1610 if (val == 0) 1611 return orglen - len; 1612 len -= val; 1613 addr += val; 1614 } 1615 return orglen; 1616 } 1617 1618 /* Make a copy of the string at PTR with SIZE characters 1619 (and add a null character at the end in the copy). 1620 Uses malloc to get the space. Returns the address of the copy. */ 1621 1622 char * 1623 savestring (const char *ptr, size_t size) 1624 { 1625 char *p = (char *) xmalloc (size + 1); 1626 1627 memcpy (p, ptr, size); 1628 p[size] = 0; 1629 return p; 1630 } 1631 1632 void 1633 print_spaces (int n, struct ui_file *file) 1634 { 1635 fputs_unfiltered (n_spaces (n), file); 1636 } 1637 1638 /* Print a host address. */ 1639 1640 void 1641 gdb_print_host_address (const void *addr, struct ui_file *stream) 1642 { 1643 fprintf_filtered (stream, "%s", host_address_to_string (addr)); 1644 } 1645 1646 1647 /* A cleanup function that calls regfree. */ 1648 1649 static void 1650 do_regfree_cleanup (void *r) 1651 { 1652 regfree (r); 1653 } 1654 1655 /* Create a new cleanup that frees the compiled regular expression R. */ 1656 1657 struct cleanup * 1658 make_regfree_cleanup (regex_t *r) 1659 { 1660 return make_cleanup (do_regfree_cleanup, r); 1661 } 1662 1663 /* Return an xmalloc'd error message resulting from a regular 1664 expression compilation failure. */ 1665 1666 char * 1667 get_regcomp_error (int code, regex_t *rx) 1668 { 1669 size_t length = regerror (code, rx, NULL, 0); 1670 char *result = xmalloc (length); 1671 1672 regerror (code, rx, result, length); 1673 return result; 1674 } 1675 1676 1677 1678 /* This function supports the query, nquery, and yquery functions. 1679 Ask user a y-or-n question and return 0 if answer is no, 1 if 1680 answer is yes, or default the answer to the specified default 1681 (for yquery or nquery). DEFCHAR may be 'y' or 'n' to provide a 1682 default answer, or '\0' for no default. 1683 CTLSTR is the control string and should end in "? ". It should 1684 not say how to answer, because we do that. 1685 ARGS are the arguments passed along with the CTLSTR argument to 1686 printf. */ 1687 1688 static int ATTRIBUTE_PRINTF (1, 0) 1689 defaulted_query (const char *ctlstr, const char defchar, va_list args) 1690 { 1691 int answer; 1692 int ans2; 1693 int retval; 1694 int def_value; 1695 char def_answer, not_def_answer; 1696 char *y_string, *n_string, *question; 1697 1698 /* Set up according to which answer is the default. */ 1699 if (defchar == '\0') 1700 { 1701 def_value = 1; 1702 def_answer = 'Y'; 1703 not_def_answer = 'N'; 1704 y_string = "y"; 1705 n_string = "n"; 1706 } 1707 else if (defchar == 'y') 1708 { 1709 def_value = 1; 1710 def_answer = 'Y'; 1711 not_def_answer = 'N'; 1712 y_string = "[y]"; 1713 n_string = "n"; 1714 } 1715 else 1716 { 1717 def_value = 0; 1718 def_answer = 'N'; 1719 not_def_answer = 'Y'; 1720 y_string = "y"; 1721 n_string = "[n]"; 1722 } 1723 1724 /* Automatically answer the default value if the user did not want 1725 prompts or the command was issued with the server prefix. */ 1726 if (! caution || server_command) 1727 return def_value; 1728 1729 /* If input isn't coming from the user directly, just say what 1730 question we're asking, and then answer the default automatically. This 1731 way, important error messages don't get lost when talking to GDB 1732 over a pipe. */ 1733 if (! input_from_terminal_p ()) 1734 { 1735 wrap_here (""); 1736 vfprintf_filtered (gdb_stdout, ctlstr, args); 1737 1738 printf_filtered (_("(%s or %s) [answered %c; " 1739 "input not from terminal]\n"), 1740 y_string, n_string, def_answer); 1741 gdb_flush (gdb_stdout); 1742 1743 return def_value; 1744 } 1745 1746 if (deprecated_query_hook) 1747 { 1748 return deprecated_query_hook (ctlstr, args); 1749 } 1750 1751 /* Format the question outside of the loop, to avoid reusing args. */ 1752 question = xstrvprintf (ctlstr, args); 1753 1754 while (1) 1755 { 1756 wrap_here (""); /* Flush any buffered output. */ 1757 gdb_flush (gdb_stdout); 1758 1759 if (annotation_level > 1) 1760 printf_filtered (("\n\032\032pre-query\n")); 1761 1762 fputs_filtered (question, gdb_stdout); 1763 printf_filtered (_("(%s or %s) "), y_string, n_string); 1764 1765 if (annotation_level > 1) 1766 printf_filtered (("\n\032\032query\n")); 1767 1768 wrap_here (""); 1769 gdb_flush (gdb_stdout); 1770 1771 answer = fgetc (stdin); 1772 1773 /* We expect fgetc to block until a character is read. But 1774 this may not be the case if the terminal was opened with 1775 the NONBLOCK flag. In that case, if there is nothing to 1776 read on stdin, fgetc returns EOF, but also sets the error 1777 condition flag on stdin and errno to EAGAIN. With a true 1778 EOF, stdin's error condition flag is not set. 1779 1780 A situation where this behavior was observed is a pseudo 1781 terminal on AIX. */ 1782 while (answer == EOF && ferror (stdin) && errno == EAGAIN) 1783 { 1784 /* Not a real EOF. Wait a little while and try again until 1785 we read something. */ 1786 clearerr (stdin); 1787 gdb_usleep (10000); 1788 answer = fgetc (stdin); 1789 } 1790 1791 clearerr (stdin); /* in case of C-d */ 1792 if (answer == EOF) /* C-d */ 1793 { 1794 printf_filtered ("EOF [assumed %c]\n", def_answer); 1795 retval = def_value; 1796 break; 1797 } 1798 /* Eat rest of input line, to EOF or newline. */ 1799 if (answer != '\n') 1800 do 1801 { 1802 ans2 = fgetc (stdin); 1803 clearerr (stdin); 1804 } 1805 while (ans2 != EOF && ans2 != '\n' && ans2 != '\r'); 1806 1807 if (answer >= 'a') 1808 answer -= 040; 1809 /* Check answer. For the non-default, the user must specify 1810 the non-default explicitly. */ 1811 if (answer == not_def_answer) 1812 { 1813 retval = !def_value; 1814 break; 1815 } 1816 /* Otherwise, if a default was specified, the user may either 1817 specify the required input or have it default by entering 1818 nothing. */ 1819 if (answer == def_answer 1820 || (defchar != '\0' && 1821 (answer == '\n' || answer == '\r' || answer == EOF))) 1822 { 1823 retval = def_value; 1824 break; 1825 } 1826 /* Invalid entries are not defaulted and require another selection. */ 1827 printf_filtered (_("Please answer %s or %s.\n"), 1828 y_string, n_string); 1829 } 1830 1831 xfree (question); 1832 if (annotation_level > 1) 1833 printf_filtered (("\n\032\032post-query\n")); 1834 return retval; 1835 } 1836 1837 1838 /* Ask user a y-or-n question and return 0 if answer is no, 1 if 1839 answer is yes, or 0 if answer is defaulted. 1840 Takes three args which are given to printf to print the question. 1841 The first, a control string, should end in "? ". 1842 It should not say how to answer, because we do that. */ 1843 1844 int 1845 nquery (const char *ctlstr, ...) 1846 { 1847 va_list args; 1848 int ret; 1849 1850 va_start (args, ctlstr); 1851 ret = defaulted_query (ctlstr, 'n', args); 1852 va_end (args); 1853 return ret; 1854 } 1855 1856 /* Ask user a y-or-n question and return 0 if answer is no, 1 if 1857 answer is yes, or 1 if answer is defaulted. 1858 Takes three args which are given to printf to print the question. 1859 The first, a control string, should end in "? ". 1860 It should not say how to answer, because we do that. */ 1861 1862 int 1863 yquery (const char *ctlstr, ...) 1864 { 1865 va_list args; 1866 int ret; 1867 1868 va_start (args, ctlstr); 1869 ret = defaulted_query (ctlstr, 'y', args); 1870 va_end (args); 1871 return ret; 1872 } 1873 1874 /* Ask user a y-or-n question and return 1 iff answer is yes. 1875 Takes three args which are given to printf to print the question. 1876 The first, a control string, should end in "? ". 1877 It should not say how to answer, because we do that. */ 1878 1879 int 1880 query (const char *ctlstr, ...) 1881 { 1882 va_list args; 1883 int ret; 1884 1885 va_start (args, ctlstr); 1886 ret = defaulted_query (ctlstr, '\0', args); 1887 va_end (args); 1888 return ret; 1889 } 1890 1891 /* A helper for parse_escape that converts a host character to a 1892 target character. C is the host character. If conversion is 1893 possible, then the target character is stored in *TARGET_C and the 1894 function returns 1. Otherwise, the function returns 0. */ 1895 1896 static int 1897 host_char_to_target (struct gdbarch *gdbarch, int c, int *target_c) 1898 { 1899 struct obstack host_data; 1900 char the_char = c; 1901 struct cleanup *cleanups; 1902 int result = 0; 1903 1904 obstack_init (&host_data); 1905 cleanups = make_cleanup_obstack_free (&host_data); 1906 1907 convert_between_encodings (target_charset (gdbarch), host_charset (), 1908 &the_char, 1, 1, &host_data, translit_none); 1909 1910 if (obstack_object_size (&host_data) == 1) 1911 { 1912 result = 1; 1913 *target_c = *(char *) obstack_base (&host_data); 1914 } 1915 1916 do_cleanups (cleanups); 1917 return result; 1918 } 1919 1920 /* Parse a C escape sequence. STRING_PTR points to a variable 1921 containing a pointer to the string to parse. That pointer 1922 should point to the character after the \. That pointer 1923 is updated past the characters we use. The value of the 1924 escape sequence is returned. 1925 1926 A negative value means the sequence \ newline was seen, 1927 which is supposed to be equivalent to nothing at all. 1928 1929 If \ is followed by a null character, we return a negative 1930 value and leave the string pointer pointing at the null character. 1931 1932 If \ is followed by 000, we return 0 and leave the string pointer 1933 after the zeros. A value of 0 does not mean end of string. */ 1934 1935 int 1936 parse_escape (struct gdbarch *gdbarch, char **string_ptr) 1937 { 1938 int target_char = -2; /* Initialize to avoid GCC warnings. */ 1939 int c = *(*string_ptr)++; 1940 1941 switch (c) 1942 { 1943 case '\n': 1944 return -2; 1945 case 0: 1946 (*string_ptr)--; 1947 return 0; 1948 1949 case '0': 1950 case '1': 1951 case '2': 1952 case '3': 1953 case '4': 1954 case '5': 1955 case '6': 1956 case '7': 1957 { 1958 int i = host_hex_value (c); 1959 int count = 0; 1960 while (++count < 3) 1961 { 1962 c = (**string_ptr); 1963 if (isdigit (c) && c != '8' && c != '9') 1964 { 1965 (*string_ptr)++; 1966 i *= 8; 1967 i += host_hex_value (c); 1968 } 1969 else 1970 { 1971 break; 1972 } 1973 } 1974 return i; 1975 } 1976 1977 case 'a': 1978 c = '\a'; 1979 break; 1980 case 'b': 1981 c = '\b'; 1982 break; 1983 case 'f': 1984 c = '\f'; 1985 break; 1986 case 'n': 1987 c = '\n'; 1988 break; 1989 case 'r': 1990 c = '\r'; 1991 break; 1992 case 't': 1993 c = '\t'; 1994 break; 1995 case 'v': 1996 c = '\v'; 1997 break; 1998 1999 default: 2000 break; 2001 } 2002 2003 if (!host_char_to_target (gdbarch, c, &target_char)) 2004 error (_("The escape sequence `\\%c' is equivalent to plain `%c'," 2005 " which has no equivalent\nin the `%s' character set."), 2006 c, c, target_charset (gdbarch)); 2007 return target_char; 2008 } 2009 2010 /* Print the character C on STREAM as part of the contents of a literal 2011 string whose delimiter is QUOTER. Note that this routine should only 2012 be call for printing things which are independent of the language 2013 of the program being debugged. */ 2014 2015 static void 2016 printchar (int c, void (*do_fputs) (const char *, struct ui_file *), 2017 void (*do_fprintf) (struct ui_file *, const char *, ...) 2018 ATTRIBUTE_FPTR_PRINTF_2, struct ui_file *stream, int quoter) 2019 { 2020 c &= 0xFF; /* Avoid sign bit follies */ 2021 2022 if (c < 0x20 || /* Low control chars */ 2023 (c >= 0x7F && c < 0xA0) || /* DEL, High controls */ 2024 (sevenbit_strings && c >= 0x80)) 2025 { /* high order bit set */ 2026 switch (c) 2027 { 2028 case '\n': 2029 do_fputs ("\\n", stream); 2030 break; 2031 case '\b': 2032 do_fputs ("\\b", stream); 2033 break; 2034 case '\t': 2035 do_fputs ("\\t", stream); 2036 break; 2037 case '\f': 2038 do_fputs ("\\f", stream); 2039 break; 2040 case '\r': 2041 do_fputs ("\\r", stream); 2042 break; 2043 case '\033': 2044 do_fputs ("\\e", stream); 2045 break; 2046 case '\007': 2047 do_fputs ("\\a", stream); 2048 break; 2049 default: 2050 do_fprintf (stream, "\\%.3o", (unsigned int) c); 2051 break; 2052 } 2053 } 2054 else 2055 { 2056 if (c == '\\' || c == quoter) 2057 do_fputs ("\\", stream); 2058 do_fprintf (stream, "%c", c); 2059 } 2060 } 2061 2062 /* Print the character C on STREAM as part of the contents of a 2063 literal string whose delimiter is QUOTER. Note that these routines 2064 should only be call for printing things which are independent of 2065 the language of the program being debugged. */ 2066 2067 void 2068 fputstr_filtered (const char *str, int quoter, struct ui_file *stream) 2069 { 2070 while (*str) 2071 printchar (*str++, fputs_filtered, fprintf_filtered, stream, quoter); 2072 } 2073 2074 void 2075 fputstr_unfiltered (const char *str, int quoter, struct ui_file *stream) 2076 { 2077 while (*str) 2078 printchar (*str++, fputs_unfiltered, fprintf_unfiltered, stream, quoter); 2079 } 2080 2081 void 2082 fputstrn_filtered (const char *str, int n, int quoter, 2083 struct ui_file *stream) 2084 { 2085 int i; 2086 2087 for (i = 0; i < n; i++) 2088 printchar (str[i], fputs_filtered, fprintf_filtered, stream, quoter); 2089 } 2090 2091 void 2092 fputstrn_unfiltered (const char *str, int n, int quoter, 2093 struct ui_file *stream) 2094 { 2095 int i; 2096 2097 for (i = 0; i < n; i++) 2098 printchar (str[i], fputs_unfiltered, fprintf_unfiltered, stream, quoter); 2099 } 2100 2101 2102 /* Number of lines per page or UINT_MAX if paging is disabled. */ 2103 static unsigned int lines_per_page; 2104 static void 2105 show_lines_per_page (struct ui_file *file, int from_tty, 2106 struct cmd_list_element *c, const char *value) 2107 { 2108 fprintf_filtered (file, 2109 _("Number of lines gdb thinks are in a page is %s.\n"), 2110 value); 2111 } 2112 2113 /* Number of chars per line or UINT_MAX if line folding is disabled. */ 2114 static unsigned int chars_per_line; 2115 static void 2116 show_chars_per_line (struct ui_file *file, int from_tty, 2117 struct cmd_list_element *c, const char *value) 2118 { 2119 fprintf_filtered (file, 2120 _("Number of characters gdb thinks " 2121 "are in a line is %s.\n"), 2122 value); 2123 } 2124 2125 /* Current count of lines printed on this page, chars on this line. */ 2126 static unsigned int lines_printed, chars_printed; 2127 2128 /* Buffer and start column of buffered text, for doing smarter word- 2129 wrapping. When someone calls wrap_here(), we start buffering output 2130 that comes through fputs_filtered(). If we see a newline, we just 2131 spit it out and forget about the wrap_here(). If we see another 2132 wrap_here(), we spit it out and remember the newer one. If we see 2133 the end of the line, we spit out a newline, the indent, and then 2134 the buffered output. */ 2135 2136 /* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which 2137 are waiting to be output (they have already been counted in chars_printed). 2138 When wrap_buffer[0] is null, the buffer is empty. */ 2139 static char *wrap_buffer; 2140 2141 /* Pointer in wrap_buffer to the next character to fill. */ 2142 static char *wrap_pointer; 2143 2144 /* String to indent by if the wrap occurs. Must not be NULL if wrap_column 2145 is non-zero. */ 2146 static char *wrap_indent; 2147 2148 /* Column number on the screen where wrap_buffer begins, or 0 if wrapping 2149 is not in effect. */ 2150 static int wrap_column; 2151 2152 2153 /* Inialize the number of lines per page and chars per line. */ 2154 2155 void 2156 init_page_info (void) 2157 { 2158 if (batch_flag) 2159 { 2160 lines_per_page = UINT_MAX; 2161 chars_per_line = UINT_MAX; 2162 } 2163 else 2164 #if defined(TUI) 2165 if (!tui_get_command_dimension (&chars_per_line, &lines_per_page)) 2166 #endif 2167 { 2168 int rows, cols; 2169 2170 #if defined(__GO32__) 2171 rows = ScreenRows (); 2172 cols = ScreenCols (); 2173 lines_per_page = rows; 2174 chars_per_line = cols; 2175 #else 2176 /* Make sure Readline has initialized its terminal settings. */ 2177 rl_reset_terminal (NULL); 2178 2179 /* Get the screen size from Readline. */ 2180 rl_get_screen_size (&rows, &cols); 2181 lines_per_page = rows; 2182 chars_per_line = cols; 2183 2184 /* Readline should have fetched the termcap entry for us. */ 2185 if (tgetnum ("li") < 0 || getenv ("EMACS")) 2186 { 2187 /* The number of lines per page is not mentioned in the 2188 terminal description. This probably means that paging is 2189 not useful (e.g. emacs shell window), so disable paging. */ 2190 lines_per_page = UINT_MAX; 2191 } 2192 2193 /* FIXME: Get rid of this junk. */ 2194 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER) 2195 SIGWINCH_HANDLER (SIGWINCH); 2196 #endif 2197 2198 /* If the output is not a terminal, don't paginate it. */ 2199 if (!ui_file_isatty (gdb_stdout)) 2200 lines_per_page = UINT_MAX; 2201 #endif 2202 } 2203 2204 set_screen_size (); 2205 set_width (); 2206 } 2207 2208 /* Helper for make_cleanup_restore_page_info. */ 2209 2210 static void 2211 do_restore_page_info_cleanup (void *arg) 2212 { 2213 set_screen_size (); 2214 set_width (); 2215 } 2216 2217 /* Provide cleanup for restoring the terminal size. */ 2218 2219 struct cleanup * 2220 make_cleanup_restore_page_info (void) 2221 { 2222 struct cleanup *back_to; 2223 2224 back_to = make_cleanup (do_restore_page_info_cleanup, NULL); 2225 make_cleanup_restore_uinteger (&lines_per_page); 2226 make_cleanup_restore_uinteger (&chars_per_line); 2227 2228 return back_to; 2229 } 2230 2231 /* Temporarily set BATCH_FLAG and the associated unlimited terminal size. 2232 Provide cleanup for restoring the original state. */ 2233 2234 struct cleanup * 2235 set_batch_flag_and_make_cleanup_restore_page_info (void) 2236 { 2237 struct cleanup *back_to = make_cleanup_restore_page_info (); 2238 2239 make_cleanup_restore_integer (&batch_flag); 2240 batch_flag = 1; 2241 init_page_info (); 2242 2243 return back_to; 2244 } 2245 2246 /* Set the screen size based on LINES_PER_PAGE and CHARS_PER_LINE. */ 2247 2248 static void 2249 set_screen_size (void) 2250 { 2251 int rows = lines_per_page; 2252 int cols = chars_per_line; 2253 2254 if (rows <= 0) 2255 rows = INT_MAX; 2256 2257 if (cols <= 0) 2258 cols = INT_MAX; 2259 2260 /* Update Readline's idea of the terminal size. */ 2261 rl_set_screen_size (rows, cols); 2262 } 2263 2264 /* Reinitialize WRAP_BUFFER according to the current value of 2265 CHARS_PER_LINE. */ 2266 2267 static void 2268 set_width (void) 2269 { 2270 if (chars_per_line == 0) 2271 init_page_info (); 2272 2273 if (!wrap_buffer) 2274 { 2275 wrap_buffer = (char *) xmalloc (chars_per_line + 2); 2276 wrap_buffer[0] = '\0'; 2277 } 2278 else 2279 wrap_buffer = (char *) xrealloc (wrap_buffer, chars_per_line + 2); 2280 wrap_pointer = wrap_buffer; /* Start it at the beginning. */ 2281 } 2282 2283 static void 2284 set_width_command (char *args, int from_tty, struct cmd_list_element *c) 2285 { 2286 set_screen_size (); 2287 set_width (); 2288 } 2289 2290 static void 2291 set_height_command (char *args, int from_tty, struct cmd_list_element *c) 2292 { 2293 set_screen_size (); 2294 } 2295 2296 /* Wait, so the user can read what's on the screen. Prompt the user 2297 to continue by pressing RETURN. */ 2298 2299 static void 2300 prompt_for_continue (void) 2301 { 2302 char *ignore; 2303 char cont_prompt[120]; 2304 2305 if (annotation_level > 1) 2306 printf_unfiltered (("\n\032\032pre-prompt-for-continue\n")); 2307 2308 strcpy (cont_prompt, 2309 "---Type <return> to continue, or q <return> to quit---"); 2310 if (annotation_level > 1) 2311 strcat (cont_prompt, "\n\032\032prompt-for-continue\n"); 2312 2313 /* We must do this *before* we call gdb_readline, else it will eventually 2314 call us -- thinking that we're trying to print beyond the end of the 2315 screen. */ 2316 reinitialize_more_filter (); 2317 2318 immediate_quit++; 2319 /* On a real operating system, the user can quit with SIGINT. 2320 But not on GO32. 2321 2322 'q' is provided on all systems so users don't have to change habits 2323 from system to system, and because telling them what to do in 2324 the prompt is more user-friendly than expecting them to think of 2325 SIGINT. */ 2326 /* Call readline, not gdb_readline, because GO32 readline handles control-C 2327 whereas control-C to gdb_readline will cause the user to get dumped 2328 out to DOS. */ 2329 ignore = gdb_readline_wrapper (cont_prompt); 2330 2331 if (annotation_level > 1) 2332 printf_unfiltered (("\n\032\032post-prompt-for-continue\n")); 2333 2334 if (ignore) 2335 { 2336 char *p = ignore; 2337 2338 while (*p == ' ' || *p == '\t') 2339 ++p; 2340 if (p[0] == 'q') 2341 async_request_quit (0); 2342 xfree (ignore); 2343 } 2344 immediate_quit--; 2345 2346 /* Now we have to do this again, so that GDB will know that it doesn't 2347 need to save the ---Type <return>--- line at the top of the screen. */ 2348 reinitialize_more_filter (); 2349 2350 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */ 2351 } 2352 2353 /* Reinitialize filter; ie. tell it to reset to original values. */ 2354 2355 void 2356 reinitialize_more_filter (void) 2357 { 2358 lines_printed = 0; 2359 chars_printed = 0; 2360 } 2361 2362 /* Indicate that if the next sequence of characters overflows the line, 2363 a newline should be inserted here rather than when it hits the end. 2364 If INDENT is non-null, it is a string to be printed to indent the 2365 wrapped part on the next line. INDENT must remain accessible until 2366 the next call to wrap_here() or until a newline is printed through 2367 fputs_filtered(). 2368 2369 If the line is already overfull, we immediately print a newline and 2370 the indentation, and disable further wrapping. 2371 2372 If we don't know the width of lines, but we know the page height, 2373 we must not wrap words, but should still keep track of newlines 2374 that were explicitly printed. 2375 2376 INDENT should not contain tabs, as that will mess up the char count 2377 on the next line. FIXME. 2378 2379 This routine is guaranteed to force out any output which has been 2380 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be 2381 used to force out output from the wrap_buffer. */ 2382 2383 void 2384 wrap_here (char *indent) 2385 { 2386 /* This should have been allocated, but be paranoid anyway. */ 2387 if (!wrap_buffer) 2388 internal_error (__FILE__, __LINE__, 2389 _("failed internal consistency check")); 2390 2391 if (wrap_buffer[0]) 2392 { 2393 *wrap_pointer = '\0'; 2394 fputs_unfiltered (wrap_buffer, gdb_stdout); 2395 } 2396 wrap_pointer = wrap_buffer; 2397 wrap_buffer[0] = '\0'; 2398 if (chars_per_line == UINT_MAX) /* No line overflow checking. */ 2399 { 2400 wrap_column = 0; 2401 } 2402 else if (chars_printed >= chars_per_line) 2403 { 2404 puts_filtered ("\n"); 2405 if (indent != NULL) 2406 puts_filtered (indent); 2407 wrap_column = 0; 2408 } 2409 else 2410 { 2411 wrap_column = chars_printed; 2412 if (indent == NULL) 2413 wrap_indent = ""; 2414 else 2415 wrap_indent = indent; 2416 } 2417 } 2418 2419 /* Print input string to gdb_stdout, filtered, with wrap, 2420 arranging strings in columns of n chars. String can be 2421 right or left justified in the column. Never prints 2422 trailing spaces. String should never be longer than 2423 width. FIXME: this could be useful for the EXAMINE 2424 command, which currently doesn't tabulate very well. */ 2425 2426 void 2427 puts_filtered_tabular (char *string, int width, int right) 2428 { 2429 int spaces = 0; 2430 int stringlen; 2431 char *spacebuf; 2432 2433 gdb_assert (chars_per_line > 0); 2434 if (chars_per_line == UINT_MAX) 2435 { 2436 fputs_filtered (string, gdb_stdout); 2437 fputs_filtered ("\n", gdb_stdout); 2438 return; 2439 } 2440 2441 if (((chars_printed - 1) / width + 2) * width >= chars_per_line) 2442 fputs_filtered ("\n", gdb_stdout); 2443 2444 if (width >= chars_per_line) 2445 width = chars_per_line - 1; 2446 2447 stringlen = strlen (string); 2448 2449 if (chars_printed > 0) 2450 spaces = width - (chars_printed - 1) % width - 1; 2451 if (right) 2452 spaces += width - stringlen; 2453 2454 spacebuf = alloca (spaces + 1); 2455 spacebuf[spaces] = '\0'; 2456 while (spaces--) 2457 spacebuf[spaces] = ' '; 2458 2459 fputs_filtered (spacebuf, gdb_stdout); 2460 fputs_filtered (string, gdb_stdout); 2461 } 2462 2463 2464 /* Ensure that whatever gets printed next, using the filtered output 2465 commands, starts at the beginning of the line. I.e. if there is 2466 any pending output for the current line, flush it and start a new 2467 line. Otherwise do nothing. */ 2468 2469 void 2470 begin_line (void) 2471 { 2472 if (chars_printed > 0) 2473 { 2474 puts_filtered ("\n"); 2475 } 2476 } 2477 2478 2479 /* Like fputs but if FILTER is true, pause after every screenful. 2480 2481 Regardless of FILTER can wrap at points other than the final 2482 character of a line. 2483 2484 Unlike fputs, fputs_maybe_filtered does not return a value. 2485 It is OK for LINEBUFFER to be NULL, in which case just don't print 2486 anything. 2487 2488 Note that a longjmp to top level may occur in this routine (only if 2489 FILTER is true) (since prompt_for_continue may do so) so this 2490 routine should not be called when cleanups are not in place. */ 2491 2492 static void 2493 fputs_maybe_filtered (const char *linebuffer, struct ui_file *stream, 2494 int filter) 2495 { 2496 const char *lineptr; 2497 2498 if (linebuffer == 0) 2499 return; 2500 2501 /* Don't do any filtering if it is disabled. */ 2502 if (stream != gdb_stdout 2503 || ! pagination_enabled 2504 || ! input_from_terminal_p () 2505 || (lines_per_page == UINT_MAX && chars_per_line == UINT_MAX) 2506 || top_level_interpreter () == NULL 2507 || ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))) 2508 { 2509 fputs_unfiltered (linebuffer, stream); 2510 return; 2511 } 2512 2513 /* Go through and output each character. Show line extension 2514 when this is necessary; prompt user for new page when this is 2515 necessary. */ 2516 2517 lineptr = linebuffer; 2518 while (*lineptr) 2519 { 2520 /* Possible new page. */ 2521 if (filter && (lines_printed >= lines_per_page - 1)) 2522 prompt_for_continue (); 2523 2524 while (*lineptr && *lineptr != '\n') 2525 { 2526 /* Print a single line. */ 2527 if (*lineptr == '\t') 2528 { 2529 if (wrap_column) 2530 *wrap_pointer++ = '\t'; 2531 else 2532 fputc_unfiltered ('\t', stream); 2533 /* Shifting right by 3 produces the number of tab stops 2534 we have already passed, and then adding one and 2535 shifting left 3 advances to the next tab stop. */ 2536 chars_printed = ((chars_printed >> 3) + 1) << 3; 2537 lineptr++; 2538 } 2539 else 2540 { 2541 if (wrap_column) 2542 *wrap_pointer++ = *lineptr; 2543 else 2544 fputc_unfiltered (*lineptr, stream); 2545 chars_printed++; 2546 lineptr++; 2547 } 2548 2549 if (chars_printed >= chars_per_line) 2550 { 2551 unsigned int save_chars = chars_printed; 2552 2553 chars_printed = 0; 2554 lines_printed++; 2555 /* If we aren't actually wrapping, don't output newline -- 2556 if chars_per_line is right, we probably just overflowed 2557 anyway; if it's wrong, let us keep going. */ 2558 if (wrap_column) 2559 fputc_unfiltered ('\n', stream); 2560 2561 /* Possible new page. */ 2562 if (lines_printed >= lines_per_page - 1) 2563 prompt_for_continue (); 2564 2565 /* Now output indentation and wrapped string. */ 2566 if (wrap_column) 2567 { 2568 fputs_unfiltered (wrap_indent, stream); 2569 *wrap_pointer = '\0'; /* Null-terminate saved stuff, */ 2570 fputs_unfiltered (wrap_buffer, stream); /* and eject it. */ 2571 /* FIXME, this strlen is what prevents wrap_indent from 2572 containing tabs. However, if we recurse to print it 2573 and count its chars, we risk trouble if wrap_indent is 2574 longer than (the user settable) chars_per_line. 2575 Note also that this can set chars_printed > chars_per_line 2576 if we are printing a long string. */ 2577 chars_printed = strlen (wrap_indent) 2578 + (save_chars - wrap_column); 2579 wrap_pointer = wrap_buffer; /* Reset buffer */ 2580 wrap_buffer[0] = '\0'; 2581 wrap_column = 0; /* And disable fancy wrap */ 2582 } 2583 } 2584 } 2585 2586 if (*lineptr == '\n') 2587 { 2588 chars_printed = 0; 2589 wrap_here ((char *) 0); /* Spit out chars, cancel 2590 further wraps. */ 2591 lines_printed++; 2592 fputc_unfiltered ('\n', stream); 2593 lineptr++; 2594 } 2595 } 2596 } 2597 2598 void 2599 fputs_filtered (const char *linebuffer, struct ui_file *stream) 2600 { 2601 fputs_maybe_filtered (linebuffer, stream, 1); 2602 } 2603 2604 int 2605 putchar_unfiltered (int c) 2606 { 2607 char buf = c; 2608 2609 ui_file_write (gdb_stdout, &buf, 1); 2610 return c; 2611 } 2612 2613 /* Write character C to gdb_stdout using GDB's paging mechanism and return C. 2614 May return nonlocally. */ 2615 2616 int 2617 putchar_filtered (int c) 2618 { 2619 return fputc_filtered (c, gdb_stdout); 2620 } 2621 2622 int 2623 fputc_unfiltered (int c, struct ui_file *stream) 2624 { 2625 char buf = c; 2626 2627 ui_file_write (stream, &buf, 1); 2628 return c; 2629 } 2630 2631 int 2632 fputc_filtered (int c, struct ui_file *stream) 2633 { 2634 char buf[2]; 2635 2636 buf[0] = c; 2637 buf[1] = 0; 2638 fputs_filtered (buf, stream); 2639 return c; 2640 } 2641 2642 /* puts_debug is like fputs_unfiltered, except it prints special 2643 characters in printable fashion. */ 2644 2645 void 2646 puts_debug (char *prefix, char *string, char *suffix) 2647 { 2648 int ch; 2649 2650 /* Print prefix and suffix after each line. */ 2651 static int new_line = 1; 2652 static int return_p = 0; 2653 static char *prev_prefix = ""; 2654 static char *prev_suffix = ""; 2655 2656 if (*string == '\n') 2657 return_p = 0; 2658 2659 /* If the prefix is changing, print the previous suffix, a new line, 2660 and the new prefix. */ 2661 if ((return_p || (strcmp (prev_prefix, prefix) != 0)) && !new_line) 2662 { 2663 fputs_unfiltered (prev_suffix, gdb_stdlog); 2664 fputs_unfiltered ("\n", gdb_stdlog); 2665 fputs_unfiltered (prefix, gdb_stdlog); 2666 } 2667 2668 /* Print prefix if we printed a newline during the previous call. */ 2669 if (new_line) 2670 { 2671 new_line = 0; 2672 fputs_unfiltered (prefix, gdb_stdlog); 2673 } 2674 2675 prev_prefix = prefix; 2676 prev_suffix = suffix; 2677 2678 /* Output characters in a printable format. */ 2679 while ((ch = *string++) != '\0') 2680 { 2681 switch (ch) 2682 { 2683 default: 2684 if (isprint (ch)) 2685 fputc_unfiltered (ch, gdb_stdlog); 2686 2687 else 2688 fprintf_unfiltered (gdb_stdlog, "\\x%02x", ch & 0xff); 2689 break; 2690 2691 case '\\': 2692 fputs_unfiltered ("\\\\", gdb_stdlog); 2693 break; 2694 case '\b': 2695 fputs_unfiltered ("\\b", gdb_stdlog); 2696 break; 2697 case '\f': 2698 fputs_unfiltered ("\\f", gdb_stdlog); 2699 break; 2700 case '\n': 2701 new_line = 1; 2702 fputs_unfiltered ("\\n", gdb_stdlog); 2703 break; 2704 case '\r': 2705 fputs_unfiltered ("\\r", gdb_stdlog); 2706 break; 2707 case '\t': 2708 fputs_unfiltered ("\\t", gdb_stdlog); 2709 break; 2710 case '\v': 2711 fputs_unfiltered ("\\v", gdb_stdlog); 2712 break; 2713 } 2714 2715 return_p = ch == '\r'; 2716 } 2717 2718 /* Print suffix if we printed a newline. */ 2719 if (new_line) 2720 { 2721 fputs_unfiltered (suffix, gdb_stdlog); 2722 fputs_unfiltered ("\n", gdb_stdlog); 2723 } 2724 } 2725 2726 2727 /* Print a variable number of ARGS using format FORMAT. If this 2728 information is going to put the amount written (since the last call 2729 to REINITIALIZE_MORE_FILTER or the last page break) over the page size, 2730 call prompt_for_continue to get the users permision to continue. 2731 2732 Unlike fprintf, this function does not return a value. 2733 2734 We implement three variants, vfprintf (takes a vararg list and stream), 2735 fprintf (takes a stream to write on), and printf (the usual). 2736 2737 Note also that a longjmp to top level may occur in this routine 2738 (since prompt_for_continue may do so) so this routine should not be 2739 called when cleanups are not in place. */ 2740 2741 static void 2742 vfprintf_maybe_filtered (struct ui_file *stream, const char *format, 2743 va_list args, int filter) 2744 { 2745 char *linebuffer; 2746 struct cleanup *old_cleanups; 2747 2748 linebuffer = xstrvprintf (format, args); 2749 old_cleanups = make_cleanup (xfree, linebuffer); 2750 fputs_maybe_filtered (linebuffer, stream, filter); 2751 do_cleanups (old_cleanups); 2752 } 2753 2754 2755 void 2756 vfprintf_filtered (struct ui_file *stream, const char *format, va_list args) 2757 { 2758 vfprintf_maybe_filtered (stream, format, args, 1); 2759 } 2760 2761 void 2762 vfprintf_unfiltered (struct ui_file *stream, const char *format, va_list args) 2763 { 2764 char *linebuffer; 2765 struct cleanup *old_cleanups; 2766 2767 linebuffer = xstrvprintf (format, args); 2768 old_cleanups = make_cleanup (xfree, linebuffer); 2769 if (debug_timestamp && stream == gdb_stdlog) 2770 { 2771 struct timeval tm; 2772 char *timestamp; 2773 int len, need_nl; 2774 2775 gettimeofday (&tm, NULL); 2776 2777 len = strlen (linebuffer); 2778 need_nl = (len > 0 && linebuffer[len - 1] != '\n'); 2779 2780 timestamp = xstrprintf ("%ld:%ld %s%s", 2781 (long) tm.tv_sec, (long) tm.tv_usec, 2782 linebuffer, 2783 need_nl ? "\n": ""); 2784 make_cleanup (xfree, timestamp); 2785 fputs_unfiltered (timestamp, stream); 2786 } 2787 else 2788 fputs_unfiltered (linebuffer, stream); 2789 do_cleanups (old_cleanups); 2790 } 2791 2792 void 2793 vprintf_filtered (const char *format, va_list args) 2794 { 2795 vfprintf_maybe_filtered (gdb_stdout, format, args, 1); 2796 } 2797 2798 void 2799 vprintf_unfiltered (const char *format, va_list args) 2800 { 2801 vfprintf_unfiltered (gdb_stdout, format, args); 2802 } 2803 2804 void 2805 fprintf_filtered (struct ui_file *stream, const char *format, ...) 2806 { 2807 va_list args; 2808 2809 va_start (args, format); 2810 vfprintf_filtered (stream, format, args); 2811 va_end (args); 2812 } 2813 2814 void 2815 fprintf_unfiltered (struct ui_file *stream, const char *format, ...) 2816 { 2817 va_list args; 2818 2819 va_start (args, format); 2820 vfprintf_unfiltered (stream, format, args); 2821 va_end (args); 2822 } 2823 2824 /* Like fprintf_filtered, but prints its result indented. 2825 Called as fprintfi_filtered (spaces, stream, format, ...); */ 2826 2827 void 2828 fprintfi_filtered (int spaces, struct ui_file *stream, const char *format, 2829 ...) 2830 { 2831 va_list args; 2832 2833 va_start (args, format); 2834 print_spaces_filtered (spaces, stream); 2835 2836 vfprintf_filtered (stream, format, args); 2837 va_end (args); 2838 } 2839 2840 2841 void 2842 printf_filtered (const char *format, ...) 2843 { 2844 va_list args; 2845 2846 va_start (args, format); 2847 vfprintf_filtered (gdb_stdout, format, args); 2848 va_end (args); 2849 } 2850 2851 2852 void 2853 printf_unfiltered (const char *format, ...) 2854 { 2855 va_list args; 2856 2857 va_start (args, format); 2858 vfprintf_unfiltered (gdb_stdout, format, args); 2859 va_end (args); 2860 } 2861 2862 /* Like printf_filtered, but prints it's result indented. 2863 Called as printfi_filtered (spaces, format, ...); */ 2864 2865 void 2866 printfi_filtered (int spaces, const char *format, ...) 2867 { 2868 va_list args; 2869 2870 va_start (args, format); 2871 print_spaces_filtered (spaces, gdb_stdout); 2872 vfprintf_filtered (gdb_stdout, format, args); 2873 va_end (args); 2874 } 2875 2876 /* Easy -- but watch out! 2877 2878 This routine is *not* a replacement for puts()! puts() appends a newline. 2879 This one doesn't, and had better not! */ 2880 2881 void 2882 puts_filtered (const char *string) 2883 { 2884 fputs_filtered (string, gdb_stdout); 2885 } 2886 2887 void 2888 puts_unfiltered (const char *string) 2889 { 2890 fputs_unfiltered (string, gdb_stdout); 2891 } 2892 2893 /* Return a pointer to N spaces and a null. The pointer is good 2894 until the next call to here. */ 2895 char * 2896 n_spaces (int n) 2897 { 2898 char *t; 2899 static char *spaces = 0; 2900 static int max_spaces = -1; 2901 2902 if (n > max_spaces) 2903 { 2904 if (spaces) 2905 xfree (spaces); 2906 spaces = (char *) xmalloc (n + 1); 2907 for (t = spaces + n; t != spaces;) 2908 *--t = ' '; 2909 spaces[n] = '\0'; 2910 max_spaces = n; 2911 } 2912 2913 return spaces + max_spaces - n; 2914 } 2915 2916 /* Print N spaces. */ 2917 void 2918 print_spaces_filtered (int n, struct ui_file *stream) 2919 { 2920 fputs_filtered (n_spaces (n), stream); 2921 } 2922 2923 /* C++/ObjC demangler stuff. */ 2924 2925 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language 2926 LANG, using demangling args ARG_MODE, and print it filtered to STREAM. 2927 If the name is not mangled, or the language for the name is unknown, or 2928 demangling is off, the name is printed in its "raw" form. */ 2929 2930 void 2931 fprintf_symbol_filtered (struct ui_file *stream, char *name, 2932 enum language lang, int arg_mode) 2933 { 2934 char *demangled; 2935 2936 if (name != NULL) 2937 { 2938 /* If user wants to see raw output, no problem. */ 2939 if (!demangle) 2940 { 2941 fputs_filtered (name, stream); 2942 } 2943 else 2944 { 2945 demangled = language_demangle (language_def (lang), name, arg_mode); 2946 fputs_filtered (demangled ? demangled : name, stream); 2947 if (demangled != NULL) 2948 { 2949 xfree (demangled); 2950 } 2951 } 2952 } 2953 } 2954 2955 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any 2956 differences in whitespace. Returns 0 if they match, non-zero if they 2957 don't (slightly different than strcmp()'s range of return values). 2958 2959 As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO". 2960 This "feature" is useful when searching for matching C++ function names 2961 (such as if the user types 'break FOO', where FOO is a mangled C++ 2962 function). */ 2963 2964 int 2965 strcmp_iw (const char *string1, const char *string2) 2966 { 2967 while ((*string1 != '\0') && (*string2 != '\0')) 2968 { 2969 while (isspace (*string1)) 2970 { 2971 string1++; 2972 } 2973 while (isspace (*string2)) 2974 { 2975 string2++; 2976 } 2977 if (*string1 != *string2) 2978 { 2979 break; 2980 } 2981 if (*string1 != '\0') 2982 { 2983 string1++; 2984 string2++; 2985 } 2986 } 2987 return (*string1 != '\0' && *string1 != '(') || (*string2 != '\0'); 2988 } 2989 2990 /* This is like strcmp except that it ignores whitespace and treats 2991 '(' as the first non-NULL character in terms of ordering. Like 2992 strcmp (and unlike strcmp_iw), it returns negative if STRING1 < 2993 STRING2, 0 if STRING2 = STRING2, and positive if STRING1 > STRING2 2994 according to that ordering. 2995 2996 If a list is sorted according to this function and if you want to 2997 find names in the list that match some fixed NAME according to 2998 strcmp_iw(LIST_ELT, NAME), then the place to start looking is right 2999 where this function would put NAME. 3000 3001 Here are some examples of why using strcmp to sort is a bad idea: 3002 3003 Whitespace example: 3004 3005 Say your partial symtab contains: "foo<char *>", "goo". Then, if 3006 we try to do a search for "foo<char*>", strcmp will locate this 3007 after "foo<char *>" and before "goo". Then lookup_partial_symbol 3008 will start looking at strings beginning with "goo", and will never 3009 see the correct match of "foo<char *>". 3010 3011 Parenthesis example: 3012 3013 In practice, this is less like to be an issue, but I'll give it a 3014 shot. Let's assume that '$' is a legitimate character to occur in 3015 symbols. (Which may well even be the case on some systems.) Then 3016 say that the partial symbol table contains "foo$" and "foo(int)". 3017 strcmp will put them in this order, since '$' < '('. Now, if the 3018 user searches for "foo", then strcmp will sort "foo" before "foo$". 3019 Then lookup_partial_symbol will notice that strcmp_iw("foo$", 3020 "foo") is false, so it won't proceed to the actual match of 3021 "foo(int)" with "foo". */ 3022 3023 int 3024 strcmp_iw_ordered (const char *string1, const char *string2) 3025 { 3026 while ((*string1 != '\0') && (*string2 != '\0')) 3027 { 3028 while (isspace (*string1)) 3029 { 3030 string1++; 3031 } 3032 while (isspace (*string2)) 3033 { 3034 string2++; 3035 } 3036 if (*string1 != *string2) 3037 { 3038 break; 3039 } 3040 if (*string1 != '\0') 3041 { 3042 string1++; 3043 string2++; 3044 } 3045 } 3046 3047 switch (*string1) 3048 { 3049 /* Characters are non-equal unless they're both '\0'; we want to 3050 make sure we get the comparison right according to our 3051 comparison in the cases where one of them is '\0' or '('. */ 3052 case '\0': 3053 if (*string2 == '\0') 3054 return 0; 3055 else 3056 return -1; 3057 case '(': 3058 if (*string2 == '\0') 3059 return 1; 3060 else 3061 return -1; 3062 default: 3063 if (*string2 == '(') 3064 return 1; 3065 else 3066 return *string1 - *string2; 3067 } 3068 } 3069 3070 /* A simple comparison function with opposite semantics to strcmp. */ 3071 3072 int 3073 streq (const char *lhs, const char *rhs) 3074 { 3075 return !strcmp (lhs, rhs); 3076 } 3077 3078 3079 /* 3080 ** subset_compare() 3081 ** Answer whether string_to_compare is a full or partial match to 3082 ** template_string. The partial match must be in sequence starting 3083 ** at index 0. 3084 */ 3085 int 3086 subset_compare (char *string_to_compare, char *template_string) 3087 { 3088 int match; 3089 3090 if (template_string != (char *) NULL && string_to_compare != (char *) NULL 3091 && strlen (string_to_compare) <= strlen (template_string)) 3092 match = 3093 (strncmp 3094 (template_string, string_to_compare, strlen (string_to_compare)) == 0); 3095 else 3096 match = 0; 3097 return match; 3098 } 3099 3100 static void 3101 pagination_on_command (char *arg, int from_tty) 3102 { 3103 pagination_enabled = 1; 3104 } 3105 3106 static void 3107 pagination_off_command (char *arg, int from_tty) 3108 { 3109 pagination_enabled = 0; 3110 } 3111 3112 static void 3113 show_debug_timestamp (struct ui_file *file, int from_tty, 3114 struct cmd_list_element *c, const char *value) 3115 { 3116 fprintf_filtered (file, _("Timestamping debugging messages is %s.\n"), 3117 value); 3118 } 3119 3120 3121 void 3122 initialize_utils (void) 3123 { 3124 add_setshow_uinteger_cmd ("width", class_support, &chars_per_line, _("\ 3125 Set number of characters gdb thinks are in a line."), _("\ 3126 Show number of characters gdb thinks are in a line."), NULL, 3127 set_width_command, 3128 show_chars_per_line, 3129 &setlist, &showlist); 3130 3131 add_setshow_uinteger_cmd ("height", class_support, &lines_per_page, _("\ 3132 Set number of lines gdb thinks are in a page."), _("\ 3133 Show number of lines gdb thinks are in a page."), NULL, 3134 set_height_command, 3135 show_lines_per_page, 3136 &setlist, &showlist); 3137 3138 init_page_info (); 3139 3140 add_setshow_boolean_cmd ("demangle", class_support, &demangle, _("\ 3141 Set demangling of encoded C++/ObjC names when displaying symbols."), _("\ 3142 Show demangling of encoded C++/ObjC names when displaying symbols."), NULL, 3143 NULL, 3144 show_demangle, 3145 &setprintlist, &showprintlist); 3146 3147 add_setshow_boolean_cmd ("pagination", class_support, 3148 &pagination_enabled, _("\ 3149 Set state of pagination."), _("\ 3150 Show state of pagination."), NULL, 3151 NULL, 3152 show_pagination_enabled, 3153 &setlist, &showlist); 3154 3155 if (xdb_commands) 3156 { 3157 add_com ("am", class_support, pagination_on_command, 3158 _("Enable pagination")); 3159 add_com ("sm", class_support, pagination_off_command, 3160 _("Disable pagination")); 3161 } 3162 3163 add_setshow_boolean_cmd ("sevenbit-strings", class_support, 3164 &sevenbit_strings, _("\ 3165 Set printing of 8-bit characters in strings as \\nnn."), _("\ 3166 Show printing of 8-bit characters in strings as \\nnn."), NULL, 3167 NULL, 3168 show_sevenbit_strings, 3169 &setprintlist, &showprintlist); 3170 3171 add_setshow_boolean_cmd ("asm-demangle", class_support, &asm_demangle, _("\ 3172 Set demangling of C++/ObjC names in disassembly listings."), _("\ 3173 Show demangling of C++/ObjC names in disassembly listings."), NULL, 3174 NULL, 3175 show_asm_demangle, 3176 &setprintlist, &showprintlist); 3177 3178 add_setshow_boolean_cmd ("timestamp", class_maintenance, 3179 &debug_timestamp, _("\ 3180 Set timestamping of debugging messages."), _("\ 3181 Show timestamping of debugging messages."), _("\ 3182 When set, debugging messages will be marked with seconds and microseconds."), 3183 NULL, 3184 show_debug_timestamp, 3185 &setdebuglist, &showdebuglist); 3186 } 3187 3188 /* Machine specific function to handle SIGWINCH signal. */ 3189 3190 #ifdef SIGWINCH_HANDLER_BODY 3191 SIGWINCH_HANDLER_BODY 3192 #endif 3193 /* Print routines to handle variable size regs, etc. */ 3194 /* Temporary storage using circular buffer. */ 3195 #define NUMCELLS 16 3196 #define CELLSIZE 50 3197 static char * 3198 get_cell (void) 3199 { 3200 static char buf[NUMCELLS][CELLSIZE]; 3201 static int cell = 0; 3202 3203 if (++cell >= NUMCELLS) 3204 cell = 0; 3205 return buf[cell]; 3206 } 3207 3208 const char * 3209 paddress (struct gdbarch *gdbarch, CORE_ADDR addr) 3210 { 3211 /* Truncate address to the size of a target address, avoiding shifts 3212 larger or equal than the width of a CORE_ADDR. The local 3213 variable ADDR_BIT stops the compiler reporting a shift overflow 3214 when it won't occur. */ 3215 /* NOTE: This assumes that the significant address information is 3216 kept in the least significant bits of ADDR - the upper bits were 3217 either zero or sign extended. Should gdbarch_address_to_pointer or 3218 some ADDRESS_TO_PRINTABLE() be used to do the conversion? */ 3219 3220 int addr_bit = gdbarch_addr_bit (gdbarch); 3221 3222 if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT)) 3223 addr &= ((CORE_ADDR) 1 << addr_bit) - 1; 3224 return hex_string (addr); 3225 } 3226 3227 /* This function is described in "defs.h". */ 3228 3229 const char * 3230 print_core_address (struct gdbarch *gdbarch, CORE_ADDR address) 3231 { 3232 int addr_bit = gdbarch_addr_bit (gdbarch); 3233 3234 if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT)) 3235 address &= ((CORE_ADDR) 1 << addr_bit) - 1; 3236 3237 /* FIXME: cagney/2002-05-03: Need local_address_string() function 3238 that returns the language localized string formatted to a width 3239 based on gdbarch_addr_bit. */ 3240 if (addr_bit <= 32) 3241 return hex_string_custom (address, 8); 3242 else 3243 return hex_string_custom (address, 16); 3244 } 3245 3246 static char * 3247 decimal2str (char *sign, ULONGEST addr, int width) 3248 { 3249 /* Steal code from valprint.c:print_decimal(). Should this worry 3250 about the real size of addr as the above does? */ 3251 unsigned long temp[3]; 3252 char *str = get_cell (); 3253 int i = 0; 3254 3255 do 3256 { 3257 temp[i] = addr % (1000 * 1000 * 1000); 3258 addr /= (1000 * 1000 * 1000); 3259 i++; 3260 width -= 9; 3261 } 3262 while (addr != 0 && i < (sizeof (temp) / sizeof (temp[0]))); 3263 3264 width += 9; 3265 if (width < 0) 3266 width = 0; 3267 3268 switch (i) 3269 { 3270 case 1: 3271 xsnprintf (str, CELLSIZE, "%s%0*lu", sign, width, temp[0]); 3272 break; 3273 case 2: 3274 xsnprintf (str, CELLSIZE, "%s%0*lu%09lu", sign, width, 3275 temp[1], temp[0]); 3276 break; 3277 case 3: 3278 xsnprintf (str, CELLSIZE, "%s%0*lu%09lu%09lu", sign, width, 3279 temp[2], temp[1], temp[0]); 3280 break; 3281 default: 3282 internal_error (__FILE__, __LINE__, 3283 _("failed internal consistency check")); 3284 } 3285 3286 return str; 3287 } 3288 3289 static char * 3290 octal2str (ULONGEST addr, int width) 3291 { 3292 unsigned long temp[3]; 3293 char *str = get_cell (); 3294 int i = 0; 3295 3296 do 3297 { 3298 temp[i] = addr % (0100000 * 0100000); 3299 addr /= (0100000 * 0100000); 3300 i++; 3301 width -= 10; 3302 } 3303 while (addr != 0 && i < (sizeof (temp) / sizeof (temp[0]))); 3304 3305 width += 10; 3306 if (width < 0) 3307 width = 0; 3308 3309 switch (i) 3310 { 3311 case 1: 3312 if (temp[0] == 0) 3313 xsnprintf (str, CELLSIZE, "%*o", width, 0); 3314 else 3315 xsnprintf (str, CELLSIZE, "0%0*lo", width, temp[0]); 3316 break; 3317 case 2: 3318 xsnprintf (str, CELLSIZE, "0%0*lo%010lo", width, temp[1], temp[0]); 3319 break; 3320 case 3: 3321 xsnprintf (str, CELLSIZE, "0%0*lo%010lo%010lo", width, 3322 temp[2], temp[1], temp[0]); 3323 break; 3324 default: 3325 internal_error (__FILE__, __LINE__, 3326 _("failed internal consistency check")); 3327 } 3328 3329 return str; 3330 } 3331 3332 char * 3333 pulongest (ULONGEST u) 3334 { 3335 return decimal2str ("", u, 0); 3336 } 3337 3338 char * 3339 plongest (LONGEST l) 3340 { 3341 if (l < 0) 3342 return decimal2str ("-", -l, 0); 3343 else 3344 return decimal2str ("", l, 0); 3345 } 3346 3347 /* Eliminate warning from compiler on 32-bit systems. */ 3348 static int thirty_two = 32; 3349 3350 char * 3351 phex (ULONGEST l, int sizeof_l) 3352 { 3353 char *str; 3354 3355 switch (sizeof_l) 3356 { 3357 case 8: 3358 str = get_cell (); 3359 xsnprintf (str, CELLSIZE, "%08lx%08lx", 3360 (unsigned long) (l >> thirty_two), 3361 (unsigned long) (l & 0xffffffff)); 3362 break; 3363 case 4: 3364 str = get_cell (); 3365 xsnprintf (str, CELLSIZE, "%08lx", (unsigned long) l); 3366 break; 3367 case 2: 3368 str = get_cell (); 3369 xsnprintf (str, CELLSIZE, "%04x", (unsigned short) (l & 0xffff)); 3370 break; 3371 default: 3372 str = phex (l, sizeof (l)); 3373 break; 3374 } 3375 3376 return str; 3377 } 3378 3379 char * 3380 phex_nz (ULONGEST l, int sizeof_l) 3381 { 3382 char *str; 3383 3384 switch (sizeof_l) 3385 { 3386 case 8: 3387 { 3388 unsigned long high = (unsigned long) (l >> thirty_two); 3389 3390 str = get_cell (); 3391 if (high == 0) 3392 xsnprintf (str, CELLSIZE, "%lx", 3393 (unsigned long) (l & 0xffffffff)); 3394 else 3395 xsnprintf (str, CELLSIZE, "%lx%08lx", high, 3396 (unsigned long) (l & 0xffffffff)); 3397 break; 3398 } 3399 case 4: 3400 str = get_cell (); 3401 xsnprintf (str, CELLSIZE, "%lx", (unsigned long) l); 3402 break; 3403 case 2: 3404 str = get_cell (); 3405 xsnprintf (str, CELLSIZE, "%x", (unsigned short) (l & 0xffff)); 3406 break; 3407 default: 3408 str = phex_nz (l, sizeof (l)); 3409 break; 3410 } 3411 3412 return str; 3413 } 3414 3415 /* Converts a LONGEST to a C-format hexadecimal literal and stores it 3416 in a static string. Returns a pointer to this string. */ 3417 char * 3418 hex_string (LONGEST num) 3419 { 3420 char *result = get_cell (); 3421 3422 xsnprintf (result, CELLSIZE, "0x%s", phex_nz (num, sizeof (num))); 3423 return result; 3424 } 3425 3426 /* Converts a LONGEST number to a C-format hexadecimal literal and 3427 stores it in a static string. Returns a pointer to this string 3428 that is valid until the next call. The number is padded on the 3429 left with 0s to at least WIDTH characters. */ 3430 char * 3431 hex_string_custom (LONGEST num, int width) 3432 { 3433 char *result = get_cell (); 3434 char *result_end = result + CELLSIZE - 1; 3435 const char *hex = phex_nz (num, sizeof (num)); 3436 int hex_len = strlen (hex); 3437 3438 if (hex_len > width) 3439 width = hex_len; 3440 if (width + 2 >= CELLSIZE) 3441 internal_error (__FILE__, __LINE__, _("\ 3442 hex_string_custom: insufficient space to store result")); 3443 3444 strcpy (result_end - width - 2, "0x"); 3445 memset (result_end - width, '0', width); 3446 strcpy (result_end - hex_len, hex); 3447 return result_end - width - 2; 3448 } 3449 3450 /* Convert VAL to a numeral in the given radix. For 3451 * radix 10, IS_SIGNED may be true, indicating a signed quantity; 3452 * otherwise VAL is interpreted as unsigned. If WIDTH is supplied, 3453 * it is the minimum width (0-padded if needed). USE_C_FORMAT means 3454 * to use C format in all cases. If it is false, then 'x' 3455 * and 'o' formats do not include a prefix (0x or leading 0). */ 3456 3457 char * 3458 int_string (LONGEST val, int radix, int is_signed, int width, 3459 int use_c_format) 3460 { 3461 switch (radix) 3462 { 3463 case 16: 3464 { 3465 char *result; 3466 3467 if (width == 0) 3468 result = hex_string (val); 3469 else 3470 result = hex_string_custom (val, width); 3471 if (! use_c_format) 3472 result += 2; 3473 return result; 3474 } 3475 case 10: 3476 { 3477 if (is_signed && val < 0) 3478 return decimal2str ("-", -val, width); 3479 else 3480 return decimal2str ("", val, width); 3481 } 3482 case 8: 3483 { 3484 char *result = octal2str (val, width); 3485 3486 if (use_c_format || val == 0) 3487 return result; 3488 else 3489 return result + 1; 3490 } 3491 default: 3492 internal_error (__FILE__, __LINE__, 3493 _("failed internal consistency check")); 3494 } 3495 } 3496 3497 /* Convert a CORE_ADDR into a string. */ 3498 const char * 3499 core_addr_to_string (const CORE_ADDR addr) 3500 { 3501 char *str = get_cell (); 3502 3503 strcpy (str, "0x"); 3504 strcat (str, phex (addr, sizeof (addr))); 3505 return str; 3506 } 3507 3508 const char * 3509 core_addr_to_string_nz (const CORE_ADDR addr) 3510 { 3511 char *str = get_cell (); 3512 3513 strcpy (str, "0x"); 3514 strcat (str, phex_nz (addr, sizeof (addr))); 3515 return str; 3516 } 3517 3518 /* Convert a string back into a CORE_ADDR. */ 3519 CORE_ADDR 3520 string_to_core_addr (const char *my_string) 3521 { 3522 CORE_ADDR addr = 0; 3523 3524 if (my_string[0] == '0' && tolower (my_string[1]) == 'x') 3525 { 3526 /* Assume that it is in hex. */ 3527 int i; 3528 3529 for (i = 2; my_string[i] != '\0'; i++) 3530 { 3531 if (isdigit (my_string[i])) 3532 addr = (my_string[i] - '0') + (addr * 16); 3533 else if (isxdigit (my_string[i])) 3534 addr = (tolower (my_string[i]) - 'a' + 0xa) + (addr * 16); 3535 else 3536 error (_("invalid hex \"%s\""), my_string); 3537 } 3538 } 3539 else 3540 { 3541 /* Assume that it is in decimal. */ 3542 int i; 3543 3544 for (i = 0; my_string[i] != '\0'; i++) 3545 { 3546 if (isdigit (my_string[i])) 3547 addr = (my_string[i] - '0') + (addr * 10); 3548 else 3549 error (_("invalid decimal \"%s\""), my_string); 3550 } 3551 } 3552 3553 return addr; 3554 } 3555 3556 const char * 3557 host_address_to_string (const void *addr) 3558 { 3559 char *str = get_cell (); 3560 3561 xsnprintf (str, CELLSIZE, "0x%s", phex_nz ((uintptr_t) addr, sizeof (addr))); 3562 return str; 3563 } 3564 3565 char * 3566 gdb_realpath (const char *filename) 3567 { 3568 /* Method 1: The system has a compile time upper bound on a filename 3569 path. Use that and realpath() to canonicalize the name. This is 3570 the most common case. Note that, if there isn't a compile time 3571 upper bound, you want to avoid realpath() at all costs. */ 3572 #if defined(HAVE_REALPATH) 3573 { 3574 # if defined (PATH_MAX) 3575 char buf[PATH_MAX]; 3576 # define USE_REALPATH 3577 # elif defined (MAXPATHLEN) 3578 char buf[MAXPATHLEN]; 3579 # define USE_REALPATH 3580 # endif 3581 # if defined (USE_REALPATH) 3582 const char *rp = realpath (filename, buf); 3583 3584 if (rp == NULL) 3585 rp = filename; 3586 return xstrdup (rp); 3587 # endif 3588 } 3589 #endif /* HAVE_REALPATH */ 3590 3591 /* Method 2: The host system (i.e., GNU) has the function 3592 canonicalize_file_name() which malloc's a chunk of memory and 3593 returns that, use that. */ 3594 #if defined(HAVE_CANONICALIZE_FILE_NAME) 3595 { 3596 char *rp = canonicalize_file_name (filename); 3597 3598 if (rp == NULL) 3599 return xstrdup (filename); 3600 else 3601 return rp; 3602 } 3603 #endif 3604 3605 /* FIXME: cagney/2002-11-13: 3606 3607 Method 2a: Use realpath() with a NULL buffer. Some systems, due 3608 to the problems described in in method 3, have modified their 3609 realpath() implementation so that it will allocate a buffer when 3610 NULL is passed in. Before this can be used, though, some sort of 3611 configure time test would need to be added. Otherwize the code 3612 will likely core dump. */ 3613 3614 /* Method 3: Now we're getting desperate! The system doesn't have a 3615 compile time buffer size and no alternative function. Query the 3616 OS, using pathconf(), for the buffer limit. Care is needed 3617 though, some systems do not limit PATH_MAX (return -1 for 3618 pathconf()) making it impossible to pass a correctly sized buffer 3619 to realpath() (it could always overflow). On those systems, we 3620 skip this. */ 3621 #if defined (HAVE_REALPATH) && defined (HAVE_UNISTD_H) && defined(HAVE_ALLOCA) 3622 { 3623 /* Find out the max path size. */ 3624 long path_max = pathconf ("/", _PC_PATH_MAX); 3625 3626 if (path_max > 0) 3627 { 3628 /* PATH_MAX is bounded. */ 3629 char *buf = alloca (path_max); 3630 char *rp = realpath (filename, buf); 3631 3632 return xstrdup (rp ? rp : filename); 3633 } 3634 } 3635 #endif 3636 3637 /* This system is a lost cause, just dup the buffer. */ 3638 return xstrdup (filename); 3639 } 3640 3641 /* Return a copy of FILENAME, with its directory prefix canonicalized 3642 by gdb_realpath. */ 3643 3644 char * 3645 xfullpath (const char *filename) 3646 { 3647 const char *base_name = lbasename (filename); 3648 char *dir_name; 3649 char *real_path; 3650 char *result; 3651 3652 /* Extract the basename of filename, and return immediately 3653 a copy of filename if it does not contain any directory prefix. */ 3654 if (base_name == filename) 3655 return xstrdup (filename); 3656 3657 dir_name = alloca ((size_t) (base_name - filename + 2)); 3658 /* Allocate enough space to store the dir_name + plus one extra 3659 character sometimes needed under Windows (see below), and 3660 then the closing \000 character. */ 3661 strncpy (dir_name, filename, base_name - filename); 3662 dir_name[base_name - filename] = '\000'; 3663 3664 #ifdef HAVE_DOS_BASED_FILE_SYSTEM 3665 /* We need to be careful when filename is of the form 'd:foo', which 3666 is equivalent of d:./foo, which is totally different from d:/foo. */ 3667 if (strlen (dir_name) == 2 && isalpha (dir_name[0]) && dir_name[1] == ':') 3668 { 3669 dir_name[2] = '.'; 3670 dir_name[3] = '\000'; 3671 } 3672 #endif 3673 3674 /* Canonicalize the directory prefix, and build the resulting 3675 filename. If the dirname realpath already contains an ending 3676 directory separator, avoid doubling it. */ 3677 real_path = gdb_realpath (dir_name); 3678 if (IS_DIR_SEPARATOR (real_path[strlen (real_path) - 1])) 3679 result = concat (real_path, base_name, (char *) NULL); 3680 else 3681 result = concat (real_path, SLASH_STRING, base_name, (char *) NULL); 3682 3683 xfree (real_path); 3684 return result; 3685 } 3686 3687 3688 /* This is the 32-bit CRC function used by the GNU separate debug 3689 facility. An executable may contain a section named 3690 .gnu_debuglink, which holds the name of a separate executable file 3691 containing its debug info, and a checksum of that file's contents, 3692 computed using this function. */ 3693 unsigned long 3694 gnu_debuglink_crc32 (unsigned long crc, unsigned char *buf, size_t len) 3695 { 3696 static const unsigned int crc32_table[256] = { 3697 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 3698 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 3699 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 3700 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 3701 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 3702 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 3703 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 3704 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 3705 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 3706 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a, 3707 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 3708 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 3709 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 3710 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 3711 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e, 3712 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, 3713 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 3714 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, 3715 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 3716 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 3717 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 3718 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 3719 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010, 3720 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, 3721 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 3722 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 3723 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 3724 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 3725 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344, 3726 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 3727 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 3728 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 3729 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 3730 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, 3731 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 3732 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 3733 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 3734 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 3735 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, 3736 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, 3737 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 3738 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, 3739 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 3740 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 3741 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278, 3742 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 3743 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 3744 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, 3745 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 3746 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 3747 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 3748 0x2d02ef8d 3749 }; 3750 unsigned char *end; 3751 3752 crc = ~crc & 0xffffffff; 3753 for (end = buf + len; buf < end; ++buf) 3754 crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8); 3755 return ~crc & 0xffffffff; 3756 } 3757 3758 ULONGEST 3759 align_up (ULONGEST v, int n) 3760 { 3761 /* Check that N is really a power of two. */ 3762 gdb_assert (n && (n & (n-1)) == 0); 3763 return (v + n - 1) & -n; 3764 } 3765 3766 ULONGEST 3767 align_down (ULONGEST v, int n) 3768 { 3769 /* Check that N is really a power of two. */ 3770 gdb_assert (n && (n & (n-1)) == 0); 3771 return (v & -n); 3772 } 3773 3774 /* Allocation function for the libiberty hash table which uses an 3775 obstack. The obstack is passed as DATA. */ 3776 3777 void * 3778 hashtab_obstack_allocate (void *data, size_t size, size_t count) 3779 { 3780 unsigned int total = size * count; 3781 void *ptr = obstack_alloc ((struct obstack *) data, total); 3782 3783 memset (ptr, 0, total); 3784 return ptr; 3785 } 3786 3787 /* Trivial deallocation function for the libiberty splay tree and hash 3788 table - don't deallocate anything. Rely on later deletion of the 3789 obstack. DATA will be the obstack, although it is not needed 3790 here. */ 3791 3792 void 3793 dummy_obstack_deallocate (void *object, void *data) 3794 { 3795 return; 3796 } 3797 3798 /* The bit offset of the highest byte in a ULONGEST, for overflow 3799 checking. */ 3800 3801 #define HIGH_BYTE_POSN ((sizeof (ULONGEST) - 1) * HOST_CHAR_BIT) 3802 3803 /* True (non-zero) iff DIGIT is a valid digit in radix BASE, 3804 where 2 <= BASE <= 36. */ 3805 3806 static int 3807 is_digit_in_base (unsigned char digit, int base) 3808 { 3809 if (!isalnum (digit)) 3810 return 0; 3811 if (base <= 10) 3812 return (isdigit (digit) && digit < base + '0'); 3813 else 3814 return (isdigit (digit) || tolower (digit) < base - 10 + 'a'); 3815 } 3816 3817 static int 3818 digit_to_int (unsigned char c) 3819 { 3820 if (isdigit (c)) 3821 return c - '0'; 3822 else 3823 return tolower (c) - 'a' + 10; 3824 } 3825 3826 /* As for strtoul, but for ULONGEST results. */ 3827 3828 ULONGEST 3829 strtoulst (const char *num, const char **trailer, int base) 3830 { 3831 unsigned int high_part; 3832 ULONGEST result; 3833 int minus = 0; 3834 int i = 0; 3835 3836 /* Skip leading whitespace. */ 3837 while (isspace (num[i])) 3838 i++; 3839 3840 /* Handle prefixes. */ 3841 if (num[i] == '+') 3842 i++; 3843 else if (num[i] == '-') 3844 { 3845 minus = 1; 3846 i++; 3847 } 3848 3849 if (base == 0 || base == 16) 3850 { 3851 if (num[i] == '0' && (num[i + 1] == 'x' || num[i + 1] == 'X')) 3852 { 3853 i += 2; 3854 if (base == 0) 3855 base = 16; 3856 } 3857 } 3858 3859 if (base == 0 && num[i] == '0') 3860 base = 8; 3861 3862 if (base == 0) 3863 base = 10; 3864 3865 if (base < 2 || base > 36) 3866 { 3867 errno = EINVAL; 3868 return 0; 3869 } 3870 3871 result = high_part = 0; 3872 for (; is_digit_in_base (num[i], base); i += 1) 3873 { 3874 result = result * base + digit_to_int (num[i]); 3875 high_part = high_part * base + (unsigned int) (result >> HIGH_BYTE_POSN); 3876 result &= ((ULONGEST) 1 << HIGH_BYTE_POSN) - 1; 3877 if (high_part > 0xff) 3878 { 3879 errno = ERANGE; 3880 result = ~ (ULONGEST) 0; 3881 high_part = 0; 3882 minus = 0; 3883 break; 3884 } 3885 } 3886 3887 if (trailer != NULL) 3888 *trailer = &num[i]; 3889 3890 result = result + ((ULONGEST) high_part << HIGH_BYTE_POSN); 3891 if (minus) 3892 return -result; 3893 else 3894 return result; 3895 } 3896 3897 /* Simple, portable version of dirname that does not modify its 3898 argument. */ 3899 3900 char * 3901 ldirname (const char *filename) 3902 { 3903 const char *base = lbasename (filename); 3904 char *dirname; 3905 3906 while (base > filename && IS_DIR_SEPARATOR (base[-1])) 3907 --base; 3908 3909 if (base == filename) 3910 return NULL; 3911 3912 dirname = xmalloc (base - filename + 2); 3913 memcpy (dirname, filename, base - filename); 3914 3915 /* On DOS based file systems, convert "d:foo" to "d:.", so that we 3916 create "d:./bar" later instead of the (different) "d:/bar". */ 3917 if (base - filename == 2 && IS_ABSOLUTE_PATH (base) 3918 && !IS_DIR_SEPARATOR (filename[0])) 3919 dirname[base++ - filename] = '.'; 3920 3921 dirname[base - filename] = '\0'; 3922 return dirname; 3923 } 3924 3925 /* Call libiberty's buildargv, and return the result. 3926 If buildargv fails due to out-of-memory, call nomem. 3927 Therefore, the returned value is guaranteed to be non-NULL, 3928 unless the parameter itself is NULL. */ 3929 3930 char ** 3931 gdb_buildargv (const char *s) 3932 { 3933 char **argv = buildargv (s); 3934 3935 if (s != NULL && argv == NULL) 3936 nomem (0); 3937 return argv; 3938 } 3939 3940 int 3941 compare_positive_ints (const void *ap, const void *bp) 3942 { 3943 /* Because we know we're comparing two ints which are positive, 3944 there's no danger of overflow here. */ 3945 return * (int *) ap - * (int *) bp; 3946 } 3947 3948 #define AMBIGUOUS_MESS1 ".\nMatching formats:" 3949 #define AMBIGUOUS_MESS2 \ 3950 ".\nUse \"set gnutarget format-name\" to specify the format." 3951 3952 const char * 3953 gdb_bfd_errmsg (bfd_error_type error_tag, char **matching) 3954 { 3955 char *ret, *retp; 3956 int ret_len; 3957 char **p; 3958 3959 /* Check if errmsg just need simple return. */ 3960 if (error_tag != bfd_error_file_ambiguously_recognized || matching == NULL) 3961 return bfd_errmsg (error_tag); 3962 3963 ret_len = strlen (bfd_errmsg (error_tag)) + strlen (AMBIGUOUS_MESS1) 3964 + strlen (AMBIGUOUS_MESS2); 3965 for (p = matching; *p; p++) 3966 ret_len += strlen (*p) + 1; 3967 ret = xmalloc (ret_len + 1); 3968 retp = ret; 3969 make_cleanup (xfree, ret); 3970 3971 strcpy (retp, bfd_errmsg (error_tag)); 3972 retp += strlen (retp); 3973 3974 strcpy (retp, AMBIGUOUS_MESS1); 3975 retp += strlen (retp); 3976 3977 for (p = matching; *p; p++) 3978 { 3979 sprintf (retp, " %s", *p); 3980 retp += strlen (retp); 3981 } 3982 xfree (matching); 3983 3984 strcpy (retp, AMBIGUOUS_MESS2); 3985 3986 return ret; 3987 } 3988 3989 /* Return ARGS parsed as a valid pid, or throw an error. */ 3990 3991 int 3992 parse_pid_to_attach (char *args) 3993 { 3994 unsigned long pid; 3995 char *dummy; 3996 3997 if (!args) 3998 error_no_arg (_("process-id to attach")); 3999 4000 dummy = args; 4001 pid = strtoul (args, &dummy, 0); 4002 /* Some targets don't set errno on errors, grrr! */ 4003 if ((pid == 0 && dummy == args) || dummy != &args[strlen (args)]) 4004 error (_("Illegal process-id: %s."), args); 4005 4006 return pid; 4007 } 4008 4009 /* Provide a prototype to silence -Wmissing-prototypes. */ 4010 extern initialize_file_ftype _initialize_utils; 4011 4012 void 4013 _initialize_utils (void) 4014 { 4015 add_internal_problem_command (&internal_error_problem); 4016 add_internal_problem_command (&internal_warning_problem); 4017 } 4018