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
);
315 do_free_section_addr_info (void *arg
)
317 free_section_addr_info (arg
);
321 make_cleanup_free_section_addr_info (struct section_addr_info
*addrs
)
323 return make_my_cleanup (&cleanup_chain
, do_free_section_addr_info
, addrs
);
326 struct restore_integer_closure
333 restore_integer (void *p
)
335 struct restore_integer_closure
*closure
= p
;
337 *(closure
->variable
) = closure
->value
;
340 /* Remember the current value of *VARIABLE and make it restored when the cleanup
343 make_cleanup_restore_integer (int *variable
)
345 struct restore_integer_closure
*c
=
346 xmalloc (sizeof (struct restore_integer_closure
));
348 c
->variable
= variable
;
349 c
->value
= *variable
;
351 return make_my_cleanup2 (&cleanup_chain
, restore_integer
, (void *)c
,
356 make_my_cleanup2 (struct cleanup
**pmy_chain
, make_cleanup_ftype
*function
,
357 void *arg
, void (*free_arg
) (void *))
360 = (struct cleanup
*) xmalloc (sizeof (struct cleanup
));
361 struct cleanup
*old_chain
= *pmy_chain
;
363 new->next
= *pmy_chain
;
364 new->function
= function
;
365 new->free_arg
= free_arg
;
373 make_my_cleanup (struct cleanup
**pmy_chain
, make_cleanup_ftype
*function
,
376 return make_my_cleanup2 (pmy_chain
, function
, arg
, NULL
);
379 /* Discard cleanups and do the actions they describe
380 until we get back to the point OLD_CHAIN in the cleanup_chain. */
383 do_cleanups (struct cleanup
*old_chain
)
385 do_my_cleanups (&cleanup_chain
, old_chain
);
389 do_final_cleanups (struct cleanup
*old_chain
)
391 do_my_cleanups (&final_cleanup_chain
, old_chain
);
395 do_my_cleanups (struct cleanup
**pmy_chain
,
396 struct cleanup
*old_chain
)
400 while ((ptr
= *pmy_chain
) != old_chain
)
402 *pmy_chain
= ptr
->next
; /* Do this first incase recursion */
403 (*ptr
->function
) (ptr
->arg
);
405 (*ptr
->free_arg
) (ptr
->arg
);
410 /* Discard cleanups, not doing the actions they describe,
411 until we get back to the point OLD_CHAIN in the cleanup_chain. */
414 discard_cleanups (struct cleanup
*old_chain
)
416 discard_my_cleanups (&cleanup_chain
, old_chain
);
420 discard_final_cleanups (struct cleanup
*old_chain
)
422 discard_my_cleanups (&final_cleanup_chain
, old_chain
);
426 discard_my_cleanups (struct cleanup
**pmy_chain
,
427 struct cleanup
*old_chain
)
431 while ((ptr
= *pmy_chain
) != old_chain
)
433 *pmy_chain
= ptr
->next
;
435 (*ptr
->free_arg
) (ptr
->arg
);
440 /* Set the cleanup_chain to 0, and return the old cleanup chain. */
444 return save_my_cleanups (&cleanup_chain
);
448 save_final_cleanups (void)
450 return save_my_cleanups (&final_cleanup_chain
);
454 save_my_cleanups (struct cleanup
**pmy_chain
)
456 struct cleanup
*old_chain
= *pmy_chain
;
462 /* Restore the cleanup chain from a previously saved chain. */
464 restore_cleanups (struct cleanup
*chain
)
466 restore_my_cleanups (&cleanup_chain
, chain
);
470 restore_final_cleanups (struct cleanup
*chain
)
472 restore_my_cleanups (&final_cleanup_chain
, chain
);
476 restore_my_cleanups (struct cleanup
**pmy_chain
, struct cleanup
*chain
)
481 /* This function is useful for cleanups.
485 old_chain = make_cleanup (free_current_contents, &foo);
487 to arrange to free the object thus allocated. */
490 free_current_contents (void *ptr
)
492 void **location
= ptr
;
494 if (location
== NULL
)
495 internal_error (__FILE__
, __LINE__
,
496 _("free_current_contents: NULL pointer"));
497 if (*location
!= NULL
)
504 /* Provide a known function that does nothing, to use as a base for
505 for a possibly long chain of cleanups. This is useful where we
506 use the cleanup chain for handling normal cleanups as well as dealing
507 with cleanups that need to be done as a result of a call to error().
508 In such cases, we may not be certain where the first cleanup is, unless
509 we have a do-nothing one to always use as the base. */
512 null_cleanup (void *arg
)
516 /* Continuations are implemented as cleanups internally. Inherit from
523 /* Add a continuation to the continuation list of THREAD. The new
524 continuation will be added at the front. */
526 add_continuation (struct thread_info
*thread
,
527 void (*continuation_hook
) (void *), void *args
,
528 void (*continuation_free_args
) (void *))
530 struct cleanup
*as_cleanup
= &thread
->continuations
->base
;
531 make_cleanup_ftype
*continuation_hook_fn
= continuation_hook
;
533 make_my_cleanup2 (&as_cleanup
,
534 continuation_hook_fn
,
536 continuation_free_args
);
538 thread
->continuations
= (struct continuation
*) as_cleanup
;
541 /* Add a continuation to the continuation list of INFERIOR. The new
542 continuation will be added at the front. */
545 add_inferior_continuation (void (*continuation_hook
) (void *), void *args
,
546 void (*continuation_free_args
) (void *))
548 struct inferior
*inf
= current_inferior ();
549 struct cleanup
*as_cleanup
= &inf
->continuations
->base
;
550 make_cleanup_ftype
*continuation_hook_fn
= continuation_hook
;
552 make_my_cleanup2 (&as_cleanup
,
553 continuation_hook_fn
,
555 continuation_free_args
);
557 inf
->continuations
= (struct continuation
*) as_cleanup
;
560 /* Do all continuations of the current inferior. */
563 do_all_inferior_continuations (void)
565 struct cleanup
*as_cleanup
;
566 struct inferior
*inf
= current_inferior ();
568 if (inf
->continuations
== NULL
)
571 /* Copy the list header into another pointer, and set the global
572 list header to null, so that the global list can change as a side
573 effect of invoking the continuations and the processing of the
574 preexisting continuations will not be affected. */
576 as_cleanup
= &inf
->continuations
->base
;
577 inf
->continuations
= NULL
;
579 /* Work now on the list we have set aside. */
580 do_my_cleanups (&as_cleanup
, NULL
);
583 /* Get rid of all the inferior-wide continuations of INF. */
586 discard_all_inferior_continuations (struct inferior
*inf
)
588 struct cleanup
*continuation_ptr
= &inf
->continuations
->base
;
590 discard_my_cleanups (&continuation_ptr
, NULL
);
591 inf
->continuations
= NULL
;
595 restore_thread_cleanup (void *arg
)
597 ptid_t
*ptid_p
= arg
;
599 switch_to_thread (*ptid_p
);
602 /* Walk down the continuation list of PTID, and execute all the
603 continuations. There is a problem though. In some cases new
604 continuations may be added while we are in the middle of this loop.
605 If this happens they will be added in the front, and done before we
606 have a chance of exhausting those that were already there. We need
607 to then save the beginning of the list in a pointer and do the
608 continuations from there on, instead of using the global beginning
609 of list as our iteration pointer. */
611 do_all_continuations_ptid (ptid_t ptid
,
612 struct continuation
**continuations_p
)
614 struct cleanup
*old_chain
;
615 ptid_t current_thread
;
616 struct cleanup
*as_cleanup
;
618 if (*continuations_p
== NULL
)
621 current_thread
= inferior_ptid
;
623 /* Restore selected thread on exit. Don't try to restore the frame
626 - When running continuations, the selected frame is always #0.
628 - The continuations may trigger symbol file loads, which may
629 change the frame layout (frame ids change), which would trigger
630 a warning if we used make_cleanup_restore_current_thread. */
632 old_chain
= make_cleanup (restore_thread_cleanup
, ¤t_thread
);
634 /* Let the continuation see this thread as selected. */
635 switch_to_thread (ptid
);
637 /* Copy the list header into another pointer, and set the global
638 list header to null, so that the global list can change as a side
639 effect of invoking the continuations and the processing of the
640 preexisting continuations will not be affected. */
642 as_cleanup
= &(*continuations_p
)->base
;
643 *continuations_p
= NULL
;
645 /* Work now on the list we have set aside. */
646 do_my_cleanups (&as_cleanup
, NULL
);
648 do_cleanups (old_chain
);
651 /* Callback for iterate over threads. */
653 do_all_continuations_thread_callback (struct thread_info
*thread
, void *data
)
655 do_all_continuations_ptid (thread
->ptid
, &thread
->continuations
);
659 /* Do all continuations of thread THREAD. */
661 do_all_continuations_thread (struct thread_info
*thread
)
663 do_all_continuations_thread_callback (thread
, NULL
);
666 /* Do all continuations of all threads. */
668 do_all_continuations (void)
670 iterate_over_threads (do_all_continuations_thread_callback
, NULL
);
673 /* Callback for iterate over threads. */
675 discard_all_continuations_thread_callback (struct thread_info
*thread
,
678 struct cleanup
*continuation_ptr
= &thread
->continuations
->base
;
680 discard_my_cleanups (&continuation_ptr
, NULL
);
681 thread
->continuations
= NULL
;
685 /* Get rid of all the continuations of THREAD. */
687 discard_all_continuations_thread (struct thread_info
*thread
)
689 discard_all_continuations_thread_callback (thread
, NULL
);
692 /* Get rid of all the continuations of all threads. */
694 discard_all_continuations (void)
696 iterate_over_threads (discard_all_continuations_thread_callback
, NULL
);
700 /* Add a continuation to the intermediate continuation list of THREAD.
701 The new continuation will be added at the front. */
703 add_intermediate_continuation (struct thread_info
*thread
,
704 void (*continuation_hook
)
705 (void *), void *args
,
706 void (*continuation_free_args
) (void *))
708 struct cleanup
*as_cleanup
= &thread
->intermediate_continuations
->base
;
709 make_cleanup_ftype
*continuation_hook_fn
= continuation_hook
;
711 make_my_cleanup2 (&as_cleanup
,
712 continuation_hook_fn
,
714 continuation_free_args
);
716 thread
->intermediate_continuations
= (struct continuation
*) as_cleanup
;
719 /* Walk down the cmd_continuation list, and execute all the
720 continuations. There is a problem though. In some cases new
721 continuations may be added while we are in the middle of this
722 loop. If this happens they will be added in the front, and done
723 before we have a chance of exhausting those that were already
724 there. We need to then save the beginning of the list in a pointer
725 and do the continuations from there on, instead of using the
726 global beginning of list as our iteration pointer.*/
728 do_all_intermediate_continuations_thread_callback (struct thread_info
*thread
,
731 do_all_continuations_ptid (thread
->ptid
,
732 &thread
->intermediate_continuations
);
736 /* Do all intermediate continuations of thread THREAD. */
738 do_all_intermediate_continuations_thread (struct thread_info
*thread
)
740 do_all_intermediate_continuations_thread_callback (thread
, NULL
);
743 /* Do all intermediate continuations of all threads. */
745 do_all_intermediate_continuations (void)
747 iterate_over_threads (do_all_intermediate_continuations_thread_callback
, NULL
);
750 /* Callback for iterate over threads. */
752 discard_all_intermediate_continuations_thread_callback (struct thread_info
*thread
,
755 struct cleanup
*continuation_ptr
= &thread
->intermediate_continuations
->base
;
757 discard_my_cleanups (&continuation_ptr
, NULL
);
758 thread
->intermediate_continuations
= NULL
;
762 /* Get rid of all the intermediate continuations of THREAD. */
764 discard_all_intermediate_continuations_thread (struct thread_info
*thread
)
766 discard_all_intermediate_continuations_thread_callback (thread
, NULL
);
769 /* Get rid of all the intermediate continuations of all threads. */
771 discard_all_intermediate_continuations (void)
773 iterate_over_threads (discard_all_intermediate_continuations_thread_callback
, NULL
);
778 /* Print a warning message. The first argument STRING is the warning
779 message, used as an fprintf format string, the second is the
780 va_list of arguments for that string. A warning is unfiltered (not
781 paginated) so that the user does not need to page through each
782 screen full of warnings when there are lots of them. */
785 vwarning (const char *string
, va_list args
)
787 if (deprecated_warning_hook
)
788 (*deprecated_warning_hook
) (string
, args
);
791 target_terminal_ours ();
792 wrap_here (""); /* Force out any buffered output */
793 gdb_flush (gdb_stdout
);
794 if (warning_pre_print
)
795 fputs_unfiltered (warning_pre_print
, gdb_stderr
);
796 vfprintf_unfiltered (gdb_stderr
, string
, args
);
797 fprintf_unfiltered (gdb_stderr
, "\n");
802 /* Print a warning message.
803 The first argument STRING is the warning message, used as a fprintf string,
804 and the remaining args are passed as arguments to it.
805 The primary difference between warnings and errors is that a warning
806 does not force the return to command level. */
809 warning (const char *string
, ...)
813 va_start (args
, string
);
814 vwarning (string
, args
);
818 /* Print an error message and return to command level.
819 The first argument STRING is the error message, used as a fprintf string,
820 and the remaining args are passed as arguments to it. */
823 verror (const char *string
, va_list args
)
825 throw_verror (GENERIC_ERROR
, string
, args
);
829 error (const char *string
, ...)
833 va_start (args
, string
);
834 throw_verror (GENERIC_ERROR
, string
, args
);
838 /* Print an error message and quit.
839 The first argument STRING is the error message, used as a fprintf string,
840 and the remaining args are passed as arguments to it. */
843 vfatal (const char *string
, va_list args
)
845 throw_vfatal (string
, args
);
849 fatal (const char *string
, ...)
853 va_start (args
, string
);
854 throw_vfatal (string
, args
);
859 error_stream (struct ui_file
*stream
)
861 char *message
= ui_file_xstrdup (stream
, NULL
);
863 make_cleanup (xfree
, message
);
864 error (("%s"), message
);
867 /* Dump core trying to increase the core soft limit to hard limit first. */
872 #ifdef HAVE_SETRLIMIT
873 struct rlimit rlim
= { RLIM_INFINITY
, RLIM_INFINITY
};
875 setrlimit (RLIMIT_CORE
, &rlim
);
876 #endif /* HAVE_SETRLIMIT */
878 abort (); /* NOTE: GDB has only three calls to abort(). */
881 /* Check whether GDB will be able to dump core using the dump_core function. */
884 can_dump_core (const char *reason
)
886 #ifdef HAVE_GETRLIMIT
889 /* Be quiet and assume we can dump if an error is returned. */
890 if (getrlimit (RLIMIT_CORE
, &rlim
) != 0)
893 if (rlim
.rlim_max
== 0)
895 fprintf_unfiltered (gdb_stderr
,
896 _("%s\nUnable to dump core, use `ulimit -c unlimited'"
897 " before executing GDB next time.\n"), reason
);
900 #endif /* HAVE_GETRLIMIT */
905 /* Allow the user to configure the debugger behavior with respect to
906 what to do when an internal problem is detected. */
908 const char internal_problem_ask
[] = "ask";
909 const char internal_problem_yes
[] = "yes";
910 const char internal_problem_no
[] = "no";
911 static const char *internal_problem_modes
[] =
913 internal_problem_ask
,
914 internal_problem_yes
,
919 /* Print a message reporting an internal error/warning. Ask the user
920 if they want to continue, dump core, or just exit. Return
921 something to indicate a quit. */
923 struct internal_problem
926 const char *should_quit
;
927 const char *should_dump_core
;
930 /* Report a problem, internal to GDB, to the user. Once the problem
931 has been reported, and assuming GDB didn't quit, the caller can
932 either allow execution to resume or throw an error. */
934 static void ATTRIBUTE_PRINTF (4, 0)
935 internal_vproblem (struct internal_problem
*problem
,
936 const char *file
, int line
, const char *fmt
, va_list ap
)
943 /* Don't allow infinite error/warning recursion. */
945 static char msg
[] = "Recursive internal problem.\n";
953 fputs_unfiltered (msg
, gdb_stderr
);
954 abort (); /* NOTE: GDB has only three calls to abort(). */
957 /* Newer GLIBC versions put the warn_unused_result attribute
958 on write, but this is one of those rare cases where
959 ignoring the return value is correct. Casting to (void)
960 does not fix this problem. This is the solution suggested
961 at http://gcc.gnu.org/bugzilla/show_bug.cgi?id=25509. */
962 if (write (STDERR_FILENO
, msg
, sizeof (msg
)) != sizeof (msg
))
963 abort (); /* NOTE: GDB has only three calls to abort(). */
968 /* Try to get the message out and at the start of a new line. */
969 target_terminal_ours ();
972 /* Create a string containing the full error/warning message. Need
973 to call query with this full string, as otherwize the reason
974 (error/warning) and question become separated. Format using a
975 style similar to a compiler error message. Include extra detail
976 so that the user knows that they are living on the edge. */
979 msg
= xstrvprintf (fmt
, ap
);
980 reason
= xstrprintf ("\
982 A problem internal to GDB has been detected,\n\
983 further debugging may prove unreliable.", file
, line
, problem
->name
, msg
);
985 make_cleanup (xfree
, reason
);
988 if (problem
->should_quit
== internal_problem_ask
)
990 /* Default (yes/batch case) is to quit GDB. When in batch mode
991 this lessens the likelihood of GDB going into an infinite
995 /* Emit the message and quit. */
996 fputs_unfiltered (reason
, gdb_stderr
);
997 fputs_unfiltered ("\n", gdb_stderr
);
1001 quit_p
= query (_("%s\nQuit this debugging session? "), reason
);
1003 else if (problem
->should_quit
== internal_problem_yes
)
1005 else if (problem
->should_quit
== internal_problem_no
)
1008 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1010 if (problem
->should_dump_core
== internal_problem_ask
)
1012 if (!can_dump_core (reason
))
1016 /* Default (yes/batch case) is to dump core. This leaves a GDB
1017 `dropping' so that it is easier to see that something went
1019 dump_core_p
= query (_("%s\nCreate a core file of GDB? "), reason
);
1022 else if (problem
->should_dump_core
== internal_problem_yes
)
1023 dump_core_p
= can_dump_core (reason
);
1024 else if (problem
->should_dump_core
== internal_problem_no
)
1027 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1040 #ifdef HAVE_WORKING_FORK
1050 static struct internal_problem internal_error_problem
= {
1051 "internal-error", internal_problem_ask
, internal_problem_ask
1055 internal_verror (const char *file
, int line
, const char *fmt
, va_list ap
)
1057 internal_vproblem (&internal_error_problem
, file
, line
, fmt
, ap
);
1058 deprecated_throw_reason (RETURN_ERROR
);
1062 internal_error (const char *file
, int line
, const char *string
, ...)
1066 va_start (ap
, string
);
1067 internal_verror (file
, line
, string
, ap
);
1071 static struct internal_problem internal_warning_problem
= {
1072 "internal-warning", internal_problem_ask
, internal_problem_ask
1076 internal_vwarning (const char *file
, int line
, const char *fmt
, va_list ap
)
1078 internal_vproblem (&internal_warning_problem
, file
, line
, fmt
, ap
);
1082 internal_warning (const char *file
, int line
, const char *string
, ...)
1086 va_start (ap
, string
);
1087 internal_vwarning (file
, line
, string
, ap
);
1091 /* Dummy functions to keep add_prefix_cmd happy. */
1094 set_internal_problem_cmd (char *args
, int from_tty
)
1099 show_internal_problem_cmd (char *args
, int from_tty
)
1103 /* When GDB reports an internal problem (error or warning) it gives
1104 the user the opportunity to quit GDB and/or create a core file of
1105 the current debug session. This function registers a few commands
1106 that make it possible to specify that GDB should always or never
1107 quit or create a core file, without asking. The commands look
1110 maint set PROBLEM-NAME quit ask|yes|no
1111 maint show PROBLEM-NAME quit
1112 maint set PROBLEM-NAME corefile ask|yes|no
1113 maint show PROBLEM-NAME corefile
1115 Where PROBLEM-NAME is currently "internal-error" or
1116 "internal-warning". */
1119 add_internal_problem_command (struct internal_problem
*problem
)
1121 struct cmd_list_element
**set_cmd_list
;
1122 struct cmd_list_element
**show_cmd_list
;
1126 set_cmd_list
= xmalloc (sizeof (*set_cmd_list
));
1127 show_cmd_list
= xmalloc (sizeof (*set_cmd_list
));
1128 *set_cmd_list
= NULL
;
1129 *show_cmd_list
= NULL
;
1131 set_doc
= xstrprintf (_("Configure what GDB does when %s is detected."),
1134 show_doc
= xstrprintf (_("Show what GDB does when %s is detected."),
1137 add_prefix_cmd ((char*) problem
->name
,
1138 class_maintenance
, set_internal_problem_cmd
, set_doc
,
1140 concat ("maintenance set ", problem
->name
, " ",
1142 0/*allow-unknown*/, &maintenance_set_cmdlist
);
1144 add_prefix_cmd ((char*) problem
->name
,
1145 class_maintenance
, show_internal_problem_cmd
, show_doc
,
1147 concat ("maintenance show ", problem
->name
, " ",
1149 0/*allow-unknown*/, &maintenance_show_cmdlist
);
1151 set_doc
= xstrprintf (_("\
1152 Set whether GDB should quit when an %s is detected"),
1154 show_doc
= xstrprintf (_("\
1155 Show whether GDB will quit when an %s is detected"),
1157 add_setshow_enum_cmd ("quit", class_maintenance
,
1158 internal_problem_modes
,
1159 &problem
->should_quit
,
1162 NULL
, /* help_doc */
1164 NULL
, /* showfunc */
1171 set_doc
= xstrprintf (_("\
1172 Set whether GDB should create a core file of GDB when %s is detected"),
1174 show_doc
= xstrprintf (_("\
1175 Show whether GDB will create a core file of GDB when %s is detected"),
1177 add_setshow_enum_cmd ("corefile", class_maintenance
,
1178 internal_problem_modes
,
1179 &problem
->should_dump_core
,
1182 NULL
, /* help_doc */
1184 NULL
, /* showfunc */
1192 /* Print the system error message for errno, and also mention STRING
1193 as the file name for which the error was encountered.
1194 Then return to command level. */
1197 perror_with_name (const char *string
)
1202 err
= safe_strerror (errno
);
1203 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
1204 strcpy (combined
, string
);
1205 strcat (combined
, ": ");
1206 strcat (combined
, err
);
1208 /* I understand setting these is a matter of taste. Still, some people
1209 may clear errno but not know about bfd_error. Doing this here is not
1211 bfd_set_error (bfd_error_no_error
);
1214 error (_("%s."), combined
);
1217 /* Print the system error message for ERRCODE, and also mention STRING
1218 as the file name for which the error was encountered. */
1221 print_sys_errmsg (const char *string
, int errcode
)
1226 err
= safe_strerror (errcode
);
1227 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
1228 strcpy (combined
, string
);
1229 strcat (combined
, ": ");
1230 strcat (combined
, err
);
1232 /* We want anything which was printed on stdout to come out first, before
1234 gdb_flush (gdb_stdout
);
1235 fprintf_unfiltered (gdb_stderr
, "%s.\n", combined
);
1238 /* Control C eventually causes this to be called, at a convenient time. */
1244 /* No steenking SIGINT will ever be coming our way when the
1245 program is resumed. Don't lie. */
1249 /* If there is no terminal switching for this target, then we can't
1250 possibly get screwed by the lack of job control. */
1251 || current_target
.to_terminal_ours
== NULL
)
1254 fatal ("Quit (expect signal SIGINT when the program is resumed)");
1259 /* Called when a memory allocation fails, with the number of bytes of
1260 memory requested in SIZE. */
1267 internal_error (__FILE__
, __LINE__
,
1268 _("virtual memory exhausted: can't allocate %ld bytes."),
1273 internal_error (__FILE__
, __LINE__
, _("virtual memory exhausted."));
1277 /* The xmalloc() (libiberty.h) family of memory management routines.
1279 These are like the ISO-C malloc() family except that they implement
1280 consistent semantics and guard against typical memory management
1283 /* NOTE: These are declared using PTR to ensure consistency with
1284 "libiberty.h". xfree() is GDB local. */
1287 xmalloc (size_t size
)
1291 /* See libiberty/xmalloc.c. This function need's to match that's
1292 semantics. It never returns NULL. */
1296 val
= malloc (size
); /* ARI: malloc */
1304 xzalloc (size_t size
)
1306 return xcalloc (1, size
);
1310 xrealloc (PTR ptr
, size_t size
) /* ARI: PTR */
1314 /* See libiberty/xmalloc.c. This function need's to match that's
1315 semantics. It never returns NULL. */
1320 val
= realloc (ptr
, size
); /* ARI: realloc */
1322 val
= malloc (size
); /* ARI: malloc */
1330 xcalloc (size_t number
, size_t size
)
1334 /* See libiberty/xmalloc.c. This function need's to match that's
1335 semantics. It never returns NULL. */
1336 if (number
== 0 || size
== 0)
1342 mem
= calloc (number
, size
); /* ARI: xcalloc */
1344 nomem (number
* size
);
1353 free (ptr
); /* ARI: free */
1357 /* Like asprintf/vasprintf but get an internal_error if the call
1361 xstrprintf (const char *format
, ...)
1366 va_start (args
, format
);
1367 ret
= xstrvprintf (format
, args
);
1373 xasprintf (char **ret
, const char *format
, ...)
1377 va_start (args
, format
);
1378 (*ret
) = xstrvprintf (format
, args
);
1383 xvasprintf (char **ret
, const char *format
, va_list ap
)
1385 (*ret
) = xstrvprintf (format
, ap
);
1389 xstrvprintf (const char *format
, va_list ap
)
1392 int status
= vasprintf (&ret
, format
, ap
);
1394 /* NULL is returned when there was a memory allocation problem, or
1395 any other error (for instance, a bad format string). A negative
1396 status (the printed length) with a non-NULL buffer should never
1397 happen, but just to be sure. */
1398 if (ret
== NULL
|| status
< 0)
1399 internal_error (__FILE__
, __LINE__
, _("vasprintf call failed"));
1404 xsnprintf (char *str
, size_t size
, const char *format
, ...)
1409 va_start (args
, format
);
1410 ret
= vsnprintf (str
, size
, format
, args
);
1411 gdb_assert (ret
< size
);
1417 /* My replacement for the read system call.
1418 Used like `read' but keeps going if `read' returns too soon. */
1421 myread (int desc
, char *addr
, int len
)
1428 val
= read (desc
, addr
, len
);
1432 return orglen
- len
;
1439 /* Make a copy of the string at PTR with SIZE characters
1440 (and add a null character at the end in the copy).
1441 Uses malloc to get the space. Returns the address of the copy. */
1444 savestring (const char *ptr
, size_t size
)
1446 char *p
= (char *) xmalloc (size
+ 1);
1448 memcpy (p
, ptr
, size
);
1454 print_spaces (int n
, struct ui_file
*file
)
1456 fputs_unfiltered (n_spaces (n
), file
);
1459 /* Print a host address. */
1462 gdb_print_host_address (const void *addr
, struct ui_file
*stream
)
1464 fprintf_filtered (stream
, "%s", host_address_to_string (addr
));
1468 /* This function supports the query, nquery, and yquery functions.
1469 Ask user a y-or-n question and return 0 if answer is no, 1 if
1470 answer is yes, or default the answer to the specified default
1471 (for yquery or nquery). DEFCHAR may be 'y' or 'n' to provide a
1472 default answer, or '\0' for no default.
1473 CTLSTR is the control string and should end in "? ". It should
1474 not say how to answer, because we do that.
1475 ARGS are the arguments passed along with the CTLSTR argument to
1478 static int ATTRIBUTE_PRINTF (1, 0)
1479 defaulted_query (const char *ctlstr
, const char defchar
, va_list args
)
1485 char def_answer
, not_def_answer
;
1486 char *y_string
, *n_string
, *question
;
1488 /* Set up according to which answer is the default. */
1489 if (defchar
== '\0')
1493 not_def_answer
= 'N';
1497 else if (defchar
== 'y')
1501 not_def_answer
= 'N';
1509 not_def_answer
= 'Y';
1514 /* Automatically answer the default value if the user did not want
1515 prompts or the command was issued with the server prefix. */
1516 if (! caution
|| server_command
)
1519 /* If input isn't coming from the user directly, just say what
1520 question we're asking, and then answer the default automatically. This
1521 way, important error messages don't get lost when talking to GDB
1523 if (batch_flag
|| ! input_from_terminal_p ())
1526 vfprintf_filtered (gdb_stdout
, ctlstr
, args
);
1528 printf_filtered (_("(%s or %s) [answered %c; input not from terminal]\n"),
1529 y_string
, n_string
, def_answer
);
1530 gdb_flush (gdb_stdout
);
1535 if (deprecated_query_hook
)
1537 return deprecated_query_hook (ctlstr
, args
);
1540 /* Format the question outside of the loop, to avoid reusing args. */
1541 question
= xstrvprintf (ctlstr
, args
);
1545 wrap_here (""); /* Flush any buffered output */
1546 gdb_flush (gdb_stdout
);
1548 if (annotation_level
> 1)
1549 printf_filtered (("\n\032\032pre-query\n"));
1551 fputs_filtered (question
, gdb_stdout
);
1552 printf_filtered (_("(%s or %s) "), y_string
, n_string
);
1554 if (annotation_level
> 1)
1555 printf_filtered (("\n\032\032query\n"));
1558 gdb_flush (gdb_stdout
);
1560 answer
= fgetc (stdin
);
1562 /* We expect fgetc to block until a character is read. But
1563 this may not be the case if the terminal was opened with
1564 the NONBLOCK flag. In that case, if there is nothing to
1565 read on stdin, fgetc returns EOF, but also sets the error
1566 condition flag on stdin and errno to EAGAIN. With a true
1567 EOF, stdin's error condition flag is not set.
1569 A situation where this behavior was observed is a pseudo
1571 while (answer
== EOF
&& ferror (stdin
) && errno
== EAGAIN
)
1573 /* Not a real EOF. Wait a little while and try again until
1574 we read something. */
1577 answer
= fgetc (stdin
);
1580 clearerr (stdin
); /* in case of C-d */
1581 if (answer
== EOF
) /* C-d */
1583 printf_filtered ("EOF [assumed %c]\n", def_answer
);
1587 /* Eat rest of input line, to EOF or newline */
1591 ans2
= fgetc (stdin
);
1594 while (ans2
!= EOF
&& ans2
!= '\n' && ans2
!= '\r');
1598 /* Check answer. For the non-default, the user must specify
1599 the non-default explicitly. */
1600 if (answer
== not_def_answer
)
1602 retval
= !def_value
;
1605 /* Otherwise, if a default was specified, the user may either
1606 specify the required input or have it default by entering
1608 if (answer
== def_answer
1609 || (defchar
!= '\0' &&
1610 (answer
== '\n' || answer
== '\r' || answer
== EOF
)))
1615 /* Invalid entries are not defaulted and require another selection. */
1616 printf_filtered (_("Please answer %s or %s.\n"),
1617 y_string
, n_string
);
1621 if (annotation_level
> 1)
1622 printf_filtered (("\n\032\032post-query\n"));
1627 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1628 answer is yes, or 0 if answer is defaulted.
1629 Takes three args which are given to printf to print the question.
1630 The first, a control string, should end in "? ".
1631 It should not say how to answer, because we do that. */
1634 nquery (const char *ctlstr
, ...)
1638 va_start (args
, ctlstr
);
1639 return defaulted_query (ctlstr
, 'n', args
);
1643 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1644 answer is yes, or 1 if answer is defaulted.
1645 Takes three args which are given to printf to print the question.
1646 The first, a control string, should end in "? ".
1647 It should not say how to answer, because we do that. */
1650 yquery (const char *ctlstr
, ...)
1654 va_start (args
, ctlstr
);
1655 return defaulted_query (ctlstr
, 'y', args
);
1659 /* Ask user a y-or-n question and return 1 iff answer is yes.
1660 Takes three args which are given to printf to print the question.
1661 The first, a control string, should end in "? ".
1662 It should not say how to answer, because we do that. */
1665 query (const char *ctlstr
, ...)
1669 va_start (args
, ctlstr
);
1670 return defaulted_query (ctlstr
, '\0', args
);
1674 /* A helper for parse_escape that converts a host character to a
1675 target character. C is the host character. If conversion is
1676 possible, then the target character is stored in *TARGET_C and the
1677 function returns 1. Otherwise, the function returns 0. */
1680 host_char_to_target (struct gdbarch
*gdbarch
, int c
, int *target_c
)
1682 struct obstack host_data
;
1684 struct cleanup
*cleanups
;
1687 obstack_init (&host_data
);
1688 cleanups
= make_cleanup_obstack_free (&host_data
);
1690 convert_between_encodings (target_charset (gdbarch
), host_charset (),
1691 &the_char
, 1, 1, &host_data
, translit_none
);
1693 if (obstack_object_size (&host_data
) == 1)
1696 *target_c
= *(char *) obstack_base (&host_data
);
1699 do_cleanups (cleanups
);
1703 /* Parse a C escape sequence. STRING_PTR points to a variable
1704 containing a pointer to the string to parse. That pointer
1705 should point to the character after the \. That pointer
1706 is updated past the characters we use. The value of the
1707 escape sequence is returned.
1709 A negative value means the sequence \ newline was seen,
1710 which is supposed to be equivalent to nothing at all.
1712 If \ is followed by a null character, we return a negative
1713 value and leave the string pointer pointing at the null character.
1715 If \ is followed by 000, we return 0 and leave the string pointer
1716 after the zeros. A value of 0 does not mean end of string. */
1719 parse_escape (struct gdbarch
*gdbarch
, char **string_ptr
)
1721 int target_char
= -2; /* initialize to avoid GCC warnings */
1722 int c
= *(*string_ptr
)++;
1741 int i
= host_hex_value (c
);
1746 if (isdigit (c
) && c
!= '8' && c
!= '9')
1750 i
+= host_hex_value (c
);
1786 if (!host_char_to_target (gdbarch
, c
, &target_char
))
1788 ("The escape sequence `\%c' is equivalent to plain `%c', which"
1789 " has no equivalent\n" "in the `%s' character set.", c
, c
,
1790 target_charset (gdbarch
));
1794 /* Print the character C on STREAM as part of the contents of a literal
1795 string whose delimiter is QUOTER. Note that this routine should only
1796 be call for printing things which are independent of the language
1797 of the program being debugged. */
1800 printchar (int c
, void (*do_fputs
) (const char *, struct ui_file
*),
1801 void (*do_fprintf
) (struct ui_file
*, const char *, ...)
1802 ATTRIBUTE_FPTR_PRINTF_2
, struct ui_file
*stream
, int quoter
)
1805 c
&= 0xFF; /* Avoid sign bit follies */
1807 if (c
< 0x20 || /* Low control chars */
1808 (c
>= 0x7F && c
< 0xA0) || /* DEL, High controls */
1809 (sevenbit_strings
&& c
>= 0x80))
1810 { /* high order bit set */
1814 do_fputs ("\\n", stream
);
1817 do_fputs ("\\b", stream
);
1820 do_fputs ("\\t", stream
);
1823 do_fputs ("\\f", stream
);
1826 do_fputs ("\\r", stream
);
1829 do_fputs ("\\e", stream
);
1832 do_fputs ("\\a", stream
);
1835 do_fprintf (stream
, "\\%.3o", (unsigned int) c
);
1841 if (c
== '\\' || c
== quoter
)
1842 do_fputs ("\\", stream
);
1843 do_fprintf (stream
, "%c", c
);
1847 /* Print the character C on STREAM as part of the contents of a
1848 literal string whose delimiter is QUOTER. Note that these routines
1849 should only be call for printing things which are independent of
1850 the language of the program being debugged. */
1853 fputstr_filtered (const char *str
, int quoter
, struct ui_file
*stream
)
1856 printchar (*str
++, fputs_filtered
, fprintf_filtered
, stream
, quoter
);
1860 fputstr_unfiltered (const char *str
, int quoter
, struct ui_file
*stream
)
1863 printchar (*str
++, fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1867 fputstrn_filtered (const char *str
, int n
, int quoter
,
1868 struct ui_file
*stream
)
1872 for (i
= 0; i
< n
; i
++)
1873 printchar (str
[i
], fputs_filtered
, fprintf_filtered
, stream
, quoter
);
1877 fputstrn_unfiltered (const char *str
, int n
, int quoter
,
1878 struct ui_file
*stream
)
1881 for (i
= 0; i
< n
; i
++)
1882 printchar (str
[i
], fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1886 /* Number of lines per page or UINT_MAX if paging is disabled. */
1887 static unsigned int lines_per_page
;
1889 show_lines_per_page (struct ui_file
*file
, int from_tty
,
1890 struct cmd_list_element
*c
, const char *value
)
1892 fprintf_filtered (file
, _("\
1893 Number of lines gdb thinks are in a page is %s.\n"),
1897 /* Number of chars per line or UINT_MAX if line folding is disabled. */
1898 static unsigned int chars_per_line
;
1900 show_chars_per_line (struct ui_file
*file
, int from_tty
,
1901 struct cmd_list_element
*c
, const char *value
)
1903 fprintf_filtered (file
, _("\
1904 Number of characters gdb thinks are in a line is %s.\n"),
1908 /* Current count of lines printed on this page, chars on this line. */
1909 static unsigned int lines_printed
, chars_printed
;
1911 /* Buffer and start column of buffered text, for doing smarter word-
1912 wrapping. When someone calls wrap_here(), we start buffering output
1913 that comes through fputs_filtered(). If we see a newline, we just
1914 spit it out and forget about the wrap_here(). If we see another
1915 wrap_here(), we spit it out and remember the newer one. If we see
1916 the end of the line, we spit out a newline, the indent, and then
1917 the buffered output. */
1919 /* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
1920 are waiting to be output (they have already been counted in chars_printed).
1921 When wrap_buffer[0] is null, the buffer is empty. */
1922 static char *wrap_buffer
;
1924 /* Pointer in wrap_buffer to the next character to fill. */
1925 static char *wrap_pointer
;
1927 /* String to indent by if the wrap occurs. Must not be NULL if wrap_column
1929 static char *wrap_indent
;
1931 /* Column number on the screen where wrap_buffer begins, or 0 if wrapping
1932 is not in effect. */
1933 static int wrap_column
;
1936 /* Inialize the number of lines per page and chars per line. */
1939 init_page_info (void)
1942 if (!tui_get_command_dimension (&chars_per_line
, &lines_per_page
))
1947 #if defined(__GO32__)
1948 rows
= ScreenRows ();
1949 cols
= ScreenCols ();
1950 lines_per_page
= rows
;
1951 chars_per_line
= cols
;
1953 /* Make sure Readline has initialized its terminal settings. */
1954 rl_reset_terminal (NULL
);
1956 /* Get the screen size from Readline. */
1957 rl_get_screen_size (&rows
, &cols
);
1958 lines_per_page
= rows
;
1959 chars_per_line
= cols
;
1961 /* Readline should have fetched the termcap entry for us. */
1962 if (tgetnum ("li") < 0 || getenv ("EMACS"))
1964 /* The number of lines per page is not mentioned in the
1965 terminal description. This probably means that paging is
1966 not useful (e.g. emacs shell window), so disable paging. */
1967 lines_per_page
= UINT_MAX
;
1970 /* FIXME: Get rid of this junk. */
1971 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
1972 SIGWINCH_HANDLER (SIGWINCH
);
1975 /* If the output is not a terminal, don't paginate it. */
1976 if (!ui_file_isatty (gdb_stdout
))
1977 lines_per_page
= UINT_MAX
;
1985 /* Set the screen size based on LINES_PER_PAGE and CHARS_PER_LINE. */
1988 set_screen_size (void)
1990 int rows
= lines_per_page
;
1991 int cols
= chars_per_line
;
1999 /* Update Readline's idea of the terminal size. */
2000 rl_set_screen_size (rows
, cols
);
2003 /* Reinitialize WRAP_BUFFER according to the current value of
2009 if (chars_per_line
== 0)
2014 wrap_buffer
= (char *) xmalloc (chars_per_line
+ 2);
2015 wrap_buffer
[0] = '\0';
2018 wrap_buffer
= (char *) xrealloc (wrap_buffer
, chars_per_line
+ 2);
2019 wrap_pointer
= wrap_buffer
; /* Start it at the beginning. */
2023 set_width_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
2030 set_height_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
2035 /* Wait, so the user can read what's on the screen. Prompt the user
2036 to continue by pressing RETURN. */
2039 prompt_for_continue (void)
2042 char cont_prompt
[120];
2044 if (annotation_level
> 1)
2045 printf_unfiltered (("\n\032\032pre-prompt-for-continue\n"));
2047 strcpy (cont_prompt
,
2048 "---Type <return> to continue, or q <return> to quit---");
2049 if (annotation_level
> 1)
2050 strcat (cont_prompt
, "\n\032\032prompt-for-continue\n");
2052 /* We must do this *before* we call gdb_readline, else it will eventually
2053 call us -- thinking that we're trying to print beyond the end of the
2055 reinitialize_more_filter ();
2058 /* On a real operating system, the user can quit with SIGINT.
2061 'q' is provided on all systems so users don't have to change habits
2062 from system to system, and because telling them what to do in
2063 the prompt is more user-friendly than expecting them to think of
2065 /* Call readline, not gdb_readline, because GO32 readline handles control-C
2066 whereas control-C to gdb_readline will cause the user to get dumped
2068 ignore
= gdb_readline_wrapper (cont_prompt
);
2070 if (annotation_level
> 1)
2071 printf_unfiltered (("\n\032\032post-prompt-for-continue\n"));
2076 while (*p
== ' ' || *p
== '\t')
2079 async_request_quit (0);
2084 /* Now we have to do this again, so that GDB will know that it doesn't
2085 need to save the ---Type <return>--- line at the top of the screen. */
2086 reinitialize_more_filter ();
2088 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
2091 /* Reinitialize filter; ie. tell it to reset to original values. */
2094 reinitialize_more_filter (void)
2100 /* Indicate that if the next sequence of characters overflows the line,
2101 a newline should be inserted here rather than when it hits the end.
2102 If INDENT is non-null, it is a string to be printed to indent the
2103 wrapped part on the next line. INDENT must remain accessible until
2104 the next call to wrap_here() or until a newline is printed through
2107 If the line is already overfull, we immediately print a newline and
2108 the indentation, and disable further wrapping.
2110 If we don't know the width of lines, but we know the page height,
2111 we must not wrap words, but should still keep track of newlines
2112 that were explicitly printed.
2114 INDENT should not contain tabs, as that will mess up the char count
2115 on the next line. FIXME.
2117 This routine is guaranteed to force out any output which has been
2118 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
2119 used to force out output from the wrap_buffer. */
2122 wrap_here (char *indent
)
2124 /* This should have been allocated, but be paranoid anyway. */
2126 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
2130 *wrap_pointer
= '\0';
2131 fputs_unfiltered (wrap_buffer
, gdb_stdout
);
2133 wrap_pointer
= wrap_buffer
;
2134 wrap_buffer
[0] = '\0';
2135 if (chars_per_line
== UINT_MAX
) /* No line overflow checking */
2139 else if (chars_printed
>= chars_per_line
)
2141 puts_filtered ("\n");
2143 puts_filtered (indent
);
2148 wrap_column
= chars_printed
;
2152 wrap_indent
= indent
;
2156 /* Print input string to gdb_stdout, filtered, with wrap,
2157 arranging strings in columns of n chars. String can be
2158 right or left justified in the column. Never prints
2159 trailing spaces. String should never be longer than
2160 width. FIXME: this could be useful for the EXAMINE
2161 command, which currently doesn't tabulate very well */
2164 puts_filtered_tabular (char *string
, int width
, int right
)
2170 gdb_assert (chars_per_line
> 0);
2171 if (chars_per_line
== UINT_MAX
)
2173 fputs_filtered (string
, gdb_stdout
);
2174 fputs_filtered ("\n", gdb_stdout
);
2178 if (((chars_printed
- 1) / width
+ 2) * width
>= chars_per_line
)
2179 fputs_filtered ("\n", gdb_stdout
);
2181 if (width
>= chars_per_line
)
2182 width
= chars_per_line
- 1;
2184 stringlen
= strlen (string
);
2186 if (chars_printed
> 0)
2187 spaces
= width
- (chars_printed
- 1) % width
- 1;
2189 spaces
+= width
- stringlen
;
2191 spacebuf
= alloca (spaces
+ 1);
2192 spacebuf
[spaces
] = '\0';
2194 spacebuf
[spaces
] = ' ';
2196 fputs_filtered (spacebuf
, gdb_stdout
);
2197 fputs_filtered (string
, gdb_stdout
);
2201 /* Ensure that whatever gets printed next, using the filtered output
2202 commands, starts at the beginning of the line. I.E. if there is
2203 any pending output for the current line, flush it and start a new
2204 line. Otherwise do nothing. */
2209 if (chars_printed
> 0)
2211 puts_filtered ("\n");
2216 /* Like fputs but if FILTER is true, pause after every screenful.
2218 Regardless of FILTER can wrap at points other than the final
2219 character of a line.
2221 Unlike fputs, fputs_maybe_filtered does not return a value.
2222 It is OK for LINEBUFFER to be NULL, in which case just don't print
2225 Note that a longjmp to top level may occur in this routine (only if
2226 FILTER is true) (since prompt_for_continue may do so) so this
2227 routine should not be called when cleanups are not in place. */
2230 fputs_maybe_filtered (const char *linebuffer
, struct ui_file
*stream
,
2233 const char *lineptr
;
2235 if (linebuffer
== 0)
2238 /* Don't do any filtering if it is disabled. */
2239 if (stream
!= gdb_stdout
2240 || !pagination_enabled
2241 || (lines_per_page
== UINT_MAX
&& chars_per_line
== UINT_MAX
)
2242 || top_level_interpreter () == NULL
2243 || ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ())))
2245 fputs_unfiltered (linebuffer
, stream
);
2249 /* Go through and output each character. Show line extension
2250 when this is necessary; prompt user for new page when this is
2253 lineptr
= linebuffer
;
2256 /* Possible new page. */
2257 if (filter
&& (lines_printed
>= lines_per_page
- 1))
2258 prompt_for_continue ();
2260 while (*lineptr
&& *lineptr
!= '\n')
2262 /* Print a single line. */
2263 if (*lineptr
== '\t')
2266 *wrap_pointer
++ = '\t';
2268 fputc_unfiltered ('\t', stream
);
2269 /* Shifting right by 3 produces the number of tab stops
2270 we have already passed, and then adding one and
2271 shifting left 3 advances to the next tab stop. */
2272 chars_printed
= ((chars_printed
>> 3) + 1) << 3;
2278 *wrap_pointer
++ = *lineptr
;
2280 fputc_unfiltered (*lineptr
, stream
);
2285 if (chars_printed
>= chars_per_line
)
2287 unsigned int save_chars
= chars_printed
;
2291 /* If we aren't actually wrapping, don't output newline --
2292 if chars_per_line is right, we probably just overflowed
2293 anyway; if it's wrong, let us keep going. */
2295 fputc_unfiltered ('\n', stream
);
2297 /* Possible new page. */
2298 if (lines_printed
>= lines_per_page
- 1)
2299 prompt_for_continue ();
2301 /* Now output indentation and wrapped string */
2304 fputs_unfiltered (wrap_indent
, stream
);
2305 *wrap_pointer
= '\0'; /* Null-terminate saved stuff */
2306 fputs_unfiltered (wrap_buffer
, stream
); /* and eject it */
2307 /* FIXME, this strlen is what prevents wrap_indent from
2308 containing tabs. However, if we recurse to print it
2309 and count its chars, we risk trouble if wrap_indent is
2310 longer than (the user settable) chars_per_line.
2311 Note also that this can set chars_printed > chars_per_line
2312 if we are printing a long string. */
2313 chars_printed
= strlen (wrap_indent
)
2314 + (save_chars
- wrap_column
);
2315 wrap_pointer
= wrap_buffer
; /* Reset buffer */
2316 wrap_buffer
[0] = '\0';
2317 wrap_column
= 0; /* And disable fancy wrap */
2322 if (*lineptr
== '\n')
2325 wrap_here ((char *) 0); /* Spit out chars, cancel further wraps */
2327 fputc_unfiltered ('\n', stream
);
2334 fputs_filtered (const char *linebuffer
, struct ui_file
*stream
)
2336 fputs_maybe_filtered (linebuffer
, stream
, 1);
2340 putchar_unfiltered (int c
)
2344 ui_file_write (gdb_stdout
, &buf
, 1);
2348 /* Write character C to gdb_stdout using GDB's paging mechanism and return C.
2349 May return nonlocally. */
2352 putchar_filtered (int c
)
2354 return fputc_filtered (c
, gdb_stdout
);
2358 fputc_unfiltered (int c
, struct ui_file
*stream
)
2362 ui_file_write (stream
, &buf
, 1);
2367 fputc_filtered (int c
, struct ui_file
*stream
)
2373 fputs_filtered (buf
, stream
);
2377 /* puts_debug is like fputs_unfiltered, except it prints special
2378 characters in printable fashion. */
2381 puts_debug (char *prefix
, char *string
, char *suffix
)
2385 /* Print prefix and suffix after each line. */
2386 static int new_line
= 1;
2387 static int return_p
= 0;
2388 static char *prev_prefix
= "";
2389 static char *prev_suffix
= "";
2391 if (*string
== '\n')
2394 /* If the prefix is changing, print the previous suffix, a new line,
2395 and the new prefix. */
2396 if ((return_p
|| (strcmp (prev_prefix
, prefix
) != 0)) && !new_line
)
2398 fputs_unfiltered (prev_suffix
, gdb_stdlog
);
2399 fputs_unfiltered ("\n", gdb_stdlog
);
2400 fputs_unfiltered (prefix
, gdb_stdlog
);
2403 /* Print prefix if we printed a newline during the previous call. */
2407 fputs_unfiltered (prefix
, gdb_stdlog
);
2410 prev_prefix
= prefix
;
2411 prev_suffix
= suffix
;
2413 /* Output characters in a printable format. */
2414 while ((ch
= *string
++) != '\0')
2420 fputc_unfiltered (ch
, gdb_stdlog
);
2423 fprintf_unfiltered (gdb_stdlog
, "\\x%02x", ch
& 0xff);
2427 fputs_unfiltered ("\\\\", gdb_stdlog
);
2430 fputs_unfiltered ("\\b", gdb_stdlog
);
2433 fputs_unfiltered ("\\f", gdb_stdlog
);
2437 fputs_unfiltered ("\\n", gdb_stdlog
);
2440 fputs_unfiltered ("\\r", gdb_stdlog
);
2443 fputs_unfiltered ("\\t", gdb_stdlog
);
2446 fputs_unfiltered ("\\v", gdb_stdlog
);
2450 return_p
= ch
== '\r';
2453 /* Print suffix if we printed a newline. */
2456 fputs_unfiltered (suffix
, gdb_stdlog
);
2457 fputs_unfiltered ("\n", gdb_stdlog
);
2462 /* Print a variable number of ARGS using format FORMAT. If this
2463 information is going to put the amount written (since the last call
2464 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
2465 call prompt_for_continue to get the users permision to continue.
2467 Unlike fprintf, this function does not return a value.
2469 We implement three variants, vfprintf (takes a vararg list and stream),
2470 fprintf (takes a stream to write on), and printf (the usual).
2472 Note also that a longjmp to top level may occur in this routine
2473 (since prompt_for_continue may do so) so this routine should not be
2474 called when cleanups are not in place. */
2477 vfprintf_maybe_filtered (struct ui_file
*stream
, const char *format
,
2478 va_list args
, int filter
)
2481 struct cleanup
*old_cleanups
;
2483 linebuffer
= xstrvprintf (format
, args
);
2484 old_cleanups
= make_cleanup (xfree
, linebuffer
);
2485 fputs_maybe_filtered (linebuffer
, stream
, filter
);
2486 do_cleanups (old_cleanups
);
2491 vfprintf_filtered (struct ui_file
*stream
, const char *format
, va_list args
)
2493 vfprintf_maybe_filtered (stream
, format
, args
, 1);
2497 vfprintf_unfiltered (struct ui_file
*stream
, const char *format
, va_list args
)
2500 struct cleanup
*old_cleanups
;
2502 linebuffer
= xstrvprintf (format
, args
);
2503 old_cleanups
= make_cleanup (xfree
, linebuffer
);
2504 if (debug_timestamp
&& stream
== gdb_stdlog
)
2510 gettimeofday (&tm
, NULL
);
2512 len
= strlen (linebuffer
);
2513 need_nl
= (len
> 0 && linebuffer
[len
- 1] != '\n');
2515 timestamp
= xstrprintf ("%ld:%ld %s%s",
2516 (long) tm
.tv_sec
, (long) tm
.tv_usec
,
2518 need_nl
? "\n": "");
2519 make_cleanup (xfree
, timestamp
);
2520 fputs_unfiltered (timestamp
, stream
);
2523 fputs_unfiltered (linebuffer
, stream
);
2524 do_cleanups (old_cleanups
);
2528 vprintf_filtered (const char *format
, va_list args
)
2530 vfprintf_maybe_filtered (gdb_stdout
, format
, args
, 1);
2534 vprintf_unfiltered (const char *format
, va_list args
)
2536 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2540 fprintf_filtered (struct ui_file
*stream
, const char *format
, ...)
2544 va_start (args
, format
);
2545 vfprintf_filtered (stream
, format
, args
);
2550 fprintf_unfiltered (struct ui_file
*stream
, const char *format
, ...)
2554 va_start (args
, format
);
2555 vfprintf_unfiltered (stream
, format
, args
);
2559 /* Like fprintf_filtered, but prints its result indented.
2560 Called as fprintfi_filtered (spaces, stream, format, ...); */
2563 fprintfi_filtered (int spaces
, struct ui_file
*stream
, const char *format
,
2568 va_start (args
, format
);
2569 print_spaces_filtered (spaces
, stream
);
2571 vfprintf_filtered (stream
, format
, args
);
2577 printf_filtered (const char *format
, ...)
2581 va_start (args
, format
);
2582 vfprintf_filtered (gdb_stdout
, format
, args
);
2588 printf_unfiltered (const char *format
, ...)
2592 va_start (args
, format
);
2593 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2597 /* Like printf_filtered, but prints it's result indented.
2598 Called as printfi_filtered (spaces, format, ...); */
2601 printfi_filtered (int spaces
, const char *format
, ...)
2605 va_start (args
, format
);
2606 print_spaces_filtered (spaces
, gdb_stdout
);
2607 vfprintf_filtered (gdb_stdout
, format
, args
);
2611 /* Easy -- but watch out!
2613 This routine is *not* a replacement for puts()! puts() appends a newline.
2614 This one doesn't, and had better not! */
2617 puts_filtered (const char *string
)
2619 fputs_filtered (string
, gdb_stdout
);
2623 puts_unfiltered (const char *string
)
2625 fputs_unfiltered (string
, gdb_stdout
);
2628 /* Return a pointer to N spaces and a null. The pointer is good
2629 until the next call to here. */
2634 static char *spaces
= 0;
2635 static int max_spaces
= -1;
2641 spaces
= (char *) xmalloc (n
+ 1);
2642 for (t
= spaces
+ n
; t
!= spaces
;)
2648 return spaces
+ max_spaces
- n
;
2651 /* Print N spaces. */
2653 print_spaces_filtered (int n
, struct ui_file
*stream
)
2655 fputs_filtered (n_spaces (n
), stream
);
2658 /* C++/ObjC demangler stuff. */
2660 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2661 LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2662 If the name is not mangled, or the language for the name is unknown, or
2663 demangling is off, the name is printed in its "raw" form. */
2666 fprintf_symbol_filtered (struct ui_file
*stream
, char *name
,
2667 enum language lang
, int arg_mode
)
2673 /* If user wants to see raw output, no problem. */
2676 fputs_filtered (name
, stream
);
2680 demangled
= language_demangle (language_def (lang
), name
, arg_mode
);
2681 fputs_filtered (demangled
? demangled
: name
, stream
);
2682 if (demangled
!= NULL
)
2690 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
2691 differences in whitespace. Returns 0 if they match, non-zero if they
2692 don't (slightly different than strcmp()'s range of return values).
2694 As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
2695 This "feature" is useful when searching for matching C++ function names
2696 (such as if the user types 'break FOO', where FOO is a mangled C++
2700 strcmp_iw (const char *string1
, const char *string2
)
2702 while ((*string1
!= '\0') && (*string2
!= '\0'))
2704 while (isspace (*string1
))
2708 while (isspace (*string2
))
2712 if (*string1
!= *string2
)
2716 if (*string1
!= '\0')
2722 return (*string1
!= '\0' && *string1
!= '(') || (*string2
!= '\0');
2725 /* This is like strcmp except that it ignores whitespace and treats
2726 '(' as the first non-NULL character in terms of ordering. Like
2727 strcmp (and unlike strcmp_iw), it returns negative if STRING1 <
2728 STRING2, 0 if STRING2 = STRING2, and positive if STRING1 > STRING2
2729 according to that ordering.
2731 If a list is sorted according to this function and if you want to
2732 find names in the list that match some fixed NAME according to
2733 strcmp_iw(LIST_ELT, NAME), then the place to start looking is right
2734 where this function would put NAME.
2736 Here are some examples of why using strcmp to sort is a bad idea:
2740 Say your partial symtab contains: "foo<char *>", "goo". Then, if
2741 we try to do a search for "foo<char*>", strcmp will locate this
2742 after "foo<char *>" and before "goo". Then lookup_partial_symbol
2743 will start looking at strings beginning with "goo", and will never
2744 see the correct match of "foo<char *>".
2746 Parenthesis example:
2748 In practice, this is less like to be an issue, but I'll give it a
2749 shot. Let's assume that '$' is a legitimate character to occur in
2750 symbols. (Which may well even be the case on some systems.) Then
2751 say that the partial symbol table contains "foo$" and "foo(int)".
2752 strcmp will put them in this order, since '$' < '('. Now, if the
2753 user searches for "foo", then strcmp will sort "foo" before "foo$".
2754 Then lookup_partial_symbol will notice that strcmp_iw("foo$",
2755 "foo") is false, so it won't proceed to the actual match of
2756 "foo(int)" with "foo". */
2759 strcmp_iw_ordered (const char *string1
, const char *string2
)
2761 while ((*string1
!= '\0') && (*string2
!= '\0'))
2763 while (isspace (*string1
))
2767 while (isspace (*string2
))
2771 if (*string1
!= *string2
)
2775 if (*string1
!= '\0')
2784 /* Characters are non-equal unless they're both '\0'; we want to
2785 make sure we get the comparison right according to our
2786 comparison in the cases where one of them is '\0' or '('. */
2788 if (*string2
== '\0')
2793 if (*string2
== '\0')
2798 if (*string2
== '(')
2801 return *string1
- *string2
;
2805 /* A simple comparison function with opposite semantics to strcmp. */
2808 streq (const char *lhs
, const char *rhs
)
2810 return !strcmp (lhs
, rhs
);
2816 ** Answer whether string_to_compare is a full or partial match to
2817 ** template_string. The partial match must be in sequence starting
2821 subset_compare (char *string_to_compare
, char *template_string
)
2825 if (template_string
!= (char *) NULL
&& string_to_compare
!= (char *) NULL
2826 && strlen (string_to_compare
) <= strlen (template_string
))
2829 (template_string
, string_to_compare
, strlen (string_to_compare
)) == 0);
2836 pagination_on_command (char *arg
, int from_tty
)
2838 pagination_enabled
= 1;
2842 pagination_off_command (char *arg
, int from_tty
)
2844 pagination_enabled
= 0;
2848 show_debug_timestamp (struct ui_file
*file
, int from_tty
,
2849 struct cmd_list_element
*c
, const char *value
)
2851 fprintf_filtered (file
, _("Timestamping debugging messages is %s.\n"), value
);
2856 initialize_utils (void)
2858 add_setshow_uinteger_cmd ("width", class_support
, &chars_per_line
, _("\
2859 Set number of characters gdb thinks are in a line."), _("\
2860 Show number of characters gdb thinks are in a line."), NULL
,
2862 show_chars_per_line
,
2863 &setlist
, &showlist
);
2865 add_setshow_uinteger_cmd ("height", class_support
, &lines_per_page
, _("\
2866 Set number of lines gdb thinks are in a page."), _("\
2867 Show number of lines gdb thinks are in a page."), NULL
,
2869 show_lines_per_page
,
2870 &setlist
, &showlist
);
2874 add_setshow_boolean_cmd ("demangle", class_support
, &demangle
, _("\
2875 Set demangling of encoded C++/ObjC names when displaying symbols."), _("\
2876 Show demangling of encoded C++/ObjC names when displaying symbols."), NULL
,
2879 &setprintlist
, &showprintlist
);
2881 add_setshow_boolean_cmd ("pagination", class_support
,
2882 &pagination_enabled
, _("\
2883 Set state of pagination."), _("\
2884 Show state of pagination."), NULL
,
2886 show_pagination_enabled
,
2887 &setlist
, &showlist
);
2891 add_com ("am", class_support
, pagination_on_command
,
2892 _("Enable pagination"));
2893 add_com ("sm", class_support
, pagination_off_command
,
2894 _("Disable pagination"));
2897 add_setshow_boolean_cmd ("sevenbit-strings", class_support
,
2898 &sevenbit_strings
, _("\
2899 Set printing of 8-bit characters in strings as \\nnn."), _("\
2900 Show printing of 8-bit characters in strings as \\nnn."), NULL
,
2902 show_sevenbit_strings
,
2903 &setprintlist
, &showprintlist
);
2905 add_setshow_boolean_cmd ("asm-demangle", class_support
, &asm_demangle
, _("\
2906 Set demangling of C++/ObjC names in disassembly listings."), _("\
2907 Show demangling of C++/ObjC names in disassembly listings."), NULL
,
2910 &setprintlist
, &showprintlist
);
2912 add_setshow_boolean_cmd ("timestamp", class_maintenance
,
2913 &debug_timestamp
, _("\
2914 Set timestamping of debugging messages."), _("\
2915 Show timestamping of debugging messages."), _("\
2916 When set, debugging messages will be marked with seconds and microseconds."),
2918 show_debug_timestamp
,
2919 &setdebuglist
, &showdebuglist
);
2922 /* Machine specific function to handle SIGWINCH signal. */
2924 #ifdef SIGWINCH_HANDLER_BODY
2925 SIGWINCH_HANDLER_BODY
2927 /* print routines to handle variable size regs, etc. */
2928 /* temporary storage using circular buffer */
2934 static char buf
[NUMCELLS
][CELLSIZE
];
2935 static int cell
= 0;
2937 if (++cell
>= NUMCELLS
)
2943 paddress (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2945 /* Truncate address to the size of a target address, avoiding shifts
2946 larger or equal than the width of a CORE_ADDR. The local
2947 variable ADDR_BIT stops the compiler reporting a shift overflow
2948 when it won't occur. */
2949 /* NOTE: This assumes that the significant address information is
2950 kept in the least significant bits of ADDR - the upper bits were
2951 either zero or sign extended. Should gdbarch_address_to_pointer or
2952 some ADDRESS_TO_PRINTABLE() be used to do the conversion? */
2954 int addr_bit
= gdbarch_addr_bit (gdbarch
);
2956 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
2957 addr
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
2958 return hex_string (addr
);
2962 decimal2str (char *sign
, ULONGEST addr
, int width
)
2964 /* Steal code from valprint.c:print_decimal(). Should this worry
2965 about the real size of addr as the above does? */
2966 unsigned long temp
[3];
2967 char *str
= get_cell ();
2972 temp
[i
] = addr
% (1000 * 1000 * 1000);
2973 addr
/= (1000 * 1000 * 1000);
2977 while (addr
!= 0 && i
< (sizeof (temp
) / sizeof (temp
[0])));
2986 xsnprintf (str
, CELLSIZE
, "%s%0*lu", sign
, width
, temp
[0]);
2989 xsnprintf (str
, CELLSIZE
, "%s%0*lu%09lu", sign
, width
,
2993 xsnprintf (str
, CELLSIZE
, "%s%0*lu%09lu%09lu", sign
, width
,
2994 temp
[2], temp
[1], temp
[0]);
2997 internal_error (__FILE__
, __LINE__
,
2998 _("failed internal consistency check"));
3005 octal2str (ULONGEST addr
, int width
)
3007 unsigned long temp
[3];
3008 char *str
= get_cell ();
3013 temp
[i
] = addr
% (0100000 * 0100000);
3014 addr
/= (0100000 * 0100000);
3018 while (addr
!= 0 && i
< (sizeof (temp
) / sizeof (temp
[0])));
3028 xsnprintf (str
, CELLSIZE
, "%*o", width
, 0);
3030 xsnprintf (str
, CELLSIZE
, "0%0*lo", width
, temp
[0]);
3033 xsnprintf (str
, CELLSIZE
, "0%0*lo%010lo", width
, temp
[1], temp
[0]);
3036 xsnprintf (str
, CELLSIZE
, "0%0*lo%010lo%010lo", width
,
3037 temp
[2], temp
[1], temp
[0]);
3040 internal_error (__FILE__
, __LINE__
,
3041 _("failed internal consistency check"));
3048 pulongest (ULONGEST u
)
3050 return decimal2str ("", u
, 0);
3054 plongest (LONGEST l
)
3057 return decimal2str ("-", -l
, 0);
3059 return decimal2str ("", l
, 0);
3062 /* Eliminate warning from compiler on 32-bit systems. */
3063 static int thirty_two
= 32;
3066 phex (ULONGEST l
, int sizeof_l
)
3074 xsnprintf (str
, CELLSIZE
, "%08lx%08lx",
3075 (unsigned long) (l
>> thirty_two
),
3076 (unsigned long) (l
& 0xffffffff));
3080 xsnprintf (str
, CELLSIZE
, "%08lx", (unsigned long) l
);
3084 xsnprintf (str
, CELLSIZE
, "%04x", (unsigned short) (l
& 0xffff));
3087 str
= phex (l
, sizeof (l
));
3095 phex_nz (ULONGEST l
, int sizeof_l
)
3103 unsigned long high
= (unsigned long) (l
>> thirty_two
);
3106 xsnprintf (str
, CELLSIZE
, "%lx",
3107 (unsigned long) (l
& 0xffffffff));
3109 xsnprintf (str
, CELLSIZE
, "%lx%08lx", high
,
3110 (unsigned long) (l
& 0xffffffff));
3115 xsnprintf (str
, CELLSIZE
, "%lx", (unsigned long) l
);
3119 xsnprintf (str
, CELLSIZE
, "%x", (unsigned short) (l
& 0xffff));
3122 str
= phex_nz (l
, sizeof (l
));
3129 /* Converts a LONGEST to a C-format hexadecimal literal and stores it
3130 in a static string. Returns a pointer to this string. */
3132 hex_string (LONGEST num
)
3134 char *result
= get_cell ();
3136 xsnprintf (result
, CELLSIZE
, "0x%s", phex_nz (num
, sizeof (num
)));
3140 /* Converts a LONGEST number to a C-format hexadecimal literal and
3141 stores it in a static string. Returns a pointer to this string
3142 that is valid until the next call. The number is padded on the
3143 left with 0s to at least WIDTH characters. */
3145 hex_string_custom (LONGEST num
, int width
)
3147 char *result
= get_cell ();
3148 char *result_end
= result
+ CELLSIZE
- 1;
3149 const char *hex
= phex_nz (num
, sizeof (num
));
3150 int hex_len
= strlen (hex
);
3152 if (hex_len
> width
)
3154 if (width
+ 2 >= CELLSIZE
)
3155 internal_error (__FILE__
, __LINE__
,
3156 _("hex_string_custom: insufficient space to store result"));
3158 strcpy (result_end
- width
- 2, "0x");
3159 memset (result_end
- width
, '0', width
);
3160 strcpy (result_end
- hex_len
, hex
);
3161 return result_end
- width
- 2;
3164 /* Convert VAL to a numeral in the given radix. For
3165 * radix 10, IS_SIGNED may be true, indicating a signed quantity;
3166 * otherwise VAL is interpreted as unsigned. If WIDTH is supplied,
3167 * it is the minimum width (0-padded if needed). USE_C_FORMAT means
3168 * to use C format in all cases. If it is false, then 'x'
3169 * and 'o' formats do not include a prefix (0x or leading 0). */
3172 int_string (LONGEST val
, int radix
, int is_signed
, int width
,
3181 result
= hex_string (val
);
3183 result
= hex_string_custom (val
, width
);
3190 if (is_signed
&& val
< 0)
3191 return decimal2str ("-", -val
, width
);
3193 return decimal2str ("", val
, width
);
3197 char *result
= octal2str (val
, width
);
3198 if (use_c_format
|| val
== 0)
3204 internal_error (__FILE__
, __LINE__
,
3205 _("failed internal consistency check"));
3209 /* Convert a CORE_ADDR into a string. */
3211 core_addr_to_string (const CORE_ADDR addr
)
3213 char *str
= get_cell ();
3216 strcat (str
, phex (addr
, sizeof (addr
)));
3221 core_addr_to_string_nz (const CORE_ADDR addr
)
3223 char *str
= get_cell ();
3226 strcat (str
, phex_nz (addr
, sizeof (addr
)));
3230 /* Convert a string back into a CORE_ADDR. */
3232 string_to_core_addr (const char *my_string
)
3236 if (my_string
[0] == '0' && tolower (my_string
[1]) == 'x')
3238 /* Assume that it is in hex. */
3240 for (i
= 2; my_string
[i
] != '\0'; i
++)
3242 if (isdigit (my_string
[i
]))
3243 addr
= (my_string
[i
] - '0') + (addr
* 16);
3244 else if (isxdigit (my_string
[i
]))
3245 addr
= (tolower (my_string
[i
]) - 'a' + 0xa) + (addr
* 16);
3247 error (_("invalid hex \"%s\""), my_string
);
3252 /* Assume that it is in decimal. */
3254 for (i
= 0; my_string
[i
] != '\0'; i
++)
3256 if (isdigit (my_string
[i
]))
3257 addr
= (my_string
[i
] - '0') + (addr
* 10);
3259 error (_("invalid decimal \"%s\""), my_string
);
3267 host_address_to_string (const void *addr
)
3269 char *str
= get_cell ();
3271 xsnprintf (str
, CELLSIZE
, "0x%s", phex_nz ((uintptr_t) addr
, sizeof (addr
)));
3276 gdb_realpath (const char *filename
)
3278 /* Method 1: The system has a compile time upper bound on a filename
3279 path. Use that and realpath() to canonicalize the name. This is
3280 the most common case. Note that, if there isn't a compile time
3281 upper bound, you want to avoid realpath() at all costs. */
3282 #if defined(HAVE_REALPATH)
3284 # if defined (PATH_MAX)
3286 # define USE_REALPATH
3287 # elif defined (MAXPATHLEN)
3288 char buf
[MAXPATHLEN
];
3289 # define USE_REALPATH
3291 # if defined (USE_REALPATH)
3292 const char *rp
= realpath (filename
, buf
);
3295 return xstrdup (rp
);
3298 #endif /* HAVE_REALPATH */
3300 /* Method 2: The host system (i.e., GNU) has the function
3301 canonicalize_file_name() which malloc's a chunk of memory and
3302 returns that, use that. */
3303 #if defined(HAVE_CANONICALIZE_FILE_NAME)
3305 char *rp
= canonicalize_file_name (filename
);
3307 return xstrdup (filename
);
3313 /* FIXME: cagney/2002-11-13:
3315 Method 2a: Use realpath() with a NULL buffer. Some systems, due
3316 to the problems described in in method 3, have modified their
3317 realpath() implementation so that it will allocate a buffer when
3318 NULL is passed in. Before this can be used, though, some sort of
3319 configure time test would need to be added. Otherwize the code
3320 will likely core dump. */
3322 /* Method 3: Now we're getting desperate! The system doesn't have a
3323 compile time buffer size and no alternative function. Query the
3324 OS, using pathconf(), for the buffer limit. Care is needed
3325 though, some systems do not limit PATH_MAX (return -1 for
3326 pathconf()) making it impossible to pass a correctly sized buffer
3327 to realpath() (it could always overflow). On those systems, we
3329 #if defined (HAVE_REALPATH) && defined (HAVE_UNISTD_H) && defined(HAVE_ALLOCA)
3331 /* Find out the max path size. */
3332 long path_max
= pathconf ("/", _PC_PATH_MAX
);
3335 /* PATH_MAX is bounded. */
3336 char *buf
= alloca (path_max
);
3337 char *rp
= realpath (filename
, buf
);
3338 return xstrdup (rp
? rp
: filename
);
3343 /* This system is a lost cause, just dup the buffer. */
3344 return xstrdup (filename
);
3347 /* Return a copy of FILENAME, with its directory prefix canonicalized
3351 xfullpath (const char *filename
)
3353 const char *base_name
= lbasename (filename
);
3358 /* Extract the basename of filename, and return immediately
3359 a copy of filename if it does not contain any directory prefix. */
3360 if (base_name
== filename
)
3361 return xstrdup (filename
);
3363 dir_name
= alloca ((size_t) (base_name
- filename
+ 2));
3364 /* Allocate enough space to store the dir_name + plus one extra
3365 character sometimes needed under Windows (see below), and
3366 then the closing \000 character */
3367 strncpy (dir_name
, filename
, base_name
- filename
);
3368 dir_name
[base_name
- filename
] = '\000';
3370 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3371 /* We need to be careful when filename is of the form 'd:foo', which
3372 is equivalent of d:./foo, which is totally different from d:/foo. */
3373 if (strlen (dir_name
) == 2 && isalpha (dir_name
[0]) && dir_name
[1] == ':')
3376 dir_name
[3] = '\000';
3380 /* Canonicalize the directory prefix, and build the resulting
3381 filename. If the dirname realpath already contains an ending
3382 directory separator, avoid doubling it. */
3383 real_path
= gdb_realpath (dir_name
);
3384 if (IS_DIR_SEPARATOR (real_path
[strlen (real_path
) - 1]))
3385 result
= concat (real_path
, base_name
, (char *) NULL
);
3387 result
= concat (real_path
, SLASH_STRING
, base_name
, (char *) NULL
);
3394 /* This is the 32-bit CRC function used by the GNU separate debug
3395 facility. An executable may contain a section named
3396 .gnu_debuglink, which holds the name of a separate executable file
3397 containing its debug info, and a checksum of that file's contents,
3398 computed using this function. */
3400 gnu_debuglink_crc32 (unsigned long crc
, unsigned char *buf
, size_t len
)
3402 static const unsigned int crc32_table
[256] = {
3403 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
3404 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
3405 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
3406 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
3407 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
3408 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
3409 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
3410 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
3411 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
3412 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
3413 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
3414 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
3415 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
3416 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
3417 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
3418 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
3419 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
3420 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
3421 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
3422 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
3423 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
3424 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
3425 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
3426 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
3427 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
3428 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
3429 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
3430 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
3431 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
3432 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
3433 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
3434 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
3435 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
3436 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
3437 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
3438 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
3439 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
3440 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
3441 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
3442 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
3443 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
3444 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
3445 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
3446 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
3447 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
3448 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
3449 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
3450 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
3451 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
3452 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
3453 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
3458 crc
= ~crc
& 0xffffffff;
3459 for (end
= buf
+ len
; buf
< end
; ++buf
)
3460 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
3461 return ~crc
& 0xffffffff;;
3465 align_up (ULONGEST v
, int n
)
3467 /* Check that N is really a power of two. */
3468 gdb_assert (n
&& (n
& (n
-1)) == 0);
3469 return (v
+ n
- 1) & -n
;
3473 align_down (ULONGEST v
, int n
)
3475 /* Check that N is really a power of two. */
3476 gdb_assert (n
&& (n
& (n
-1)) == 0);
3480 /* Allocation function for the libiberty hash table which uses an
3481 obstack. The obstack is passed as DATA. */
3484 hashtab_obstack_allocate (void *data
, size_t size
, size_t count
)
3486 unsigned int total
= size
* count
;
3487 void *ptr
= obstack_alloc ((struct obstack
*) data
, total
);
3489 memset (ptr
, 0, total
);
3493 /* Trivial deallocation function for the libiberty splay tree and hash
3494 table - don't deallocate anything. Rely on later deletion of the
3495 obstack. DATA will be the obstack, although it is not needed
3499 dummy_obstack_deallocate (void *object
, void *data
)
3504 /* The bit offset of the highest byte in a ULONGEST, for overflow
3507 #define HIGH_BYTE_POSN ((sizeof (ULONGEST) - 1) * HOST_CHAR_BIT)
3509 /* True (non-zero) iff DIGIT is a valid digit in radix BASE,
3510 where 2 <= BASE <= 36. */
3513 is_digit_in_base (unsigned char digit
, int base
)
3515 if (!isalnum (digit
))
3518 return (isdigit (digit
) && digit
< base
+ '0');
3520 return (isdigit (digit
) || tolower (digit
) < base
- 10 + 'a');
3524 digit_to_int (unsigned char c
)
3529 return tolower (c
) - 'a' + 10;
3532 /* As for strtoul, but for ULONGEST results. */
3535 strtoulst (const char *num
, const char **trailer
, int base
)
3537 unsigned int high_part
;
3542 /* Skip leading whitespace. */
3543 while (isspace (num
[i
]))
3546 /* Handle prefixes. */
3549 else if (num
[i
] == '-')
3555 if (base
== 0 || base
== 16)
3557 if (num
[i
] == '0' && (num
[i
+ 1] == 'x' || num
[i
+ 1] == 'X'))
3565 if (base
== 0 && num
[i
] == '0')
3571 if (base
< 2 || base
> 36)
3577 result
= high_part
= 0;
3578 for (; is_digit_in_base (num
[i
], base
); i
+= 1)
3580 result
= result
* base
+ digit_to_int (num
[i
]);
3581 high_part
= high_part
* base
+ (unsigned int) (result
>> HIGH_BYTE_POSN
);
3582 result
&= ((ULONGEST
) 1 << HIGH_BYTE_POSN
) - 1;
3583 if (high_part
> 0xff)
3586 result
= ~ (ULONGEST
) 0;
3593 if (trailer
!= NULL
)
3596 result
= result
+ ((ULONGEST
) high_part
<< HIGH_BYTE_POSN
);
3603 /* Simple, portable version of dirname that does not modify its
3607 ldirname (const char *filename
)
3609 const char *base
= lbasename (filename
);
3612 while (base
> filename
&& IS_DIR_SEPARATOR (base
[-1]))
3615 if (base
== filename
)
3618 dirname
= xmalloc (base
- filename
+ 2);
3619 memcpy (dirname
, filename
, base
- filename
);
3621 /* On DOS based file systems, convert "d:foo" to "d:.", so that we
3622 create "d:./bar" later instead of the (different) "d:/bar". */
3623 if (base
- filename
== 2 && IS_ABSOLUTE_PATH (base
)
3624 && !IS_DIR_SEPARATOR (filename
[0]))
3625 dirname
[base
++ - filename
] = '.';
3627 dirname
[base
- filename
] = '\0';
3631 /* Call libiberty's buildargv, and return the result.
3632 If buildargv fails due to out-of-memory, call nomem.
3633 Therefore, the returned value is guaranteed to be non-NULL,
3634 unless the parameter itself is NULL. */
3637 gdb_buildargv (const char *s
)
3639 char **argv
= buildargv (s
);
3641 if (s
!= NULL
&& argv
== NULL
)
3647 compare_positive_ints (const void *ap
, const void *bp
)
3649 /* Because we know we're comparing two ints which are positive,
3650 there's no danger of overflow here. */
3651 return * (int *) ap
- * (int *) bp
;
3654 #define AMBIGUOUS_MESS1 ".\nMatching formats:"
3655 #define AMBIGUOUS_MESS2 ".\nUse \"set gnutarget format-name\" to specify the format."
3658 gdb_bfd_errmsg (bfd_error_type error_tag
, char **matching
)
3664 /* Check if errmsg just need simple return. */
3665 if (error_tag
!= bfd_error_file_ambiguously_recognized
|| matching
== NULL
)
3666 return bfd_errmsg (error_tag
);
3668 ret_len
= strlen (bfd_errmsg (error_tag
)) + strlen (AMBIGUOUS_MESS1
)
3669 + strlen (AMBIGUOUS_MESS2
);
3670 for (p
= matching
; *p
; p
++)
3671 ret_len
+= strlen (*p
) + 1;
3672 ret
= xmalloc (ret_len
+ 1);
3674 make_cleanup (xfree
, ret
);
3676 strcpy (retp
, bfd_errmsg (error_tag
));
3677 retp
+= strlen (retp
);
3679 strcpy (retp
, AMBIGUOUS_MESS1
);
3680 retp
+= strlen (retp
);
3682 for (p
= matching
; *p
; p
++)
3684 sprintf (retp
, " %s", *p
);
3685 retp
+= strlen (retp
);
3689 strcpy (retp
, AMBIGUOUS_MESS2
);
3694 /* Return ARGS parsed as a valid pid, or throw an error. */
3697 parse_pid_to_attach (char *args
)
3703 error_no_arg (_("process-id to attach"));
3706 pid
= strtoul (args
, &dummy
, 0);
3707 /* Some targets don't set errno on errors, grrr! */
3708 if ((pid
== 0 && dummy
== args
) || dummy
!= &args
[strlen (args
)])
3709 error (_("Illegal process-id: %s."), args
);
3714 /* Provide a prototype to silence -Wmissing-prototypes. */
3715 extern initialize_file_ftype _initialize_utils
;
3718 _initialize_utils (void)
3720 add_internal_problem_command (&internal_error_problem
);
3721 add_internal_problem_command (&internal_warning_problem
);