1 /* General utility routines for GDB, the GNU debugger.
3 Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
25 #include "gdb_assert.h"
27 #include "gdb_string.h"
28 #include "event-top.h"
34 /* SunOS's curses.h has a '#define reg register' in it. Thank you Sun. */
45 #include "expression.h"
49 #include "filenames.h"
51 #include "inferior.h" /* for signed_pointer_to_address */
53 #include <sys/param.h> /* For MAXPATHLEN */
62 #include <readline/readline.h>
64 #ifdef NEED_DECLARATION_MALLOC
65 extern PTR
malloc (); /* OK: PTR */
67 #ifdef NEED_DECLARATION_REALLOC
68 extern PTR
realloc (); /* OK: PTR */
70 #ifdef NEED_DECLARATION_FREE
73 /* Actually, we'll never have the decl, since we don't define _GNU_SOURCE. */
74 #if defined(HAVE_CANONICALIZE_FILE_NAME) \
75 && defined(NEED_DECLARATION_CANONICALIZE_FILE_NAME)
76 extern char *canonicalize_file_name (const char *);
79 /* readline defines this. */
82 void (*error_begin_hook
) (void);
84 /* Holds the last error message issued by gdb */
86 static struct ui_file
*gdb_lasterr
;
88 /* Prototypes for local functions */
90 static void vfprintf_maybe_filtered (struct ui_file
*, const char *,
93 static void fputs_maybe_filtered (const char *, struct ui_file
*, int);
95 static void do_my_cleanups (struct cleanup
**, struct cleanup
*);
97 static void prompt_for_continue (void);
99 static void set_screen_size (void);
100 static void set_width (void);
102 /* Chain of cleanup actions established with make_cleanup,
103 to be executed if an error happens. */
105 static struct cleanup
*cleanup_chain
; /* cleaned up after a failed command */
106 static struct cleanup
*final_cleanup_chain
; /* cleaned up when gdb exits */
107 static struct cleanup
*run_cleanup_chain
; /* cleaned up on each 'run' */
108 static struct cleanup
*exec_cleanup_chain
; /* cleaned up on each execution command */
109 /* cleaned up on each error from within an execution command */
110 static struct cleanup
*exec_error_cleanup_chain
;
112 /* Pointer to what is left to do for an execution command after the
113 target stops. Used only in asynchronous mode, by targets that
114 support async execution. The finish and until commands use it. So
115 does the target extended-remote command. */
116 struct continuation
*cmd_continuation
;
117 struct continuation
*intermediate_continuation
;
119 /* Nonzero if we have job control. */
123 /* Nonzero means a quit has been requested. */
127 /* Nonzero means quit immediately if Control-C is typed now, rather
128 than waiting until QUIT is executed. Be careful in setting this;
129 code which executes with immediate_quit set has to be very careful
130 about being able to deal with being interrupted at any time. It is
131 almost always better to use QUIT; the only exception I can think of
132 is being able to quit out of a system call (using EINTR loses if
133 the SIGINT happens between the previous QUIT and the system call).
134 To immediately quit in the case in which a SIGINT happens between
135 the previous QUIT and setting immediate_quit (desirable anytime we
136 expect to block), call QUIT after setting immediate_quit. */
140 /* Nonzero means that encoded C++/ObjC names should be printed out in their
141 C++/ObjC form rather than raw. */
145 /* Nonzero means that encoded C++/ObjC names should be printed out in their
146 C++/ObjC form even in assembler language displays. If this is set, but
147 DEMANGLE is zero, names are printed raw, i.e. DEMANGLE controls. */
149 int asm_demangle
= 0;
151 /* Nonzero means that strings with character values >0x7F should be printed
152 as octal escapes. Zero means just print the value (e.g. it's an
153 international character, and the terminal or window can cope.) */
155 int sevenbit_strings
= 0;
157 /* String to be printed before error messages, if any. */
159 char *error_pre_print
;
161 /* String to be printed before quit messages, if any. */
163 char *quit_pre_print
;
165 /* String to be printed before warning messages, if any. */
167 char *warning_pre_print
= "\nwarning: ";
169 int pagination_enabled
= 1;
172 /* Add a new cleanup to the cleanup_chain,
173 and return the previous chain pointer
174 to be passed later to do_cleanups or discard_cleanups.
175 Args are FUNCTION to clean up with, and ARG to pass to it. */
178 make_cleanup (make_cleanup_ftype
*function
, void *arg
)
180 return make_my_cleanup (&cleanup_chain
, function
, arg
);
184 make_final_cleanup (make_cleanup_ftype
*function
, void *arg
)
186 return make_my_cleanup (&final_cleanup_chain
, function
, arg
);
190 make_run_cleanup (make_cleanup_ftype
*function
, void *arg
)
192 return make_my_cleanup (&run_cleanup_chain
, function
, arg
);
196 make_exec_cleanup (make_cleanup_ftype
*function
, void *arg
)
198 return make_my_cleanup (&exec_cleanup_chain
, function
, arg
);
202 make_exec_error_cleanup (make_cleanup_ftype
*function
, void *arg
)
204 return make_my_cleanup (&exec_error_cleanup_chain
, function
, arg
);
208 do_freeargv (void *arg
)
210 freeargv ((char **) arg
);
214 make_cleanup_freeargv (char **arg
)
216 return make_my_cleanup (&cleanup_chain
, do_freeargv
, arg
);
220 do_bfd_close_cleanup (void *arg
)
226 make_cleanup_bfd_close (bfd
*abfd
)
228 return make_cleanup (do_bfd_close_cleanup
, abfd
);
232 do_close_cleanup (void *arg
)
240 make_cleanup_close (int fd
)
242 int *saved_fd
= xmalloc (sizeof (fd
));
244 return make_cleanup (do_close_cleanup
, saved_fd
);
248 do_ui_file_delete (void *arg
)
250 ui_file_delete (arg
);
254 make_cleanup_ui_file_delete (struct ui_file
*arg
)
256 return make_my_cleanup (&cleanup_chain
, do_ui_file_delete
, arg
);
260 make_my_cleanup (struct cleanup
**pmy_chain
, make_cleanup_ftype
*function
,
264 = (struct cleanup
*) xmalloc (sizeof (struct cleanup
));
265 struct cleanup
*old_chain
= *pmy_chain
;
267 new->next
= *pmy_chain
;
268 new->function
= function
;
275 /* Discard cleanups and do the actions they describe
276 until we get back to the point OLD_CHAIN in the cleanup_chain. */
279 do_cleanups (struct cleanup
*old_chain
)
281 do_my_cleanups (&cleanup_chain
, old_chain
);
285 do_final_cleanups (struct cleanup
*old_chain
)
287 do_my_cleanups (&final_cleanup_chain
, old_chain
);
291 do_run_cleanups (struct cleanup
*old_chain
)
293 do_my_cleanups (&run_cleanup_chain
, old_chain
);
297 do_exec_cleanups (struct cleanup
*old_chain
)
299 do_my_cleanups (&exec_cleanup_chain
, old_chain
);
303 do_exec_error_cleanups (struct cleanup
*old_chain
)
305 do_my_cleanups (&exec_error_cleanup_chain
, old_chain
);
309 do_my_cleanups (struct cleanup
**pmy_chain
,
310 struct cleanup
*old_chain
)
313 while ((ptr
= *pmy_chain
) != old_chain
)
315 *pmy_chain
= ptr
->next
; /* Do this first incase recursion */
316 (*ptr
->function
) (ptr
->arg
);
321 /* Discard cleanups, not doing the actions they describe,
322 until we get back to the point OLD_CHAIN in the cleanup_chain. */
325 discard_cleanups (struct cleanup
*old_chain
)
327 discard_my_cleanups (&cleanup_chain
, old_chain
);
331 discard_final_cleanups (struct cleanup
*old_chain
)
333 discard_my_cleanups (&final_cleanup_chain
, old_chain
);
337 discard_exec_error_cleanups (struct cleanup
*old_chain
)
339 discard_my_cleanups (&exec_error_cleanup_chain
, old_chain
);
343 discard_my_cleanups (struct cleanup
**pmy_chain
,
344 struct cleanup
*old_chain
)
347 while ((ptr
= *pmy_chain
) != old_chain
)
349 *pmy_chain
= ptr
->next
;
354 /* Set the cleanup_chain to 0, and return the old cleanup chain. */
358 return save_my_cleanups (&cleanup_chain
);
362 save_final_cleanups (void)
364 return save_my_cleanups (&final_cleanup_chain
);
368 save_my_cleanups (struct cleanup
**pmy_chain
)
370 struct cleanup
*old_chain
= *pmy_chain
;
376 /* Restore the cleanup chain from a previously saved chain. */
378 restore_cleanups (struct cleanup
*chain
)
380 restore_my_cleanups (&cleanup_chain
, chain
);
384 restore_final_cleanups (struct cleanup
*chain
)
386 restore_my_cleanups (&final_cleanup_chain
, chain
);
390 restore_my_cleanups (struct cleanup
**pmy_chain
, struct cleanup
*chain
)
395 /* This function is useful for cleanups.
399 old_chain = make_cleanup (free_current_contents, &foo);
401 to arrange to free the object thus allocated. */
404 free_current_contents (void *ptr
)
406 void **location
= ptr
;
407 if (location
== NULL
)
408 internal_error (__FILE__
, __LINE__
,
409 "free_current_contents: NULL pointer");
410 if (*location
!= NULL
)
417 /* Provide a known function that does nothing, to use as a base for
418 for a possibly long chain of cleanups. This is useful where we
419 use the cleanup chain for handling normal cleanups as well as dealing
420 with cleanups that need to be done as a result of a call to error().
421 In such cases, we may not be certain where the first cleanup is, unless
422 we have a do-nothing one to always use as the base. */
425 null_cleanup (void *arg
)
429 /* Add a continuation to the continuation list, the global list
430 cmd_continuation. The new continuation will be added at the front.*/
432 add_continuation (void (*continuation_hook
) (struct continuation_arg
*),
433 struct continuation_arg
*arg_list
)
435 struct continuation
*continuation_ptr
;
438 (struct continuation
*) xmalloc (sizeof (struct continuation
));
439 continuation_ptr
->continuation_hook
= continuation_hook
;
440 continuation_ptr
->arg_list
= arg_list
;
441 continuation_ptr
->next
= cmd_continuation
;
442 cmd_continuation
= continuation_ptr
;
445 /* Walk down the cmd_continuation list, and execute all the
446 continuations. There is a problem though. In some cases new
447 continuations may be added while we are in the middle of this
448 loop. If this happens they will be added in the front, and done
449 before we have a chance of exhausting those that were already
450 there. We need to then save the beginning of the list in a pointer
451 and do the continuations from there on, instead of using the
452 global beginning of list as our iteration pointer.*/
454 do_all_continuations (void)
456 struct continuation
*continuation_ptr
;
457 struct continuation
*saved_continuation
;
459 /* Copy the list header into another pointer, and set the global
460 list header to null, so that the global list can change as a side
461 effect of invoking the continuations and the processing of
462 the preexisting continuations will not be affected. */
463 continuation_ptr
= cmd_continuation
;
464 cmd_continuation
= NULL
;
466 /* Work now on the list we have set aside. */
467 while (continuation_ptr
)
469 (continuation_ptr
->continuation_hook
) (continuation_ptr
->arg_list
);
470 saved_continuation
= continuation_ptr
;
471 continuation_ptr
= continuation_ptr
->next
;
472 xfree (saved_continuation
);
476 /* Walk down the cmd_continuation list, and get rid of all the
479 discard_all_continuations (void)
481 struct continuation
*continuation_ptr
;
483 while (cmd_continuation
)
485 continuation_ptr
= cmd_continuation
;
486 cmd_continuation
= continuation_ptr
->next
;
487 xfree (continuation_ptr
);
491 /* Add a continuation to the continuation list, the global list
492 intermediate_continuation. The new continuation will be added at the front.*/
494 add_intermediate_continuation (void (*continuation_hook
)
495 (struct continuation_arg
*),
496 struct continuation_arg
*arg_list
)
498 struct continuation
*continuation_ptr
;
501 (struct continuation
*) xmalloc (sizeof (struct continuation
));
502 continuation_ptr
->continuation_hook
= continuation_hook
;
503 continuation_ptr
->arg_list
= arg_list
;
504 continuation_ptr
->next
= intermediate_continuation
;
505 intermediate_continuation
= continuation_ptr
;
508 /* Walk down the cmd_continuation list, and execute all the
509 continuations. There is a problem though. In some cases new
510 continuations may be added while we are in the middle of this
511 loop. If this happens they will be added in the front, and done
512 before we have a chance of exhausting those that were already
513 there. We need to then save the beginning of the list in a pointer
514 and do the continuations from there on, instead of using the
515 global beginning of list as our iteration pointer.*/
517 do_all_intermediate_continuations (void)
519 struct continuation
*continuation_ptr
;
520 struct continuation
*saved_continuation
;
522 /* Copy the list header into another pointer, and set the global
523 list header to null, so that the global list can change as a side
524 effect of invoking the continuations and the processing of
525 the preexisting continuations will not be affected. */
526 continuation_ptr
= intermediate_continuation
;
527 intermediate_continuation
= NULL
;
529 /* Work now on the list we have set aside. */
530 while (continuation_ptr
)
532 (continuation_ptr
->continuation_hook
) (continuation_ptr
->arg_list
);
533 saved_continuation
= continuation_ptr
;
534 continuation_ptr
= continuation_ptr
->next
;
535 xfree (saved_continuation
);
539 /* Walk down the cmd_continuation list, and get rid of all the
542 discard_all_intermediate_continuations (void)
544 struct continuation
*continuation_ptr
;
546 while (intermediate_continuation
)
548 continuation_ptr
= intermediate_continuation
;
549 intermediate_continuation
= continuation_ptr
->next
;
550 xfree (continuation_ptr
);
556 /* Print a warning message. The first argument STRING is the warning
557 message, used as an fprintf format string, the second is the
558 va_list of arguments for that string. A warning is unfiltered (not
559 paginated) so that the user does not need to page through each
560 screen full of warnings when there are lots of them. */
563 vwarning (const char *string
, va_list args
)
566 (*warning_hook
) (string
, args
);
569 target_terminal_ours ();
570 wrap_here (""); /* Force out any buffered output */
571 gdb_flush (gdb_stdout
);
572 if (warning_pre_print
)
573 fputs_unfiltered (warning_pre_print
, gdb_stderr
);
574 vfprintf_unfiltered (gdb_stderr
, string
, args
);
575 fprintf_unfiltered (gdb_stderr
, "\n");
580 /* Print a warning message.
581 The first argument STRING is the warning message, used as a fprintf string,
582 and the remaining args are passed as arguments to it.
583 The primary difference between warnings and errors is that a warning
584 does not force the return to command level. */
587 warning (const char *string
, ...)
590 va_start (args
, string
);
591 vwarning (string
, args
);
595 /* Print an error message and return to command level.
596 The first argument STRING is the error message, used as a fprintf string,
597 and the remaining args are passed as arguments to it. */
600 verror (const char *string
, va_list args
)
602 struct ui_file
*tmp_stream
= mem_fileopen ();
603 make_cleanup_ui_file_delete (tmp_stream
);
604 vfprintf_unfiltered (tmp_stream
, string
, args
);
605 error_stream (tmp_stream
);
609 error (const char *string
, ...)
612 va_start (args
, string
);
613 verror (string
, args
);
618 do_write (void *data
, const char *buffer
, long length_buffer
)
620 ui_file_write (data
, buffer
, length_buffer
);
623 /* Cause a silent error to occur. Any error message is recorded
624 though it is not issued. */
626 error_silent (const char *string
, ...)
629 struct ui_file
*tmp_stream
= mem_fileopen ();
630 va_start (args
, string
);
631 make_cleanup_ui_file_delete (tmp_stream
);
632 vfprintf_unfiltered (tmp_stream
, string
, args
);
633 /* Copy the stream into the GDB_LASTERR buffer. */
634 ui_file_rewind (gdb_lasterr
);
635 ui_file_put (tmp_stream
, do_write
, gdb_lasterr
);
638 throw_exception (RETURN_ERROR
);
641 /* Output an error message including any pre-print text to gdb_stderr. */
643 error_output_message (char *pre_print
, char *msg
)
645 target_terminal_ours ();
646 wrap_here (""); /* Force out any buffered output */
647 gdb_flush (gdb_stdout
);
648 annotate_error_begin ();
650 fputs_filtered (pre_print
, gdb_stderr
);
651 fputs_filtered (msg
, gdb_stderr
);
652 fprintf_filtered (gdb_stderr
, "\n");
656 error_stream (struct ui_file
*stream
)
658 if (error_begin_hook
)
661 /* Copy the stream into the GDB_LASTERR buffer. */
662 ui_file_rewind (gdb_lasterr
);
663 ui_file_put (stream
, do_write
, gdb_lasterr
);
665 /* Write the message plus any error_pre_print to gdb_stderr. */
666 target_terminal_ours ();
667 wrap_here (""); /* Force out any buffered output */
668 gdb_flush (gdb_stdout
);
669 annotate_error_begin ();
671 fputs_filtered (error_pre_print
, gdb_stderr
);
672 ui_file_put (stream
, do_write
, gdb_stderr
);
673 fprintf_filtered (gdb_stderr
, "\n");
675 throw_exception (RETURN_ERROR
);
678 /* Get the last error message issued by gdb */
681 error_last_message (void)
684 return ui_file_xstrdup (gdb_lasterr
, &len
);
687 /* This is to be called by main() at the very beginning */
692 gdb_lasterr
= mem_fileopen ();
695 /* Print a message reporting an internal error/warning. Ask the user
696 if they want to continue, dump core, or just exit. Return
697 something to indicate a quit. */
699 struct internal_problem
702 /* FIXME: cagney/2002-08-15: There should be ``maint set/show''
703 commands available for controlling these variables. */
704 enum auto_boolean should_quit
;
705 enum auto_boolean should_dump_core
;
708 /* Report a problem, internal to GDB, to the user. Once the problem
709 has been reported, and assuming GDB didn't quit, the caller can
710 either allow execution to resume or throw an error. */
713 internal_vproblem (struct internal_problem
*problem
,
714 const char *file
, int line
, const char *fmt
, va_list ap
)
721 /* Don't allow infinite error/warning recursion. */
723 static char msg
[] = "Recursive internal problem.\n";
731 fputs_unfiltered (msg
, gdb_stderr
);
732 abort (); /* NOTE: GDB has only three calls to abort(). */
735 write (STDERR_FILENO
, msg
, sizeof (msg
));
740 /* Try to get the message out and at the start of a new line. */
741 target_terminal_ours ();
744 /* Create a string containing the full error/warning message. Need
745 to call query with this full string, as otherwize the reason
746 (error/warning) and question become separated. Format using a
747 style similar to a compiler error message. Include extra detail
748 so that the user knows that they are living on the edge. */
751 xvasprintf (&msg
, fmt
, ap
);
752 xasprintf (&reason
, "\
754 A problem internal to GDB has been detected,\n\
755 further debugging may prove unreliable.", file
, line
, problem
->name
, msg
);
757 make_cleanup (xfree
, reason
);
760 switch (problem
->should_quit
)
762 case AUTO_BOOLEAN_AUTO
:
763 /* Default (yes/batch case) is to quit GDB. When in batch mode
764 this lessens the likelhood of GDB going into an infinate
766 quit_p
= query ("%s\nQuit this debugging session? ", reason
);
768 case AUTO_BOOLEAN_TRUE
:
771 case AUTO_BOOLEAN_FALSE
:
775 internal_error (__FILE__
, __LINE__
, "bad switch");
778 switch (problem
->should_dump_core
)
780 case AUTO_BOOLEAN_AUTO
:
781 /* Default (yes/batch case) is to dump core. This leaves a GDB
782 `dropping' so that it is easier to see that something went
784 dump_core_p
= query ("%s\nCreate a core file of GDB? ", reason
);
787 case AUTO_BOOLEAN_TRUE
:
790 case AUTO_BOOLEAN_FALSE
:
794 internal_error (__FILE__
, __LINE__
, "bad switch");
800 abort (); /* NOTE: GDB has only three calls to abort(). */
809 abort (); /* NOTE: GDB has only three calls to abort(). */
816 static struct internal_problem internal_error_problem
= {
817 "internal-error", AUTO_BOOLEAN_AUTO
, AUTO_BOOLEAN_AUTO
821 internal_verror (const char *file
, int line
, const char *fmt
, va_list ap
)
823 internal_vproblem (&internal_error_problem
, file
, line
, fmt
, ap
);
824 throw_exception (RETURN_ERROR
);
828 internal_error (const char *file
, int line
, const char *string
, ...)
831 va_start (ap
, string
);
832 internal_verror (file
, line
, string
, ap
);
836 static struct internal_problem internal_warning_problem
= {
837 "internal-error", AUTO_BOOLEAN_AUTO
, AUTO_BOOLEAN_AUTO
841 internal_vwarning (const char *file
, int line
, const char *fmt
, va_list ap
)
843 internal_vproblem (&internal_warning_problem
, file
, line
, fmt
, ap
);
847 internal_warning (const char *file
, int line
, const char *string
, ...)
850 va_start (ap
, string
);
851 internal_vwarning (file
, line
, string
, ap
);
855 /* The strerror() function can return NULL for errno values that are
856 out of range. Provide a "safe" version that always returns a
860 safe_strerror (int errnum
)
865 msg
= strerror (errnum
);
868 sprintf (buf
, "(undocumented errno %d)", errnum
);
874 /* Print the system error message for errno, and also mention STRING
875 as the file name for which the error was encountered.
876 Then return to command level. */
879 perror_with_name (const char *string
)
884 err
= safe_strerror (errno
);
885 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
886 strcpy (combined
, string
);
887 strcat (combined
, ": ");
888 strcat (combined
, err
);
890 /* I understand setting these is a matter of taste. Still, some people
891 may clear errno but not know about bfd_error. Doing this here is not
893 bfd_set_error (bfd_error_no_error
);
896 error ("%s.", combined
);
899 /* Print the system error message for ERRCODE, and also mention STRING
900 as the file name for which the error was encountered. */
903 print_sys_errmsg (const char *string
, int errcode
)
908 err
= safe_strerror (errcode
);
909 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
910 strcpy (combined
, string
);
911 strcat (combined
, ": ");
912 strcat (combined
, err
);
914 /* We want anything which was printed on stdout to come out first, before
916 gdb_flush (gdb_stdout
);
917 fprintf_unfiltered (gdb_stderr
, "%s.\n", combined
);
920 /* Control C eventually causes this to be called, at a convenient time. */
925 struct serial
*gdb_stdout_serial
= serial_fdopen (1);
927 target_terminal_ours ();
929 /* We want all output to appear now, before we print "Quit". We
930 have 3 levels of buffering we have to flush (it's possible that
931 some of these should be changed to flush the lower-level ones
934 /* 1. The _filtered buffer. */
935 wrap_here ((char *) 0);
937 /* 2. The stdio buffer. */
938 gdb_flush (gdb_stdout
);
939 gdb_flush (gdb_stderr
);
941 /* 3. The system-level buffer. */
942 serial_drain_output (gdb_stdout_serial
);
943 serial_un_fdopen (gdb_stdout_serial
);
945 annotate_error_begin ();
947 /* Don't use *_filtered; we don't want to prompt the user to continue. */
949 fputs_unfiltered (quit_pre_print
, gdb_stderr
);
952 /* No steenking SIGINT will ever be coming our way when the
953 program is resumed. Don't lie. */
954 fprintf_unfiltered (gdb_stderr
, "Quit\n");
957 /* If there is no terminal switching for this target, then we can't
958 possibly get screwed by the lack of job control. */
959 || current_target
.to_terminal_ours
== NULL
)
960 fprintf_unfiltered (gdb_stderr
, "Quit\n");
962 fprintf_unfiltered (gdb_stderr
,
963 "Quit (expect signal SIGINT when the program is resumed)\n");
965 throw_exception (RETURN_QUIT
);
968 /* Control C comes here */
970 request_quit (int signo
)
973 /* Restore the signal handler. Harmless with BSD-style signals, needed
974 for System V-style signals. So just always do it, rather than worrying
975 about USG defines and stuff like that. */
976 signal (signo
, request_quit
);
986 /* Memory management stuff (malloc friends). */
989 mmalloc (void *md
, size_t size
)
991 return malloc (size
); /* NOTE: GDB's only call to malloc() */
995 mrealloc (void *md
, void *ptr
, size_t size
)
997 if (ptr
== 0) /* Guard against old realloc's */
998 return mmalloc (md
, size
);
1000 return realloc (ptr
, size
); /* NOTE: GDB's only call to ralloc() */
1004 mcalloc (void *md
, size_t number
, size_t size
)
1006 return calloc (number
, size
); /* NOTE: GDB's only call to calloc() */
1010 mfree (void *md
, void *ptr
)
1012 free (ptr
); /* NOTE: GDB's only call to free() */
1015 /* This used to do something interesting with USE_MMALLOC.
1016 * It can be retired any time. -- chastain 2004-01-19. */
1018 init_malloc (void *md
)
1022 /* Called when a memory allocation fails, with the number of bytes of
1023 memory requested in SIZE. */
1030 internal_error (__FILE__
, __LINE__
,
1031 "virtual memory exhausted: can't allocate %ld bytes.",
1036 internal_error (__FILE__
, __LINE__
, "virtual memory exhausted.");
1040 /* The xmmalloc() family of memory management routines.
1042 These are are like the mmalloc() family except that they implement
1043 consistent semantics and guard against typical memory management
1044 problems: if a malloc fails, an internal error is thrown; if
1045 free(NULL) is called, it is ignored; if *alloc(0) is called, NULL
1048 All these routines are implemented using the mmalloc() family. */
1051 xmmalloc (void *md
, size_t size
)
1055 /* See libiberty/xmalloc.c. This function need's to match that's
1056 semantics. It never returns NULL. */
1060 val
= mmalloc (md
, size
);
1068 xmrealloc (void *md
, void *ptr
, size_t size
)
1072 /* See libiberty/xmalloc.c. This function need's to match that's
1073 semantics. It never returns NULL. */
1078 val
= mrealloc (md
, ptr
, size
);
1080 val
= mmalloc (md
, size
);
1088 xmcalloc (void *md
, size_t number
, size_t size
)
1092 /* See libiberty/xmalloc.c. This function need's to match that's
1093 semantics. It never returns NULL. */
1094 if (number
== 0 || size
== 0)
1100 mem
= mcalloc (md
, number
, size
);
1102 nomem (number
* size
);
1108 xmfree (void *md
, void *ptr
)
1114 /* The xmalloc() (libiberty.h) family of memory management routines.
1116 These are like the ISO-C malloc() family except that they implement
1117 consistent semantics and guard against typical memory management
1118 problems. See xmmalloc() above for further information.
1120 All these routines are wrappers to the xmmalloc() family. */
1122 /* NOTE: These are declared using PTR to ensure consistency with
1123 "libiberty.h". xfree() is GDB local. */
1126 xmalloc (size_t size
)
1128 return xmmalloc (NULL
, size
);
1132 xrealloc (PTR ptr
, size_t size
) /* OK: PTR */
1134 return xmrealloc (NULL
, ptr
, size
);
1138 xcalloc (size_t number
, size_t size
)
1140 return xmcalloc (NULL
, number
, size
);
1150 /* Like asprintf/vasprintf but get an internal_error if the call
1154 xstrprintf (const char *format
, ...)
1158 va_start (args
, format
);
1159 xvasprintf (&ret
, format
, args
);
1165 xasprintf (char **ret
, const char *format
, ...)
1168 va_start (args
, format
);
1169 xvasprintf (ret
, format
, args
);
1174 xvasprintf (char **ret
, const char *format
, va_list ap
)
1176 int status
= vasprintf (ret
, format
, ap
);
1177 /* NULL could be returned due to a memory allocation problem; a
1178 badly format string; or something else. */
1180 internal_error (__FILE__
, __LINE__
,
1181 "vasprintf returned NULL buffer (errno %d)", errno
);
1182 /* A negative status with a non-NULL buffer shouldn't never
1183 happen. But to be sure. */
1185 internal_error (__FILE__
, __LINE__
,
1186 "vasprintf call failed (errno %d)", errno
);
1190 /* My replacement for the read system call.
1191 Used like `read' but keeps going if `read' returns too soon. */
1194 myread (int desc
, char *addr
, int len
)
1201 val
= read (desc
, addr
, len
);
1205 return orglen
- len
;
1212 /* Make a copy of the string at PTR with SIZE characters
1213 (and add a null character at the end in the copy).
1214 Uses malloc to get the space. Returns the address of the copy. */
1217 savestring (const char *ptr
, size_t size
)
1219 char *p
= (char *) xmalloc (size
+ 1);
1220 memcpy (p
, ptr
, size
);
1226 msavestring (void *md
, const char *ptr
, size_t size
)
1228 char *p
= (char *) xmmalloc (md
, size
+ 1);
1229 memcpy (p
, ptr
, size
);
1235 mstrsave (void *md
, const char *ptr
)
1237 return (msavestring (md
, ptr
, strlen (ptr
)));
1241 print_spaces (int n
, struct ui_file
*file
)
1243 fputs_unfiltered (n_spaces (n
), file
);
1246 /* Print a host address. */
1249 gdb_print_host_address (const void *addr
, struct ui_file
*stream
)
1252 /* We could use the %p conversion specifier to fprintf if we had any
1253 way of knowing whether this host supports it. But the following
1254 should work on the Alpha and on 32 bit machines. */
1256 fprintf_filtered (stream
, "0x%lx", (unsigned long) addr
);
1259 /* Ask user a y-or-n question and return 1 iff answer is yes.
1260 Takes three args which are given to printf to print the question.
1261 The first, a control string, should end in "? ".
1262 It should not say how to answer, because we do that. */
1266 query (const char *ctlstr
, ...)
1273 va_start (args
, ctlstr
);
1277 return query_hook (ctlstr
, args
);
1280 /* Automatically answer "yes" if input is not from a terminal. */
1281 if (!input_from_terminal_p ())
1286 wrap_here (""); /* Flush any buffered output */
1287 gdb_flush (gdb_stdout
);
1289 if (annotation_level
> 1)
1290 printf_filtered ("\n\032\032pre-query\n");
1292 vfprintf_filtered (gdb_stdout
, ctlstr
, args
);
1293 printf_filtered ("(y or n) ");
1295 if (annotation_level
> 1)
1296 printf_filtered ("\n\032\032query\n");
1299 gdb_flush (gdb_stdout
);
1301 answer
= fgetc (stdin
);
1302 clearerr (stdin
); /* in case of C-d */
1303 if (answer
== EOF
) /* C-d */
1308 /* Eat rest of input line, to EOF or newline */
1312 ans2
= fgetc (stdin
);
1315 while (ans2
!= EOF
&& ans2
!= '\n' && ans2
!= '\r');
1329 printf_filtered ("Please answer y or n.\n");
1332 if (annotation_level
> 1)
1333 printf_filtered ("\n\032\032post-query\n");
1338 /* Print an error message saying that we couldn't make sense of a
1339 \^mumble sequence in a string or character constant. START and END
1340 indicate a substring of some larger string that contains the
1341 erroneous backslash sequence, missing the initial backslash. */
1343 no_control_char_error (const char *start
, const char *end
)
1345 int len
= end
- start
;
1346 char *copy
= alloca (end
- start
+ 1);
1348 memcpy (copy
, start
, len
);
1351 error ("There is no control character `\\%s' in the `%s' character set.",
1352 copy
, target_charset ());
1355 /* Parse a C escape sequence. STRING_PTR points to a variable
1356 containing a pointer to the string to parse. That pointer
1357 should point to the character after the \. That pointer
1358 is updated past the characters we use. The value of the
1359 escape sequence is returned.
1361 A negative value means the sequence \ newline was seen,
1362 which is supposed to be equivalent to nothing at all.
1364 If \ is followed by a null character, we return a negative
1365 value and leave the string pointer pointing at the null character.
1367 If \ is followed by 000, we return 0 and leave the string pointer
1368 after the zeros. A value of 0 does not mean end of string. */
1371 parse_escape (char **string_ptr
)
1374 int c
= *(*string_ptr
)++;
1375 if (c_parse_backslash (c
, &target_char
))
1387 /* Remember where this escape sequence started, for reporting
1389 char *sequence_start_pos
= *string_ptr
- 1;
1391 c
= *(*string_ptr
)++;
1395 /* XXXCHARSET: What is `delete' in the host character set? */
1398 if (!host_char_to_target (c
, &target_char
))
1399 error ("There is no character corresponding to `Delete' "
1400 "in the target character set `%s'.", host_charset ());
1405 target_char
= parse_escape (string_ptr
);
1408 if (!host_char_to_target (c
, &target_char
))
1409 no_control_char_error (sequence_start_pos
, *string_ptr
);
1412 /* Now target_char is something like `c', and we want to find
1413 its control-character equivalent. */
1414 if (!target_char_to_control_char (target_char
, &target_char
))
1415 no_control_char_error (sequence_start_pos
, *string_ptr
);
1420 /* XXXCHARSET: we need to use isdigit and value-of-digit
1421 methods of the host character set here. */
1437 if (c
>= '0' && c
<= '7')
1451 if (!host_char_to_target (c
, &target_char
))
1453 ("The escape sequence `\%c' is equivalent to plain `%c', which"
1454 " has no equivalent\n" "in the `%s' character set.", c
, c
,
1460 /* Print the character C on STREAM as part of the contents of a literal
1461 string whose delimiter is QUOTER. Note that this routine should only
1462 be call for printing things which are independent of the language
1463 of the program being debugged. */
1466 printchar (int c
, void (*do_fputs
) (const char *, struct ui_file
*),
1467 void (*do_fprintf
) (struct ui_file
*, const char *, ...),
1468 struct ui_file
*stream
, int quoter
)
1471 c
&= 0xFF; /* Avoid sign bit follies */
1473 if (c
< 0x20 || /* Low control chars */
1474 (c
>= 0x7F && c
< 0xA0) || /* DEL, High controls */
1475 (sevenbit_strings
&& c
>= 0x80))
1476 { /* high order bit set */
1480 do_fputs ("\\n", stream
);
1483 do_fputs ("\\b", stream
);
1486 do_fputs ("\\t", stream
);
1489 do_fputs ("\\f", stream
);
1492 do_fputs ("\\r", stream
);
1495 do_fputs ("\\e", stream
);
1498 do_fputs ("\\a", stream
);
1501 do_fprintf (stream
, "\\%.3o", (unsigned int) c
);
1507 if (c
== '\\' || c
== quoter
)
1508 do_fputs ("\\", stream
);
1509 do_fprintf (stream
, "%c", c
);
1513 /* Print the character C on STREAM as part of the contents of a
1514 literal string whose delimiter is QUOTER. Note that these routines
1515 should only be call for printing things which are independent of
1516 the language of the program being debugged. */
1519 fputstr_filtered (const char *str
, int quoter
, struct ui_file
*stream
)
1522 printchar (*str
++, fputs_filtered
, fprintf_filtered
, stream
, quoter
);
1526 fputstr_unfiltered (const char *str
, int quoter
, struct ui_file
*stream
)
1529 printchar (*str
++, fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1533 fputstrn_unfiltered (const char *str
, int n
, int quoter
,
1534 struct ui_file
*stream
)
1537 for (i
= 0; i
< n
; i
++)
1538 printchar (str
[i
], fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1542 /* Number of lines per page or UINT_MAX if paging is disabled. */
1543 static unsigned int lines_per_page
;
1545 /* Number of chars per line or UINT_MAX if line folding is disabled. */
1546 static unsigned int chars_per_line
;
1548 /* Current count of lines printed on this page, chars on this line. */
1549 static unsigned int lines_printed
, chars_printed
;
1551 /* Buffer and start column of buffered text, for doing smarter word-
1552 wrapping. When someone calls wrap_here(), we start buffering output
1553 that comes through fputs_filtered(). If we see a newline, we just
1554 spit it out and forget about the wrap_here(). If we see another
1555 wrap_here(), we spit it out and remember the newer one. If we see
1556 the end of the line, we spit out a newline, the indent, and then
1557 the buffered output. */
1559 /* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
1560 are waiting to be output (they have already been counted in chars_printed).
1561 When wrap_buffer[0] is null, the buffer is empty. */
1562 static char *wrap_buffer
;
1564 /* Pointer in wrap_buffer to the next character to fill. */
1565 static char *wrap_pointer
;
1567 /* String to indent by if the wrap occurs. Must not be NULL if wrap_column
1569 static char *wrap_indent
;
1571 /* Column number on the screen where wrap_buffer begins, or 0 if wrapping
1572 is not in effect. */
1573 static int wrap_column
;
1576 /* Inialize the number of lines per page and chars per line. */
1579 init_page_info (void)
1582 if (!tui_get_command_dimension (&chars_per_line
, &lines_per_page
))
1585 #if defined(__GO32__)
1586 lines_per_page
= ScreenRows ();
1587 chars_per_line
= ScreenCols ();
1591 /* Make sure Readline has initialized its terminal settings. */
1592 rl_reset_terminal (NULL
);
1594 /* Get the screen size from Readline. */
1595 rl_get_screen_size (&rows
, &cols
);
1596 lines_per_page
= rows
;
1597 chars_per_line
= cols
;
1599 /* Readline should have fetched the termcap entry for us. */
1600 if (tgetnum ("li") < 0 || getenv ("EMACS"))
1602 /* The number of lines per page is not mentioned in the
1603 terminal description. This probably means that paging is
1604 not useful (e.g. emacs shell window), so disable paging. */
1605 lines_per_page
= UINT_MAX
;
1608 /* FIXME: Get rid of this junk. */
1609 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
1610 SIGWINCH_HANDLER (SIGWINCH
);
1613 /* If the output is not a terminal, don't paginate it. */
1614 if (!ui_file_isatty (gdb_stdout
))
1615 lines_per_page
= UINT_MAX
;
1623 /* Set the screen size based on LINES_PER_PAGE and CHARS_PER_LINE. */
1626 set_screen_size (void)
1628 int rows
= lines_per_page
;
1629 int cols
= chars_per_line
;
1635 rl_get_screen_size (NULL
, &cols
);
1637 /* Update Readline's idea of the terminal size. */
1638 rl_set_screen_size (rows
, cols
);
1641 /* Reinitialize WRAP_BUFFER according to the current value of
1647 if (chars_per_line
== 0)
1652 wrap_buffer
= (char *) xmalloc (chars_per_line
+ 2);
1653 wrap_buffer
[0] = '\0';
1656 wrap_buffer
= (char *) xrealloc (wrap_buffer
, chars_per_line
+ 2);
1657 wrap_pointer
= wrap_buffer
; /* Start it at the beginning. */
1661 set_width_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
1668 set_height_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
1673 /* Wait, so the user can read what's on the screen. Prompt the user
1674 to continue by pressing RETURN. */
1677 prompt_for_continue (void)
1680 char cont_prompt
[120];
1682 if (annotation_level
> 1)
1683 printf_unfiltered ("\n\032\032pre-prompt-for-continue\n");
1685 strcpy (cont_prompt
,
1686 "---Type <return> to continue, or q <return> to quit---");
1687 if (annotation_level
> 1)
1688 strcat (cont_prompt
, "\n\032\032prompt-for-continue\n");
1690 /* We must do this *before* we call gdb_readline, else it will eventually
1691 call us -- thinking that we're trying to print beyond the end of the
1693 reinitialize_more_filter ();
1696 /* On a real operating system, the user can quit with SIGINT.
1699 'q' is provided on all systems so users don't have to change habits
1700 from system to system, and because telling them what to do in
1701 the prompt is more user-friendly than expecting them to think of
1703 /* Call readline, not gdb_readline, because GO32 readline handles control-C
1704 whereas control-C to gdb_readline will cause the user to get dumped
1706 ignore
= gdb_readline_wrapper (cont_prompt
);
1708 if (annotation_level
> 1)
1709 printf_unfiltered ("\n\032\032post-prompt-for-continue\n");
1714 while (*p
== ' ' || *p
== '\t')
1719 request_quit (SIGINT
);
1721 async_request_quit (0);
1727 /* Now we have to do this again, so that GDB will know that it doesn't
1728 need to save the ---Type <return>--- line at the top of the screen. */
1729 reinitialize_more_filter ();
1731 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
1734 /* Reinitialize filter; ie. tell it to reset to original values. */
1737 reinitialize_more_filter (void)
1743 /* Indicate that if the next sequence of characters overflows the line,
1744 a newline should be inserted here rather than when it hits the end.
1745 If INDENT is non-null, it is a string to be printed to indent the
1746 wrapped part on the next line. INDENT must remain accessible until
1747 the next call to wrap_here() or until a newline is printed through
1750 If the line is already overfull, we immediately print a newline and
1751 the indentation, and disable further wrapping.
1753 If we don't know the width of lines, but we know the page height,
1754 we must not wrap words, but should still keep track of newlines
1755 that were explicitly printed.
1757 INDENT should not contain tabs, as that will mess up the char count
1758 on the next line. FIXME.
1760 This routine is guaranteed to force out any output which has been
1761 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
1762 used to force out output from the wrap_buffer. */
1765 wrap_here (char *indent
)
1767 /* This should have been allocated, but be paranoid anyway. */
1769 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
1773 *wrap_pointer
= '\0';
1774 fputs_unfiltered (wrap_buffer
, gdb_stdout
);
1776 wrap_pointer
= wrap_buffer
;
1777 wrap_buffer
[0] = '\0';
1778 if (chars_per_line
== UINT_MAX
) /* No line overflow checking */
1782 else if (chars_printed
>= chars_per_line
)
1784 puts_filtered ("\n");
1786 puts_filtered (indent
);
1791 wrap_column
= chars_printed
;
1795 wrap_indent
= indent
;
1799 /* Print input string to gdb_stdout, filtered, with wrap,
1800 arranging strings in columns of n chars. String can be
1801 right or left justified in the column. Never prints
1802 trailing spaces. String should never be longer than
1803 width. FIXME: this could be useful for the EXAMINE
1804 command, which currently doesn't tabulate very well */
1807 puts_filtered_tabular (char *string
, int width
, int right
)
1813 gdb_assert (chars_per_line
> 0);
1814 if (chars_per_line
== UINT_MAX
)
1816 fputs_filtered (string
, gdb_stdout
);
1817 fputs_filtered ("\n", gdb_stdout
);
1821 if (((chars_printed
- 1) / width
+ 2) * width
>= chars_per_line
)
1822 fputs_filtered ("\n", gdb_stdout
);
1824 if (width
>= chars_per_line
)
1825 width
= chars_per_line
- 1;
1827 stringlen
= strlen (string
);
1829 if (chars_printed
> 0)
1830 spaces
= width
- (chars_printed
- 1) % width
- 1;
1832 spaces
+= width
- stringlen
;
1834 spacebuf
= alloca (spaces
+ 1);
1835 spacebuf
[spaces
] = '\0';
1837 spacebuf
[spaces
] = ' ';
1839 fputs_filtered (spacebuf
, gdb_stdout
);
1840 fputs_filtered (string
, gdb_stdout
);
1844 /* Ensure that whatever gets printed next, using the filtered output
1845 commands, starts at the beginning of the line. I.E. if there is
1846 any pending output for the current line, flush it and start a new
1847 line. Otherwise do nothing. */
1852 if (chars_printed
> 0)
1854 puts_filtered ("\n");
1859 /* Like fputs but if FILTER is true, pause after every screenful.
1861 Regardless of FILTER can wrap at points other than the final
1862 character of a line.
1864 Unlike fputs, fputs_maybe_filtered does not return a value.
1865 It is OK for LINEBUFFER to be NULL, in which case just don't print
1868 Note that a longjmp to top level may occur in this routine (only if
1869 FILTER is true) (since prompt_for_continue may do so) so this
1870 routine should not be called when cleanups are not in place. */
1873 fputs_maybe_filtered (const char *linebuffer
, struct ui_file
*stream
,
1876 const char *lineptr
;
1878 if (linebuffer
== 0)
1881 /* Don't do any filtering if it is disabled. */
1882 if ((stream
!= gdb_stdout
) || !pagination_enabled
1883 || (lines_per_page
== UINT_MAX
&& chars_per_line
== UINT_MAX
))
1885 fputs_unfiltered (linebuffer
, stream
);
1889 /* Go through and output each character. Show line extension
1890 when this is necessary; prompt user for new page when this is
1893 lineptr
= linebuffer
;
1896 /* Possible new page. */
1897 if (filter
&& (lines_printed
>= lines_per_page
- 1))
1898 prompt_for_continue ();
1900 while (*lineptr
&& *lineptr
!= '\n')
1902 /* Print a single line. */
1903 if (*lineptr
== '\t')
1906 *wrap_pointer
++ = '\t';
1908 fputc_unfiltered ('\t', stream
);
1909 /* Shifting right by 3 produces the number of tab stops
1910 we have already passed, and then adding one and
1911 shifting left 3 advances to the next tab stop. */
1912 chars_printed
= ((chars_printed
>> 3) + 1) << 3;
1918 *wrap_pointer
++ = *lineptr
;
1920 fputc_unfiltered (*lineptr
, stream
);
1925 if (chars_printed
>= chars_per_line
)
1927 unsigned int save_chars
= chars_printed
;
1931 /* If we aren't actually wrapping, don't output newline --
1932 if chars_per_line is right, we probably just overflowed
1933 anyway; if it's wrong, let us keep going. */
1935 fputc_unfiltered ('\n', stream
);
1937 /* Possible new page. */
1938 if (lines_printed
>= lines_per_page
- 1)
1939 prompt_for_continue ();
1941 /* Now output indentation and wrapped string */
1944 fputs_unfiltered (wrap_indent
, stream
);
1945 *wrap_pointer
= '\0'; /* Null-terminate saved stuff */
1946 fputs_unfiltered (wrap_buffer
, stream
); /* and eject it */
1947 /* FIXME, this strlen is what prevents wrap_indent from
1948 containing tabs. However, if we recurse to print it
1949 and count its chars, we risk trouble if wrap_indent is
1950 longer than (the user settable) chars_per_line.
1951 Note also that this can set chars_printed > chars_per_line
1952 if we are printing a long string. */
1953 chars_printed
= strlen (wrap_indent
)
1954 + (save_chars
- wrap_column
);
1955 wrap_pointer
= wrap_buffer
; /* Reset buffer */
1956 wrap_buffer
[0] = '\0';
1957 wrap_column
= 0; /* And disable fancy wrap */
1962 if (*lineptr
== '\n')
1965 wrap_here ((char *) 0); /* Spit out chars, cancel further wraps */
1967 fputc_unfiltered ('\n', stream
);
1974 fputs_filtered (const char *linebuffer
, struct ui_file
*stream
)
1976 fputs_maybe_filtered (linebuffer
, stream
, 1);
1980 putchar_unfiltered (int c
)
1983 ui_file_write (gdb_stdout
, &buf
, 1);
1987 /* Write character C to gdb_stdout using GDB's paging mechanism and return C.
1988 May return nonlocally. */
1991 putchar_filtered (int c
)
1993 return fputc_filtered (c
, gdb_stdout
);
1997 fputc_unfiltered (int c
, struct ui_file
*stream
)
2000 ui_file_write (stream
, &buf
, 1);
2005 fputc_filtered (int c
, struct ui_file
*stream
)
2011 fputs_filtered (buf
, stream
);
2015 /* puts_debug is like fputs_unfiltered, except it prints special
2016 characters in printable fashion. */
2019 puts_debug (char *prefix
, char *string
, char *suffix
)
2023 /* Print prefix and suffix after each line. */
2024 static int new_line
= 1;
2025 static int return_p
= 0;
2026 static char *prev_prefix
= "";
2027 static char *prev_suffix
= "";
2029 if (*string
== '\n')
2032 /* If the prefix is changing, print the previous suffix, a new line,
2033 and the new prefix. */
2034 if ((return_p
|| (strcmp (prev_prefix
, prefix
) != 0)) && !new_line
)
2036 fputs_unfiltered (prev_suffix
, gdb_stdlog
);
2037 fputs_unfiltered ("\n", gdb_stdlog
);
2038 fputs_unfiltered (prefix
, gdb_stdlog
);
2041 /* Print prefix if we printed a newline during the previous call. */
2045 fputs_unfiltered (prefix
, gdb_stdlog
);
2048 prev_prefix
= prefix
;
2049 prev_suffix
= suffix
;
2051 /* Output characters in a printable format. */
2052 while ((ch
= *string
++) != '\0')
2058 fputc_unfiltered (ch
, gdb_stdlog
);
2061 fprintf_unfiltered (gdb_stdlog
, "\\x%02x", ch
& 0xff);
2065 fputs_unfiltered ("\\\\", gdb_stdlog
);
2068 fputs_unfiltered ("\\b", gdb_stdlog
);
2071 fputs_unfiltered ("\\f", gdb_stdlog
);
2075 fputs_unfiltered ("\\n", gdb_stdlog
);
2078 fputs_unfiltered ("\\r", gdb_stdlog
);
2081 fputs_unfiltered ("\\t", gdb_stdlog
);
2084 fputs_unfiltered ("\\v", gdb_stdlog
);
2088 return_p
= ch
== '\r';
2091 /* Print suffix if we printed a newline. */
2094 fputs_unfiltered (suffix
, gdb_stdlog
);
2095 fputs_unfiltered ("\n", gdb_stdlog
);
2100 /* Print a variable number of ARGS using format FORMAT. If this
2101 information is going to put the amount written (since the last call
2102 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
2103 call prompt_for_continue to get the users permision to continue.
2105 Unlike fprintf, this function does not return a value.
2107 We implement three variants, vfprintf (takes a vararg list and stream),
2108 fprintf (takes a stream to write on), and printf (the usual).
2110 Note also that a longjmp to top level may occur in this routine
2111 (since prompt_for_continue may do so) so this routine should not be
2112 called when cleanups are not in place. */
2115 vfprintf_maybe_filtered (struct ui_file
*stream
, const char *format
,
2116 va_list args
, int filter
)
2119 struct cleanup
*old_cleanups
;
2121 xvasprintf (&linebuffer
, format
, args
);
2122 old_cleanups
= make_cleanup (xfree
, linebuffer
);
2123 fputs_maybe_filtered (linebuffer
, stream
, filter
);
2124 do_cleanups (old_cleanups
);
2129 vfprintf_filtered (struct ui_file
*stream
, const char *format
, va_list args
)
2131 vfprintf_maybe_filtered (stream
, format
, args
, 1);
2135 vfprintf_unfiltered (struct ui_file
*stream
, const char *format
, va_list args
)
2138 struct cleanup
*old_cleanups
;
2140 xvasprintf (&linebuffer
, format
, args
);
2141 old_cleanups
= make_cleanup (xfree
, linebuffer
);
2142 fputs_unfiltered (linebuffer
, stream
);
2143 do_cleanups (old_cleanups
);
2147 vprintf_filtered (const char *format
, va_list args
)
2149 vfprintf_maybe_filtered (gdb_stdout
, format
, args
, 1);
2153 vprintf_unfiltered (const char *format
, va_list args
)
2155 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2159 fprintf_filtered (struct ui_file
*stream
, const char *format
, ...)
2162 va_start (args
, format
);
2163 vfprintf_filtered (stream
, format
, args
);
2168 fprintf_unfiltered (struct ui_file
*stream
, const char *format
, ...)
2171 va_start (args
, format
);
2172 vfprintf_unfiltered (stream
, format
, args
);
2176 /* Like fprintf_filtered, but prints its result indented.
2177 Called as fprintfi_filtered (spaces, stream, format, ...); */
2180 fprintfi_filtered (int spaces
, struct ui_file
*stream
, const char *format
,
2184 va_start (args
, format
);
2185 print_spaces_filtered (spaces
, stream
);
2187 vfprintf_filtered (stream
, format
, args
);
2193 printf_filtered (const char *format
, ...)
2196 va_start (args
, format
);
2197 vfprintf_filtered (gdb_stdout
, format
, args
);
2203 printf_unfiltered (const char *format
, ...)
2206 va_start (args
, format
);
2207 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2211 /* Like printf_filtered, but prints it's result indented.
2212 Called as printfi_filtered (spaces, format, ...); */
2215 printfi_filtered (int spaces
, const char *format
, ...)
2218 va_start (args
, format
);
2219 print_spaces_filtered (spaces
, gdb_stdout
);
2220 vfprintf_filtered (gdb_stdout
, format
, args
);
2224 /* Easy -- but watch out!
2226 This routine is *not* a replacement for puts()! puts() appends a newline.
2227 This one doesn't, and had better not! */
2230 puts_filtered (const char *string
)
2232 fputs_filtered (string
, gdb_stdout
);
2236 puts_unfiltered (const char *string
)
2238 fputs_unfiltered (string
, gdb_stdout
);
2241 /* Return a pointer to N spaces and a null. The pointer is good
2242 until the next call to here. */
2247 static char *spaces
= 0;
2248 static int max_spaces
= -1;
2254 spaces
= (char *) xmalloc (n
+ 1);
2255 for (t
= spaces
+ n
; t
!= spaces
;)
2261 return spaces
+ max_spaces
- n
;
2264 /* Print N spaces. */
2266 print_spaces_filtered (int n
, struct ui_file
*stream
)
2268 fputs_filtered (n_spaces (n
), stream
);
2271 /* C++/ObjC demangler stuff. */
2273 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2274 LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2275 If the name is not mangled, or the language for the name is unknown, or
2276 demangling is off, the name is printed in its "raw" form. */
2279 fprintf_symbol_filtered (struct ui_file
*stream
, char *name
,
2280 enum language lang
, int arg_mode
)
2286 /* If user wants to see raw output, no problem. */
2289 fputs_filtered (name
, stream
);
2293 demangled
= language_demangle (language_def (lang
), name
, arg_mode
);
2294 fputs_filtered (demangled
? demangled
: name
, stream
);
2295 if (demangled
!= NULL
)
2303 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
2304 differences in whitespace. Returns 0 if they match, non-zero if they
2305 don't (slightly different than strcmp()'s range of return values).
2307 As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
2308 This "feature" is useful when searching for matching C++ function names
2309 (such as if the user types 'break FOO', where FOO is a mangled C++
2313 strcmp_iw (const char *string1
, const char *string2
)
2315 while ((*string1
!= '\0') && (*string2
!= '\0'))
2317 while (isspace (*string1
))
2321 while (isspace (*string2
))
2325 if (*string1
!= *string2
)
2329 if (*string1
!= '\0')
2335 return (*string1
!= '\0' && *string1
!= '(') || (*string2
!= '\0');
2338 /* This is like strcmp except that it ignores whitespace and treats
2339 '(' as the first non-NULL character in terms of ordering. Like
2340 strcmp (and unlike strcmp_iw), it returns negative if STRING1 <
2341 STRING2, 0 if STRING2 = STRING2, and positive if STRING1 > STRING2
2342 according to that ordering.
2344 If a list is sorted according to this function and if you want to
2345 find names in the list that match some fixed NAME according to
2346 strcmp_iw(LIST_ELT, NAME), then the place to start looking is right
2347 where this function would put NAME.
2349 Here are some examples of why using strcmp to sort is a bad idea:
2353 Say your partial symtab contains: "foo<char *>", "goo". Then, if
2354 we try to do a search for "foo<char*>", strcmp will locate this
2355 after "foo<char *>" and before "goo". Then lookup_partial_symbol
2356 will start looking at strings beginning with "goo", and will never
2357 see the correct match of "foo<char *>".
2359 Parenthesis example:
2361 In practice, this is less like to be an issue, but I'll give it a
2362 shot. Let's assume that '$' is a legitimate character to occur in
2363 symbols. (Which may well even be the case on some systems.) Then
2364 say that the partial symbol table contains "foo$" and "foo(int)".
2365 strcmp will put them in this order, since '$' < '('. Now, if the
2366 user searches for "foo", then strcmp will sort "foo" before "foo$".
2367 Then lookup_partial_symbol will notice that strcmp_iw("foo$",
2368 "foo") is false, so it won't proceed to the actual match of
2369 "foo(int)" with "foo". */
2372 strcmp_iw_ordered (const char *string1
, const char *string2
)
2374 while ((*string1
!= '\0') && (*string2
!= '\0'))
2376 while (isspace (*string1
))
2380 while (isspace (*string2
))
2384 if (*string1
!= *string2
)
2388 if (*string1
!= '\0')
2397 /* Characters are non-equal unless they're both '\0'; we want to
2398 make sure we get the comparison right according to our
2399 comparison in the cases where one of them is '\0' or '('. */
2401 if (*string2
== '\0')
2406 if (*string2
== '\0')
2411 if (*string2
== '(')
2414 return *string1
- *string2
;
2418 /* A simple comparison function with opposite semantics to strcmp. */
2421 streq (const char *lhs
, const char *rhs
)
2423 return !strcmp (lhs
, rhs
);
2429 ** Answer whether string_to_compare is a full or partial match to
2430 ** template_string. The partial match must be in sequence starting
2434 subset_compare (char *string_to_compare
, char *template_string
)
2437 if (template_string
!= (char *) NULL
&& string_to_compare
!= (char *) NULL
2438 && strlen (string_to_compare
) <= strlen (template_string
))
2441 (template_string
, string_to_compare
, strlen (string_to_compare
)) == 0);
2448 static void pagination_on_command (char *arg
, int from_tty
);
2450 pagination_on_command (char *arg
, int from_tty
)
2452 pagination_enabled
= 1;
2455 static void pagination_on_command (char *arg
, int from_tty
);
2457 pagination_off_command (char *arg
, int from_tty
)
2459 pagination_enabled
= 0;
2464 initialize_utils (void)
2466 struct cmd_list_element
*c
;
2468 c
= add_set_cmd ("width", class_support
, var_uinteger
, &chars_per_line
,
2469 "Set number of characters gdb thinks are in a line.",
2471 add_show_from_set (c
, &showlist
);
2472 set_cmd_sfunc (c
, set_width_command
);
2474 c
= add_set_cmd ("height", class_support
, var_uinteger
, &lines_per_page
,
2475 "Set number of lines gdb thinks are in a page.", &setlist
);
2476 add_show_from_set (c
, &showlist
);
2477 set_cmd_sfunc (c
, set_height_command
);
2482 (add_set_cmd ("demangle", class_support
, var_boolean
,
2484 "Set demangling of encoded C++/ObjC names when displaying symbols.",
2485 &setprintlist
), &showprintlist
);
2488 (add_set_cmd ("pagination", class_support
,
2489 var_boolean
, (char *) &pagination_enabled
,
2490 "Set state of pagination.", &setlist
), &showlist
);
2494 add_com ("am", class_support
, pagination_on_command
,
2495 "Enable pagination");
2496 add_com ("sm", class_support
, pagination_off_command
,
2497 "Disable pagination");
2501 (add_set_cmd ("sevenbit-strings", class_support
, var_boolean
,
2502 (char *) &sevenbit_strings
,
2503 "Set printing of 8-bit characters in strings as \\nnn.",
2504 &setprintlist
), &showprintlist
);
2507 (add_set_cmd ("asm-demangle", class_support
, var_boolean
,
2508 (char *) &asm_demangle
,
2509 "Set demangling of C++/ObjC names in disassembly listings.",
2510 &setprintlist
), &showprintlist
);
2513 /* Machine specific function to handle SIGWINCH signal. */
2515 #ifdef SIGWINCH_HANDLER_BODY
2516 SIGWINCH_HANDLER_BODY
2518 /* print routines to handle variable size regs, etc. */
2519 /* temporary storage using circular buffer */
2525 static char buf
[NUMCELLS
][CELLSIZE
];
2526 static int cell
= 0;
2527 if (++cell
>= NUMCELLS
)
2535 return (TARGET_ADDR_BIT
/ 8 * 2);
2539 paddr (CORE_ADDR addr
)
2541 return phex (addr
, TARGET_ADDR_BIT
/ 8);
2545 paddr_nz (CORE_ADDR addr
)
2547 return phex_nz (addr
, TARGET_ADDR_BIT
/ 8);
2551 decimal2str (char *paddr_str
, char *sign
, ULONGEST addr
)
2553 /* steal code from valprint.c:print_decimal(). Should this worry
2554 about the real size of addr as the above does? */
2555 unsigned long temp
[3];
2559 temp
[i
] = addr
% (1000 * 1000 * 1000);
2560 addr
/= (1000 * 1000 * 1000);
2563 while (addr
!= 0 && i
< (sizeof (temp
) / sizeof (temp
[0])));
2567 sprintf (paddr_str
, "%s%lu", sign
, temp
[0]);
2570 sprintf (paddr_str
, "%s%lu%09lu", sign
, temp
[1], temp
[0]);
2573 sprintf (paddr_str
, "%s%lu%09lu%09lu", sign
, temp
[2], temp
[1], temp
[0]);
2576 internal_error (__FILE__
, __LINE__
,
2577 "failed internal consistency check");
2582 paddr_u (CORE_ADDR addr
)
2584 char *paddr_str
= get_cell ();
2585 decimal2str (paddr_str
, "", addr
);
2590 paddr_d (LONGEST addr
)
2592 char *paddr_str
= get_cell ();
2594 decimal2str (paddr_str
, "-", -addr
);
2596 decimal2str (paddr_str
, "", addr
);
2600 /* eliminate warning from compiler on 32-bit systems */
2601 static int thirty_two
= 32;
2604 phex (ULONGEST l
, int sizeof_l
)
2611 sprintf (str
, "%08lx%08lx",
2612 (unsigned long) (l
>> thirty_two
),
2613 (unsigned long) (l
& 0xffffffff));
2617 sprintf (str
, "%08lx", (unsigned long) l
);
2621 sprintf (str
, "%04x", (unsigned short) (l
& 0xffff));
2624 str
= phex (l
, sizeof (l
));
2631 phex_nz (ULONGEST l
, int sizeof_l
)
2638 unsigned long high
= (unsigned long) (l
>> thirty_two
);
2641 sprintf (str
, "%lx", (unsigned long) (l
& 0xffffffff));
2643 sprintf (str
, "%lx%08lx", high
, (unsigned long) (l
& 0xffffffff));
2648 sprintf (str
, "%lx", (unsigned long) l
);
2652 sprintf (str
, "%x", (unsigned short) (l
& 0xffff));
2655 str
= phex_nz (l
, sizeof (l
));
2662 /* Convert a CORE_ADDR into a string. */
2664 core_addr_to_string (const CORE_ADDR addr
)
2666 char *str
= get_cell ();
2668 strcat (str
, phex (addr
, sizeof (addr
)));
2673 core_addr_to_string_nz (const CORE_ADDR addr
)
2675 char *str
= get_cell ();
2677 strcat (str
, phex_nz (addr
, sizeof (addr
)));
2681 /* Convert a string back into a CORE_ADDR. */
2683 string_to_core_addr (const char *my_string
)
2686 if (my_string
[0] == '0' && tolower (my_string
[1]) == 'x')
2688 /* Assume that it is in decimal. */
2690 for (i
= 2; my_string
[i
] != '\0'; i
++)
2692 if (isdigit (my_string
[i
]))
2693 addr
= (my_string
[i
] - '0') + (addr
* 16);
2694 else if (isxdigit (my_string
[i
]))
2695 addr
= (tolower (my_string
[i
]) - 'a' + 0xa) + (addr
* 16);
2697 internal_error (__FILE__
, __LINE__
, "invalid hex");
2702 /* Assume that it is in decimal. */
2704 for (i
= 0; my_string
[i
] != '\0'; i
++)
2706 if (isdigit (my_string
[i
]))
2707 addr
= (my_string
[i
] - '0') + (addr
* 10);
2709 internal_error (__FILE__
, __LINE__
, "invalid decimal");
2716 gdb_realpath (const char *filename
)
2718 /* Method 1: The system has a compile time upper bound on a filename
2719 path. Use that and realpath() to canonicalize the name. This is
2720 the most common case. Note that, if there isn't a compile time
2721 upper bound, you want to avoid realpath() at all costs. */
2722 #if defined(HAVE_REALPATH)
2724 # if defined (PATH_MAX)
2726 # define USE_REALPATH
2727 # elif defined (MAXPATHLEN)
2728 char buf
[MAXPATHLEN
];
2729 # define USE_REALPATH
2731 # if defined (USE_REALPATH)
2732 const char *rp
= realpath (filename
, buf
);
2735 return xstrdup (rp
);
2738 #endif /* HAVE_REALPATH */
2740 /* Method 2: The host system (i.e., GNU) has the function
2741 canonicalize_file_name() which malloc's a chunk of memory and
2742 returns that, use that. */
2743 #if defined(HAVE_CANONICALIZE_FILE_NAME)
2745 char *rp
= canonicalize_file_name (filename
);
2747 return xstrdup (filename
);
2753 /* FIXME: cagney/2002-11-13:
2755 Method 2a: Use realpath() with a NULL buffer. Some systems, due
2756 to the problems described in in method 3, have modified their
2757 realpath() implementation so that it will allocate a buffer when
2758 NULL is passed in. Before this can be used, though, some sort of
2759 configure time test would need to be added. Otherwize the code
2760 will likely core dump. */
2762 /* Method 3: Now we're getting desperate! The system doesn't have a
2763 compile time buffer size and no alternative function. Query the
2764 OS, using pathconf(), for the buffer limit. Care is needed
2765 though, some systems do not limit PATH_MAX (return -1 for
2766 pathconf()) making it impossible to pass a correctly sized buffer
2767 to realpath() (it could always overflow). On those systems, we
2769 #if defined (HAVE_REALPATH) && defined (HAVE_UNISTD_H) && defined(HAVE_ALLOCA)
2771 /* Find out the max path size. */
2772 long path_max
= pathconf ("/", _PC_PATH_MAX
);
2775 /* PATH_MAX is bounded. */
2776 char *buf
= alloca (path_max
);
2777 char *rp
= realpath (filename
, buf
);
2778 return xstrdup (rp
? rp
: filename
);
2783 /* This system is a lost cause, just dup the buffer. */
2784 return xstrdup (filename
);
2787 /* Return a copy of FILENAME, with its directory prefix canonicalized
2791 xfullpath (const char *filename
)
2793 const char *base_name
= lbasename (filename
);
2798 /* Extract the basename of filename, and return immediately
2799 a copy of filename if it does not contain any directory prefix. */
2800 if (base_name
== filename
)
2801 return xstrdup (filename
);
2803 dir_name
= alloca ((size_t) (base_name
- filename
+ 2));
2804 /* Allocate enough space to store the dir_name + plus one extra
2805 character sometimes needed under Windows (see below), and
2806 then the closing \000 character */
2807 strncpy (dir_name
, filename
, base_name
- filename
);
2808 dir_name
[base_name
- filename
] = '\000';
2810 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2811 /* We need to be careful when filename is of the form 'd:foo', which
2812 is equivalent of d:./foo, which is totally different from d:/foo. */
2813 if (strlen (dir_name
) == 2 && isalpha (dir_name
[0]) && dir_name
[1] == ':')
2816 dir_name
[3] = '\000';
2820 /* Canonicalize the directory prefix, and build the resulting
2821 filename. If the dirname realpath already contains an ending
2822 directory separator, avoid doubling it. */
2823 real_path
= gdb_realpath (dir_name
);
2824 if (IS_DIR_SEPARATOR (real_path
[strlen (real_path
) - 1]))
2825 result
= concat (real_path
, base_name
, NULL
);
2827 result
= concat (real_path
, SLASH_STRING
, base_name
, NULL
);
2834 /* This is the 32-bit CRC function used by the GNU separate debug
2835 facility. An executable may contain a section named
2836 .gnu_debuglink, which holds the name of a separate executable file
2837 containing its debug info, and a checksum of that file's contents,
2838 computed using this function. */
2840 gnu_debuglink_crc32 (unsigned long crc
, unsigned char *buf
, size_t len
)
2842 static const unsigned long crc32_table
[256] = {
2843 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
2844 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
2845 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
2846 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
2847 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
2848 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
2849 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
2850 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
2851 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
2852 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
2853 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
2854 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
2855 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
2856 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
2857 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
2858 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
2859 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
2860 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
2861 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
2862 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
2863 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
2864 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
2865 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
2866 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
2867 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
2868 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
2869 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
2870 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
2871 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
2872 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
2873 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
2874 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
2875 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
2876 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
2877 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
2878 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
2879 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
2880 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
2881 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
2882 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
2883 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
2884 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
2885 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
2886 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
2887 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
2888 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
2889 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
2890 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
2891 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
2892 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
2893 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
2898 crc
= ~crc
& 0xffffffff;
2899 for (end
= buf
+ len
; buf
< end
; ++buf
)
2900 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
2901 return ~crc
& 0xffffffff;;
2905 align_up (ULONGEST v
, int n
)
2907 /* Check that N is really a power of two. */
2908 gdb_assert (n
&& (n
& (n
-1)) == 0);
2909 return (v
+ n
- 1) & -n
;
2913 align_down (ULONGEST v
, int n
)
2915 /* Check that N is really a power of two. */
2916 gdb_assert (n
&& (n
& (n
-1)) == 0);