X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Futils.c;h=e3e88dffae99a1647cbb9f56484808d583c15895;hb=fba45db2faf619e71856ee38ec63949c0ef6903e;hp=2c8d402849363807a7fe5ce882906533ff19e4f8;hpb=abd8680d6efd97e7ba848a6392ee3ad72be18cd0;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/utils.c b/gdb/utils.c index 2c8d402849..e3e88dffae 100644 --- a/gdb/utils.c +++ b/gdb/utils.c @@ -31,6 +31,10 @@ #include #endif +#ifdef __GO32__ +#include +#endif + /* SunOS's curses.h has a '#define reg register' in it. Thank you Sun. */ #ifdef reg #undef reg @@ -46,6 +50,8 @@ #include "language.h" #include "annotate.h" +#include "inferior.h" /* for signed_pointer_to_address */ + #include #undef XMALLOC @@ -54,7 +60,7 @@ /* readline defines this. */ #undef savestring -void (*error_begin_hook) PARAMS ((void)); +void (*error_begin_hook) (void); /* Holds the last error message issued by gdb */ @@ -68,17 +74,14 @@ static void vfprintf_maybe_filtered (struct ui_file *, const char *, static void fputs_maybe_filtered (const char *, struct ui_file *, int); #if defined (USE_MMALLOC) && !defined (NO_MMCHECK) -static void malloc_botch PARAMS ((void)); +static void malloc_botch (void); #endif -static void -prompt_for_continue PARAMS ((void)); +static void prompt_for_continue (void); -static void -set_width_command PARAMS ((char *, int, struct cmd_list_element *)); +static void set_width_command (char *, int, struct cmd_list_element *); -static void -set_width PARAMS ((void)); +static void set_width (void); /* Chain of cleanup actions established with make_cleanup, to be executed if an error happens. */ @@ -156,59 +159,72 @@ int pagination_enabled = 1; Args are FUNCTION to clean up with, and ARG to pass to it. */ struct cleanup * -make_cleanup (function, arg) - void (*function) PARAMS ((PTR)); - PTR arg; +make_cleanup (make_cleanup_ftype *function, void *arg) { return make_my_cleanup (&cleanup_chain, function, arg); } struct cleanup * -make_final_cleanup (function, arg) - void (*function) PARAMS ((PTR)); - PTR arg; +make_final_cleanup (make_cleanup_ftype *function, void *arg) { return make_my_cleanup (&final_cleanup_chain, function, arg); } struct cleanup * -make_run_cleanup (function, arg) - void (*function) PARAMS ((PTR)); - PTR arg; +make_run_cleanup (make_cleanup_ftype *function, void *arg) { return make_my_cleanup (&run_cleanup_chain, function, arg); } struct cleanup * -make_exec_cleanup (function, arg) - void (*function) PARAMS ((PTR)); - PTR arg; +make_exec_cleanup (make_cleanup_ftype *function, void *arg) { return make_my_cleanup (&exec_cleanup_chain, function, arg); } struct cleanup * -make_exec_error_cleanup (function, arg) - void (*function) PARAMS ((PTR)); - PTR arg; +make_exec_error_cleanup (make_cleanup_ftype *function, void *arg) { return make_my_cleanup (&exec_error_cleanup_chain, function, arg); } static void -do_freeargv (arg) - void *arg; +do_freeargv (void *arg) { freeargv ((char **) arg); } struct cleanup * -make_cleanup_freeargv (arg) - char **arg; +make_cleanup_freeargv (char **arg) { return make_my_cleanup (&cleanup_chain, do_freeargv, arg); } +static void +do_bfd_close_cleanup (void *arg) +{ + bfd_close (arg); +} + +struct cleanup * +make_cleanup_bfd_close (bfd *abfd) +{ + return make_cleanup (do_bfd_close_cleanup, abfd); +} + +static void +do_close_cleanup (void *arg) +{ + close ((int) arg); +} + +struct cleanup * +make_cleanup_close (int fd) +{ + /* int into void*. Outch!! */ + return make_cleanup (do_close_cleanup, (void *) fd); +} + static void do_ui_file_delete (void *arg) { @@ -222,10 +238,8 @@ make_cleanup_ui_file_delete (struct ui_file *arg) } struct cleanup * -make_my_cleanup (pmy_chain, function, arg) - struct cleanup **pmy_chain; - void (*function) PARAMS ((PTR)); - PTR arg; +make_my_cleanup (struct cleanup **pmy_chain, make_cleanup_ftype *function, + void *arg) { register struct cleanup *new = (struct cleanup *) xmalloc (sizeof (struct cleanup)); @@ -243,44 +257,38 @@ make_my_cleanup (pmy_chain, function, arg) until we get back to the point OLD_CHAIN in the cleanup_chain. */ void -do_cleanups (old_chain) - register struct cleanup *old_chain; +do_cleanups (register struct cleanup *old_chain) { do_my_cleanups (&cleanup_chain, old_chain); } void -do_final_cleanups (old_chain) - register struct cleanup *old_chain; +do_final_cleanups (register struct cleanup *old_chain) { do_my_cleanups (&final_cleanup_chain, old_chain); } void -do_run_cleanups (old_chain) - register struct cleanup *old_chain; +do_run_cleanups (register struct cleanup *old_chain) { do_my_cleanups (&run_cleanup_chain, old_chain); } void -do_exec_cleanups (old_chain) - register struct cleanup *old_chain; +do_exec_cleanups (register struct cleanup *old_chain) { do_my_cleanups (&exec_cleanup_chain, old_chain); } void -do_exec_error_cleanups (old_chain) - register struct cleanup *old_chain; +do_exec_error_cleanups (register struct cleanup *old_chain) { do_my_cleanups (&exec_error_cleanup_chain, old_chain); } void -do_my_cleanups (pmy_chain, old_chain) - register struct cleanup **pmy_chain; - register struct cleanup *old_chain; +do_my_cleanups (register struct cleanup **pmy_chain, + register struct cleanup *old_chain) { register struct cleanup *ptr; while ((ptr = *pmy_chain) != old_chain) @@ -295,55 +303,50 @@ do_my_cleanups (pmy_chain, old_chain) until we get back to the point OLD_CHAIN in the cleanup_chain. */ void -discard_cleanups (old_chain) - register struct cleanup *old_chain; +discard_cleanups (register struct cleanup *old_chain) { discard_my_cleanups (&cleanup_chain, old_chain); } void -discard_final_cleanups (old_chain) - register struct cleanup *old_chain; +discard_final_cleanups (register struct cleanup *old_chain) { discard_my_cleanups (&final_cleanup_chain, old_chain); } void -discard_exec_error_cleanups (old_chain) - register struct cleanup *old_chain; +discard_exec_error_cleanups (register struct cleanup *old_chain) { discard_my_cleanups (&exec_error_cleanup_chain, old_chain); } void -discard_my_cleanups (pmy_chain, old_chain) - register struct cleanup **pmy_chain; - register struct cleanup *old_chain; +discard_my_cleanups (register struct cleanup **pmy_chain, + register struct cleanup *old_chain) { register struct cleanup *ptr; while ((ptr = *pmy_chain) != old_chain) { *pmy_chain = ptr->next; - free ((PTR) ptr); + free (ptr); } } /* Set the cleanup_chain to 0, and return the old cleanup chain. */ struct cleanup * -save_cleanups () +save_cleanups (void) { return save_my_cleanups (&cleanup_chain); } struct cleanup * -save_final_cleanups () +save_final_cleanups (void) { return save_my_cleanups (&final_cleanup_chain); } struct cleanup * -save_my_cleanups (pmy_chain) - struct cleanup **pmy_chain; +save_my_cleanups (struct cleanup **pmy_chain) { struct cleanup *old_chain = *pmy_chain; @@ -353,23 +356,19 @@ save_my_cleanups (pmy_chain) /* Restore the cleanup chain from a previously saved chain. */ void -restore_cleanups (chain) - struct cleanup *chain; +restore_cleanups (struct cleanup *chain) { restore_my_cleanups (&cleanup_chain, chain); } void -restore_final_cleanups (chain) - struct cleanup *chain; +restore_final_cleanups (struct cleanup *chain) { restore_my_cleanups (&final_cleanup_chain, chain); } void -restore_my_cleanups (pmy_chain, chain) - struct cleanup **pmy_chain; - struct cleanup *chain; +restore_my_cleanups (struct cleanup **pmy_chain, struct cleanup *chain) { *pmy_chain = chain; } @@ -383,10 +382,16 @@ restore_my_cleanups (pmy_chain, chain) to arrange to free the object thus allocated. */ void -free_current_contents (location) - char **location; +free_current_contents (void *ptr) { - free (*location); + void **location = ptr; + if (location == NULL) + internal_error ("free_current_contents: NULL pointer"); + if (*location != NULL) + { + free (*location); + *location = NULL; + } } /* Provide a known function that does nothing, to use as a base for @@ -398,8 +403,7 @@ free_current_contents (location) /* ARGSUSED */ void -null_cleanup (arg) - PTR arg; +null_cleanup (void *arg) { } @@ -407,7 +411,7 @@ null_cleanup (arg) cmd_continuation. The new continuation will be added at the front.*/ void add_continuation (continuation_hook, arg_list) - void (*continuation_hook) PARAMS ((struct continuation_arg *)); + void (*continuation_hook) (struct continuation_arg *); struct continuation_arg *arg_list; { struct continuation *continuation_ptr; @@ -428,7 +432,7 @@ add_continuation (continuation_hook, arg_list) and do the continuations from there on, instead of using the global beginning of list as our iteration pointer.*/ void -do_all_continuations () +do_all_continuations (void) { struct continuation *continuation_ptr; struct continuation *saved_continuation; @@ -453,7 +457,7 @@ do_all_continuations () /* Walk down the cmd_continuation list, and get rid of all the continuations. */ void -discard_all_continuations () +discard_all_continuations (void) { struct continuation *continuation_ptr; @@ -465,11 +469,11 @@ discard_all_continuations () } } -/* Add a continuation to the continuation list, the gloabl list +/* Add a continuation to the continuation list, the global list intermediate_continuation. The new continuation will be added at the front.*/ void add_intermediate_continuation (continuation_hook, arg_list) - void (*continuation_hook) PARAMS ((struct continuation_arg *)); + void (*continuation_hook) (struct continuation_arg *); struct continuation_arg *arg_list; { struct continuation *continuation_ptr; @@ -490,7 +494,7 @@ add_intermediate_continuation (continuation_hook, arg_list) and do the continuations from there on, instead of using the global beginning of list as our iteration pointer.*/ void -do_all_intermediate_continuations () +do_all_intermediate_continuations (void) { struct continuation *continuation_ptr; struct continuation *saved_continuation; @@ -515,7 +519,7 @@ do_all_intermediate_continuations () /* Walk down the cmd_continuation list, and get rid of all the continuations. */ void -discard_all_intermediate_continuations () +discard_all_intermediate_continuations (void) { struct continuation *continuation_ptr; @@ -539,7 +543,7 @@ discard_all_intermediate_continuations () Is this anything other than a historical accident? */ void -warning_begin () +warning_begin (void) { target_terminal_ours (); wrap_here (""); /* Force out any buffered output */ @@ -578,7 +582,7 @@ warning (const char *string,...) that the error message can be formatted with a single printf call, but this is more general. */ void -error_begin () +error_begin (void) { if (error_begin_hook) error_begin_hook (); @@ -688,6 +692,7 @@ internal_verror (const char *fmt, va_list ap) } /* Try to get the message out */ + target_terminal_ours (); fputs_unfiltered ("gdb-internal-error: ", gdb_stderr); vfprintf_unfiltered (gdb_stderr, fmt, ap); fputs_unfiltered ("\n", gdb_stderr); @@ -728,6 +733,7 @@ internal_error (char *string, ...) { va_list ap; va_start (ap, string); + internal_verror (string, ap); va_end (ap); } @@ -737,8 +743,7 @@ internal_error (char *string, ...) printable string. */ char * -safe_strerror (errnum) - int errnum; +safe_strerror (int errnum) { char *msg; static char buf[32]; @@ -751,33 +756,12 @@ safe_strerror (errnum) return (msg); } -/* The strsignal() function can return NULL for signal values that are - out of range. Provide a "safe" version that always returns a - printable string. */ - -char * -safe_strsignal (signo) - int signo; -{ - char *msg; - static char buf[32]; - - if ((msg = strsignal (signo)) == NULL) - { - sprintf (buf, "(undocumented signal %d)", signo); - msg = buf; - } - return (msg); -} - - /* Print the system error message for errno, and also mention STRING as the file name for which the error was encountered. Then return to command level. */ NORETURN void -perror_with_name (string) - char *string; +perror_with_name (char *string) { char *err; char *combined; @@ -801,9 +785,7 @@ perror_with_name (string) as the file name for which the error was encountered. */ void -print_sys_errmsg (string, errcode) - char *string; - int errcode; +print_sys_errmsg (char *string, int errcode) { char *err; char *combined; @@ -823,7 +805,7 @@ print_sys_errmsg (string, errcode) /* Control C eventually causes this to be called, at a convenient time. */ void -quit () +quit (void) { serial_t gdb_stdout_serial = serial_fdopen (1); @@ -878,7 +860,7 @@ quit () */ void -notice_quit () +notice_quit (void) { int k = win32pollquit (); if (k == 1) @@ -890,7 +872,7 @@ notice_quit () #else /* !defined(_MSC_VER) */ void -notice_quit () +notice_quit (void) { /* Done by signals */ } @@ -899,8 +881,7 @@ notice_quit () /* Control C comes here */ void -request_quit (signo) - int signo; +request_quit (int signo) { quit_flag = 1; /* Restore the signal handler. Harmless with BSD-style signals, needed @@ -928,25 +909,20 @@ request_quit (signo) #if !defined (USE_MMALLOC) -void * -mcalloc (void *md, size_t number, size_t size) +PTR +mcalloc (PTR md, size_t number, size_t size) { return calloc (number, size); } PTR -mmalloc (md, size) - PTR md; - size_t size; +mmalloc (PTR md, size_t size) { return malloc (size); } PTR -mrealloc (md, ptr, size) - PTR md; - PTR ptr; - size_t size; +mrealloc (PTR md, PTR ptr, size_t size) { if (ptr == 0) /* Guard against old realloc's */ return malloc (size); @@ -955,9 +931,7 @@ mrealloc (md, ptr, size) } void -mfree (md, ptr) - PTR md; - PTR ptr; +mfree (PTR md, PTR ptr) { free (ptr); } @@ -967,15 +941,14 @@ mfree (md, ptr) #if !defined (USE_MMALLOC) || defined (NO_MMCHECK) void -init_malloc (md) - PTR md; +init_malloc (void *md) { } #else /* Have mmalloc and want corruption checking */ static void -malloc_botch () +malloc_botch (void) { fprintf_unfiltered (gdb_stderr, "Memory corruption\n"); abort (); @@ -1000,8 +973,7 @@ malloc_botch () #endif void -init_malloc (md) - PTR md; +init_malloc (void *md) { if (!mmcheckf (md, malloc_botch, MMCHECK_FORCE)) { @@ -1024,8 +996,7 @@ init_malloc (md) memory requested in SIZE. */ NORETURN void -nomem (size) - long size; +nomem (long size) { if (size > 0) { @@ -1043,9 +1014,7 @@ nomem (size) byte of zero'd storage, is a religious issue. */ PTR -xmmalloc (md, size) - PTR md; - long size; +xmmalloc (PTR md, long size) { register PTR val; @@ -1063,10 +1032,7 @@ xmmalloc (md, size) /* Like mrealloc but get error if no storage available. */ PTR -xmrealloc (md, ptr, size) - PTR md; - PTR ptr; - long size; +xmrealloc (PTR md, PTR ptr, long size) { register PTR val; @@ -1089,8 +1055,7 @@ xmrealloc (md, ptr, size) the caller wanting to allocate zero bytes. */ PTR -xmalloc (size) - size_t size; +xmalloc (size_t size) { return (xmmalloc ((PTR) NULL, size)); } @@ -1109,9 +1074,7 @@ xcalloc (size_t number, size_t size) /* Like mrealloc but get error if no storage available. */ PTR -xrealloc (ptr, size) - PTR ptr; - size_t size; +xrealloc (PTR ptr, size_t size) { return (xmrealloc ((PTR) NULL, ptr, size)); } @@ -1121,10 +1084,7 @@ xrealloc (ptr, size) Used like `read' but keeps going if `read' returns too soon. */ int -myread (desc, addr, len) - int desc; - char *addr; - int len; +myread (int desc, char *addr, int len) { register int val; int orglen = len; @@ -1147,9 +1107,7 @@ myread (desc, addr, len) Uses malloc to get the space. Returns the address of the copy. */ char * -savestring (ptr, size) - const char *ptr; - int size; +savestring (const char *ptr, int size) { register char *p = (char *) xmalloc (size + 1); memcpy (p, ptr, size); @@ -1158,10 +1116,7 @@ savestring (ptr, size) } char * -msavestring (md, ptr, size) - PTR md; - const char *ptr; - int size; +msavestring (void *md, const char *ptr, int size) { register char *p = (char *) xmmalloc (md, size + 1); memcpy (p, ptr, size); @@ -1173,24 +1128,19 @@ msavestring (md, ptr, size) in . FIXME: This should be named "xstrsave", shouldn't it? Doesn't real strsave return NULL if out of memory? */ char * -strsave (ptr) - const char *ptr; +strsave (const char *ptr) { return savestring (ptr, strlen (ptr)); } char * -mstrsave (md, ptr) - PTR md; - const char *ptr; +mstrsave (void *md, const char *ptr) { return (msavestring (md, ptr, strlen (ptr))); } void -print_spaces (n, file) - register int n; - register struct ui_file *file; +print_spaces (register int n, register struct ui_file *file) { fputs_unfiltered (n_spaces (n), file); } @@ -1331,8 +1281,7 @@ query (char *ctlstr,...) after the zeros. A value of 0 does not mean end of string. */ int -parse_escape (string_ptr) - char **string_ptr; +parse_escape (char **string_ptr) { register int c = *(*string_ptr)++; switch (c) @@ -1407,8 +1356,8 @@ static void printchar (int c, void (*do_fputs) (const char *, struct ui_file*), static void printchar (c, do_fputs, do_fprintf, stream, quoter) int c; - void (*do_fputs) PARAMS ((const char *, struct ui_file*)); - void (*do_fprintf) PARAMS ((struct ui_file*, const char *, ...)); + void (*do_fputs) (const char *, struct ui_file *); + void (*do_fprintf) (struct ui_file *, const char *, ...); struct ui_file *stream; int quoter; { @@ -1461,31 +1410,21 @@ printchar (c, do_fputs, do_fprintf, stream, quoter) the language of the program being debugged. */ void -fputstr_filtered (str, quoter, stream) - const char *str; - int quoter; - struct ui_file *stream; +fputstr_filtered (const char *str, int quoter, struct ui_file *stream) { while (*str) printchar (*str++, fputs_filtered, fprintf_filtered, stream, quoter); } void -fputstr_unfiltered (str, quoter, stream) - const char *str; - int quoter; - struct ui_file *stream; +fputstr_unfiltered (const char *str, int quoter, struct ui_file *stream) { while (*str) printchar (*str++, fputs_unfiltered, fprintf_unfiltered, stream, quoter); } void -fputstrn_unfiltered (str, n, quoter, stream) - const char *str; - int n; - int quoter; - struct ui_file *stream; +fputstrn_unfiltered (const char *str, int n, int quoter, struct ui_file *stream) { int i; for (i = 0; i < n; i++) @@ -1496,7 +1435,7 @@ fputstrn_unfiltered (str, n, quoter, stream) /* Number of lines per page or UINT_MAX if paging is disabled. */ static unsigned int lines_per_page; -/* Number of chars per line or UNIT_MAX if line folding is disabled. */ +/* Number of chars per line or UINT_MAX if line folding is disabled. */ static unsigned int chars_per_line; /* Current count of lines printed on this page, chars on this line. */ static unsigned int lines_printed, chars_printed; @@ -1528,7 +1467,7 @@ static int wrap_column; /* Inialize the lines and chars per page */ void -init_page_info () +init_page_info (void) { #if defined(TUI) if (tui_version && m_winPtrNotNull (cmdWin)) @@ -1602,7 +1541,7 @@ init_page_info () } static void -set_width () +set_width (void) { if (chars_per_line == 0) init_page_info (); @@ -1619,10 +1558,7 @@ set_width () /* ARGSUSED */ static void -set_width_command (args, from_tty, c) - char *args; - int from_tty; - struct cmd_list_element *c; +set_width_command (char *args, int from_tty, struct cmd_list_element *c) { set_width (); } @@ -1631,7 +1567,7 @@ set_width_command (args, from_tty, c) to continue by pressing RETURN. */ static void -prompt_for_continue () +prompt_for_continue (void) { char *ignore; char cont_prompt[120]; @@ -1691,7 +1627,7 @@ prompt_for_continue () /* Reinitialize filter; ie. tell it to reset to original values. */ void -reinitialize_more_filter () +reinitialize_more_filter (void) { lines_printed = 0; chars_printed = 0; @@ -1719,8 +1655,7 @@ reinitialize_more_filter () used to force out output from the wrap_buffer. */ void -wrap_here (indent) - char *indent; +wrap_here (char *indent) { /* This should have been allocated, but be paranoid anyway. */ if (!wrap_buffer) @@ -1760,7 +1695,7 @@ wrap_here (indent) line. Otherwise do nothing. */ void -begin_line () +begin_line (void) { if (chars_printed > 0) { @@ -1783,10 +1718,8 @@ begin_line () routine should not be called when cleanups are not in place. */ static void -fputs_maybe_filtered (linebuffer, stream, filter) - const char *linebuffer; - struct ui_file *stream; - int filter; +fputs_maybe_filtered (const char *linebuffer, struct ui_file *stream, + int filter) { const char *lineptr; @@ -1887,16 +1820,13 @@ fputs_maybe_filtered (linebuffer, stream, filter) } void -fputs_filtered (linebuffer, stream) - const char *linebuffer; - struct ui_file *stream; +fputs_filtered (const char *linebuffer, struct ui_file *stream) { fputs_maybe_filtered (linebuffer, stream, 1); } int -putchar_unfiltered (c) - int c; +putchar_unfiltered (int c) { char buf = c; ui_file_write (gdb_stdout, &buf, 1); @@ -1904,9 +1834,7 @@ putchar_unfiltered (c) } int -fputc_unfiltered (c, stream) - int c; - struct ui_file *stream; +fputc_unfiltered (int c, struct ui_file *stream) { char buf = c; ui_file_write (stream, &buf, 1); @@ -1914,9 +1842,7 @@ fputc_unfiltered (c, stream) } int -fputc_filtered (c, stream) - int c; - struct ui_file *stream; +fputc_filtered (int c, struct ui_file *stream) { char buf[2]; @@ -1930,10 +1856,7 @@ fputc_filtered (c, stream) characters in printable fashion. */ void -puts_debug (prefix, string, suffix) - char *prefix; - char *string; - char *suffix; +puts_debug (char *prefix, char *string, char *suffix) { int ch; @@ -2029,11 +1952,8 @@ puts_debug (prefix, string, suffix) called when cleanups are not in place. */ static void -vfprintf_maybe_filtered (stream, format, args, filter) - struct ui_file *stream; - const char *format; - va_list args; - int filter; +vfprintf_maybe_filtered (struct ui_file *stream, const char *format, + va_list args, int filter) { char *linebuffer; struct cleanup *old_cleanups; @@ -2051,19 +1971,13 @@ vfprintf_maybe_filtered (stream, format, args, filter) void -vfprintf_filtered (stream, format, args) - struct ui_file *stream; - const char *format; - va_list args; +vfprintf_filtered (struct ui_file *stream, const char *format, va_list args) { vfprintf_maybe_filtered (stream, format, args, 1); } void -vfprintf_unfiltered (stream, format, args) - struct ui_file *stream; - const char *format; - va_list args; +vfprintf_unfiltered (struct ui_file *stream, const char *format, va_list args) { char *linebuffer; struct cleanup *old_cleanups; @@ -2080,17 +1994,13 @@ vfprintf_unfiltered (stream, format, args) } void -vprintf_filtered (format, args) - const char *format; - va_list args; +vprintf_filtered (const char *format, va_list args) { vfprintf_maybe_filtered (gdb_stdout, format, args, 1); } void -vprintf_unfiltered (format, args) - const char *format; - va_list args; +vprintf_unfiltered (const char *format, va_list args) { vfprintf_unfiltered (gdb_stdout, format, args); } @@ -2166,15 +2076,13 @@ printfi_filtered (int spaces, const char *format,...) This one doesn't, and had better not! */ void -puts_filtered (string) - const char *string; +puts_filtered (const char *string) { fputs_filtered (string, gdb_stdout); } void -puts_unfiltered (string) - const char *string; +puts_unfiltered (const char *string) { fputs_unfiltered (string, gdb_stdout); } @@ -2182,8 +2090,7 @@ puts_unfiltered (string) /* Return a pointer to N spaces and a null. The pointer is good until the next call to here. */ char * -n_spaces (n) - int n; +n_spaces (int n) { char *t; static char *spaces = 0; @@ -2205,9 +2112,7 @@ n_spaces (n) /* Print N spaces. */ void -print_spaces_filtered (n, stream) - int n; - struct ui_file *stream; +print_spaces_filtered (int n, struct ui_file *stream) { fputs_filtered (n_spaces (n), stream); } @@ -2220,11 +2125,8 @@ print_spaces_filtered (n, stream) demangling is off, the name is printed in its "raw" form. */ void -fprintf_symbol_filtered (stream, name, lang, arg_mode) - struct ui_file *stream; - char *name; - enum language lang; - int arg_mode; +fprintf_symbol_filtered (struct ui_file *stream, char *name, enum language lang, + int arg_mode) { char *demangled; @@ -2271,9 +2173,7 @@ fprintf_symbol_filtered (stream, name, lang, arg_mode) function). */ int -strcmp_iw (string1, string2) - const char *string1; - const char *string2; +strcmp_iw (const char *string1, const char *string2) { while ((*string1 != '\0') && (*string2 != '\0')) { @@ -2306,9 +2206,7 @@ strcmp_iw (string1, string2) ** at index 0. */ int -subset_compare (string_to_compare, template_string) - char *string_to_compare; - char *template_string; +subset_compare (char *string_to_compare, char *template_string) { int match; if (template_string != (char *) NULL && string_to_compare != (char *) NULL && @@ -2322,27 +2220,23 @@ subset_compare (string_to_compare, template_string) } -static void pagination_on_command PARAMS ((char *arg, int from_tty)); +static void pagination_on_command (char *arg, int from_tty); static void -pagination_on_command (arg, from_tty) - char *arg; - int from_tty; +pagination_on_command (char *arg, int from_tty) { pagination_enabled = 1; } -static void pagination_on_command PARAMS ((char *arg, int from_tty)); +static void pagination_on_command (char *arg, int from_tty); static void -pagination_off_command (arg, from_tty) - char *arg; - int from_tty; +pagination_off_command (char *arg, int from_tty) { pagination_enabled = 0; } void -initialize_utils () +initialize_utils (void) { struct cmd_list_element *c; @@ -2379,6 +2273,7 @@ initialize_utils () var_boolean, (char *) &pagination_enabled, "Set state of pagination.", &setlist), &showlist); + if (xdb_commands) { add_com ("am", class_support, pagination_on_command, @@ -2422,21 +2317,15 @@ SIGWINCH_HANDLER_BODY a system header, what we do if not, etc. */ #define FLOATFORMAT_CHAR_BIT 8 -static unsigned long get_field PARAMS ((unsigned char *, - enum floatformat_byteorders, - unsigned int, - unsigned int, - unsigned int)); +static unsigned long get_field (unsigned char *, + enum floatformat_byteorders, + unsigned int, unsigned int, unsigned int); /* Extract a field which starts at START and is LEN bytes long. DATA and TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */ static unsigned long -get_field (data, order, total_len, start, len) - unsigned char *data; - enum floatformat_byteorders order; - unsigned int total_len; - unsigned int start; - unsigned int len; +get_field (unsigned char *data, enum floatformat_byteorders order, + unsigned int total_len, unsigned int start, unsigned int len) { unsigned long result; unsigned int cur_byte; @@ -2495,10 +2384,8 @@ get_field (data, order, total_len, start, len) Store the DOUBLEST in *TO. */ void -floatformat_to_doublest (fmt, from, to) - const struct floatformat *fmt; - char *from; - DOUBLEST *to; +floatformat_to_doublest (const struct floatformat *fmt, char *from, + DOUBLEST *to) { unsigned char *ufrom = (unsigned char *) from; DOUBLEST dto; @@ -2602,22 +2489,16 @@ floatformat_to_doublest (fmt, from, to) *to = dto; } -static void put_field PARAMS ((unsigned char *, enum floatformat_byteorders, - unsigned int, - unsigned int, - unsigned int, - unsigned long)); +static void put_field (unsigned char *, enum floatformat_byteorders, + unsigned int, + unsigned int, unsigned int, unsigned long); /* Set a field which starts at START and is LEN bytes long. DATA and TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */ static void -put_field (data, order, total_len, start, len, stuff_to_put) - unsigned char *data; - enum floatformat_byteorders order; - unsigned int total_len; - unsigned int start; - unsigned int len; - unsigned long stuff_to_put; +put_field (unsigned char *data, enum floatformat_byteorders order, + unsigned int total_len, unsigned int start, unsigned int len, + unsigned long stuff_to_put) { unsigned int cur_byte; int cur_bitshift; @@ -2677,12 +2558,10 @@ put_field (data, order, total_len, start, len, stuff_to_put) The range of the returned value is >= 0.5 and < 1.0. This is equivalent to frexp, but operates on the long double data type. */ -static long double ldfrexp PARAMS ((long double value, int *eptr)); +static long double ldfrexp (long double value, int *eptr); static long double -ldfrexp (value, eptr) - long double value; - int *eptr; +ldfrexp (long double value, int *eptr) { long double tmp; int exp; @@ -2725,10 +2604,8 @@ ldfrexp (value, eptr) restrictions. */ void -floatformat_from_doublest (fmt, from, to) - CONST struct floatformat *fmt; - DOUBLEST *from; - char *to; +floatformat_from_doublest (CONST struct floatformat *fmt, DOUBLEST *from, + char *to) { DOUBLEST dfrom; int exponent; @@ -2738,7 +2615,8 @@ floatformat_from_doublest (fmt, from, to) unsigned char *uto = (unsigned char *) to; memcpy (&dfrom, from, sizeof (dfrom)); - memset (uto, 0, fmt->totalsize / FLOATFORMAT_CHAR_BIT); + memset (uto, 0, (fmt->totalsize + FLOATFORMAT_CHAR_BIT - 1) + / FLOATFORMAT_CHAR_BIT); if (dfrom == 0) return; /* Result is zero */ if (dfrom != dfrom) /* Result is NaN */ @@ -2787,7 +2665,7 @@ floatformat_from_doublest (fmt, from, to) mant_bits = mant_bits_left < 32 ? mant_bits_left : 32; mant *= 4294967296.0; - mant_long = (unsigned long) mant; + mant_long = ((unsigned long) mant) & 0xffffffffL; mant -= mant_long; /* If the integer bit is implicit, then we need to discard it. @@ -2798,6 +2676,7 @@ floatformat_from_doublest (fmt, from, to) && fmt->intbit == floatformat_intbit_no) { mant_long <<= 1; + mant_long &= 0xffffffffL; mant_bits -= 1; } @@ -2829,11 +2708,13 @@ floatformat_from_doublest (fmt, from, to) } } +/* print routines to handle variable size regs, etc. */ + /* temporary storage using circular buffer */ #define NUMCELLS 16 #define CELLSIZE 32 static char * -get_cell () +get_cell (void) { static char buf[NUMCELLS][CELLSIZE]; static int cell = 0; @@ -2842,79 +2723,22 @@ get_cell () return buf[cell]; } -/* print routines to handle variable size regs, etc. - - FIXME: Note that t_addr is a bfd_vma, which is currently either an - unsigned long or unsigned long long, determined at configure time. - If t_addr is an unsigned long long and sizeof (unsigned long long) - is greater than sizeof (unsigned long), then I believe this code will - probably lose, at least for little endian machines. I believe that - it would also be better to eliminate the switch on the absolute size - of t_addr and replace it with a sequence of if statements that compare - sizeof t_addr with sizeof the various types and do the right thing, - which includes knowing whether or not the host supports long long. - -fnf - - */ - int strlen_paddr (void) { return (TARGET_PTR_BIT / 8 * 2); } - -/* eliminate warning from compiler on 32-bit systems */ -static int thirty_two = 32; - char * paddr (CORE_ADDR addr) { - char *paddr_str = get_cell (); - switch (TARGET_PTR_BIT / 8) - { - case 8: - sprintf (paddr_str, "%08lx%08lx", - (unsigned long) (addr >> thirty_two), (unsigned long) (addr & 0xffffffff)); - break; - case 4: - sprintf (paddr_str, "%08lx", (unsigned long) addr); - break; - case 2: - sprintf (paddr_str, "%04x", (unsigned short) (addr & 0xffff)); - break; - default: - sprintf (paddr_str, "%lx", (unsigned long) addr); - } - return paddr_str; + return phex (addr, TARGET_PTR_BIT / 8); } char * paddr_nz (CORE_ADDR addr) { - char *paddr_str = get_cell (); - switch (TARGET_PTR_BIT / 8) - { - case 8: - { - unsigned long high = (unsigned long) (addr >> thirty_two); - if (high == 0) - sprintf (paddr_str, "%lx", (unsigned long) (addr & 0xffffffff)); - else - sprintf (paddr_str, "%lx%08lx", - high, (unsigned long) (addr & 0xffffffff)); - break; - } - case 4: - sprintf (paddr_str, "%lx", (unsigned long) addr); - break; - case 2: - sprintf (paddr_str, "%x", (unsigned short) (addr & 0xffff)); - break; - default: - sprintf (paddr_str, "%lx", (unsigned long) addr); - } - return paddr_str; + return phex_nz (addr, TARGET_PTR_BIT / 8); } static void @@ -2969,71 +2793,79 @@ paddr_d (LONGEST addr) return paddr_str; } +/* eliminate warning from compiler on 32-bit systems */ +static int thirty_two = 32; + char * -preg (reg) - t_reg reg; +phex (ULONGEST l, int sizeof_l) { - char *preg_str = get_cell (); - switch (sizeof (t_reg)) + char *str = get_cell (); + switch (sizeof_l) { case 8: - sprintf (preg_str, "%08lx%08lx", - (unsigned long) (reg >> thirty_two), (unsigned long) (reg & 0xffffffff)); + sprintf (str, "%08lx%08lx", + (unsigned long) (l >> thirty_two), + (unsigned long) (l & 0xffffffff)); break; case 4: - sprintf (preg_str, "%08lx", (unsigned long) reg); + sprintf (str, "%08lx", (unsigned long) l); break; case 2: - sprintf (preg_str, "%04x", (unsigned short) (reg & 0xffff)); + sprintf (str, "%04x", (unsigned short) (l & 0xffff)); break; default: - sprintf (preg_str, "%lx", (unsigned long) reg); + phex (l, sizeof (l)); + break; } - return preg_str; + return str; } char * -preg_nz (reg) - t_reg reg; +phex_nz (ULONGEST l, int sizeof_l) { - char *preg_str = get_cell (); - switch (sizeof (t_reg)) + char *str = get_cell (); + switch (sizeof_l) { case 8: { - unsigned long high = (unsigned long) (reg >> thirty_two); + unsigned long high = (unsigned long) (l >> thirty_two); if (high == 0) - sprintf (preg_str, "%lx", (unsigned long) (reg & 0xffffffff)); + sprintf (str, "%lx", (unsigned long) (l & 0xffffffff)); else - sprintf (preg_str, "%lx%08lx", - high, (unsigned long) (reg & 0xffffffff)); + sprintf (str, "%lx%08lx", + high, (unsigned long) (l & 0xffffffff)); break; } case 4: - sprintf (preg_str, "%lx", (unsigned long) reg); + sprintf (str, "%lx", (unsigned long) l); break; case 2: - sprintf (preg_str, "%x", (unsigned short) (reg & 0xffff)); + sprintf (str, "%x", (unsigned short) (l & 0xffff)); break; default: - sprintf (preg_str, "%lx", (unsigned long) reg); + phex_nz (l, sizeof (l)); + break; } - return preg_str; + return str; } -/* Helper functions for INNER_THAN */ -int -core_addr_lessthan (lhs, rhs) - CORE_ADDR lhs; - CORE_ADDR rhs; + +/* Convert to / from the hosts pointer to GDB's internal CORE_ADDR + using the target's conversion routines. */ +CORE_ADDR +host_pointer_to_address (void *ptr) { - return (lhs < rhs); + if (sizeof (ptr) != TYPE_LENGTH (builtin_type_ptr)) + internal_error ("core_addr_to_void_ptr: bad cast"); + return POINTER_TO_ADDRESS (builtin_type_ptr, &ptr); } -int -core_addr_greaterthan (lhs, rhs) - CORE_ADDR lhs; - CORE_ADDR rhs; +void * +address_to_host_pointer (CORE_ADDR addr) { - return (lhs > rhs); + void *ptr; + if (sizeof (ptr) != TYPE_LENGTH (builtin_type_ptr)) + internal_error ("core_addr_to_void_ptr: bad cast"); + ADDRESS_TO_POINTER (builtin_type_ptr, &ptr, addr); + return ptr; }