1 /* General utility routines for GDB, the GNU debugger.
2 Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
3 1997, 1998, 1999, 2000, 2001
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
24 #include "gdb_assert.h"
26 #include "gdb_string.h"
27 #include "event-top.h"
40 /* SunOS's curses.h has a '#define reg register' in it. Thank you Sun. */
51 #include "expression.h"
55 #include "inferior.h" /* for signed_pointer_to_address */
57 #include <readline/readline.h>
59 #ifndef MALLOC_INCOMPATIBLE
60 #ifdef NEED_DECLARATION_MALLOC
63 #ifdef NEED_DECLARATION_REALLOC
64 extern PTR
realloc ();
66 #ifdef NEED_DECLARATION_FREE
72 #define XMALLOC(TYPE) ((TYPE*) xmalloc (sizeof (TYPE)))
74 /* readline defines this. */
77 void (*error_begin_hook
) (void);
79 /* Holds the last error message issued by gdb */
81 static struct ui_file
*gdb_lasterr
;
83 /* Prototypes for local functions */
85 static void vfprintf_maybe_filtered (struct ui_file
*, const char *,
88 static void fputs_maybe_filtered (const char *, struct ui_file
*, int);
90 #if defined (USE_MMALLOC) && !defined (NO_MMCHECK)
91 static void malloc_botch (void);
94 static void prompt_for_continue (void);
96 static void set_width_command (char *, int, struct cmd_list_element
*);
98 static void set_width (void);
100 /* Chain of cleanup actions established with make_cleanup,
101 to be executed if an error happens. */
103 static struct cleanup
*cleanup_chain
; /* cleaned up after a failed command */
104 static struct cleanup
*final_cleanup_chain
; /* cleaned up when gdb exits */
105 static struct cleanup
*run_cleanup_chain
; /* cleaned up on each 'run' */
106 static struct cleanup
*exec_cleanup_chain
; /* cleaned up on each execution command */
107 /* cleaned up on each error from within an execution command */
108 static struct cleanup
*exec_error_cleanup_chain
;
110 /* Pointer to what is left to do for an execution command after the
111 target stops. Used only in asynchronous mode, by targets that
112 support async execution. The finish and until commands use it. So
113 does the target extended-remote command. */
114 struct continuation
*cmd_continuation
;
115 struct continuation
*intermediate_continuation
;
117 /* Nonzero if we have job control. */
121 /* Nonzero means a quit has been requested. */
125 /* Nonzero means quit immediately if Control-C is typed now, rather
126 than waiting until QUIT is executed. Be careful in setting this;
127 code which executes with immediate_quit set has to be very careful
128 about being able to deal with being interrupted at any time. It is
129 almost always better to use QUIT; the only exception I can think of
130 is being able to quit out of a system call (using EINTR loses if
131 the SIGINT happens between the previous QUIT and the system call).
132 To immediately quit in the case in which a SIGINT happens between
133 the previous QUIT and setting immediate_quit (desirable anytime we
134 expect to block), call QUIT after setting immediate_quit. */
138 /* Nonzero means that encoded C++ names should be printed out in their
139 C++ form rather than raw. */
143 /* Nonzero means that encoded C++ names should be printed out in their
144 C++ form even in assembler language displays. If this is set, but
145 DEMANGLE is zero, names are printed raw, i.e. DEMANGLE controls. */
147 int asm_demangle
= 0;
149 /* Nonzero means that strings with character values >0x7F should be printed
150 as octal escapes. Zero means just print the value (e.g. it's an
151 international character, and the terminal or window can cope.) */
153 int sevenbit_strings
= 0;
155 /* String to be printed before error messages, if any. */
157 char *error_pre_print
;
159 /* String to be printed before quit messages, if any. */
161 char *quit_pre_print
;
163 /* String to be printed before warning messages, if any. */
165 char *warning_pre_print
= "\nwarning: ";
167 int pagination_enabled
= 1;
170 /* Add a new cleanup to the cleanup_chain,
171 and return the previous chain pointer
172 to be passed later to do_cleanups or discard_cleanups.
173 Args are FUNCTION to clean up with, and ARG to pass to it. */
176 make_cleanup (make_cleanup_ftype
*function
, void *arg
)
178 return make_my_cleanup (&cleanup_chain
, function
, arg
);
182 make_final_cleanup (make_cleanup_ftype
*function
, void *arg
)
184 return make_my_cleanup (&final_cleanup_chain
, function
, arg
);
188 make_run_cleanup (make_cleanup_ftype
*function
, void *arg
)
190 return make_my_cleanup (&run_cleanup_chain
, function
, arg
);
194 make_exec_cleanup (make_cleanup_ftype
*function
, void *arg
)
196 return make_my_cleanup (&exec_cleanup_chain
, function
, arg
);
200 make_exec_error_cleanup (make_cleanup_ftype
*function
, void *arg
)
202 return make_my_cleanup (&exec_error_cleanup_chain
, function
, arg
);
206 do_freeargv (void *arg
)
208 freeargv ((char **) arg
);
212 make_cleanup_freeargv (char **arg
)
214 return make_my_cleanup (&cleanup_chain
, do_freeargv
, arg
);
218 do_bfd_close_cleanup (void *arg
)
224 make_cleanup_bfd_close (bfd
*abfd
)
226 return make_cleanup (do_bfd_close_cleanup
, abfd
);
230 do_close_cleanup (void *arg
)
238 make_cleanup_close (int fd
)
240 int *saved_fd
= xmalloc (sizeof (fd
));
242 return make_cleanup (do_close_cleanup
, saved_fd
);
246 do_ui_file_delete (void *arg
)
248 ui_file_delete (arg
);
252 make_cleanup_ui_file_delete (struct ui_file
*arg
)
254 return make_my_cleanup (&cleanup_chain
, do_ui_file_delete
, arg
);
258 make_my_cleanup (struct cleanup
**pmy_chain
, make_cleanup_ftype
*function
,
261 register struct cleanup
*new
262 = (struct cleanup
*) xmalloc (sizeof (struct cleanup
));
263 register struct cleanup
*old_chain
= *pmy_chain
;
265 new->next
= *pmy_chain
;
266 new->function
= function
;
273 /* Discard cleanups and do the actions they describe
274 until we get back to the point OLD_CHAIN in the cleanup_chain. */
277 do_cleanups (register struct cleanup
*old_chain
)
279 do_my_cleanups (&cleanup_chain
, old_chain
);
283 do_final_cleanups (register struct cleanup
*old_chain
)
285 do_my_cleanups (&final_cleanup_chain
, old_chain
);
289 do_run_cleanups (register struct cleanup
*old_chain
)
291 do_my_cleanups (&run_cleanup_chain
, old_chain
);
295 do_exec_cleanups (register struct cleanup
*old_chain
)
297 do_my_cleanups (&exec_cleanup_chain
, old_chain
);
301 do_exec_error_cleanups (register struct cleanup
*old_chain
)
303 do_my_cleanups (&exec_error_cleanup_chain
, old_chain
);
307 do_my_cleanups (register struct cleanup
**pmy_chain
,
308 register struct cleanup
*old_chain
)
310 register struct cleanup
*ptr
;
311 while ((ptr
= *pmy_chain
) != old_chain
)
313 *pmy_chain
= ptr
->next
; /* Do this first incase recursion */
314 (*ptr
->function
) (ptr
->arg
);
319 /* Discard cleanups, not doing the actions they describe,
320 until we get back to the point OLD_CHAIN in the cleanup_chain. */
323 discard_cleanups (register struct cleanup
*old_chain
)
325 discard_my_cleanups (&cleanup_chain
, old_chain
);
329 discard_final_cleanups (register struct cleanup
*old_chain
)
331 discard_my_cleanups (&final_cleanup_chain
, old_chain
);
335 discard_exec_error_cleanups (register struct cleanup
*old_chain
)
337 discard_my_cleanups (&exec_error_cleanup_chain
, old_chain
);
341 discard_my_cleanups (register struct cleanup
**pmy_chain
,
342 register struct cleanup
*old_chain
)
344 register struct cleanup
*ptr
;
345 while ((ptr
= *pmy_chain
) != old_chain
)
347 *pmy_chain
= ptr
->next
;
352 /* Set the cleanup_chain to 0, and return the old cleanup chain. */
356 return save_my_cleanups (&cleanup_chain
);
360 save_final_cleanups (void)
362 return save_my_cleanups (&final_cleanup_chain
);
366 save_my_cleanups (struct cleanup
**pmy_chain
)
368 struct cleanup
*old_chain
= *pmy_chain
;
374 /* Restore the cleanup chain from a previously saved chain. */
376 restore_cleanups (struct cleanup
*chain
)
378 restore_my_cleanups (&cleanup_chain
, chain
);
382 restore_final_cleanups (struct cleanup
*chain
)
384 restore_my_cleanups (&final_cleanup_chain
, chain
);
388 restore_my_cleanups (struct cleanup
**pmy_chain
, struct cleanup
*chain
)
393 /* This function is useful for cleanups.
397 old_chain = make_cleanup (free_current_contents, &foo);
399 to arrange to free the object thus allocated. */
402 free_current_contents (void *ptr
)
404 void **location
= ptr
;
405 if (location
== NULL
)
406 internal_error (__FILE__
, __LINE__
,
407 "free_current_contents: NULL pointer");
408 if (*location
!= NULL
)
415 /* Provide a known function that does nothing, to use as a base for
416 for a possibly long chain of cleanups. This is useful where we
417 use the cleanup chain for handling normal cleanups as well as dealing
418 with cleanups that need to be done as a result of a call to error().
419 In such cases, we may not be certain where the first cleanup is, unless
420 we have a do-nothing one to always use as the base. */
424 null_cleanup (void *arg
)
428 /* Add a continuation to the continuation list, the global list
429 cmd_continuation. The new continuation will be added at the front.*/
431 add_continuation (void (*continuation_hook
) (struct continuation_arg
*),
432 struct continuation_arg
*arg_list
)
434 struct continuation
*continuation_ptr
;
436 continuation_ptr
= (struct continuation
*) xmalloc (sizeof (struct continuation
));
437 continuation_ptr
->continuation_hook
= continuation_hook
;
438 continuation_ptr
->arg_list
= arg_list
;
439 continuation_ptr
->next
= cmd_continuation
;
440 cmd_continuation
= continuation_ptr
;
443 /* Walk down the cmd_continuation list, and execute all the
444 continuations. There is a problem though. In some cases new
445 continuations may be added while we are in the middle of this
446 loop. If this happens they will be added in the front, and done
447 before we have a chance of exhausting those that were already
448 there. We need to then save the beginning of the list in a pointer
449 and do the continuations from there on, instead of using the
450 global beginning of list as our iteration pointer.*/
452 do_all_continuations (void)
454 struct continuation
*continuation_ptr
;
455 struct continuation
*saved_continuation
;
457 /* Copy the list header into another pointer, and set the global
458 list header to null, so that the global list can change as a side
459 effect of invoking the continuations and the processing of
460 the preexisting continuations will not be affected. */
461 continuation_ptr
= cmd_continuation
;
462 cmd_continuation
= NULL
;
464 /* Work now on the list we have set aside. */
465 while (continuation_ptr
)
467 (continuation_ptr
->continuation_hook
) (continuation_ptr
->arg_list
);
468 saved_continuation
= continuation_ptr
;
469 continuation_ptr
= continuation_ptr
->next
;
470 xfree (saved_continuation
);
474 /* Walk down the cmd_continuation list, and get rid of all the
477 discard_all_continuations (void)
479 struct continuation
*continuation_ptr
;
481 while (cmd_continuation
)
483 continuation_ptr
= cmd_continuation
;
484 cmd_continuation
= continuation_ptr
->next
;
485 xfree (continuation_ptr
);
489 /* Add a continuation to the continuation list, the global list
490 intermediate_continuation. The new continuation will be added at the front.*/
492 add_intermediate_continuation (void (*continuation_hook
)
493 (struct continuation_arg
*),
494 struct continuation_arg
*arg_list
)
496 struct continuation
*continuation_ptr
;
498 continuation_ptr
= (struct continuation
*) xmalloc (sizeof (struct continuation
));
499 continuation_ptr
->continuation_hook
= continuation_hook
;
500 continuation_ptr
->arg_list
= arg_list
;
501 continuation_ptr
->next
= intermediate_continuation
;
502 intermediate_continuation
= continuation_ptr
;
505 /* Walk down the cmd_continuation list, and execute all the
506 continuations. There is a problem though. In some cases new
507 continuations may be added while we are in the middle of this
508 loop. If this happens they will be added in the front, and done
509 before we have a chance of exhausting those that were already
510 there. We need to then save the beginning of the list in a pointer
511 and do the continuations from there on, instead of using the
512 global beginning of list as our iteration pointer.*/
514 do_all_intermediate_continuations (void)
516 struct continuation
*continuation_ptr
;
517 struct continuation
*saved_continuation
;
519 /* Copy the list header into another pointer, and set the global
520 list header to null, so that the global list can change as a side
521 effect of invoking the continuations and the processing of
522 the preexisting continuations will not be affected. */
523 continuation_ptr
= intermediate_continuation
;
524 intermediate_continuation
= NULL
;
526 /* Work now on the list we have set aside. */
527 while (continuation_ptr
)
529 (continuation_ptr
->continuation_hook
) (continuation_ptr
->arg_list
);
530 saved_continuation
= continuation_ptr
;
531 continuation_ptr
= continuation_ptr
->next
;
532 xfree (saved_continuation
);
536 /* Walk down the cmd_continuation list, and get rid of all the
539 discard_all_intermediate_continuations (void)
541 struct continuation
*continuation_ptr
;
543 while (intermediate_continuation
)
545 continuation_ptr
= intermediate_continuation
;
546 intermediate_continuation
= continuation_ptr
->next
;
547 xfree (continuation_ptr
);
553 /* Print a warning message. Way to use this is to call warning_begin,
554 output the warning message (use unfiltered output to gdb_stderr),
555 ending in a newline. There is not currently a warning_end that you
556 call afterwards, but such a thing might be added if it is useful
557 for a GUI to separate warning messages from other output.
559 FIXME: Why do warnings use unfiltered output and errors filtered?
560 Is this anything other than a historical accident? */
565 target_terminal_ours ();
566 wrap_here (""); /* Force out any buffered output */
567 gdb_flush (gdb_stdout
);
568 if (warning_pre_print
)
569 fprintf_unfiltered (gdb_stderr
, warning_pre_print
);
572 /* Print a warning message.
573 The first argument STRING is the warning message, used as a fprintf string,
574 and the remaining args are passed as arguments to it.
575 The primary difference between warnings and errors is that a warning
576 does not force the return to command level. */
579 warning (const char *string
,...)
582 va_start (args
, string
);
584 (*warning_hook
) (string
, args
);
588 vfprintf_unfiltered (gdb_stderr
, string
, args
);
589 fprintf_unfiltered (gdb_stderr
, "\n");
594 /* Start the printing of an error message. Way to use this is to call
595 this, output the error message (use filtered output to gdb_stderr
596 (FIXME: Some callers, like memory_error, use gdb_stdout)), ending
597 in a newline, and then call return_to_top_level (RETURN_ERROR).
598 error() provides a convenient way to do this for the special case
599 that the error message can be formatted with a single printf call,
600 but this is more general. */
604 if (error_begin_hook
)
607 target_terminal_ours ();
608 wrap_here (""); /* Force out any buffered output */
609 gdb_flush (gdb_stdout
);
611 annotate_error_begin ();
614 fprintf_filtered (gdb_stderr
, error_pre_print
);
617 /* Print an error message and return to command level.
618 The first argument STRING is the error message, used as a fprintf string,
619 and the remaining args are passed as arguments to it. */
622 verror (const char *string
, va_list args
)
625 struct cleanup
*err_string_cleanup
;
626 /* FIXME: cagney/1999-11-10: All error calls should come here.
627 Unfortunately some code uses the sequence: error_begin(); print
628 error message; return_to_top_level. That code should be
631 /* NOTE: It's tempting to just do the following...
632 vfprintf_filtered (gdb_stderr, string, args);
633 and then follow with a similar looking statement to cause the message
634 to also go to gdb_lasterr. But if we do this, we'll be traversing the
635 va_list twice which works on some platforms and fails miserably on
637 /* Save it as the last error */
638 ui_file_rewind (gdb_lasterr
);
639 vfprintf_filtered (gdb_lasterr
, string
, args
);
640 /* Retrieve the last error and print it to gdb_stderr */
641 err_string
= error_last_message ();
642 err_string_cleanup
= make_cleanup (xfree
, err_string
);
643 fputs_filtered (err_string
, gdb_stderr
);
644 fprintf_filtered (gdb_stderr
, "\n");
645 do_cleanups (err_string_cleanup
);
646 return_to_top_level (RETURN_ERROR
);
650 error (const char *string
,...)
653 va_start (args
, string
);
654 verror (string
, args
);
659 error_stream (struct ui_file
*stream
)
662 char *msg
= ui_file_xstrdup (stream
, &size
);
663 make_cleanup (xfree
, msg
);
667 /* Get the last error message issued by gdb */
670 error_last_message (void)
673 return ui_file_xstrdup (gdb_lasterr
, &len
);
676 /* This is to be called by main() at the very beginning */
681 gdb_lasterr
= mem_fileopen ();
684 /* Print a message reporting an internal error. Ask the user if they
685 want to continue, dump core, or just exit. */
688 internal_verror (const char *file
, int line
,
689 const char *fmt
, va_list ap
)
691 static char msg
[] = "Internal GDB error: recursive internal error.\n";
692 static int dejavu
= 0;
696 /* don't allow infinite error recursion. */
704 fputs_unfiltered (msg
, gdb_stderr
);
705 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
708 write (STDERR_FILENO
, msg
, sizeof (msg
));
712 /* Try to get the message out */
713 target_terminal_ours ();
714 fprintf_unfiltered (gdb_stderr
, "%s:%d: gdb-internal-error: ", file
, line
);
715 vfprintf_unfiltered (gdb_stderr
, fmt
, ap
);
716 fputs_unfiltered ("\n", gdb_stderr
);
718 /* Default (no case) is to quit GDB. When in batch mode this
719 lessens the likelhood of GDB going into an infinate loop. */
720 continue_p
= query ("\
721 An internal GDB error was detected. This may make further\n\
722 debugging unreliable. Continue this debugging session? ");
724 /* Default (no case) is to not dump core. Lessen the chance of GDB
725 leaving random core files around. */
726 dump_core_p
= query ("\
727 Create a core file containing the current state of GDB? ");
734 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
740 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
746 return_to_top_level (RETURN_ERROR
);
750 internal_error (const char *file
, int line
, const char *string
, ...)
753 va_start (ap
, string
);
755 internal_verror (file
, line
, string
, ap
);
759 /* The strerror() function can return NULL for errno values that are
760 out of range. Provide a "safe" version that always returns a
764 safe_strerror (int errnum
)
769 if ((msg
= strerror (errnum
)) == NULL
)
771 sprintf (buf
, "(undocumented errno %d)", errnum
);
777 /* Print the system error message for errno, and also mention STRING
778 as the file name for which the error was encountered.
779 Then return to command level. */
782 perror_with_name (char *string
)
787 err
= safe_strerror (errno
);
788 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
789 strcpy (combined
, string
);
790 strcat (combined
, ": ");
791 strcat (combined
, err
);
793 /* I understand setting these is a matter of taste. Still, some people
794 may clear errno but not know about bfd_error. Doing this here is not
796 bfd_set_error (bfd_error_no_error
);
799 error ("%s.", combined
);
802 /* Print the system error message for ERRCODE, and also mention STRING
803 as the file name for which the error was encountered. */
806 print_sys_errmsg (char *string
, int errcode
)
811 err
= safe_strerror (errcode
);
812 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
813 strcpy (combined
, string
);
814 strcat (combined
, ": ");
815 strcat (combined
, err
);
817 /* We want anything which was printed on stdout to come out first, before
819 gdb_flush (gdb_stdout
);
820 fprintf_unfiltered (gdb_stderr
, "%s.\n", combined
);
823 /* Control C eventually causes this to be called, at a convenient time. */
828 serial_t gdb_stdout_serial
= serial_fdopen (1);
830 target_terminal_ours ();
832 /* We want all output to appear now, before we print "Quit". We
833 have 3 levels of buffering we have to flush (it's possible that
834 some of these should be changed to flush the lower-level ones
837 /* 1. The _filtered buffer. */
838 wrap_here ((char *) 0);
840 /* 2. The stdio buffer. */
841 gdb_flush (gdb_stdout
);
842 gdb_flush (gdb_stderr
);
844 /* 3. The system-level buffer. */
845 SERIAL_DRAIN_OUTPUT (gdb_stdout_serial
);
846 SERIAL_UN_FDOPEN (gdb_stdout_serial
);
848 annotate_error_begin ();
850 /* Don't use *_filtered; we don't want to prompt the user to continue. */
852 fprintf_unfiltered (gdb_stderr
, quit_pre_print
);
855 /* No steenking SIGINT will ever be coming our way when the
856 program is resumed. Don't lie. */
857 fprintf_unfiltered (gdb_stderr
, "Quit\n");
860 /* If there is no terminal switching for this target, then we can't
861 possibly get screwed by the lack of job control. */
862 || current_target
.to_terminal_ours
== NULL
)
863 fprintf_unfiltered (gdb_stderr
, "Quit\n");
865 fprintf_unfiltered (gdb_stderr
,
866 "Quit (expect signal SIGINT when the program is resumed)\n");
868 return_to_top_level (RETURN_QUIT
);
872 #if defined(_MSC_VER) /* should test for wingdb instead? */
875 * Windows translates all keyboard and mouse events
876 * into a message which is appended to the message
877 * queue for the process.
883 int k
= win32pollquit ();
890 #else /* !defined(_MSC_VER) */
895 /* Done by signals */
898 #endif /* !defined(_MSC_VER) */
900 /* Control C comes here */
902 request_quit (int signo
)
905 /* Restore the signal handler. Harmless with BSD-style signals, needed
906 for System V-style signals. So just always do it, rather than worrying
907 about USG defines and stuff like that. */
908 signal (signo
, request_quit
);
918 /* Memory management stuff (malloc friends). */
920 #if !defined (USE_MMALLOC)
922 /* NOTE: These must use PTR so that their definition matches the
923 declaration found in "mmalloc.h". */
926 mmalloc (PTR md
, size_t size
)
928 return malloc (size
); /* NOTE: GDB's only call to malloc() */
932 mrealloc (PTR md
, PTR ptr
, size_t size
)
934 if (ptr
== 0) /* Guard against old realloc's */
935 return mmalloc (md
, size
);
937 return realloc (ptr
, size
); /* NOTE: GDB's only call to ralloc() */
941 mcalloc (PTR md
, size_t number
, size_t size
)
943 return calloc (number
, size
); /* NOTE: GDB's only call to calloc() */
947 mfree (PTR md
, PTR ptr
)
949 free (ptr
); /* NOTE: GDB's only call to free() */
952 #endif /* USE_MMALLOC */
954 #if !defined (USE_MMALLOC) || defined (NO_MMCHECK)
957 init_malloc (void *md
)
961 #else /* Have mmalloc and want corruption checking */
966 fprintf_unfiltered (gdb_stderr
, "Memory corruption\n");
967 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
970 /* Attempt to install hooks in mmalloc/mrealloc/mfree for the heap specified
971 by MD, to detect memory corruption. Note that MD may be NULL to specify
972 the default heap that grows via sbrk.
974 Note that for freshly created regions, we must call mmcheckf prior to any
975 mallocs in the region. Otherwise, any region which was allocated prior to
976 installing the checking hooks, which is later reallocated or freed, will
977 fail the checks! The mmcheck function only allows initial hooks to be
978 installed before the first mmalloc. However, anytime after we have called
979 mmcheck the first time to install the checking hooks, we can call it again
980 to update the function pointer to the memory corruption handler.
982 Returns zero on failure, non-zero on success. */
984 #ifndef MMCHECK_FORCE
985 #define MMCHECK_FORCE 0
989 init_malloc (void *md
)
991 if (!mmcheckf (md
, malloc_botch
, MMCHECK_FORCE
))
993 /* Don't use warning(), which relies on current_target being set
994 to something other than dummy_target, until after
995 initialize_all_files(). */
998 (gdb_stderr
, "warning: failed to install memory consistency checks; ");
1000 (gdb_stderr
, "configuration should define NO_MMCHECK or MMCHECK_FORCE\n");
1006 #endif /* Have mmalloc and want corruption checking */
1008 /* Called when a memory allocation fails, with the number of bytes of
1009 memory requested in SIZE. */
1016 internal_error (__FILE__
, __LINE__
,
1017 "virtual memory exhausted: can't allocate %ld bytes.", size
);
1021 internal_error (__FILE__
, __LINE__
,
1022 "virtual memory exhausted.");
1026 /* The xmmalloc() family of memory management routines.
1028 These are are like the mmalloc() family except that they implement
1029 consistent semantics and guard against typical memory management
1030 problems: if a malloc fails, an internal error is thrown; if
1031 free(NULL) is called, it is ignored; if *alloc(0) is called, NULL
1034 All these routines are implemented using the mmalloc() family. */
1037 xmmalloc (void *md
, size_t size
)
1047 val
= mmalloc (md
, size
);
1055 xmrealloc (void *md
, void *ptr
, size_t size
)
1069 val
= mrealloc (md
, ptr
, size
);
1073 val
= mmalloc (md
, size
);
1084 xmcalloc (void *md
, size_t number
, size_t size
)
1087 if (number
== 0 || size
== 0)
1091 mem
= mcalloc (md
, number
, size
);
1093 nomem (number
* size
);
1099 xmfree (void *md
, void *ptr
)
1105 /* The xmalloc() (libiberty.h) family of memory management routines.
1107 These are like the ISO-C malloc() family except that they implement
1108 consistent semantics and guard against typical memory management
1109 problems. See xmmalloc() above for further information.
1111 All these routines are wrappers to the xmmalloc() family. */
1113 /* NOTE: These are declared using PTR to ensure consistency with
1114 "libiberty.h". xfree() is GDB local. */
1117 xmalloc (size_t size
)
1119 return xmmalloc (NULL
, size
);
1123 xrealloc (PTR ptr
, size_t size
)
1125 return xmrealloc (NULL
, ptr
, size
);
1129 xcalloc (size_t number
, size_t size
)
1131 return xmcalloc (NULL
, number
, size
);
1141 /* Like asprintf/vasprintf but get an internal_error if the call
1145 xasprintf (char **ret
, const char *format
, ...)
1148 va_start (args
, format
);
1149 xvasprintf (ret
, format
, args
);
1154 xvasprintf (char **ret
, const char *format
, va_list ap
)
1156 int status
= vasprintf (ret
, format
, ap
);
1157 /* NULL could be returned due to a memory allocation problem; a
1158 badly format string; or something else. */
1160 internal_error (__FILE__
, __LINE__
,
1161 "vasprintf returned NULL buffer (errno %d)",
1163 /* A negative status with a non-NULL buffer shouldn't never
1164 happen. But to be sure. */
1166 internal_error (__FILE__
, __LINE__
,
1167 "vasprintf call failed (errno %d)",
1172 /* My replacement for the read system call.
1173 Used like `read' but keeps going if `read' returns too soon. */
1176 myread (int desc
, char *addr
, int len
)
1183 val
= read (desc
, addr
, len
);
1187 return orglen
- len
;
1194 /* Make a copy of the string at PTR with SIZE characters
1195 (and add a null character at the end in the copy).
1196 Uses malloc to get the space. Returns the address of the copy. */
1199 savestring (const char *ptr
, size_t size
)
1201 register char *p
= (char *) xmalloc (size
+ 1);
1202 memcpy (p
, ptr
, size
);
1208 msavestring (void *md
, const char *ptr
, size_t size
)
1210 register char *p
= (char *) xmmalloc (md
, size
+ 1);
1211 memcpy (p
, ptr
, size
);
1217 mstrsave (void *md
, const char *ptr
)
1219 return (msavestring (md
, ptr
, strlen (ptr
)));
1223 print_spaces (register int n
, register struct ui_file
*file
)
1225 fputs_unfiltered (n_spaces (n
), file
);
1228 /* Print a host address. */
1231 gdb_print_host_address (void *addr
, struct ui_file
*stream
)
1234 /* We could use the %p conversion specifier to fprintf if we had any
1235 way of knowing whether this host supports it. But the following
1236 should work on the Alpha and on 32 bit machines. */
1238 fprintf_filtered (stream
, "0x%lx", (unsigned long) addr
);
1241 /* Ask user a y-or-n question and return 1 iff answer is yes.
1242 Takes three args which are given to printf to print the question.
1243 The first, a control string, should end in "? ".
1244 It should not say how to answer, because we do that. */
1248 query (char *ctlstr
,...)
1251 register int answer
;
1255 va_start (args
, ctlstr
);
1259 return query_hook (ctlstr
, args
);
1262 /* Automatically answer "yes" if input is not from a terminal. */
1263 if (!input_from_terminal_p ())
1266 /* FIXME Automatically answer "yes" if called from MacGDB. */
1273 wrap_here (""); /* Flush any buffered output */
1274 gdb_flush (gdb_stdout
);
1276 if (annotation_level
> 1)
1277 printf_filtered ("\n\032\032pre-query\n");
1279 vfprintf_filtered (gdb_stdout
, ctlstr
, args
);
1280 printf_filtered ("(y or n) ");
1282 if (annotation_level
> 1)
1283 printf_filtered ("\n\032\032query\n");
1286 /* If not in MacGDB, move to a new line so the entered line doesn't
1287 have a prompt on the front of it. */
1289 fputs_unfiltered ("\n", gdb_stdout
);
1293 gdb_flush (gdb_stdout
);
1296 if (!tui_version
|| cmdWin
== tuiWinWithFocus ())
1298 answer
= fgetc (stdin
);
1301 answer
= (unsigned char) tuiBufferGetc ();
1304 clearerr (stdin
); /* in case of C-d */
1305 if (answer
== EOF
) /* C-d */
1310 /* Eat rest of input line, to EOF or newline */
1311 if ((answer
!= '\n') || (tui_version
&& answer
!= '\r'))
1315 if (!tui_version
|| cmdWin
== tuiWinWithFocus ())
1317 ans2
= fgetc (stdin
);
1320 ans2
= (unsigned char) tuiBufferGetc ();
1324 while (ans2
!= EOF
&& ans2
!= '\n' && ans2
!= '\r');
1325 TUIDO (((TuiOpaqueFuncPtr
) tui_vStartNewLines
, 1));
1339 printf_filtered ("Please answer y or n.\n");
1342 if (annotation_level
> 1)
1343 printf_filtered ("\n\032\032post-query\n");
1348 /* Parse a C escape sequence. STRING_PTR points to a variable
1349 containing a pointer to the string to parse. That pointer
1350 should point to the character after the \. That pointer
1351 is updated past the characters we use. The value of the
1352 escape sequence is returned.
1354 A negative value means the sequence \ newline was seen,
1355 which is supposed to be equivalent to nothing at all.
1357 If \ is followed by a null character, we return a negative
1358 value and leave the string pointer pointing at the null character.
1360 If \ is followed by 000, we return 0 and leave the string pointer
1361 after the zeros. A value of 0 does not mean end of string. */
1364 parse_escape (char **string_ptr
)
1366 register int c
= *(*string_ptr
)++;
1370 return 007; /* Bell (alert) char */
1373 case 'e': /* Escape character */
1391 c
= *(*string_ptr
)++;
1393 c
= parse_escape (string_ptr
);
1396 return (c
& 0200) | (c
& 037);
1407 register int i
= c
- '0';
1408 register int count
= 0;
1411 if ((c
= *(*string_ptr
)++) >= '0' && c
<= '7')
1429 /* Print the character C on STREAM as part of the contents of a literal
1430 string whose delimiter is QUOTER. Note that this routine should only
1431 be call for printing things which are independent of the language
1432 of the program being debugged. */
1435 printchar (int c
, void (*do_fputs
) (const char *, struct ui_file
*),
1436 void (*do_fprintf
) (struct ui_file
*, const char *, ...),
1437 struct ui_file
*stream
, int quoter
)
1440 c
&= 0xFF; /* Avoid sign bit follies */
1442 if (c
< 0x20 || /* Low control chars */
1443 (c
>= 0x7F && c
< 0xA0) || /* DEL, High controls */
1444 (sevenbit_strings
&& c
>= 0x80))
1445 { /* high order bit set */
1449 do_fputs ("\\n", stream
);
1452 do_fputs ("\\b", stream
);
1455 do_fputs ("\\t", stream
);
1458 do_fputs ("\\f", stream
);
1461 do_fputs ("\\r", stream
);
1464 do_fputs ("\\e", stream
);
1467 do_fputs ("\\a", stream
);
1470 do_fprintf (stream
, "\\%.3o", (unsigned int) c
);
1476 if (c
== '\\' || c
== quoter
)
1477 do_fputs ("\\", stream
);
1478 do_fprintf (stream
, "%c", c
);
1482 /* Print the character C on STREAM as part of the contents of a
1483 literal string whose delimiter is QUOTER. Note that these routines
1484 should only be call for printing things which are independent of
1485 the language of the program being debugged. */
1488 fputstr_filtered (const char *str
, int quoter
, struct ui_file
*stream
)
1491 printchar (*str
++, fputs_filtered
, fprintf_filtered
, stream
, quoter
);
1495 fputstr_unfiltered (const char *str
, int quoter
, struct ui_file
*stream
)
1498 printchar (*str
++, fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1502 fputstrn_unfiltered (const char *str
, int n
, int quoter
, struct ui_file
*stream
)
1505 for (i
= 0; i
< n
; i
++)
1506 printchar (str
[i
], fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1511 /* Number of lines per page or UINT_MAX if paging is disabled. */
1512 static unsigned int lines_per_page
;
1513 /* Number of chars per line or UINT_MAX if line folding is disabled. */
1514 static unsigned int chars_per_line
;
1515 /* Current count of lines printed on this page, chars on this line. */
1516 static unsigned int lines_printed
, chars_printed
;
1518 /* Buffer and start column of buffered text, for doing smarter word-
1519 wrapping. When someone calls wrap_here(), we start buffering output
1520 that comes through fputs_filtered(). If we see a newline, we just
1521 spit it out and forget about the wrap_here(). If we see another
1522 wrap_here(), we spit it out and remember the newer one. If we see
1523 the end of the line, we spit out a newline, the indent, and then
1524 the buffered output. */
1526 /* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
1527 are waiting to be output (they have already been counted in chars_printed).
1528 When wrap_buffer[0] is null, the buffer is empty. */
1529 static char *wrap_buffer
;
1531 /* Pointer in wrap_buffer to the next character to fill. */
1532 static char *wrap_pointer
;
1534 /* String to indent by if the wrap occurs. Must not be NULL if wrap_column
1536 static char *wrap_indent
;
1538 /* Column number on the screen where wrap_buffer begins, or 0 if wrapping
1539 is not in effect. */
1540 static int wrap_column
;
1543 /* Inialize the lines and chars per page */
1545 init_page_info (void)
1548 if (tui_version
&& m_winPtrNotNull (cmdWin
))
1550 lines_per_page
= cmdWin
->generic
.height
;
1551 chars_per_line
= cmdWin
->generic
.width
;
1556 /* These defaults will be used if we are unable to get the correct
1557 values from termcap. */
1558 #if defined(__GO32__)
1559 lines_per_page
= ScreenRows ();
1560 chars_per_line
= ScreenCols ();
1562 lines_per_page
= 24;
1563 chars_per_line
= 80;
1565 #if !defined (MPW) && !defined (_WIN32)
1566 /* No termcap under MPW, although might be cool to do something
1567 by looking at worksheet or console window sizes. */
1568 /* Initialize the screen height and width from termcap. */
1570 char *termtype
= getenv ("TERM");
1572 /* Positive means success, nonpositive means failure. */
1575 /* 2048 is large enough for all known terminals, according to the
1576 GNU termcap manual. */
1577 char term_buffer
[2048];
1581 status
= tgetent (term_buffer
, termtype
);
1585 int running_in_emacs
= getenv ("EMACS") != NULL
;
1587 val
= tgetnum ("li");
1588 if (val
>= 0 && !running_in_emacs
)
1589 lines_per_page
= val
;
1591 /* The number of lines per page is not mentioned
1592 in the terminal description. This probably means
1593 that paging is not useful (e.g. emacs shell window),
1594 so disable paging. */
1595 lines_per_page
= UINT_MAX
;
1597 val
= tgetnum ("co");
1599 chars_per_line
= val
;
1605 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
1607 /* If there is a better way to determine the window size, use it. */
1608 SIGWINCH_HANDLER (SIGWINCH
);
1611 /* If the output is not a terminal, don't paginate it. */
1612 if (!ui_file_isatty (gdb_stdout
))
1613 lines_per_page
= UINT_MAX
;
1614 } /* the command_line_version */
1621 if (chars_per_line
== 0)
1626 wrap_buffer
= (char *) xmalloc (chars_per_line
+ 2);
1627 wrap_buffer
[0] = '\0';
1630 wrap_buffer
= (char *) xrealloc (wrap_buffer
, chars_per_line
+ 2);
1631 wrap_pointer
= wrap_buffer
; /* Start it at the beginning */
1636 set_width_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
1641 /* Wait, so the user can read what's on the screen. Prompt the user
1642 to continue by pressing RETURN. */
1645 prompt_for_continue (void)
1648 char cont_prompt
[120];
1650 if (annotation_level
> 1)
1651 printf_unfiltered ("\n\032\032pre-prompt-for-continue\n");
1653 strcpy (cont_prompt
,
1654 "---Type <return> to continue, or q <return> to quit---");
1655 if (annotation_level
> 1)
1656 strcat (cont_prompt
, "\n\032\032prompt-for-continue\n");
1658 /* We must do this *before* we call gdb_readline, else it will eventually
1659 call us -- thinking that we're trying to print beyond the end of the
1661 reinitialize_more_filter ();
1664 /* On a real operating system, the user can quit with SIGINT.
1667 'q' is provided on all systems so users don't have to change habits
1668 from system to system, and because telling them what to do in
1669 the prompt is more user-friendly than expecting them to think of
1671 /* Call readline, not gdb_readline, because GO32 readline handles control-C
1672 whereas control-C to gdb_readline will cause the user to get dumped
1674 ignore
= readline (cont_prompt
);
1676 if (annotation_level
> 1)
1677 printf_unfiltered ("\n\032\032post-prompt-for-continue\n");
1682 while (*p
== ' ' || *p
== '\t')
1687 request_quit (SIGINT
);
1689 async_request_quit (0);
1695 /* Now we have to do this again, so that GDB will know that it doesn't
1696 need to save the ---Type <return>--- line at the top of the screen. */
1697 reinitialize_more_filter ();
1699 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
1702 /* Reinitialize filter; ie. tell it to reset to original values. */
1705 reinitialize_more_filter (void)
1711 /* Indicate that if the next sequence of characters overflows the line,
1712 a newline should be inserted here rather than when it hits the end.
1713 If INDENT is non-null, it is a string to be printed to indent the
1714 wrapped part on the next line. INDENT must remain accessible until
1715 the next call to wrap_here() or until a newline is printed through
1718 If the line is already overfull, we immediately print a newline and
1719 the indentation, and disable further wrapping.
1721 If we don't know the width of lines, but we know the page height,
1722 we must not wrap words, but should still keep track of newlines
1723 that were explicitly printed.
1725 INDENT should not contain tabs, as that will mess up the char count
1726 on the next line. FIXME.
1728 This routine is guaranteed to force out any output which has been
1729 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
1730 used to force out output from the wrap_buffer. */
1733 wrap_here (char *indent
)
1735 /* This should have been allocated, but be paranoid anyway. */
1737 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
1741 *wrap_pointer
= '\0';
1742 fputs_unfiltered (wrap_buffer
, gdb_stdout
);
1744 wrap_pointer
= wrap_buffer
;
1745 wrap_buffer
[0] = '\0';
1746 if (chars_per_line
== UINT_MAX
) /* No line overflow checking */
1750 else if (chars_printed
>= chars_per_line
)
1752 puts_filtered ("\n");
1754 puts_filtered (indent
);
1759 wrap_column
= chars_printed
;
1763 wrap_indent
= indent
;
1767 /* Ensure that whatever gets printed next, using the filtered output
1768 commands, starts at the beginning of the line. I.E. if there is
1769 any pending output for the current line, flush it and start a new
1770 line. Otherwise do nothing. */
1775 if (chars_printed
> 0)
1777 puts_filtered ("\n");
1782 /* Like fputs but if FILTER is true, pause after every screenful.
1784 Regardless of FILTER can wrap at points other than the final
1785 character of a line.
1787 Unlike fputs, fputs_maybe_filtered does not return a value.
1788 It is OK for LINEBUFFER to be NULL, in which case just don't print
1791 Note that a longjmp to top level may occur in this routine (only if
1792 FILTER is true) (since prompt_for_continue may do so) so this
1793 routine should not be called when cleanups are not in place. */
1796 fputs_maybe_filtered (const char *linebuffer
, struct ui_file
*stream
,
1799 const char *lineptr
;
1801 if (linebuffer
== 0)
1804 /* Don't do any filtering if it is disabled. */
1805 if ((stream
!= gdb_stdout
) || !pagination_enabled
1806 || (lines_per_page
== UINT_MAX
&& chars_per_line
== UINT_MAX
))
1808 fputs_unfiltered (linebuffer
, stream
);
1812 /* Go through and output each character. Show line extension
1813 when this is necessary; prompt user for new page when this is
1816 lineptr
= linebuffer
;
1819 /* Possible new page. */
1821 (lines_printed
>= lines_per_page
- 1))
1822 prompt_for_continue ();
1824 while (*lineptr
&& *lineptr
!= '\n')
1826 /* Print a single line. */
1827 if (*lineptr
== '\t')
1830 *wrap_pointer
++ = '\t';
1832 fputc_unfiltered ('\t', stream
);
1833 /* Shifting right by 3 produces the number of tab stops
1834 we have already passed, and then adding one and
1835 shifting left 3 advances to the next tab stop. */
1836 chars_printed
= ((chars_printed
>> 3) + 1) << 3;
1842 *wrap_pointer
++ = *lineptr
;
1844 fputc_unfiltered (*lineptr
, stream
);
1849 if (chars_printed
>= chars_per_line
)
1851 unsigned int save_chars
= chars_printed
;
1855 /* If we aren't actually wrapping, don't output newline --
1856 if chars_per_line is right, we probably just overflowed
1857 anyway; if it's wrong, let us keep going. */
1859 fputc_unfiltered ('\n', stream
);
1861 /* Possible new page. */
1862 if (lines_printed
>= lines_per_page
- 1)
1863 prompt_for_continue ();
1865 /* Now output indentation and wrapped string */
1868 fputs_unfiltered (wrap_indent
, stream
);
1869 *wrap_pointer
= '\0'; /* Null-terminate saved stuff */
1870 fputs_unfiltered (wrap_buffer
, stream
); /* and eject it */
1871 /* FIXME, this strlen is what prevents wrap_indent from
1872 containing tabs. However, if we recurse to print it
1873 and count its chars, we risk trouble if wrap_indent is
1874 longer than (the user settable) chars_per_line.
1875 Note also that this can set chars_printed > chars_per_line
1876 if we are printing a long string. */
1877 chars_printed
= strlen (wrap_indent
)
1878 + (save_chars
- wrap_column
);
1879 wrap_pointer
= wrap_buffer
; /* Reset buffer */
1880 wrap_buffer
[0] = '\0';
1881 wrap_column
= 0; /* And disable fancy wrap */
1886 if (*lineptr
== '\n')
1889 wrap_here ((char *) 0); /* Spit out chars, cancel further wraps */
1891 fputc_unfiltered ('\n', stream
);
1898 fputs_filtered (const char *linebuffer
, struct ui_file
*stream
)
1900 fputs_maybe_filtered (linebuffer
, stream
, 1);
1904 putchar_unfiltered (int c
)
1907 ui_file_write (gdb_stdout
, &buf
, 1);
1911 /* Write character C to gdb_stdout using GDB's paging mechanism and return C.
1912 May return nonlocally. */
1915 putchar_filtered (int c
)
1917 return fputc_filtered (c
, gdb_stdout
);
1921 fputc_unfiltered (int c
, struct ui_file
*stream
)
1924 ui_file_write (stream
, &buf
, 1);
1929 fputc_filtered (int c
, struct ui_file
*stream
)
1935 fputs_filtered (buf
, stream
);
1939 /* puts_debug is like fputs_unfiltered, except it prints special
1940 characters in printable fashion. */
1943 puts_debug (char *prefix
, char *string
, char *suffix
)
1947 /* Print prefix and suffix after each line. */
1948 static int new_line
= 1;
1949 static int return_p
= 0;
1950 static char *prev_prefix
= "";
1951 static char *prev_suffix
= "";
1953 if (*string
== '\n')
1956 /* If the prefix is changing, print the previous suffix, a new line,
1957 and the new prefix. */
1958 if ((return_p
|| (strcmp (prev_prefix
, prefix
) != 0)) && !new_line
)
1960 fputs_unfiltered (prev_suffix
, gdb_stdlog
);
1961 fputs_unfiltered ("\n", gdb_stdlog
);
1962 fputs_unfiltered (prefix
, gdb_stdlog
);
1965 /* Print prefix if we printed a newline during the previous call. */
1969 fputs_unfiltered (prefix
, gdb_stdlog
);
1972 prev_prefix
= prefix
;
1973 prev_suffix
= suffix
;
1975 /* Output characters in a printable format. */
1976 while ((ch
= *string
++) != '\0')
1982 fputc_unfiltered (ch
, gdb_stdlog
);
1985 fprintf_unfiltered (gdb_stdlog
, "\\x%02x", ch
& 0xff);
1989 fputs_unfiltered ("\\\\", gdb_stdlog
);
1992 fputs_unfiltered ("\\b", gdb_stdlog
);
1995 fputs_unfiltered ("\\f", gdb_stdlog
);
1999 fputs_unfiltered ("\\n", gdb_stdlog
);
2002 fputs_unfiltered ("\\r", gdb_stdlog
);
2005 fputs_unfiltered ("\\t", gdb_stdlog
);
2008 fputs_unfiltered ("\\v", gdb_stdlog
);
2012 return_p
= ch
== '\r';
2015 /* Print suffix if we printed a newline. */
2018 fputs_unfiltered (suffix
, gdb_stdlog
);
2019 fputs_unfiltered ("\n", gdb_stdlog
);
2024 /* Print a variable number of ARGS using format FORMAT. If this
2025 information is going to put the amount written (since the last call
2026 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
2027 call prompt_for_continue to get the users permision to continue.
2029 Unlike fprintf, this function does not return a value.
2031 We implement three variants, vfprintf (takes a vararg list and stream),
2032 fprintf (takes a stream to write on), and printf (the usual).
2034 Note also that a longjmp to top level may occur in this routine
2035 (since prompt_for_continue may do so) so this routine should not be
2036 called when cleanups are not in place. */
2039 vfprintf_maybe_filtered (struct ui_file
*stream
, const char *format
,
2040 va_list args
, int filter
)
2043 struct cleanup
*old_cleanups
;
2045 xvasprintf (&linebuffer
, format
, args
);
2046 old_cleanups
= make_cleanup (xfree
, linebuffer
);
2047 fputs_maybe_filtered (linebuffer
, stream
, filter
);
2048 do_cleanups (old_cleanups
);
2053 vfprintf_filtered (struct ui_file
*stream
, const char *format
, va_list args
)
2055 vfprintf_maybe_filtered (stream
, format
, args
, 1);
2059 vfprintf_unfiltered (struct ui_file
*stream
, const char *format
, va_list args
)
2062 struct cleanup
*old_cleanups
;
2064 xvasprintf (&linebuffer
, format
, args
);
2065 old_cleanups
= make_cleanup (xfree
, linebuffer
);
2066 fputs_unfiltered (linebuffer
, stream
);
2067 do_cleanups (old_cleanups
);
2071 vprintf_filtered (const char *format
, va_list args
)
2073 vfprintf_maybe_filtered (gdb_stdout
, format
, args
, 1);
2077 vprintf_unfiltered (const char *format
, va_list args
)
2079 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2083 fprintf_filtered (struct ui_file
* stream
, const char *format
,...)
2086 va_start (args
, format
);
2087 vfprintf_filtered (stream
, format
, args
);
2092 fprintf_unfiltered (struct ui_file
* stream
, const char *format
,...)
2095 va_start (args
, format
);
2096 vfprintf_unfiltered (stream
, format
, args
);
2100 /* Like fprintf_filtered, but prints its result indented.
2101 Called as fprintfi_filtered (spaces, stream, format, ...); */
2104 fprintfi_filtered (int spaces
, struct ui_file
* stream
, const char *format
,...)
2107 va_start (args
, format
);
2108 print_spaces_filtered (spaces
, stream
);
2110 vfprintf_filtered (stream
, format
, args
);
2116 printf_filtered (const char *format
,...)
2119 va_start (args
, format
);
2120 vfprintf_filtered (gdb_stdout
, format
, args
);
2126 printf_unfiltered (const char *format
,...)
2129 va_start (args
, format
);
2130 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2134 /* Like printf_filtered, but prints it's result indented.
2135 Called as printfi_filtered (spaces, format, ...); */
2138 printfi_filtered (int spaces
, const char *format
,...)
2141 va_start (args
, format
);
2142 print_spaces_filtered (spaces
, gdb_stdout
);
2143 vfprintf_filtered (gdb_stdout
, format
, args
);
2147 /* Easy -- but watch out!
2149 This routine is *not* a replacement for puts()! puts() appends a newline.
2150 This one doesn't, and had better not! */
2153 puts_filtered (const char *string
)
2155 fputs_filtered (string
, gdb_stdout
);
2159 puts_unfiltered (const char *string
)
2161 fputs_unfiltered (string
, gdb_stdout
);
2164 /* Return a pointer to N spaces and a null. The pointer is good
2165 until the next call to here. */
2170 static char *spaces
= 0;
2171 static int max_spaces
= -1;
2177 spaces
= (char *) xmalloc (n
+ 1);
2178 for (t
= spaces
+ n
; t
!= spaces
;)
2184 return spaces
+ max_spaces
- n
;
2187 /* Print N spaces. */
2189 print_spaces_filtered (int n
, struct ui_file
*stream
)
2191 fputs_filtered (n_spaces (n
), stream
);
2194 /* C++ demangler stuff. */
2196 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2197 LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2198 If the name is not mangled, or the language for the name is unknown, or
2199 demangling is off, the name is printed in its "raw" form. */
2202 fprintf_symbol_filtered (struct ui_file
*stream
, char *name
, enum language lang
,
2209 /* If user wants to see raw output, no problem. */
2212 fputs_filtered (name
, stream
);
2218 case language_cplus
:
2219 demangled
= cplus_demangle (name
, arg_mode
);
2222 demangled
= cplus_demangle (name
, arg_mode
| DMGL_JAVA
);
2224 case language_chill
:
2225 demangled
= chill_demangle (name
);
2231 fputs_filtered (demangled
? demangled
: name
, stream
);
2232 if (demangled
!= NULL
)
2240 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
2241 differences in whitespace. Returns 0 if they match, non-zero if they
2242 don't (slightly different than strcmp()'s range of return values).
2244 As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
2245 This "feature" is useful when searching for matching C++ function names
2246 (such as if the user types 'break FOO', where FOO is a mangled C++
2250 strcmp_iw (const char *string1
, const char *string2
)
2252 while ((*string1
!= '\0') && (*string2
!= '\0'))
2254 while (isspace (*string1
))
2258 while (isspace (*string2
))
2262 if (*string1
!= *string2
)
2266 if (*string1
!= '\0')
2272 return (*string1
!= '\0' && *string1
!= '(') || (*string2
!= '\0');
2278 ** Answer whether string_to_compare is a full or partial match to
2279 ** template_string. The partial match must be in sequence starting
2283 subset_compare (char *string_to_compare
, char *template_string
)
2286 if (template_string
!= (char *) NULL
&& string_to_compare
!= (char *) NULL
&&
2287 strlen (string_to_compare
) <= strlen (template_string
))
2288 match
= (strncmp (template_string
,
2290 strlen (string_to_compare
)) == 0);
2297 static void pagination_on_command (char *arg
, int from_tty
);
2299 pagination_on_command (char *arg
, int from_tty
)
2301 pagination_enabled
= 1;
2304 static void pagination_on_command (char *arg
, int from_tty
);
2306 pagination_off_command (char *arg
, int from_tty
)
2308 pagination_enabled
= 0;
2313 initialize_utils (void)
2315 struct cmd_list_element
*c
;
2317 c
= add_set_cmd ("width", class_support
, var_uinteger
,
2318 (char *) &chars_per_line
,
2319 "Set number of characters gdb thinks are in a line.",
2321 add_show_from_set (c
, &showlist
);
2322 c
->function
.sfunc
= set_width_command
;
2325 (add_set_cmd ("height", class_support
,
2326 var_uinteger
, (char *) &lines_per_page
,
2327 "Set number of lines gdb thinks are in a page.", &setlist
),
2332 /* If the output is not a terminal, don't paginate it. */
2333 if (!ui_file_isatty (gdb_stdout
))
2334 lines_per_page
= UINT_MAX
;
2336 set_width_command ((char *) NULL
, 0, c
);
2339 (add_set_cmd ("demangle", class_support
, var_boolean
,
2341 "Set demangling of encoded C++ names when displaying symbols.",
2346 (add_set_cmd ("pagination", class_support
,
2347 var_boolean
, (char *) &pagination_enabled
,
2348 "Set state of pagination.", &setlist
),
2353 add_com ("am", class_support
, pagination_on_command
,
2354 "Enable pagination");
2355 add_com ("sm", class_support
, pagination_off_command
,
2356 "Disable pagination");
2360 (add_set_cmd ("sevenbit-strings", class_support
, var_boolean
,
2361 (char *) &sevenbit_strings
,
2362 "Set printing of 8-bit characters in strings as \\nnn.",
2367 (add_set_cmd ("asm-demangle", class_support
, var_boolean
,
2368 (char *) &asm_demangle
,
2369 "Set demangling of C++ names in disassembly listings.",
2374 /* Machine specific function to handle SIGWINCH signal. */
2376 #ifdef SIGWINCH_HANDLER_BODY
2377 SIGWINCH_HANDLER_BODY
2380 /* Support for converting target fp numbers into host DOUBLEST format. */
2382 /* XXX - This code should really be in libiberty/floatformat.c, however
2383 configuration issues with libiberty made this very difficult to do in the
2386 #include "floatformat.h"
2387 #include <math.h> /* ldexp */
2389 /* The odds that CHAR_BIT will be anything but 8 are low enough that I'm not
2390 going to bother with trying to muck around with whether it is defined in
2391 a system header, what we do if not, etc. */
2392 #define FLOATFORMAT_CHAR_BIT 8
2394 static unsigned long get_field (unsigned char *,
2395 enum floatformat_byteorders
,
2396 unsigned int, unsigned int, unsigned int);
2398 /* Extract a field which starts at START and is LEN bytes long. DATA and
2399 TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */
2400 static unsigned long
2401 get_field (unsigned char *data
, enum floatformat_byteorders order
,
2402 unsigned int total_len
, unsigned int start
, unsigned int len
)
2404 unsigned long result
;
2405 unsigned int cur_byte
;
2408 /* Start at the least significant part of the field. */
2409 if (order
== floatformat_little
|| order
== floatformat_littlebyte_bigword
)
2411 /* We start counting from the other end (i.e, from the high bytes
2412 rather than the low bytes). As such, we need to be concerned
2413 with what happens if bit 0 doesn't start on a byte boundary.
2414 I.e, we need to properly handle the case where total_len is
2415 not evenly divisible by 8. So we compute ``excess'' which
2416 represents the number of bits from the end of our starting
2417 byte needed to get to bit 0. */
2418 int excess
= FLOATFORMAT_CHAR_BIT
- (total_len
% FLOATFORMAT_CHAR_BIT
);
2419 cur_byte
= (total_len
/ FLOATFORMAT_CHAR_BIT
)
2420 - ((start
+ len
+ excess
) / FLOATFORMAT_CHAR_BIT
);
2421 cur_bitshift
= ((start
+ len
+ excess
) % FLOATFORMAT_CHAR_BIT
)
2422 - FLOATFORMAT_CHAR_BIT
;
2426 cur_byte
= (start
+ len
) / FLOATFORMAT_CHAR_BIT
;
2428 ((start
+ len
) % FLOATFORMAT_CHAR_BIT
) - FLOATFORMAT_CHAR_BIT
;
2430 if (cur_bitshift
> -FLOATFORMAT_CHAR_BIT
)
2431 result
= *(data
+ cur_byte
) >> (-cur_bitshift
);
2434 cur_bitshift
+= FLOATFORMAT_CHAR_BIT
;
2435 if (order
== floatformat_little
|| order
== floatformat_littlebyte_bigword
)
2440 /* Move towards the most significant part of the field. */
2441 while (cur_bitshift
< len
)
2443 result
|= (unsigned long)*(data
+ cur_byte
) << cur_bitshift
;
2444 cur_bitshift
+= FLOATFORMAT_CHAR_BIT
;
2445 if (order
== floatformat_little
|| order
== floatformat_littlebyte_bigword
)
2450 if (len
< sizeof(result
) * FLOATFORMAT_CHAR_BIT
)
2451 /* Mask out bits which are not part of the field */
2452 result
&= ((1UL << len
) - 1);
2456 /* Convert from FMT to a DOUBLEST.
2457 FROM is the address of the extended float.
2458 Store the DOUBLEST in *TO. */
2461 floatformat_to_doublest (const struct floatformat
*fmt
, char *from
,
2464 unsigned char *ufrom
= (unsigned char *) from
;
2468 unsigned int mant_bits
, mant_off
;
2470 int special_exponent
; /* It's a NaN, denorm or zero */
2472 /* If the mantissa bits are not contiguous from one end of the
2473 mantissa to the other, we need to make a private copy of the
2474 source bytes that is in the right order since the unpacking
2475 algorithm assumes that the bits are contiguous.
2477 Swap the bytes individually rather than accessing them through
2478 "long *" since we have no guarantee that they start on a long
2479 alignment, and also sizeof(long) for the host could be different
2480 than sizeof(long) for the target. FIXME: Assumes sizeof(long)
2481 for the target is 4. */
2483 if (fmt
->byteorder
== floatformat_littlebyte_bigword
)
2485 static unsigned char *newfrom
;
2486 unsigned char *swapin
, *swapout
;
2489 longswaps
= fmt
->totalsize
/ FLOATFORMAT_CHAR_BIT
;
2492 if (newfrom
== NULL
)
2494 newfrom
= (unsigned char *) xmalloc (fmt
->totalsize
);
2499 while (longswaps
-- > 0)
2501 /* This is ugly, but efficient */
2502 *swapout
++ = swapin
[4];
2503 *swapout
++ = swapin
[5];
2504 *swapout
++ = swapin
[6];
2505 *swapout
++ = swapin
[7];
2506 *swapout
++ = swapin
[0];
2507 *swapout
++ = swapin
[1];
2508 *swapout
++ = swapin
[2];
2509 *swapout
++ = swapin
[3];
2514 exponent
= get_field (ufrom
, fmt
->byteorder
, fmt
->totalsize
,
2515 fmt
->exp_start
, fmt
->exp_len
);
2516 /* Note that if exponent indicates a NaN, we can't really do anything useful
2517 (not knowing if the host has NaN's, or how to build one). So it will
2518 end up as an infinity or something close; that is OK. */
2520 mant_bits_left
= fmt
->man_len
;
2521 mant_off
= fmt
->man_start
;
2524 special_exponent
= exponent
== 0 || exponent
== fmt
->exp_nan
;
2526 /* Don't bias NaNs. Use minimum exponent for denorms. For simplicity,
2527 we don't check for zero as the exponent doesn't matter. */
2528 if (!special_exponent
)
2529 exponent
-= fmt
->exp_bias
;
2530 else if (exponent
== 0)
2531 exponent
= 1 - fmt
->exp_bias
;
2533 /* Build the result algebraically. Might go infinite, underflow, etc;
2536 /* If this format uses a hidden bit, explicitly add it in now. Otherwise,
2537 increment the exponent by one to account for the integer bit. */
2539 if (!special_exponent
)
2541 if (fmt
->intbit
== floatformat_intbit_no
)
2542 dto
= ldexp (1.0, exponent
);
2547 while (mant_bits_left
> 0)
2549 mant_bits
= min (mant_bits_left
, 32);
2551 mant
= get_field (ufrom
, fmt
->byteorder
, fmt
->totalsize
,
2552 mant_off
, mant_bits
);
2554 dto
+= ldexp ((double) mant
, exponent
- mant_bits
);
2555 exponent
-= mant_bits
;
2556 mant_off
+= mant_bits
;
2557 mant_bits_left
-= mant_bits
;
2560 /* Negate it if negative. */
2561 if (get_field (ufrom
, fmt
->byteorder
, fmt
->totalsize
, fmt
->sign_start
, 1))
2566 static void put_field (unsigned char *, enum floatformat_byteorders
,
2568 unsigned int, unsigned int, unsigned long);
2570 /* Set a field which starts at START and is LEN bytes long. DATA and
2571 TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */
2573 put_field (unsigned char *data
, enum floatformat_byteorders order
,
2574 unsigned int total_len
, unsigned int start
, unsigned int len
,
2575 unsigned long stuff_to_put
)
2577 unsigned int cur_byte
;
2580 /* Start at the least significant part of the field. */
2581 if (order
== floatformat_little
|| order
== floatformat_littlebyte_bigword
)
2583 int excess
= FLOATFORMAT_CHAR_BIT
- (total_len
% FLOATFORMAT_CHAR_BIT
);
2584 cur_byte
= (total_len
/ FLOATFORMAT_CHAR_BIT
)
2585 - ((start
+ len
+ excess
) / FLOATFORMAT_CHAR_BIT
);
2586 cur_bitshift
= ((start
+ len
+ excess
) % FLOATFORMAT_CHAR_BIT
)
2587 - FLOATFORMAT_CHAR_BIT
;
2591 cur_byte
= (start
+ len
) / FLOATFORMAT_CHAR_BIT
;
2593 ((start
+ len
) % FLOATFORMAT_CHAR_BIT
) - FLOATFORMAT_CHAR_BIT
;
2595 if (cur_bitshift
> -FLOATFORMAT_CHAR_BIT
)
2597 *(data
+ cur_byte
) &=
2598 ~(((1 << ((start
+ len
) % FLOATFORMAT_CHAR_BIT
)) - 1)
2599 << (-cur_bitshift
));
2600 *(data
+ cur_byte
) |=
2601 (stuff_to_put
& ((1 << FLOATFORMAT_CHAR_BIT
) - 1)) << (-cur_bitshift
);
2603 cur_bitshift
+= FLOATFORMAT_CHAR_BIT
;
2604 if (order
== floatformat_little
|| order
== floatformat_littlebyte_bigword
)
2609 /* Move towards the most significant part of the field. */
2610 while (cur_bitshift
< len
)
2612 if (len
- cur_bitshift
< FLOATFORMAT_CHAR_BIT
)
2614 /* This is the last byte. */
2615 *(data
+ cur_byte
) &=
2616 ~((1 << (len
- cur_bitshift
)) - 1);
2617 *(data
+ cur_byte
) |= (stuff_to_put
>> cur_bitshift
);
2620 *(data
+ cur_byte
) = ((stuff_to_put
>> cur_bitshift
)
2621 & ((1 << FLOATFORMAT_CHAR_BIT
) - 1));
2622 cur_bitshift
+= FLOATFORMAT_CHAR_BIT
;
2623 if (order
== floatformat_little
|| order
== floatformat_littlebyte_bigword
)
2630 #ifdef HAVE_LONG_DOUBLE
2631 /* Return the fractional part of VALUE, and put the exponent of VALUE in *EPTR.
2632 The range of the returned value is >= 0.5 and < 1.0. This is equivalent to
2633 frexp, but operates on the long double data type. */
2635 static long double ldfrexp (long double value
, int *eptr
);
2638 ldfrexp (long double value
, int *eptr
)
2643 /* Unfortunately, there are no portable functions for extracting the exponent
2644 of a long double, so we have to do it iteratively by multiplying or dividing
2645 by two until the fraction is between 0.5 and 1.0. */
2653 if (value
>= tmp
) /* Value >= 1.0 */
2654 while (value
>= tmp
)
2659 else if (value
!= 0.0l) /* Value < 1.0 and > 0.0 */
2673 #endif /* HAVE_LONG_DOUBLE */
2676 /* The converse: convert the DOUBLEST *FROM to an extended float
2677 and store where TO points. Neither FROM nor TO have any alignment
2681 floatformat_from_doublest (CONST
struct floatformat
*fmt
, DOUBLEST
*from
,
2687 unsigned int mant_bits
, mant_off
;
2689 unsigned char *uto
= (unsigned char *) to
;
2691 memcpy (&dfrom
, from
, sizeof (dfrom
));
2692 memset (uto
, 0, (fmt
->totalsize
+ FLOATFORMAT_CHAR_BIT
- 1)
2693 / FLOATFORMAT_CHAR_BIT
);
2695 return; /* Result is zero */
2696 if (dfrom
!= dfrom
) /* Result is NaN */
2699 put_field (uto
, fmt
->byteorder
, fmt
->totalsize
, fmt
->exp_start
,
2700 fmt
->exp_len
, fmt
->exp_nan
);
2701 /* Be sure it's not infinity, but NaN value is irrel */
2702 put_field (uto
, fmt
->byteorder
, fmt
->totalsize
, fmt
->man_start
,
2707 /* If negative, set the sign bit. */
2710 put_field (uto
, fmt
->byteorder
, fmt
->totalsize
, fmt
->sign_start
, 1, 1);
2714 if (dfrom
+ dfrom
== dfrom
&& dfrom
!= 0.0) /* Result is Infinity */
2716 /* Infinity exponent is same as NaN's. */
2717 put_field (uto
, fmt
->byteorder
, fmt
->totalsize
, fmt
->exp_start
,
2718 fmt
->exp_len
, fmt
->exp_nan
);
2719 /* Infinity mantissa is all zeroes. */
2720 put_field (uto
, fmt
->byteorder
, fmt
->totalsize
, fmt
->man_start
,
2725 #ifdef HAVE_LONG_DOUBLE
2726 mant
= ldfrexp (dfrom
, &exponent
);
2728 mant
= frexp (dfrom
, &exponent
);
2731 put_field (uto
, fmt
->byteorder
, fmt
->totalsize
, fmt
->exp_start
, fmt
->exp_len
,
2732 exponent
+ fmt
->exp_bias
- 1);
2734 mant_bits_left
= fmt
->man_len
;
2735 mant_off
= fmt
->man_start
;
2736 while (mant_bits_left
> 0)
2738 unsigned long mant_long
;
2739 mant_bits
= mant_bits_left
< 32 ? mant_bits_left
: 32;
2741 mant
*= 4294967296.0;
2742 mant_long
= ((unsigned long) mant
) & 0xffffffffL
;
2745 /* If the integer bit is implicit, then we need to discard it.
2746 If we are discarding a zero, we should be (but are not) creating
2747 a denormalized number which means adjusting the exponent
2749 if (mant_bits_left
== fmt
->man_len
2750 && fmt
->intbit
== floatformat_intbit_no
)
2753 mant_long
&= 0xffffffffL
;
2759 /* The bits we want are in the most significant MANT_BITS bits of
2760 mant_long. Move them to the least significant. */
2761 mant_long
>>= 32 - mant_bits
;
2764 put_field (uto
, fmt
->byteorder
, fmt
->totalsize
,
2765 mant_off
, mant_bits
, mant_long
);
2766 mant_off
+= mant_bits
;
2767 mant_bits_left
-= mant_bits
;
2769 if (fmt
->byteorder
== floatformat_littlebyte_bigword
)
2772 unsigned char *swaplow
= uto
;
2773 unsigned char *swaphigh
= uto
+ 4;
2776 for (count
= 0; count
< 4; count
++)
2779 *swaplow
++ = *swaphigh
;
2785 /* Check if VAL (which is assumed to be a floating point number whose
2786 format is described by FMT) is negative. */
2789 floatformat_is_negative (const struct floatformat
*fmt
, char *val
)
2791 unsigned char *uval
= (unsigned char *) val
;
2793 return get_field (uval
, fmt
->byteorder
, fmt
->totalsize
, fmt
->sign_start
, 1);
2796 /* Check if VAL is "not a number" (NaN) for FMT. */
2799 floatformat_is_nan (const struct floatformat
*fmt
, char *val
)
2801 unsigned char *uval
= (unsigned char *) val
;
2804 unsigned int mant_bits
, mant_off
;
2810 exponent
= get_field (uval
, fmt
->byteorder
, fmt
->totalsize
,
2811 fmt
->exp_start
, fmt
->exp_len
);
2813 if (exponent
!= fmt
->exp_nan
)
2816 mant_bits_left
= fmt
->man_len
;
2817 mant_off
= fmt
->man_start
;
2819 while (mant_bits_left
> 0)
2821 mant_bits
= min (mant_bits_left
, 32);
2823 mant
= get_field (uval
, fmt
->byteorder
, fmt
->totalsize
,
2824 mant_off
, mant_bits
);
2826 /* If there is an explicit integer bit, mask it off. */
2827 if (mant_off
== fmt
->man_start
2828 && fmt
->intbit
== floatformat_intbit_yes
)
2829 mant
&= ~(1 << (mant_bits
- 1));
2834 mant_off
+= mant_bits
;
2835 mant_bits_left
-= mant_bits
;
2841 /* Convert the mantissa of VAL (which is assumed to be a floating
2842 point number whose format is described by FMT) into a hexadecimal
2843 and store it in a static string. Return a pointer to that string. */
2846 floatformat_mantissa (const struct floatformat
*fmt
, char *val
)
2848 unsigned char *uval
= (unsigned char *) val
;
2850 unsigned int mant_bits
, mant_off
;
2852 static char res
[50];
2855 /* Make sure we have enough room to store the mantissa. */
2856 gdb_assert (sizeof res
> ((fmt
->man_len
+ 7) / 8) * 2);
2858 mant_off
= fmt
->man_start
;
2859 mant_bits_left
= fmt
->man_len
;
2860 mant_bits
= (mant_bits_left
% 32) > 0 ? mant_bits_left
% 32 : 32;
2862 mant
= get_field (uval
, fmt
->byteorder
, fmt
->totalsize
,
2863 mant_off
, mant_bits
);
2865 sprintf (res
, "%lx", mant
);
2867 mant_off
+= mant_bits
;
2868 mant_bits_left
-= mant_bits
;
2870 while (mant_bits_left
> 0)
2872 mant
= get_field (uval
, fmt
->byteorder
, fmt
->totalsize
,
2875 sprintf (buf
, "%08lx", mant
);
2879 mant_bits_left
-= 32;
2885 /* print routines to handle variable size regs, etc. */
2887 /* temporary storage using circular buffer */
2893 static char buf
[NUMCELLS
][CELLSIZE
];
2894 static int cell
= 0;
2895 if (++cell
>= NUMCELLS
)
2903 return (TARGET_ADDR_BIT
/ 8 * 2);
2907 paddr (CORE_ADDR addr
)
2909 return phex (addr
, TARGET_ADDR_BIT
/ 8);
2913 paddr_nz (CORE_ADDR addr
)
2915 return phex_nz (addr
, TARGET_ADDR_BIT
/ 8);
2919 decimal2str (char *paddr_str
, char *sign
, ULONGEST addr
)
2921 /* steal code from valprint.c:print_decimal(). Should this worry
2922 about the real size of addr as the above does? */
2923 unsigned long temp
[3];
2927 temp
[i
] = addr
% (1000 * 1000 * 1000);
2928 addr
/= (1000 * 1000 * 1000);
2931 while (addr
!= 0 && i
< (sizeof (temp
) / sizeof (temp
[0])));
2935 sprintf (paddr_str
, "%s%lu",
2939 sprintf (paddr_str
, "%s%lu%09lu",
2940 sign
, temp
[1], temp
[0]);
2943 sprintf (paddr_str
, "%s%lu%09lu%09lu",
2944 sign
, temp
[2], temp
[1], temp
[0]);
2947 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
2952 paddr_u (CORE_ADDR addr
)
2954 char *paddr_str
= get_cell ();
2955 decimal2str (paddr_str
, "", addr
);
2960 paddr_d (LONGEST addr
)
2962 char *paddr_str
= get_cell ();
2964 decimal2str (paddr_str
, "-", -addr
);
2966 decimal2str (paddr_str
, "", addr
);
2970 /* eliminate warning from compiler on 32-bit systems */
2971 static int thirty_two
= 32;
2974 phex (ULONGEST l
, int sizeof_l
)
2976 char *str
= get_cell ();
2980 sprintf (str
, "%08lx%08lx",
2981 (unsigned long) (l
>> thirty_two
),
2982 (unsigned long) (l
& 0xffffffff));
2985 sprintf (str
, "%08lx", (unsigned long) l
);
2988 sprintf (str
, "%04x", (unsigned short) (l
& 0xffff));
2991 phex (l
, sizeof (l
));
2998 phex_nz (ULONGEST l
, int sizeof_l
)
3000 char *str
= get_cell ();
3005 unsigned long high
= (unsigned long) (l
>> thirty_two
);
3007 sprintf (str
, "%lx", (unsigned long) (l
& 0xffffffff));
3009 sprintf (str
, "%lx%08lx",
3010 high
, (unsigned long) (l
& 0xffffffff));
3014 sprintf (str
, "%lx", (unsigned long) l
);
3017 sprintf (str
, "%x", (unsigned short) (l
& 0xffff));
3020 phex_nz (l
, sizeof (l
));
3027 /* Convert to / from the hosts pointer to GDB's internal CORE_ADDR
3028 using the target's conversion routines. */
3030 host_pointer_to_address (void *ptr
)
3032 if (sizeof (ptr
) != TYPE_LENGTH (builtin_type_ptr
))
3033 internal_error (__FILE__
, __LINE__
,
3034 "core_addr_to_void_ptr: bad cast");
3035 return POINTER_TO_ADDRESS (builtin_type_ptr
, &ptr
);
3039 address_to_host_pointer (CORE_ADDR addr
)
3042 if (sizeof (ptr
) != TYPE_LENGTH (builtin_type_ptr
))
3043 internal_error (__FILE__
, __LINE__
,
3044 "core_addr_to_void_ptr: bad cast");
3045 ADDRESS_TO_POINTER (builtin_type_ptr
, &ptr
, addr
);