1 /* General utility routines for GDB, the GNU debugger.
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 Free Software Foundation, Inc.
7 This file is part of GDB.
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.
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.
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/>. */
23 #include "gdb_assert.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 */
34 #include "tui/tui.h" /* For tui_get_command_dimension. */
41 /* SunOS's curses.h has a '#define reg register' in it. Thank you Sun. */
52 #include "expression.h"
56 #include "filenames.h"
58 #include "gdb_obstack.h"
63 #include "inferior.h" /* for signed_pointer_to_address */
65 #include <sys/param.h> /* For MAXPATHLEN */
67 #include "gdb_curses.h"
69 #include "readline/readline.h"
74 #include "gdb_usleep.h"
78 extern PTR malloc (); /* ARI: PTR */
80 #if !HAVE_DECL_REALLOC
81 extern PTR realloc (); /* ARI: PTR */
87 /* readline defines this. */
90 void (*deprecated_error_begin_hook) (void);
92 /* Prototypes for local functions */
94 static void vfprintf_maybe_filtered (struct ui_file *, const char *,
95 va_list, int) ATTRIBUTE_PRINTF (2, 0);
97 static void fputs_maybe_filtered (const char *, struct ui_file *, int);
99 static void do_my_cleanups (struct cleanup **, struct cleanup *);
101 static void prompt_for_continue (void);
103 static void set_screen_size (void);
104 static void set_width (void);
106 /* A flag indicating whether to timestamp debugging messages. */
108 static int debug_timestamp = 0;
110 /* Chain of cleanup actions established with make_cleanup,
111 to be executed if an error happens. */
113 static struct cleanup *cleanup_chain; /* cleaned up after a failed command */
114 static struct cleanup *final_cleanup_chain; /* cleaned up when gdb exits */
116 /* Nonzero if we have job control. */
120 /* Nonzero means a quit has been requested. */
124 /* Nonzero means quit immediately if Control-C is typed now, rather
125 than waiting until QUIT is executed. Be careful in setting this;
126 code which executes with immediate_quit set has to be very careful
127 about being able to deal with being interrupted at any time. It is
128 almost always better to use QUIT; the only exception I can think of
129 is being able to quit out of a system call (using EINTR loses if
130 the SIGINT happens between the previous QUIT and the system call).
131 To immediately quit in the case in which a SIGINT happens between
132 the previous QUIT and setting immediate_quit (desirable anytime we
133 expect to block), call QUIT after setting immediate_quit. */
137 /* Nonzero means that encoded C++/ObjC names should be printed out in their
138 C++/ObjC form rather than raw. */
142 show_demangle (struct ui_file *file, int from_tty,
143 struct cmd_list_element *c, const char *value)
145 fprintf_filtered (file, _("\
146 Demangling of encoded C++/ObjC names when displaying symbols is %s.\n"),
150 /* Nonzero means that encoded C++/ObjC names should be printed out in their
151 C++/ObjC form even in assembler language displays. If this is set, but
152 DEMANGLE is zero, names are printed raw, i.e. DEMANGLE controls. */
154 int asm_demangle = 0;
156 show_asm_demangle (struct ui_file *file, int from_tty,
157 struct cmd_list_element *c, const char *value)
159 fprintf_filtered (file, _("\
160 Demangling of C++/ObjC names in disassembly listings is %s.\n"),
164 /* Nonzero means that strings with character values >0x7F should be printed
165 as octal escapes. Zero means just print the value (e.g. it's an
166 international character, and the terminal or window can cope.) */
168 int sevenbit_strings = 0;
170 show_sevenbit_strings (struct ui_file *file, int from_tty,
171 struct cmd_list_element *c, const char *value)
173 fprintf_filtered (file, _("\
174 Printing of 8-bit characters in strings as \\nnn is %s.\n"),
178 /* String to be printed before error messages, if any. */
180 char *error_pre_print;
182 /* String to be printed before quit messages, if any. */
184 char *quit_pre_print;
186 /* String to be printed before warning messages, if any. */
188 char *warning_pre_print = "\nwarning: ";
190 int pagination_enabled = 1;
192 show_pagination_enabled (struct ui_file *file, int from_tty,
193 struct cmd_list_element *c, const char *value)
195 fprintf_filtered (file, _("State of pagination is %s.\n"), value);
200 /* Add a new cleanup to the cleanup_chain,
201 and return the previous chain pointer
202 to be passed later to do_cleanups or discard_cleanups.
203 Args are FUNCTION to clean up with, and ARG to pass to it. */
206 make_cleanup (make_cleanup_ftype *function, void *arg)
208 return make_my_cleanup (&cleanup_chain, function, arg);
212 make_cleanup_dtor (make_cleanup_ftype *function, void *arg,
213 void (*dtor) (void *))
215 return make_my_cleanup2 (&cleanup_chain,
216 function, arg, dtor);
220 make_final_cleanup (make_cleanup_ftype *function, void *arg)
222 return make_my_cleanup (&final_cleanup_chain, function, arg);
226 do_freeargv (void *arg)
228 freeargv ((char **) arg);
232 make_cleanup_freeargv (char **arg)
234 return make_my_cleanup (&cleanup_chain, do_freeargv, arg);
238 do_bfd_close_cleanup (void *arg)
244 make_cleanup_bfd_close (bfd *abfd)
246 return make_cleanup (do_bfd_close_cleanup, abfd);
250 do_close_cleanup (void *arg)
258 make_cleanup_close (int fd)
260 int *saved_fd = xmalloc (sizeof (fd));
263 return make_cleanup_dtor (do_close_cleanup, saved_fd, xfree);
266 /* Helper function which does the work for make_cleanup_fclose. */
269 do_fclose_cleanup (void *arg)
276 /* Return a new cleanup that closes FILE. */
279 make_cleanup_fclose (FILE *file)
281 return make_cleanup (do_fclose_cleanup, file);
284 /* Helper function which does the work for make_cleanup_obstack_free. */
287 do_obstack_free (void *arg)
289 struct obstack *ob = arg;
291 obstack_free (ob, NULL);
294 /* Return a new cleanup that frees OBSTACK. */
297 make_cleanup_obstack_free (struct obstack *obstack)
299 return make_cleanup (do_obstack_free, obstack);
303 do_ui_file_delete (void *arg)
305 ui_file_delete (arg);
309 make_cleanup_ui_file_delete (struct ui_file *arg)
311 return make_my_cleanup (&cleanup_chain, do_ui_file_delete, arg);
314 /* Helper function for make_cleanup_ui_out_redirect_pop. */
317 do_ui_out_redirect_pop (void *arg)
319 struct ui_out *uiout = arg;
321 if (ui_out_redirect (uiout, NULL) < 0)
322 warning (_("Cannot restore redirection of the current output protocol"));
325 /* Return a new cleanup that pops the last redirection by ui_out_redirect
326 with NULL parameter. */
329 make_cleanup_ui_out_redirect_pop (struct ui_out *uiout)
331 return make_my_cleanup (&cleanup_chain, do_ui_out_redirect_pop, uiout);
335 do_free_section_addr_info (void *arg)
337 free_section_addr_info (arg);
341 make_cleanup_free_section_addr_info (struct section_addr_info *addrs)
343 return make_my_cleanup (&cleanup_chain, do_free_section_addr_info, addrs);
346 struct restore_integer_closure
353 restore_integer (void *p)
355 struct restore_integer_closure *closure = p;
357 *(closure->variable) = closure->value;
360 /* Remember the current value of *VARIABLE and make it restored when the cleanup
364 make_cleanup_restore_integer (int *variable)
366 struct restore_integer_closure *c =
367 xmalloc (sizeof (struct restore_integer_closure));
369 c->variable = variable;
370 c->value = *variable;
372 return make_my_cleanup2 (&cleanup_chain, restore_integer, (void *)c,
376 /* Remember the current value of *VARIABLE and make it restored when the cleanup
380 make_cleanup_restore_uinteger (unsigned int *variable)
382 return make_cleanup_restore_integer ((int *) variable);
385 /* Helper for make_cleanup_unpush_target. */
388 do_unpush_target (void *arg)
390 struct target_ops *ops = arg;
395 /* Return a new cleanup that unpushes OPS. */
398 make_cleanup_unpush_target (struct target_ops *ops)
400 return make_my_cleanup (&cleanup_chain, do_unpush_target, ops);
403 struct restore_ui_file_closure
405 struct ui_file **variable;
406 struct ui_file *value;
410 do_restore_ui_file (void *p)
412 struct restore_ui_file_closure *closure = p;
414 *(closure->variable) = closure->value;
417 /* Remember the current value of *VARIABLE and make it restored when
418 the cleanup is run. */
421 make_cleanup_restore_ui_file (struct ui_file **variable)
423 struct restore_ui_file_closure *c = XNEW (struct restore_ui_file_closure);
425 c->variable = variable;
426 c->value = *variable;
428 return make_cleanup_dtor (do_restore_ui_file, (void *) c, xfree);
432 make_my_cleanup2 (struct cleanup **pmy_chain, make_cleanup_ftype *function,
433 void *arg, void (*free_arg) (void *))
436 = (struct cleanup *) xmalloc (sizeof (struct cleanup));
437 struct cleanup *old_chain = *pmy_chain;
439 new->next = *pmy_chain;
440 new->function = function;
441 new->free_arg = free_arg;
449 make_my_cleanup (struct cleanup **pmy_chain, make_cleanup_ftype *function,
452 return make_my_cleanup2 (pmy_chain, function, arg, NULL);
455 /* Discard cleanups and do the actions they describe
456 until we get back to the point OLD_CHAIN in the cleanup_chain. */
459 do_cleanups (struct cleanup *old_chain)
461 do_my_cleanups (&cleanup_chain, old_chain);
465 do_final_cleanups (struct cleanup *old_chain)
467 do_my_cleanups (&final_cleanup_chain, old_chain);
471 do_my_cleanups (struct cleanup **pmy_chain,
472 struct cleanup *old_chain)
476 while ((ptr = *pmy_chain) != old_chain)
478 *pmy_chain = ptr->next; /* Do this first incase recursion */
479 (*ptr->function) (ptr->arg);
481 (*ptr->free_arg) (ptr->arg);
486 /* Discard cleanups, not doing the actions they describe,
487 until we get back to the point OLD_CHAIN in the cleanup_chain. */
490 discard_cleanups (struct cleanup *old_chain)
492 discard_my_cleanups (&cleanup_chain, old_chain);
496 discard_final_cleanups (struct cleanup *old_chain)
498 discard_my_cleanups (&final_cleanup_chain, old_chain);
502 discard_my_cleanups (struct cleanup **pmy_chain,
503 struct cleanup *old_chain)
507 while ((ptr = *pmy_chain) != old_chain)
509 *pmy_chain = ptr->next;
511 (*ptr->free_arg) (ptr->arg);
516 /* Set the cleanup_chain to 0, and return the old cleanup chain. */
520 return save_my_cleanups (&cleanup_chain);
524 save_final_cleanups (void)
526 return save_my_cleanups (&final_cleanup_chain);
530 save_my_cleanups (struct cleanup **pmy_chain)
532 struct cleanup *old_chain = *pmy_chain;
538 /* Restore the cleanup chain from a previously saved chain. */
540 restore_cleanups (struct cleanup *chain)
542 restore_my_cleanups (&cleanup_chain, chain);
546 restore_final_cleanups (struct cleanup *chain)
548 restore_my_cleanups (&final_cleanup_chain, chain);
552 restore_my_cleanups (struct cleanup **pmy_chain, struct cleanup *chain)
557 /* This function is useful for cleanups.
561 old_chain = make_cleanup (free_current_contents, &foo);
563 to arrange to free the object thus allocated. */
566 free_current_contents (void *ptr)
568 void **location = ptr;
570 if (location == NULL)
571 internal_error (__FILE__, __LINE__,
572 _("free_current_contents: NULL pointer"));
573 if (*location != NULL)
580 /* Provide a known function that does nothing, to use as a base for
581 for a possibly long chain of cleanups. This is useful where we
582 use the cleanup chain for handling normal cleanups as well as dealing
583 with cleanups that need to be done as a result of a call to error().
584 In such cases, we may not be certain where the first cleanup is, unless
585 we have a do-nothing one to always use as the base. */
588 null_cleanup (void *arg)
592 /* If nonzero, display time usage both at startup and for each command. */
594 static int display_time;
596 /* If nonzero, display space usage both at startup and for each command. */
598 static int display_space;
600 /* Records a run time and space usage to be used as a base for
601 reporting elapsed time or change in space. In addition,
602 the msg_type field indicates whether the saved time is from the
603 beginning of GDB execution (0) or the beginning of an individual
604 command execution (1). */
612 /* Set whether to display time statistics to NEW_VALUE (non-zero
615 set_display_time (int new_value)
617 display_time = new_value;
620 /* Set whether to display space statistics to NEW_VALUE (non-zero
623 set_display_space (int new_value)
625 display_space = new_value;
628 /* As indicated by display_time and display_space, report GDB's elapsed time
629 and space usage from the base time and space provided in ARG, which
630 must be a pointer to a struct cmd_stat. This function is intended
631 to be called as a cleanup. */
633 report_command_stats (void *arg)
635 struct cmd_stats *start_stats = (struct cmd_stats *) arg;
636 int msg_type = start_stats->msg_type;
640 long cmd_time = get_run_time () - start_stats->start_time;
642 printf_unfiltered (msg_type == 0
643 ? _("Startup time: %ld.%06ld\n")
644 : _("Command execution time: %ld.%06ld\n"),
645 cmd_time / 1000000, cmd_time % 1000000);
651 char *lim = (char *) sbrk (0);
653 long space_now = lim - lim_at_start;
654 long space_diff = space_now - start_stats->start_space;
656 printf_unfiltered (msg_type == 0
657 ? _("Space used: %ld (%c%ld during startup)\n")
658 : _("Space used: %ld (%c%ld for this command)\n"),
660 (space_diff >= 0 ? '+' : '-'),
666 /* Create a cleanup that reports time and space used since its
667 creation. Precise messages depend on MSG_TYPE:
668 0: Initial time/space
669 1: Individual command time/space. */
671 make_command_stats_cleanup (int msg_type)
673 struct cmd_stats *new_stat = XMALLOC (struct cmd_stats);
676 char *lim = (char *) sbrk (0);
677 new_stat->start_space = lim - lim_at_start;
680 new_stat->msg_type = msg_type;
681 new_stat->start_time = get_run_time ();
683 return make_cleanup_dtor (report_command_stats, new_stat, xfree);
686 /* Continuations are implemented as cleanups internally. Inherit from
693 /* Add a continuation to the continuation list of THREAD. The new
694 continuation will be added at the front. */
696 add_continuation (struct thread_info *thread,
697 void (*continuation_hook) (void *), void *args,
698 void (*continuation_free_args) (void *))
700 struct cleanup *as_cleanup = &thread->continuations->base;
701 make_cleanup_ftype *continuation_hook_fn = continuation_hook;
703 make_my_cleanup2 (&as_cleanup,
704 continuation_hook_fn,
706 continuation_free_args);
708 thread->continuations = (struct continuation *) as_cleanup;
711 /* Add a continuation to the continuation list of INFERIOR. The new
712 continuation will be added at the front. */
715 add_inferior_continuation (void (*continuation_hook) (void *), void *args,
716 void (*continuation_free_args) (void *))
718 struct inferior *inf = current_inferior ();
719 struct cleanup *as_cleanup = &inf->continuations->base;
720 make_cleanup_ftype *continuation_hook_fn = continuation_hook;
722 make_my_cleanup2 (&as_cleanup,
723 continuation_hook_fn,
725 continuation_free_args);
727 inf->continuations = (struct continuation *) as_cleanup;
730 /* Do all continuations of the current inferior. */
733 do_all_inferior_continuations (void)
735 struct cleanup *as_cleanup;
736 struct inferior *inf = current_inferior ();
738 if (inf->continuations == NULL)
741 /* Copy the list header into another pointer, and set the global
742 list header to null, so that the global list can change as a side
743 effect of invoking the continuations and the processing of the
744 preexisting continuations will not be affected. */
746 as_cleanup = &inf->continuations->base;
747 inf->continuations = NULL;
749 /* Work now on the list we have set aside. */
750 do_my_cleanups (&as_cleanup, NULL);
753 /* Get rid of all the inferior-wide continuations of INF. */
756 discard_all_inferior_continuations (struct inferior *inf)
758 struct cleanup *continuation_ptr = &inf->continuations->base;
760 discard_my_cleanups (&continuation_ptr, NULL);
761 inf->continuations = NULL;
765 restore_thread_cleanup (void *arg)
767 ptid_t *ptid_p = arg;
769 switch_to_thread (*ptid_p);
772 /* Walk down the continuation list of PTID, and execute all the
773 continuations. There is a problem though. In some cases new
774 continuations may be added while we are in the middle of this loop.
775 If this happens they will be added in the front, and done before we
776 have a chance of exhausting those that were already there. We need
777 to then save the beginning of the list in a pointer and do the
778 continuations from there on, instead of using the global beginning
779 of list as our iteration pointer. */
781 do_all_continuations_ptid (ptid_t ptid,
782 struct continuation **continuations_p)
784 struct cleanup *old_chain;
785 ptid_t current_thread;
786 struct cleanup *as_cleanup;
788 if (*continuations_p == NULL)
791 current_thread = inferior_ptid;
793 /* Restore selected thread on exit. Don't try to restore the frame
796 - When running continuations, the selected frame is always #0.
798 - The continuations may trigger symbol file loads, which may
799 change the frame layout (frame ids change), which would trigger
800 a warning if we used make_cleanup_restore_current_thread. */
802 old_chain = make_cleanup (restore_thread_cleanup, ¤t_thread);
804 /* Let the continuation see this thread as selected. */
805 switch_to_thread (ptid);
807 /* Copy the list header into another pointer, and set the global
808 list header to null, so that the global list can change as a side
809 effect of invoking the continuations and the processing of the
810 preexisting continuations will not be affected. */
812 as_cleanup = &(*continuations_p)->base;
813 *continuations_p = NULL;
815 /* Work now on the list we have set aside. */
816 do_my_cleanups (&as_cleanup, NULL);
818 do_cleanups (old_chain);
821 /* Callback for iterate over threads. */
823 do_all_continuations_thread_callback (struct thread_info *thread, void *data)
825 do_all_continuations_ptid (thread->ptid, &thread->continuations);
829 /* Do all continuations of thread THREAD. */
831 do_all_continuations_thread (struct thread_info *thread)
833 do_all_continuations_thread_callback (thread, NULL);
836 /* Do all continuations of all threads. */
838 do_all_continuations (void)
840 iterate_over_threads (do_all_continuations_thread_callback, NULL);
843 /* Callback for iterate over threads. */
845 discard_all_continuations_thread_callback (struct thread_info *thread,
848 struct cleanup *continuation_ptr = &thread->continuations->base;
850 discard_my_cleanups (&continuation_ptr, NULL);
851 thread->continuations = NULL;
855 /* Get rid of all the continuations of THREAD. */
857 discard_all_continuations_thread (struct thread_info *thread)
859 discard_all_continuations_thread_callback (thread, NULL);
862 /* Get rid of all the continuations of all threads. */
864 discard_all_continuations (void)
866 iterate_over_threads (discard_all_continuations_thread_callback, NULL);
870 /* Add a continuation to the intermediate continuation list of THREAD.
871 The new continuation will be added at the front. */
873 add_intermediate_continuation (struct thread_info *thread,
874 void (*continuation_hook)
875 (void *), void *args,
876 void (*continuation_free_args) (void *))
878 struct cleanup *as_cleanup = &thread->intermediate_continuations->base;
879 make_cleanup_ftype *continuation_hook_fn = continuation_hook;
881 make_my_cleanup2 (&as_cleanup,
882 continuation_hook_fn,
884 continuation_free_args);
886 thread->intermediate_continuations = (struct continuation *) as_cleanup;
889 /* Walk down the cmd_continuation list, and execute all the
890 continuations. There is a problem though. In some cases new
891 continuations may be added while we are in the middle of this
892 loop. If this happens they will be added in the front, and done
893 before we have a chance of exhausting those that were already
894 there. We need to then save the beginning of the list in a pointer
895 and do the continuations from there on, instead of using the
896 global beginning of list as our iteration pointer.*/
898 do_all_intermediate_continuations_thread_callback (struct thread_info *thread,
901 do_all_continuations_ptid (thread->ptid,
902 &thread->intermediate_continuations);
906 /* Do all intermediate continuations of thread THREAD. */
908 do_all_intermediate_continuations_thread (struct thread_info *thread)
910 do_all_intermediate_continuations_thread_callback (thread, NULL);
913 /* Do all intermediate continuations of all threads. */
915 do_all_intermediate_continuations (void)
917 iterate_over_threads (do_all_intermediate_continuations_thread_callback, NULL);
920 /* Callback for iterate over threads. */
922 discard_all_intermediate_continuations_thread_callback (struct thread_info *thread,
925 struct cleanup *continuation_ptr = &thread->intermediate_continuations->base;
927 discard_my_cleanups (&continuation_ptr, NULL);
928 thread->intermediate_continuations = NULL;
932 /* Get rid of all the intermediate continuations of THREAD. */
934 discard_all_intermediate_continuations_thread (struct thread_info *thread)
936 discard_all_intermediate_continuations_thread_callback (thread, NULL);
939 /* Get rid of all the intermediate continuations of all threads. */
941 discard_all_intermediate_continuations (void)
943 iterate_over_threads (discard_all_intermediate_continuations_thread_callback, NULL);
948 /* Print a warning message. The first argument STRING is the warning
949 message, used as an fprintf format string, the second is the
950 va_list of arguments for that string. A warning is unfiltered (not
951 paginated) so that the user does not need to page through each
952 screen full of warnings when there are lots of them. */
955 vwarning (const char *string, va_list args)
957 if (deprecated_warning_hook)
958 (*deprecated_warning_hook) (string, args);
961 target_terminal_ours ();
962 wrap_here (""); /* Force out any buffered output */
963 gdb_flush (gdb_stdout);
964 if (warning_pre_print)
965 fputs_unfiltered (warning_pre_print, gdb_stderr);
966 vfprintf_unfiltered (gdb_stderr, string, args);
967 fprintf_unfiltered (gdb_stderr, "\n");
972 /* Print a warning message.
973 The first argument STRING is the warning message, used as a fprintf string,
974 and the remaining args are passed as arguments to it.
975 The primary difference between warnings and errors is that a warning
976 does not force the return to command level. */
979 warning (const char *string, ...)
983 va_start (args, string);
984 vwarning (string, args);
988 /* Print an error message and return to command level.
989 The first argument STRING is the error message, used as a fprintf string,
990 and the remaining args are passed as arguments to it. */
993 verror (const char *string, va_list args)
995 throw_verror (GENERIC_ERROR, string, args);
999 error (const char *string, ...)
1003 va_start (args, string);
1004 throw_verror (GENERIC_ERROR, string, args);
1008 /* Print an error message and quit.
1009 The first argument STRING is the error message, used as a fprintf string,
1010 and the remaining args are passed as arguments to it. */
1013 vfatal (const char *string, va_list args)
1015 throw_vfatal (string, args);
1019 fatal (const char *string, ...)
1023 va_start (args, string);
1024 throw_vfatal (string, args);
1029 error_stream (struct ui_file *stream)
1031 char *message = ui_file_xstrdup (stream, NULL);
1033 make_cleanup (xfree, message);
1034 error (("%s"), message);
1037 /* Dump core trying to increase the core soft limit to hard limit first. */
1042 #ifdef HAVE_SETRLIMIT
1043 struct rlimit rlim = { RLIM_INFINITY, RLIM_INFINITY };
1045 setrlimit (RLIMIT_CORE, &rlim);
1046 #endif /* HAVE_SETRLIMIT */
1048 abort (); /* NOTE: GDB has only three calls to abort(). */
1051 /* Check whether GDB will be able to dump core using the dump_core function. */
1054 can_dump_core (const char *reason)
1056 #ifdef HAVE_GETRLIMIT
1059 /* Be quiet and assume we can dump if an error is returned. */
1060 if (getrlimit (RLIMIT_CORE, &rlim) != 0)
1063 if (rlim.rlim_max == 0)
1065 fprintf_unfiltered (gdb_stderr,
1066 _("%s\nUnable to dump core, use `ulimit -c unlimited'"
1067 " before executing GDB next time.\n"), reason);
1070 #endif /* HAVE_GETRLIMIT */
1075 /* Allow the user to configure the debugger behavior with respect to
1076 what to do when an internal problem is detected. */
1078 const char internal_problem_ask[] = "ask";
1079 const char internal_problem_yes[] = "yes";
1080 const char internal_problem_no[] = "no";
1081 static const char *internal_problem_modes[] =
1083 internal_problem_ask,
1084 internal_problem_yes,
1085 internal_problem_no,
1089 /* Print a message reporting an internal error/warning. Ask the user
1090 if they want to continue, dump core, or just exit. Return
1091 something to indicate a quit. */
1093 struct internal_problem
1096 const char *should_quit;
1097 const char *should_dump_core;
1100 /* Report a problem, internal to GDB, to the user. Once the problem
1101 has been reported, and assuming GDB didn't quit, the caller can
1102 either allow execution to resume or throw an error. */
1104 static void ATTRIBUTE_PRINTF (4, 0)
1105 internal_vproblem (struct internal_problem *problem,
1106 const char *file, int line, const char *fmt, va_list ap)
1113 /* Don't allow infinite error/warning recursion. */
1115 static char msg[] = "Recursive internal problem.\n";
1124 fputs_unfiltered (msg, gdb_stderr);
1125 abort (); /* NOTE: GDB has only three calls to abort(). */
1128 /* Newer GLIBC versions put the warn_unused_result attribute
1129 on write, but this is one of those rare cases where
1130 ignoring the return value is correct. Casting to (void)
1131 does not fix this problem. This is the solution suggested
1132 at http://gcc.gnu.org/bugzilla/show_bug.cgi?id=25509. */
1133 if (write (STDERR_FILENO, msg, sizeof (msg)) != sizeof (msg))
1134 abort (); /* NOTE: GDB has only three calls to abort(). */
1139 /* Try to get the message out and at the start of a new line. */
1140 target_terminal_ours ();
1143 /* Create a string containing the full error/warning message. Need
1144 to call query with this full string, as otherwize the reason
1145 (error/warning) and question become separated. Format using a
1146 style similar to a compiler error message. Include extra detail
1147 so that the user knows that they are living on the edge. */
1151 msg = xstrvprintf (fmt, ap);
1152 reason = xstrprintf ("\
1154 A problem internal to GDB has been detected,\n\
1155 further debugging may prove unreliable.", file, line, problem->name, msg);
1157 make_cleanup (xfree, reason);
1160 if (problem->should_quit == internal_problem_ask)
1162 /* Default (yes/batch case) is to quit GDB. When in batch mode
1163 this lessens the likelihood of GDB going into an infinite
1167 /* Emit the message and quit. */
1168 fputs_unfiltered (reason, gdb_stderr);
1169 fputs_unfiltered ("\n", gdb_stderr);
1173 quit_p = query (_("%s\nQuit this debugging session? "), reason);
1175 else if (problem->should_quit == internal_problem_yes)
1177 else if (problem->should_quit == internal_problem_no)
1180 internal_error (__FILE__, __LINE__, _("bad switch"));
1182 if (problem->should_dump_core == internal_problem_ask)
1184 if (!can_dump_core (reason))
1188 /* Default (yes/batch case) is to dump core. This leaves a GDB
1189 `dropping' so that it is easier to see that something went
1191 dump_core_p = query (_("%s\nCreate a core file of GDB? "), reason);
1194 else if (problem->should_dump_core == internal_problem_yes)
1195 dump_core_p = can_dump_core (reason);
1196 else if (problem->should_dump_core == internal_problem_no)
1199 internal_error (__FILE__, __LINE__, _("bad switch"));
1212 #ifdef HAVE_WORKING_FORK
1222 static struct internal_problem internal_error_problem = {
1223 "internal-error", internal_problem_ask, internal_problem_ask
1227 internal_verror (const char *file, int line, const char *fmt, va_list ap)
1229 internal_vproblem (&internal_error_problem, file, line, fmt, ap);
1230 deprecated_throw_reason (RETURN_ERROR);
1234 internal_error (const char *file, int line, const char *string, ...)
1238 va_start (ap, string);
1239 internal_verror (file, line, string, ap);
1243 static struct internal_problem internal_warning_problem = {
1244 "internal-warning", internal_problem_ask, internal_problem_ask
1248 internal_vwarning (const char *file, int line, const char *fmt, va_list ap)
1250 internal_vproblem (&internal_warning_problem, file, line, fmt, ap);
1254 internal_warning (const char *file, int line, const char *string, ...)
1258 va_start (ap, string);
1259 internal_vwarning (file, line, string, ap);
1263 /* Dummy functions to keep add_prefix_cmd happy. */
1266 set_internal_problem_cmd (char *args, int from_tty)
1271 show_internal_problem_cmd (char *args, int from_tty)
1275 /* When GDB reports an internal problem (error or warning) it gives
1276 the user the opportunity to quit GDB and/or create a core file of
1277 the current debug session. This function registers a few commands
1278 that make it possible to specify that GDB should always or never
1279 quit or create a core file, without asking. The commands look
1282 maint set PROBLEM-NAME quit ask|yes|no
1283 maint show PROBLEM-NAME quit
1284 maint set PROBLEM-NAME corefile ask|yes|no
1285 maint show PROBLEM-NAME corefile
1287 Where PROBLEM-NAME is currently "internal-error" or
1288 "internal-warning". */
1291 add_internal_problem_command (struct internal_problem *problem)
1293 struct cmd_list_element **set_cmd_list;
1294 struct cmd_list_element **show_cmd_list;
1298 set_cmd_list = xmalloc (sizeof (*set_cmd_list));
1299 show_cmd_list = xmalloc (sizeof (*set_cmd_list));
1300 *set_cmd_list = NULL;
1301 *show_cmd_list = NULL;
1303 set_doc = xstrprintf (_("Configure what GDB does when %s is detected."),
1306 show_doc = xstrprintf (_("Show what GDB does when %s is detected."),
1309 add_prefix_cmd ((char*) problem->name,
1310 class_maintenance, set_internal_problem_cmd, set_doc,
1312 concat ("maintenance set ", problem->name, " ",
1314 0/*allow-unknown*/, &maintenance_set_cmdlist);
1316 add_prefix_cmd ((char*) problem->name,
1317 class_maintenance, show_internal_problem_cmd, show_doc,
1319 concat ("maintenance show ", problem->name, " ",
1321 0/*allow-unknown*/, &maintenance_show_cmdlist);
1323 set_doc = xstrprintf (_("\
1324 Set whether GDB should quit when an %s is detected"),
1326 show_doc = xstrprintf (_("\
1327 Show whether GDB will quit when an %s is detected"),
1329 add_setshow_enum_cmd ("quit", class_maintenance,
1330 internal_problem_modes,
1331 &problem->should_quit,
1334 NULL, /* help_doc */
1336 NULL, /* showfunc */
1343 set_doc = xstrprintf (_("\
1344 Set whether GDB should create a core file of GDB when %s is detected"),
1346 show_doc = xstrprintf (_("\
1347 Show whether GDB will create a core file of GDB when %s is detected"),
1349 add_setshow_enum_cmd ("corefile", class_maintenance,
1350 internal_problem_modes,
1351 &problem->should_dump_core,
1354 NULL, /* help_doc */
1356 NULL, /* showfunc */
1364 /* Print the system error message for errno, and also mention STRING
1365 as the file name for which the error was encountered.
1366 Then return to command level. */
1369 perror_with_name (const char *string)
1374 err = safe_strerror (errno);
1375 combined = (char *) alloca (strlen (err) + strlen (string) + 3);
1376 strcpy (combined, string);
1377 strcat (combined, ": ");
1378 strcat (combined, err);
1380 /* I understand setting these is a matter of taste. Still, some people
1381 may clear errno but not know about bfd_error. Doing this here is not
1383 bfd_set_error (bfd_error_no_error);
1386 error (_("%s."), combined);
1389 /* Print the system error message for ERRCODE, and also mention STRING
1390 as the file name for which the error was encountered. */
1393 print_sys_errmsg (const char *string, int errcode)
1398 err = safe_strerror (errcode);
1399 combined = (char *) alloca (strlen (err) + strlen (string) + 3);
1400 strcpy (combined, string);
1401 strcat (combined, ": ");
1402 strcat (combined, err);
1404 /* We want anything which was printed on stdout to come out first, before
1406 gdb_flush (gdb_stdout);
1407 fprintf_unfiltered (gdb_stderr, "%s.\n", combined);
1410 /* Control C eventually causes this to be called, at a convenient time. */
1416 /* No steenking SIGINT will ever be coming our way when the
1417 program is resumed. Don't lie. */
1421 /* If there is no terminal switching for this target, then we can't
1422 possibly get screwed by the lack of job control. */
1423 || current_target.to_terminal_ours == NULL)
1426 fatal ("Quit (expect signal SIGINT when the program is resumed)");
1431 /* Called when a memory allocation fails, with the number of bytes of
1432 memory requested in SIZE. */
1439 internal_error (__FILE__, __LINE__,
1440 _("virtual memory exhausted: can't allocate %ld bytes."),
1445 internal_error (__FILE__, __LINE__, _("virtual memory exhausted."));
1449 /* The xmalloc() (libiberty.h) family of memory management routines.
1451 These are like the ISO-C malloc() family except that they implement
1452 consistent semantics and guard against typical memory management
1455 /* NOTE: These are declared using PTR to ensure consistency with
1456 "libiberty.h". xfree() is GDB local. */
1459 xmalloc (size_t size)
1463 /* See libiberty/xmalloc.c. This function need's to match that's
1464 semantics. It never returns NULL. */
1468 val = malloc (size); /* ARI: malloc */
1476 xzalloc (size_t size)
1478 return xcalloc (1, size);
1482 xrealloc (PTR ptr, size_t size) /* ARI: PTR */
1486 /* See libiberty/xmalloc.c. This function need's to match that's
1487 semantics. It never returns NULL. */
1492 val = realloc (ptr, size); /* ARI: realloc */
1494 val = malloc (size); /* ARI: malloc */
1502 xcalloc (size_t number, size_t size)
1506 /* See libiberty/xmalloc.c. This function need's to match that's
1507 semantics. It never returns NULL. */
1508 if (number == 0 || size == 0)
1514 mem = calloc (number, size); /* ARI: xcalloc */
1516 nomem (number * size);
1525 free (ptr); /* ARI: free */
1529 /* Like asprintf/vasprintf but get an internal_error if the call
1533 xstrprintf (const char *format, ...)
1538 va_start (args, format);
1539 ret = xstrvprintf (format, args);
1545 xasprintf (char **ret, const char *format, ...)
1549 va_start (args, format);
1550 (*ret) = xstrvprintf (format, args);
1555 xvasprintf (char **ret, const char *format, va_list ap)
1557 (*ret) = xstrvprintf (format, ap);
1561 xstrvprintf (const char *format, va_list ap)
1564 int status = vasprintf (&ret, format, ap);
1566 /* NULL is returned when there was a memory allocation problem, or
1567 any other error (for instance, a bad format string). A negative
1568 status (the printed length) with a non-NULL buffer should never
1569 happen, but just to be sure. */
1570 if (ret == NULL || status < 0)
1571 internal_error (__FILE__, __LINE__, _("vasprintf call failed"));
1576 xsnprintf (char *str, size_t size, const char *format, ...)
1581 va_start (args, format);
1582 ret = vsnprintf (str, size, format, args);
1583 gdb_assert (ret < size);
1589 /* My replacement for the read system call.
1590 Used like `read' but keeps going if `read' returns too soon. */
1593 myread (int desc, char *addr, int len)
1600 val = read (desc, addr, len);
1604 return orglen - len;
1611 /* Make a copy of the string at PTR with SIZE characters
1612 (and add a null character at the end in the copy).
1613 Uses malloc to get the space. Returns the address of the copy. */
1616 savestring (const char *ptr, size_t size)
1618 char *p = (char *) xmalloc (size + 1);
1620 memcpy (p, ptr, size);
1626 print_spaces (int n, struct ui_file *file)
1628 fputs_unfiltered (n_spaces (n), file);
1631 /* Print a host address. */
1634 gdb_print_host_address (const void *addr, struct ui_file *stream)
1636 fprintf_filtered (stream, "%s", host_address_to_string (addr));
1640 /* This function supports the query, nquery, and yquery functions.
1641 Ask user a y-or-n question and return 0 if answer is no, 1 if
1642 answer is yes, or default the answer to the specified default
1643 (for yquery or nquery). DEFCHAR may be 'y' or 'n' to provide a
1644 default answer, or '\0' for no default.
1645 CTLSTR is the control string and should end in "? ". It should
1646 not say how to answer, because we do that.
1647 ARGS are the arguments passed along with the CTLSTR argument to
1650 static int ATTRIBUTE_PRINTF (1, 0)
1651 defaulted_query (const char *ctlstr, const char defchar, va_list args)
1657 char def_answer, not_def_answer;
1658 char *y_string, *n_string, *question;
1660 /* Set up according to which answer is the default. */
1661 if (defchar == '\0')
1665 not_def_answer = 'N';
1669 else if (defchar == 'y')
1673 not_def_answer = 'N';
1681 not_def_answer = 'Y';
1686 /* Automatically answer the default value if the user did not want
1687 prompts or the command was issued with the server prefix. */
1688 if (! caution || server_command)
1691 /* If input isn't coming from the user directly, just say what
1692 question we're asking, and then answer the default automatically. This
1693 way, important error messages don't get lost when talking to GDB
1695 if (! input_from_terminal_p ())
1698 vfprintf_filtered (gdb_stdout, ctlstr, args);
1700 printf_filtered (_("(%s or %s) [answered %c; input not from terminal]\n"),
1701 y_string, n_string, def_answer);
1702 gdb_flush (gdb_stdout);
1707 if (deprecated_query_hook)
1709 return deprecated_query_hook (ctlstr, args);
1712 /* Format the question outside of the loop, to avoid reusing args. */
1713 question = xstrvprintf (ctlstr, args);
1717 wrap_here (""); /* Flush any buffered output */
1718 gdb_flush (gdb_stdout);
1720 if (annotation_level > 1)
1721 printf_filtered (("\n\032\032pre-query\n"));
1723 fputs_filtered (question, gdb_stdout);
1724 printf_filtered (_("(%s or %s) "), y_string, n_string);
1726 if (annotation_level > 1)
1727 printf_filtered (("\n\032\032query\n"));
1730 gdb_flush (gdb_stdout);
1732 answer = fgetc (stdin);
1734 /* We expect fgetc to block until a character is read. But
1735 this may not be the case if the terminal was opened with
1736 the NONBLOCK flag. In that case, if there is nothing to
1737 read on stdin, fgetc returns EOF, but also sets the error
1738 condition flag on stdin and errno to EAGAIN. With a true
1739 EOF, stdin's error condition flag is not set.
1741 A situation where this behavior was observed is a pseudo
1743 while (answer == EOF && ferror (stdin) && errno == EAGAIN)
1745 /* Not a real EOF. Wait a little while and try again until
1746 we read something. */
1749 answer = fgetc (stdin);
1752 clearerr (stdin); /* in case of C-d */
1753 if (answer == EOF) /* C-d */
1755 printf_filtered ("EOF [assumed %c]\n", def_answer);
1759 /* Eat rest of input line, to EOF or newline */
1763 ans2 = fgetc (stdin);
1766 while (ans2 != EOF && ans2 != '\n' && ans2 != '\r');
1770 /* Check answer. For the non-default, the user must specify
1771 the non-default explicitly. */
1772 if (answer == not_def_answer)
1774 retval = !def_value;
1777 /* Otherwise, if a default was specified, the user may either
1778 specify the required input or have it default by entering
1780 if (answer == def_answer
1781 || (defchar != '\0' &&
1782 (answer == '\n' || answer == '\r' || answer == EOF)))
1787 /* Invalid entries are not defaulted and require another selection. */
1788 printf_filtered (_("Please answer %s or %s.\n"),
1789 y_string, n_string);
1793 if (annotation_level > 1)
1794 printf_filtered (("\n\032\032post-query\n"));
1799 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1800 answer is yes, or 0 if answer is defaulted.
1801 Takes three args which are given to printf to print the question.
1802 The first, a control string, should end in "? ".
1803 It should not say how to answer, because we do that. */
1806 nquery (const char *ctlstr, ...)
1810 va_start (args, ctlstr);
1811 return defaulted_query (ctlstr, 'n', args);
1815 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1816 answer is yes, or 1 if answer is defaulted.
1817 Takes three args which are given to printf to print the question.
1818 The first, a control string, should end in "? ".
1819 It should not say how to answer, because we do that. */
1822 yquery (const char *ctlstr, ...)
1826 va_start (args, ctlstr);
1827 return defaulted_query (ctlstr, 'y', args);
1831 /* Ask user a y-or-n question and return 1 iff answer is yes.
1832 Takes three args which are given to printf to print the question.
1833 The first, a control string, should end in "? ".
1834 It should not say how to answer, because we do that. */
1837 query (const char *ctlstr, ...)
1841 va_start (args, ctlstr);
1842 return defaulted_query (ctlstr, '\0', args);
1846 /* A helper for parse_escape that converts a host character to a
1847 target character. C is the host character. If conversion is
1848 possible, then the target character is stored in *TARGET_C and the
1849 function returns 1. Otherwise, the function returns 0. */
1852 host_char_to_target (struct gdbarch *gdbarch, int c, int *target_c)
1854 struct obstack host_data;
1856 struct cleanup *cleanups;
1859 obstack_init (&host_data);
1860 cleanups = make_cleanup_obstack_free (&host_data);
1862 convert_between_encodings (target_charset (gdbarch), host_charset (),
1863 &the_char, 1, 1, &host_data, translit_none);
1865 if (obstack_object_size (&host_data) == 1)
1868 *target_c = *(char *) obstack_base (&host_data);
1871 do_cleanups (cleanups);
1875 /* Parse a C escape sequence. STRING_PTR points to a variable
1876 containing a pointer to the string to parse. That pointer
1877 should point to the character after the \. That pointer
1878 is updated past the characters we use. The value of the
1879 escape sequence is returned.
1881 A negative value means the sequence \ newline was seen,
1882 which is supposed to be equivalent to nothing at all.
1884 If \ is followed by a null character, we return a negative
1885 value and leave the string pointer pointing at the null character.
1887 If \ is followed by 000, we return 0 and leave the string pointer
1888 after the zeros. A value of 0 does not mean end of string. */
1891 parse_escape (struct gdbarch *gdbarch, char **string_ptr)
1893 int target_char = -2; /* initialize to avoid GCC warnings */
1894 int c = *(*string_ptr)++;
1913 int i = host_hex_value (c);
1918 if (isdigit (c) && c != '8' && c != '9')
1922 i += host_hex_value (c);
1958 if (!host_char_to_target (gdbarch, c, &target_char))
1960 ("The escape sequence `\%c' is equivalent to plain `%c', which"
1961 " has no equivalent\n" "in the `%s' character set.", c, c,
1962 target_charset (gdbarch));
1966 /* Print the character C on STREAM as part of the contents of a literal
1967 string whose delimiter is QUOTER. Note that this routine should only
1968 be call for printing things which are independent of the language
1969 of the program being debugged. */
1972 printchar (int c, void (*do_fputs) (const char *, struct ui_file *),
1973 void (*do_fprintf) (struct ui_file *, const char *, ...)
1974 ATTRIBUTE_FPTR_PRINTF_2, struct ui_file *stream, int quoter)
1976 c &= 0xFF; /* Avoid sign bit follies */
1978 if (c < 0x20 || /* Low control chars */
1979 (c >= 0x7F && c < 0xA0) || /* DEL, High controls */
1980 (sevenbit_strings && c >= 0x80))
1981 { /* high order bit set */
1985 do_fputs ("\\n", stream);
1988 do_fputs ("\\b", stream);
1991 do_fputs ("\\t", stream);
1994 do_fputs ("\\f", stream);
1997 do_fputs ("\\r", stream);
2000 do_fputs ("\\e", stream);
2003 do_fputs ("\\a", stream);
2006 do_fprintf (stream, "\\%.3o", (unsigned int) c);
2012 if (c == '\\' || c == quoter)
2013 do_fputs ("\\", stream);
2014 do_fprintf (stream, "%c", c);
2018 /* Print the character C on STREAM as part of the contents of a
2019 literal string whose delimiter is QUOTER. Note that these routines
2020 should only be call for printing things which are independent of
2021 the language of the program being debugged. */
2024 fputstr_filtered (const char *str, int quoter, struct ui_file *stream)
2027 printchar (*str++, fputs_filtered, fprintf_filtered, stream, quoter);
2031 fputstr_unfiltered (const char *str, int quoter, struct ui_file *stream)
2034 printchar (*str++, fputs_unfiltered, fprintf_unfiltered, stream, quoter);
2038 fputstrn_filtered (const char *str, int n, int quoter,
2039 struct ui_file *stream)
2043 for (i = 0; i < n; i++)
2044 printchar (str[i], fputs_filtered, fprintf_filtered, stream, quoter);
2048 fputstrn_unfiltered (const char *str, int n, int quoter,
2049 struct ui_file *stream)
2053 for (i = 0; i < n; i++)
2054 printchar (str[i], fputs_unfiltered, fprintf_unfiltered, stream, quoter);
2058 /* Number of lines per page or UINT_MAX if paging is disabled. */
2059 static unsigned int lines_per_page;
2061 show_lines_per_page (struct ui_file *file, int from_tty,
2062 struct cmd_list_element *c, const char *value)
2064 fprintf_filtered (file, _("\
2065 Number of lines gdb thinks are in a page is %s.\n"),
2069 /* Number of chars per line or UINT_MAX if line folding is disabled. */
2070 static unsigned int chars_per_line;
2072 show_chars_per_line (struct ui_file *file, int from_tty,
2073 struct cmd_list_element *c, const char *value)
2075 fprintf_filtered (file, _("\
2076 Number of characters gdb thinks are in a line is %s.\n"),
2080 /* Current count of lines printed on this page, chars on this line. */
2081 static unsigned int lines_printed, chars_printed;
2083 /* Buffer and start column of buffered text, for doing smarter word-
2084 wrapping. When someone calls wrap_here(), we start buffering output
2085 that comes through fputs_filtered(). If we see a newline, we just
2086 spit it out and forget about the wrap_here(). If we see another
2087 wrap_here(), we spit it out and remember the newer one. If we see
2088 the end of the line, we spit out a newline, the indent, and then
2089 the buffered output. */
2091 /* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
2092 are waiting to be output (they have already been counted in chars_printed).
2093 When wrap_buffer[0] is null, the buffer is empty. */
2094 static char *wrap_buffer;
2096 /* Pointer in wrap_buffer to the next character to fill. */
2097 static char *wrap_pointer;
2099 /* String to indent by if the wrap occurs. Must not be NULL if wrap_column
2101 static char *wrap_indent;
2103 /* Column number on the screen where wrap_buffer begins, or 0 if wrapping
2104 is not in effect. */
2105 static int wrap_column;
2108 /* Inialize the number of lines per page and chars per line. */
2111 init_page_info (void)
2115 lines_per_page = UINT_MAX;
2116 chars_per_line = UINT_MAX;
2120 if (!tui_get_command_dimension (&chars_per_line, &lines_per_page))
2125 #if defined(__GO32__)
2126 rows = ScreenRows ();
2127 cols = ScreenCols ();
2128 lines_per_page = rows;
2129 chars_per_line = cols;
2131 /* Make sure Readline has initialized its terminal settings. */
2132 rl_reset_terminal (NULL);
2134 /* Get the screen size from Readline. */
2135 rl_get_screen_size (&rows, &cols);
2136 lines_per_page = rows;
2137 chars_per_line = cols;
2139 /* Readline should have fetched the termcap entry for us. */
2140 if (tgetnum ("li") < 0 || getenv ("EMACS"))
2142 /* The number of lines per page is not mentioned in the
2143 terminal description. This probably means that paging is
2144 not useful (e.g. emacs shell window), so disable paging. */
2145 lines_per_page = UINT_MAX;
2148 /* FIXME: Get rid of this junk. */
2149 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
2150 SIGWINCH_HANDLER (SIGWINCH);
2153 /* If the output is not a terminal, don't paginate it. */
2154 if (!ui_file_isatty (gdb_stdout))
2155 lines_per_page = UINT_MAX;
2163 /* Helper for make_cleanup_restore_page_info. */
2166 do_restore_page_info_cleanup (void *arg)
2172 /* Provide cleanup for restoring the terminal size. */
2175 make_cleanup_restore_page_info (void)
2177 struct cleanup *back_to;
2179 back_to = make_cleanup (do_restore_page_info_cleanup, NULL);
2180 make_cleanup_restore_uinteger (&lines_per_page);
2181 make_cleanup_restore_uinteger (&chars_per_line);
2186 /* Temporarily set BATCH_FLAG and the associated unlimited terminal size.
2187 Provide cleanup for restoring the original state. */
2190 set_batch_flag_and_make_cleanup_restore_page_info (void)
2192 struct cleanup *back_to = make_cleanup_restore_page_info ();
2194 make_cleanup_restore_integer (&batch_flag);
2201 /* Set the screen size based on LINES_PER_PAGE and CHARS_PER_LINE. */
2204 set_screen_size (void)
2206 int rows = lines_per_page;
2207 int cols = chars_per_line;
2215 /* Update Readline's idea of the terminal size. */
2216 rl_set_screen_size (rows, cols);
2219 /* Reinitialize WRAP_BUFFER according to the current value of
2225 if (chars_per_line == 0)
2230 wrap_buffer = (char *) xmalloc (chars_per_line + 2);
2231 wrap_buffer[0] = '\0';
2234 wrap_buffer = (char *) xrealloc (wrap_buffer, chars_per_line + 2);
2235 wrap_pointer = wrap_buffer; /* Start it at the beginning. */
2239 set_width_command (char *args, int from_tty, struct cmd_list_element *c)
2246 set_height_command (char *args, int from_tty, struct cmd_list_element *c)
2251 /* Wait, so the user can read what's on the screen. Prompt the user
2252 to continue by pressing RETURN. */
2255 prompt_for_continue (void)
2258 char cont_prompt[120];
2260 if (annotation_level > 1)
2261 printf_unfiltered (("\n\032\032pre-prompt-for-continue\n"));
2263 strcpy (cont_prompt,
2264 "---Type <return> to continue, or q <return> to quit---");
2265 if (annotation_level > 1)
2266 strcat (cont_prompt, "\n\032\032prompt-for-continue\n");
2268 /* We must do this *before* we call gdb_readline, else it will eventually
2269 call us -- thinking that we're trying to print beyond the end of the
2271 reinitialize_more_filter ();
2274 /* On a real operating system, the user can quit with SIGINT.
2277 'q' is provided on all systems so users don't have to change habits
2278 from system to system, and because telling them what to do in
2279 the prompt is more user-friendly than expecting them to think of
2281 /* Call readline, not gdb_readline, because GO32 readline handles control-C
2282 whereas control-C to gdb_readline will cause the user to get dumped
2284 ignore = gdb_readline_wrapper (cont_prompt);
2286 if (annotation_level > 1)
2287 printf_unfiltered (("\n\032\032post-prompt-for-continue\n"));
2293 while (*p == ' ' || *p == '\t')
2296 async_request_quit (0);
2301 /* Now we have to do this again, so that GDB will know that it doesn't
2302 need to save the ---Type <return>--- line at the top of the screen. */
2303 reinitialize_more_filter ();
2305 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
2308 /* Reinitialize filter; ie. tell it to reset to original values. */
2311 reinitialize_more_filter (void)
2317 /* Indicate that if the next sequence of characters overflows the line,
2318 a newline should be inserted here rather than when it hits the end.
2319 If INDENT is non-null, it is a string to be printed to indent the
2320 wrapped part on the next line. INDENT must remain accessible until
2321 the next call to wrap_here() or until a newline is printed through
2324 If the line is already overfull, we immediately print a newline and
2325 the indentation, and disable further wrapping.
2327 If we don't know the width of lines, but we know the page height,
2328 we must not wrap words, but should still keep track of newlines
2329 that were explicitly printed.
2331 INDENT should not contain tabs, as that will mess up the char count
2332 on the next line. FIXME.
2334 This routine is guaranteed to force out any output which has been
2335 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
2336 used to force out output from the wrap_buffer. */
2339 wrap_here (char *indent)
2341 /* This should have been allocated, but be paranoid anyway. */
2343 internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
2347 *wrap_pointer = '\0';
2348 fputs_unfiltered (wrap_buffer, gdb_stdout);
2350 wrap_pointer = wrap_buffer;
2351 wrap_buffer[0] = '\0';
2352 if (chars_per_line == UINT_MAX) /* No line overflow checking */
2356 else if (chars_printed >= chars_per_line)
2358 puts_filtered ("\n");
2360 puts_filtered (indent);
2365 wrap_column = chars_printed;
2369 wrap_indent = indent;
2373 /* Print input string to gdb_stdout, filtered, with wrap,
2374 arranging strings in columns of n chars. String can be
2375 right or left justified in the column. Never prints
2376 trailing spaces. String should never be longer than
2377 width. FIXME: this could be useful for the EXAMINE
2378 command, which currently doesn't tabulate very well */
2381 puts_filtered_tabular (char *string, int width, int right)
2387 gdb_assert (chars_per_line > 0);
2388 if (chars_per_line == UINT_MAX)
2390 fputs_filtered (string, gdb_stdout);
2391 fputs_filtered ("\n", gdb_stdout);
2395 if (((chars_printed - 1) / width + 2) * width >= chars_per_line)
2396 fputs_filtered ("\n", gdb_stdout);
2398 if (width >= chars_per_line)
2399 width = chars_per_line - 1;
2401 stringlen = strlen (string);
2403 if (chars_printed > 0)
2404 spaces = width - (chars_printed - 1) % width - 1;
2406 spaces += width - stringlen;
2408 spacebuf = alloca (spaces + 1);
2409 spacebuf[spaces] = '\0';
2411 spacebuf[spaces] = ' ';
2413 fputs_filtered (spacebuf, gdb_stdout);
2414 fputs_filtered (string, gdb_stdout);
2418 /* Ensure that whatever gets printed next, using the filtered output
2419 commands, starts at the beginning of the line. I.E. if there is
2420 any pending output for the current line, flush it and start a new
2421 line. Otherwise do nothing. */
2426 if (chars_printed > 0)
2428 puts_filtered ("\n");
2433 /* Like fputs but if FILTER is true, pause after every screenful.
2435 Regardless of FILTER can wrap at points other than the final
2436 character of a line.
2438 Unlike fputs, fputs_maybe_filtered does not return a value.
2439 It is OK for LINEBUFFER to be NULL, in which case just don't print
2442 Note that a longjmp to top level may occur in this routine (only if
2443 FILTER is true) (since prompt_for_continue may do so) so this
2444 routine should not be called when cleanups are not in place. */
2447 fputs_maybe_filtered (const char *linebuffer, struct ui_file *stream,
2450 const char *lineptr;
2452 if (linebuffer == 0)
2455 /* Don't do any filtering if it is disabled. */
2456 if (stream != gdb_stdout
2457 || ! pagination_enabled
2458 || ! input_from_terminal_p ()
2459 || (lines_per_page == UINT_MAX && chars_per_line == UINT_MAX)
2460 || top_level_interpreter () == NULL
2461 || ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ())))
2463 fputs_unfiltered (linebuffer, stream);
2467 /* Go through and output each character. Show line extension
2468 when this is necessary; prompt user for new page when this is
2471 lineptr = linebuffer;
2474 /* Possible new page. */
2475 if (filter && (lines_printed >= lines_per_page - 1))
2476 prompt_for_continue ();
2478 while (*lineptr && *lineptr != '\n')
2480 /* Print a single line. */
2481 if (*lineptr == '\t')
2484 *wrap_pointer++ = '\t';
2486 fputc_unfiltered ('\t', stream);
2487 /* Shifting right by 3 produces the number of tab stops
2488 we have already passed, and then adding one and
2489 shifting left 3 advances to the next tab stop. */
2490 chars_printed = ((chars_printed >> 3) + 1) << 3;
2496 *wrap_pointer++ = *lineptr;
2498 fputc_unfiltered (*lineptr, stream);
2503 if (chars_printed >= chars_per_line)
2505 unsigned int save_chars = chars_printed;
2509 /* If we aren't actually wrapping, don't output newline --
2510 if chars_per_line is right, we probably just overflowed
2511 anyway; if it's wrong, let us keep going. */
2513 fputc_unfiltered ('\n', stream);
2515 /* Possible new page. */
2516 if (lines_printed >= lines_per_page - 1)
2517 prompt_for_continue ();
2519 /* Now output indentation and wrapped string */
2522 fputs_unfiltered (wrap_indent, stream);
2523 *wrap_pointer = '\0'; /* Null-terminate saved stuff */
2524 fputs_unfiltered (wrap_buffer, stream); /* and eject it */
2525 /* FIXME, this strlen is what prevents wrap_indent from
2526 containing tabs. However, if we recurse to print it
2527 and count its chars, we risk trouble if wrap_indent is
2528 longer than (the user settable) chars_per_line.
2529 Note also that this can set chars_printed > chars_per_line
2530 if we are printing a long string. */
2531 chars_printed = strlen (wrap_indent)
2532 + (save_chars - wrap_column);
2533 wrap_pointer = wrap_buffer; /* Reset buffer */
2534 wrap_buffer[0] = '\0';
2535 wrap_column = 0; /* And disable fancy wrap */
2540 if (*lineptr == '\n')
2543 wrap_here ((char *) 0); /* Spit out chars, cancel further wraps */
2545 fputc_unfiltered ('\n', stream);
2552 fputs_filtered (const char *linebuffer, struct ui_file *stream)
2554 fputs_maybe_filtered (linebuffer, stream, 1);
2558 putchar_unfiltered (int c)
2562 ui_file_write (gdb_stdout, &buf, 1);
2566 /* Write character C to gdb_stdout using GDB's paging mechanism and return C.
2567 May return nonlocally. */
2570 putchar_filtered (int c)
2572 return fputc_filtered (c, gdb_stdout);
2576 fputc_unfiltered (int c, struct ui_file *stream)
2580 ui_file_write (stream, &buf, 1);
2585 fputc_filtered (int c, struct ui_file *stream)
2591 fputs_filtered (buf, stream);
2595 /* puts_debug is like fputs_unfiltered, except it prints special
2596 characters in printable fashion. */
2599 puts_debug (char *prefix, char *string, char *suffix)
2603 /* Print prefix and suffix after each line. */
2604 static int new_line = 1;
2605 static int return_p = 0;
2606 static char *prev_prefix = "";
2607 static char *prev_suffix = "";
2609 if (*string == '\n')
2612 /* If the prefix is changing, print the previous suffix, a new line,
2613 and the new prefix. */
2614 if ((return_p || (strcmp (prev_prefix, prefix) != 0)) && !new_line)
2616 fputs_unfiltered (prev_suffix, gdb_stdlog);
2617 fputs_unfiltered ("\n", gdb_stdlog);
2618 fputs_unfiltered (prefix, gdb_stdlog);
2621 /* Print prefix if we printed a newline during the previous call. */
2625 fputs_unfiltered (prefix, gdb_stdlog);
2628 prev_prefix = prefix;
2629 prev_suffix = suffix;
2631 /* Output characters in a printable format. */
2632 while ((ch = *string++) != '\0')
2638 fputc_unfiltered (ch, gdb_stdlog);
2641 fprintf_unfiltered (gdb_stdlog, "\\x%02x", ch & 0xff);
2645 fputs_unfiltered ("\\\\", gdb_stdlog);
2648 fputs_unfiltered ("\\b", gdb_stdlog);
2651 fputs_unfiltered ("\\f", gdb_stdlog);
2655 fputs_unfiltered ("\\n", gdb_stdlog);
2658 fputs_unfiltered ("\\r", gdb_stdlog);
2661 fputs_unfiltered ("\\t", gdb_stdlog);
2664 fputs_unfiltered ("\\v", gdb_stdlog);
2668 return_p = ch == '\r';
2671 /* Print suffix if we printed a newline. */
2674 fputs_unfiltered (suffix, gdb_stdlog);
2675 fputs_unfiltered ("\n", gdb_stdlog);
2680 /* Print a variable number of ARGS using format FORMAT. If this
2681 information is going to put the amount written (since the last call
2682 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
2683 call prompt_for_continue to get the users permision to continue.
2685 Unlike fprintf, this function does not return a value.
2687 We implement three variants, vfprintf (takes a vararg list and stream),
2688 fprintf (takes a stream to write on), and printf (the usual).
2690 Note also that a longjmp to top level may occur in this routine
2691 (since prompt_for_continue may do so) so this routine should not be
2692 called when cleanups are not in place. */
2695 vfprintf_maybe_filtered (struct ui_file *stream, const char *format,
2696 va_list args, int filter)
2699 struct cleanup *old_cleanups;
2701 linebuffer = xstrvprintf (format, args);
2702 old_cleanups = make_cleanup (xfree, linebuffer);
2703 fputs_maybe_filtered (linebuffer, stream, filter);
2704 do_cleanups (old_cleanups);
2709 vfprintf_filtered (struct ui_file *stream, const char *format, va_list args)
2711 vfprintf_maybe_filtered (stream, format, args, 1);
2715 vfprintf_unfiltered (struct ui_file *stream, const char *format, va_list args)
2718 struct cleanup *old_cleanups;
2720 linebuffer = xstrvprintf (format, args);
2721 old_cleanups = make_cleanup (xfree, linebuffer);
2722 if (debug_timestamp && stream == gdb_stdlog)
2728 gettimeofday (&tm, NULL);
2730 len = strlen (linebuffer);
2731 need_nl = (len > 0 && linebuffer[len - 1] != '\n');
2733 timestamp = xstrprintf ("%ld:%ld %s%s",
2734 (long) tm.tv_sec, (long) tm.tv_usec,
2736 need_nl ? "\n": "");
2737 make_cleanup (xfree, timestamp);
2738 fputs_unfiltered (timestamp, stream);
2741 fputs_unfiltered (linebuffer, stream);
2742 do_cleanups (old_cleanups);
2746 vprintf_filtered (const char *format, va_list args)
2748 vfprintf_maybe_filtered (gdb_stdout, format, args, 1);
2752 vprintf_unfiltered (const char *format, va_list args)
2754 vfprintf_unfiltered (gdb_stdout, format, args);
2758 fprintf_filtered (struct ui_file *stream, const char *format, ...)
2762 va_start (args, format);
2763 vfprintf_filtered (stream, format, args);
2768 fprintf_unfiltered (struct ui_file *stream, const char *format, ...)
2772 va_start (args, format);
2773 vfprintf_unfiltered (stream, format, args);
2777 /* Like fprintf_filtered, but prints its result indented.
2778 Called as fprintfi_filtered (spaces, stream, format, ...); */
2781 fprintfi_filtered (int spaces, struct ui_file *stream, const char *format,
2786 va_start (args, format);
2787 print_spaces_filtered (spaces, stream);
2789 vfprintf_filtered (stream, format, args);
2795 printf_filtered (const char *format, ...)
2799 va_start (args, format);
2800 vfprintf_filtered (gdb_stdout, format, args);
2806 printf_unfiltered (const char *format, ...)
2810 va_start (args, format);
2811 vfprintf_unfiltered (gdb_stdout, format, args);
2815 /* Like printf_filtered, but prints it's result indented.
2816 Called as printfi_filtered (spaces, format, ...); */
2819 printfi_filtered (int spaces, const char *format, ...)
2823 va_start (args, format);
2824 print_spaces_filtered (spaces, gdb_stdout);
2825 vfprintf_filtered (gdb_stdout, format, args);
2829 /* Easy -- but watch out!
2831 This routine is *not* a replacement for puts()! puts() appends a newline.
2832 This one doesn't, and had better not! */
2835 puts_filtered (const char *string)
2837 fputs_filtered (string, gdb_stdout);
2841 puts_unfiltered (const char *string)
2843 fputs_unfiltered (string, gdb_stdout);
2846 /* Return a pointer to N spaces and a null. The pointer is good
2847 until the next call to here. */
2852 static char *spaces = 0;
2853 static int max_spaces = -1;
2859 spaces = (char *) xmalloc (n + 1);
2860 for (t = spaces + n; t != spaces;)
2866 return spaces + max_spaces - n;
2869 /* Print N spaces. */
2871 print_spaces_filtered (int n, struct ui_file *stream)
2873 fputs_filtered (n_spaces (n), stream);
2876 /* C++/ObjC demangler stuff. */
2878 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2879 LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2880 If the name is not mangled, or the language for the name is unknown, or
2881 demangling is off, the name is printed in its "raw" form. */
2884 fprintf_symbol_filtered (struct ui_file *stream, char *name,
2885 enum language lang, int arg_mode)
2891 /* If user wants to see raw output, no problem. */
2894 fputs_filtered (name, stream);
2898 demangled = language_demangle (language_def (lang), name, arg_mode);
2899 fputs_filtered (demangled ? demangled : name, stream);
2900 if (demangled != NULL)
2908 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
2909 differences in whitespace. Returns 0 if they match, non-zero if they
2910 don't (slightly different than strcmp()'s range of return values).
2912 As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
2913 This "feature" is useful when searching for matching C++ function names
2914 (such as if the user types 'break FOO', where FOO is a mangled C++
2918 strcmp_iw (const char *string1, const char *string2)
2920 while ((*string1 != '\0') && (*string2 != '\0'))
2922 while (isspace (*string1))
2926 while (isspace (*string2))
2930 if (*string1 != *string2)
2934 if (*string1 != '\0')
2940 return (*string1 != '\0' && *string1 != '(') || (*string2 != '\0');
2943 /* This is like strcmp except that it ignores whitespace and treats
2944 '(' as the first non-NULL character in terms of ordering. Like
2945 strcmp (and unlike strcmp_iw), it returns negative if STRING1 <
2946 STRING2, 0 if STRING2 = STRING2, and positive if STRING1 > STRING2
2947 according to that ordering.
2949 If a list is sorted according to this function and if you want to
2950 find names in the list that match some fixed NAME according to
2951 strcmp_iw(LIST_ELT, NAME), then the place to start looking is right
2952 where this function would put NAME.
2954 Here are some examples of why using strcmp to sort is a bad idea:
2958 Say your partial symtab contains: "foo<char *>", "goo". Then, if
2959 we try to do a search for "foo<char*>", strcmp will locate this
2960 after "foo<char *>" and before "goo". Then lookup_partial_symbol
2961 will start looking at strings beginning with "goo", and will never
2962 see the correct match of "foo<char *>".
2964 Parenthesis example:
2966 In practice, this is less like to be an issue, but I'll give it a
2967 shot. Let's assume that '$' is a legitimate character to occur in
2968 symbols. (Which may well even be the case on some systems.) Then
2969 say that the partial symbol table contains "foo$" and "foo(int)".
2970 strcmp will put them in this order, since '$' < '('. Now, if the
2971 user searches for "foo", then strcmp will sort "foo" before "foo$".
2972 Then lookup_partial_symbol will notice that strcmp_iw("foo$",
2973 "foo") is false, so it won't proceed to the actual match of
2974 "foo(int)" with "foo". */
2977 strcmp_iw_ordered (const char *string1, const char *string2)
2979 while ((*string1 != '\0') && (*string2 != '\0'))
2981 while (isspace (*string1))
2985 while (isspace (*string2))
2989 if (*string1 != *string2)
2993 if (*string1 != '\0')
3002 /* Characters are non-equal unless they're both '\0'; we want to
3003 make sure we get the comparison right according to our
3004 comparison in the cases where one of them is '\0' or '('. */
3006 if (*string2 == '\0')
3011 if (*string2 == '\0')
3016 if (*string2 == '(')
3019 return *string1 - *string2;
3023 /* A simple comparison function with opposite semantics to strcmp. */
3026 streq (const char *lhs, const char *rhs)
3028 return !strcmp (lhs, rhs);
3034 ** Answer whether string_to_compare is a full or partial match to
3035 ** template_string. The partial match must be in sequence starting
3039 subset_compare (char *string_to_compare, char *template_string)
3043 if (template_string != (char *) NULL && string_to_compare != (char *) NULL
3044 && strlen (string_to_compare) <= strlen (template_string))
3047 (template_string, string_to_compare, strlen (string_to_compare)) == 0);
3054 pagination_on_command (char *arg, int from_tty)
3056 pagination_enabled = 1;
3060 pagination_off_command (char *arg, int from_tty)
3062 pagination_enabled = 0;
3066 show_debug_timestamp (struct ui_file *file, int from_tty,
3067 struct cmd_list_element *c, const char *value)
3069 fprintf_filtered (file, _("Timestamping debugging messages is %s.\n"), value);
3074 initialize_utils (void)
3076 add_setshow_uinteger_cmd ("width", class_support, &chars_per_line, _("\
3077 Set number of characters gdb thinks are in a line."), _("\
3078 Show number of characters gdb thinks are in a line."), NULL,
3080 show_chars_per_line,
3081 &setlist, &showlist);
3083 add_setshow_uinteger_cmd ("height", class_support, &lines_per_page, _("\
3084 Set number of lines gdb thinks are in a page."), _("\
3085 Show number of lines gdb thinks are in a page."), NULL,
3087 show_lines_per_page,
3088 &setlist, &showlist);
3092 add_setshow_boolean_cmd ("demangle", class_support, &demangle, _("\
3093 Set demangling of encoded C++/ObjC names when displaying symbols."), _("\
3094 Show demangling of encoded C++/ObjC names when displaying symbols."), NULL,
3097 &setprintlist, &showprintlist);
3099 add_setshow_boolean_cmd ("pagination", class_support,
3100 &pagination_enabled, _("\
3101 Set state of pagination."), _("\
3102 Show state of pagination."), NULL,
3104 show_pagination_enabled,
3105 &setlist, &showlist);
3109 add_com ("am", class_support, pagination_on_command,
3110 _("Enable pagination"));
3111 add_com ("sm", class_support, pagination_off_command,
3112 _("Disable pagination"));
3115 add_setshow_boolean_cmd ("sevenbit-strings", class_support,
3116 &sevenbit_strings, _("\
3117 Set printing of 8-bit characters in strings as \\nnn."), _("\
3118 Show printing of 8-bit characters in strings as \\nnn."), NULL,
3120 show_sevenbit_strings,
3121 &setprintlist, &showprintlist);
3123 add_setshow_boolean_cmd ("asm-demangle", class_support, &asm_demangle, _("\
3124 Set demangling of C++/ObjC names in disassembly listings."), _("\
3125 Show demangling of C++/ObjC names in disassembly listings."), NULL,
3128 &setprintlist, &showprintlist);
3130 add_setshow_boolean_cmd ("timestamp", class_maintenance,
3131 &debug_timestamp, _("\
3132 Set timestamping of debugging messages."), _("\
3133 Show timestamping of debugging messages."), _("\
3134 When set, debugging messages will be marked with seconds and microseconds."),
3136 show_debug_timestamp,
3137 &setdebuglist, &showdebuglist);
3140 /* Machine specific function to handle SIGWINCH signal. */
3142 #ifdef SIGWINCH_HANDLER_BODY
3143 SIGWINCH_HANDLER_BODY
3145 /* print routines to handle variable size regs, etc. */
3146 /* temporary storage using circular buffer */
3152 static char buf[NUMCELLS][CELLSIZE];
3153 static int cell = 0;
3155 if (++cell >= NUMCELLS)
3161 paddress (struct gdbarch *gdbarch, CORE_ADDR addr)
3163 /* Truncate address to the size of a target address, avoiding shifts
3164 larger or equal than the width of a CORE_ADDR. The local
3165 variable ADDR_BIT stops the compiler reporting a shift overflow
3166 when it won't occur. */
3167 /* NOTE: This assumes that the significant address information is
3168 kept in the least significant bits of ADDR - the upper bits were
3169 either zero or sign extended. Should gdbarch_address_to_pointer or
3170 some ADDRESS_TO_PRINTABLE() be used to do the conversion? */
3172 int addr_bit = gdbarch_addr_bit (gdbarch);
3174 if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
3175 addr &= ((CORE_ADDR) 1 << addr_bit) - 1;
3176 return hex_string (addr);
3180 decimal2str (char *sign, ULONGEST addr, int width)
3182 /* Steal code from valprint.c:print_decimal(). Should this worry
3183 about the real size of addr as the above does? */
3184 unsigned long temp[3];
3185 char *str = get_cell ();
3190 temp[i] = addr % (1000 * 1000 * 1000);
3191 addr /= (1000 * 1000 * 1000);
3195 while (addr != 0 && i < (sizeof (temp) / sizeof (temp[0])));
3204 xsnprintf (str, CELLSIZE, "%s%0*lu", sign, width, temp[0]);
3207 xsnprintf (str, CELLSIZE, "%s%0*lu%09lu", sign, width,
3211 xsnprintf (str, CELLSIZE, "%s%0*lu%09lu%09lu", sign, width,
3212 temp[2], temp[1], temp[0]);
3215 internal_error (__FILE__, __LINE__,
3216 _("failed internal consistency check"));
3223 octal2str (ULONGEST addr, int width)
3225 unsigned long temp[3];
3226 char *str = get_cell ();
3231 temp[i] = addr % (0100000 * 0100000);
3232 addr /= (0100000 * 0100000);
3236 while (addr != 0 && i < (sizeof (temp) / sizeof (temp[0])));
3246 xsnprintf (str, CELLSIZE, "%*o", width, 0);
3248 xsnprintf (str, CELLSIZE, "0%0*lo", width, temp[0]);
3251 xsnprintf (str, CELLSIZE, "0%0*lo%010lo", width, temp[1], temp[0]);
3254 xsnprintf (str, CELLSIZE, "0%0*lo%010lo%010lo", width,
3255 temp[2], temp[1], temp[0]);
3258 internal_error (__FILE__, __LINE__,
3259 _("failed internal consistency check"));
3266 pulongest (ULONGEST u)
3268 return decimal2str ("", u, 0);
3272 plongest (LONGEST l)
3275 return decimal2str ("-", -l, 0);
3277 return decimal2str ("", l, 0);
3280 /* Eliminate warning from compiler on 32-bit systems. */
3281 static int thirty_two = 32;
3284 phex (ULONGEST l, int sizeof_l)
3292 xsnprintf (str, CELLSIZE, "%08lx%08lx",
3293 (unsigned long) (l >> thirty_two),
3294 (unsigned long) (l & 0xffffffff));
3298 xsnprintf (str, CELLSIZE, "%08lx", (unsigned long) l);
3302 xsnprintf (str, CELLSIZE, "%04x", (unsigned short) (l & 0xffff));
3305 str = phex (l, sizeof (l));
3313 phex_nz (ULONGEST l, int sizeof_l)
3321 unsigned long high = (unsigned long) (l >> thirty_two);
3325 xsnprintf (str, CELLSIZE, "%lx",
3326 (unsigned long) (l & 0xffffffff));
3328 xsnprintf (str, CELLSIZE, "%lx%08lx", high,
3329 (unsigned long) (l & 0xffffffff));
3334 xsnprintf (str, CELLSIZE, "%lx", (unsigned long) l);
3338 xsnprintf (str, CELLSIZE, "%x", (unsigned short) (l & 0xffff));
3341 str = phex_nz (l, sizeof (l));
3348 /* Converts a LONGEST to a C-format hexadecimal literal and stores it
3349 in a static string. Returns a pointer to this string. */
3351 hex_string (LONGEST num)
3353 char *result = get_cell ();
3355 xsnprintf (result, CELLSIZE, "0x%s", phex_nz (num, sizeof (num)));
3359 /* Converts a LONGEST number to a C-format hexadecimal literal and
3360 stores it in a static string. Returns a pointer to this string
3361 that is valid until the next call. The number is padded on the
3362 left with 0s to at least WIDTH characters. */
3364 hex_string_custom (LONGEST num, int width)
3366 char *result = get_cell ();
3367 char *result_end = result + CELLSIZE - 1;
3368 const char *hex = phex_nz (num, sizeof (num));
3369 int hex_len = strlen (hex);
3371 if (hex_len > width)
3373 if (width + 2 >= CELLSIZE)
3374 internal_error (__FILE__, __LINE__,
3375 _("hex_string_custom: insufficient space to store result"));
3377 strcpy (result_end - width - 2, "0x");
3378 memset (result_end - width, '0', width);
3379 strcpy (result_end - hex_len, hex);
3380 return result_end - width - 2;
3383 /* Convert VAL to a numeral in the given radix. For
3384 * radix 10, IS_SIGNED may be true, indicating a signed quantity;
3385 * otherwise VAL is interpreted as unsigned. If WIDTH is supplied,
3386 * it is the minimum width (0-padded if needed). USE_C_FORMAT means
3387 * to use C format in all cases. If it is false, then 'x'
3388 * and 'o' formats do not include a prefix (0x or leading 0). */
3391 int_string (LONGEST val, int radix, int is_signed, int width,
3401 result = hex_string (val);
3403 result = hex_string_custom (val, width);
3410 if (is_signed && val < 0)
3411 return decimal2str ("-", -val, width);
3413 return decimal2str ("", val, width);
3417 char *result = octal2str (val, width);
3419 if (use_c_format || val == 0)
3425 internal_error (__FILE__, __LINE__,
3426 _("failed internal consistency check"));
3430 /* Convert a CORE_ADDR into a string. */
3432 core_addr_to_string (const CORE_ADDR addr)
3434 char *str = get_cell ();
3437 strcat (str, phex (addr, sizeof (addr)));
3442 core_addr_to_string_nz (const CORE_ADDR addr)
3444 char *str = get_cell ();
3447 strcat (str, phex_nz (addr, sizeof (addr)));
3451 /* Convert a string back into a CORE_ADDR. */
3453 string_to_core_addr (const char *my_string)
3457 if (my_string[0] == '0' && tolower (my_string[1]) == 'x')
3459 /* Assume that it is in hex. */
3462 for (i = 2; my_string[i] != '\0'; i++)
3464 if (isdigit (my_string[i]))
3465 addr = (my_string[i] - '0') + (addr * 16);
3466 else if (isxdigit (my_string[i]))
3467 addr = (tolower (my_string[i]) - 'a' + 0xa) + (addr * 16);
3469 error (_("invalid hex \"%s\""), my_string);
3474 /* Assume that it is in decimal. */
3477 for (i = 0; my_string[i] != '\0'; i++)
3479 if (isdigit (my_string[i]))
3480 addr = (my_string[i] - '0') + (addr * 10);
3482 error (_("invalid decimal \"%s\""), my_string);
3490 host_address_to_string (const void *addr)
3492 char *str = get_cell ();
3494 xsnprintf (str, CELLSIZE, "0x%s", phex_nz ((uintptr_t) addr, sizeof (addr)));
3499 gdb_realpath (const char *filename)
3501 /* Method 1: The system has a compile time upper bound on a filename
3502 path. Use that and realpath() to canonicalize the name. This is
3503 the most common case. Note that, if there isn't a compile time
3504 upper bound, you want to avoid realpath() at all costs. */
3505 #if defined(HAVE_REALPATH)
3507 # if defined (PATH_MAX)
3509 # define USE_REALPATH
3510 # elif defined (MAXPATHLEN)
3511 char buf[MAXPATHLEN];
3512 # define USE_REALPATH
3514 # if defined (USE_REALPATH)
3515 const char *rp = realpath (filename, buf);
3519 return xstrdup (rp);
3522 #endif /* HAVE_REALPATH */
3524 /* Method 2: The host system (i.e., GNU) has the function
3525 canonicalize_file_name() which malloc's a chunk of memory and
3526 returns that, use that. */
3527 #if defined(HAVE_CANONICALIZE_FILE_NAME)
3529 char *rp = canonicalize_file_name (filename);
3532 return xstrdup (filename);
3538 /* FIXME: cagney/2002-11-13:
3540 Method 2a: Use realpath() with a NULL buffer. Some systems, due
3541 to the problems described in in method 3, have modified their
3542 realpath() implementation so that it will allocate a buffer when
3543 NULL is passed in. Before this can be used, though, some sort of
3544 configure time test would need to be added. Otherwize the code
3545 will likely core dump. */
3547 /* Method 3: Now we're getting desperate! The system doesn't have a
3548 compile time buffer size and no alternative function. Query the
3549 OS, using pathconf(), for the buffer limit. Care is needed
3550 though, some systems do not limit PATH_MAX (return -1 for
3551 pathconf()) making it impossible to pass a correctly sized buffer
3552 to realpath() (it could always overflow). On those systems, we
3554 #if defined (HAVE_REALPATH) && defined (HAVE_UNISTD_H) && defined(HAVE_ALLOCA)
3556 /* Find out the max path size. */
3557 long path_max = pathconf ("/", _PC_PATH_MAX);
3561 /* PATH_MAX is bounded. */
3562 char *buf = alloca (path_max);
3563 char *rp = realpath (filename, buf);
3565 return xstrdup (rp ? rp : filename);
3570 /* This system is a lost cause, just dup the buffer. */
3571 return xstrdup (filename);
3574 /* Return a copy of FILENAME, with its directory prefix canonicalized
3578 xfullpath (const char *filename)
3580 const char *base_name = lbasename (filename);
3585 /* Extract the basename of filename, and return immediately
3586 a copy of filename if it does not contain any directory prefix. */
3587 if (base_name == filename)
3588 return xstrdup (filename);
3590 dir_name = alloca ((size_t) (base_name - filename + 2));
3591 /* Allocate enough space to store the dir_name + plus one extra
3592 character sometimes needed under Windows (see below), and
3593 then the closing \000 character */
3594 strncpy (dir_name, filename, base_name - filename);
3595 dir_name[base_name - filename] = '\000';
3597 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3598 /* We need to be careful when filename is of the form 'd:foo', which
3599 is equivalent of d:./foo, which is totally different from d:/foo. */
3600 if (strlen (dir_name) == 2 && isalpha (dir_name[0]) && dir_name[1] == ':')
3603 dir_name[3] = '\000';
3607 /* Canonicalize the directory prefix, and build the resulting
3608 filename. If the dirname realpath already contains an ending
3609 directory separator, avoid doubling it. */
3610 real_path = gdb_realpath (dir_name);
3611 if (IS_DIR_SEPARATOR (real_path[strlen (real_path) - 1]))
3612 result = concat (real_path, base_name, (char *) NULL);
3614 result = concat (real_path, SLASH_STRING, base_name, (char *) NULL);
3621 /* This is the 32-bit CRC function used by the GNU separate debug
3622 facility. An executable may contain a section named
3623 .gnu_debuglink, which holds the name of a separate executable file
3624 containing its debug info, and a checksum of that file's contents,
3625 computed using this function. */
3627 gnu_debuglink_crc32 (unsigned long crc, unsigned char *buf, size_t len)
3629 static const unsigned int crc32_table[256] = {
3630 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
3631 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
3632 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
3633 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
3634 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
3635 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
3636 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
3637 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
3638 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
3639 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
3640 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
3641 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
3642 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
3643 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
3644 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
3645 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
3646 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
3647 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
3648 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
3649 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
3650 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
3651 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
3652 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
3653 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
3654 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
3655 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
3656 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
3657 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
3658 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
3659 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
3660 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
3661 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
3662 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
3663 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
3664 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
3665 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
3666 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
3667 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
3668 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
3669 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
3670 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
3671 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
3672 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
3673 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
3674 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
3675 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
3676 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
3677 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
3678 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
3679 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
3680 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
3685 crc = ~crc & 0xffffffff;
3686 for (end = buf + len; buf < end; ++buf)
3687 crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
3688 return ~crc & 0xffffffff;;
3692 align_up (ULONGEST v, int n)
3694 /* Check that N is really a power of two. */
3695 gdb_assert (n && (n & (n-1)) == 0);
3696 return (v + n - 1) & -n;
3700 align_down (ULONGEST v, int n)
3702 /* Check that N is really a power of two. */
3703 gdb_assert (n && (n & (n-1)) == 0);
3707 /* Allocation function for the libiberty hash table which uses an
3708 obstack. The obstack is passed as DATA. */
3711 hashtab_obstack_allocate (void *data, size_t size, size_t count)
3713 unsigned int total = size * count;
3714 void *ptr = obstack_alloc ((struct obstack *) data, total);
3716 memset (ptr, 0, total);
3720 /* Trivial deallocation function for the libiberty splay tree and hash
3721 table - don't deallocate anything. Rely on later deletion of the
3722 obstack. DATA will be the obstack, although it is not needed
3726 dummy_obstack_deallocate (void *object, void *data)
3731 /* The bit offset of the highest byte in a ULONGEST, for overflow
3734 #define HIGH_BYTE_POSN ((sizeof (ULONGEST) - 1) * HOST_CHAR_BIT)
3736 /* True (non-zero) iff DIGIT is a valid digit in radix BASE,
3737 where 2 <= BASE <= 36. */
3740 is_digit_in_base (unsigned char digit, int base)
3742 if (!isalnum (digit))
3745 return (isdigit (digit) && digit < base + '0');
3747 return (isdigit (digit) || tolower (digit) < base - 10 + 'a');
3751 digit_to_int (unsigned char c)
3756 return tolower (c) - 'a' + 10;
3759 /* As for strtoul, but for ULONGEST results. */
3762 strtoulst (const char *num, const char **trailer, int base)
3764 unsigned int high_part;
3769 /* Skip leading whitespace. */
3770 while (isspace (num[i]))
3773 /* Handle prefixes. */
3776 else if (num[i] == '-')
3782 if (base == 0 || base == 16)
3784 if (num[i] == '0' && (num[i + 1] == 'x' || num[i + 1] == 'X'))
3792 if (base == 0 && num[i] == '0')
3798 if (base < 2 || base > 36)
3804 result = high_part = 0;
3805 for (; is_digit_in_base (num[i], base); i += 1)
3807 result = result * base + digit_to_int (num[i]);
3808 high_part = high_part * base + (unsigned int) (result >> HIGH_BYTE_POSN);
3809 result &= ((ULONGEST) 1 << HIGH_BYTE_POSN) - 1;
3810 if (high_part > 0xff)
3813 result = ~ (ULONGEST) 0;
3820 if (trailer != NULL)
3823 result = result + ((ULONGEST) high_part << HIGH_BYTE_POSN);
3830 /* Simple, portable version of dirname that does not modify its
3834 ldirname (const char *filename)
3836 const char *base = lbasename (filename);
3839 while (base > filename && IS_DIR_SEPARATOR (base[-1]))
3842 if (base == filename)
3845 dirname = xmalloc (base - filename + 2);
3846 memcpy (dirname, filename, base - filename);
3848 /* On DOS based file systems, convert "d:foo" to "d:.", so that we
3849 create "d:./bar" later instead of the (different) "d:/bar". */
3850 if (base - filename == 2 && IS_ABSOLUTE_PATH (base)
3851 && !IS_DIR_SEPARATOR (filename[0]))
3852 dirname[base++ - filename] = '.';
3854 dirname[base - filename] = '\0';
3858 /* Call libiberty's buildargv, and return the result.
3859 If buildargv fails due to out-of-memory, call nomem.
3860 Therefore, the returned value is guaranteed to be non-NULL,
3861 unless the parameter itself is NULL. */
3864 gdb_buildargv (const char *s)
3866 char **argv = buildargv (s);
3868 if (s != NULL && argv == NULL)
3874 compare_positive_ints (const void *ap, const void *bp)
3876 /* Because we know we're comparing two ints which are positive,
3877 there's no danger of overflow here. */
3878 return * (int *) ap - * (int *) bp;
3881 #define AMBIGUOUS_MESS1 ".\nMatching formats:"
3882 #define AMBIGUOUS_MESS2 ".\nUse \"set gnutarget format-name\" to specify the format."
3885 gdb_bfd_errmsg (bfd_error_type error_tag, char **matching)
3891 /* Check if errmsg just need simple return. */
3892 if (error_tag != bfd_error_file_ambiguously_recognized || matching == NULL)
3893 return bfd_errmsg (error_tag);
3895 ret_len = strlen (bfd_errmsg (error_tag)) + strlen (AMBIGUOUS_MESS1)
3896 + strlen (AMBIGUOUS_MESS2);
3897 for (p = matching; *p; p++)
3898 ret_len += strlen (*p) + 1;
3899 ret = xmalloc (ret_len + 1);
3901 make_cleanup (xfree, ret);
3903 strcpy (retp, bfd_errmsg (error_tag));
3904 retp += strlen (retp);
3906 strcpy (retp, AMBIGUOUS_MESS1);
3907 retp += strlen (retp);
3909 for (p = matching; *p; p++)
3911 sprintf (retp, " %s", *p);
3912 retp += strlen (retp);
3916 strcpy (retp, AMBIGUOUS_MESS2);
3921 /* Return ARGS parsed as a valid pid, or throw an error. */
3924 parse_pid_to_attach (char *args)
3930 error_no_arg (_("process-id to attach"));
3933 pid = strtoul (args, &dummy, 0);
3934 /* Some targets don't set errno on errors, grrr! */
3935 if ((pid == 0 && dummy == args) || dummy != &args[strlen (args)])
3936 error (_("Illegal process-id: %s."), args);
3941 /* Provide a prototype to silence -Wmissing-prototypes. */
3942 extern initialize_file_ftype _initialize_utils;
3945 _initialize_utils (void)
3947 add_internal_problem_command (&internal_error_problem);
3948 add_internal_problem_command (&internal_warning_problem);