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
6
Portions Copyright (C) 2001, 2002 Mission Critical Linux, Inc.
7
Copyright (c) 2002, 2003, 2004, 2005 Red Hat, Inc. All rights reserved.
9
This file is part of GDB.
11
This program is free software; you can redistribute it and/or modify
12
it under the terms of the GNU General Public License as published by
13
the Free Software Foundation; either version 2 of the License, or
14
(at your option) any later version.
16
This program is distributed in the hope that it will be useful,
17
but WITHOUT ANY WARRANTY; without even the implied warranty of
18
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19
GNU General Public License for more details.
21
You should have received a copy of the GNU General Public License
22
along with this program; if not, write to the Free Software
23
Foundation, Inc., 59 Temple Place - Suite 330,
24
Boston, MA 02111-1307, USA. */
27
#include "gdb_assert.h"
29
#include "gdb_string.h"
30
#include "event-top.h"
33
#include "tui/tui.h" /* For tui_get_command_dimension. */
40
/* SunOS's curses.h has a '#define reg register' in it. Thank you Sun. */
51
#include "expression.h"
55
#include "filenames.h"
57
#include "inferior.h" /* for signed_pointer_to_address */
59
#include <sys/param.h> /* For MAXPATHLEN */
68
#include "readline/readline.h"
70
#ifdef NEED_DECLARATION_MALLOC
71
extern PTR malloc (); /* OK: PTR */
73
#ifdef NEED_DECLARATION_REALLOC
74
extern PTR realloc (); /* OK: PTR */
76
#ifdef NEED_DECLARATION_FREE
79
/* Actually, we'll never have the decl, since we don't define _GNU_SOURCE. */
80
#if defined(HAVE_CANONICALIZE_FILE_NAME) \
81
&& defined(NEED_DECLARATION_CANONICALIZE_FILE_NAME)
82
extern char *canonicalize_file_name (const char *);
85
/* readline defines this. */
88
void (*error_begin_hook) (void);
90
/* Holds the last error message issued by gdb */
92
static struct ui_file *gdb_lasterr;
94
/* Prototypes for local functions */
96
static void vfprintf_maybe_filtered (struct ui_file *, const char *,
99
static void fputs_maybe_filtered (const char *, struct ui_file *, int);
101
static void do_my_cleanups (struct cleanup **, struct cleanup *);
103
static void prompt_for_continue (void);
105
static void set_screen_size (void);
106
static void set_width (void);
108
/* Chain of cleanup actions established with make_cleanup,
109
to be executed if an error happens. */
111
static struct cleanup *cleanup_chain; /* cleaned up after a failed command */
112
static struct cleanup *final_cleanup_chain; /* cleaned up when gdb exits */
113
static struct cleanup *run_cleanup_chain; /* cleaned up on each 'run' */
114
static struct cleanup *exec_cleanup_chain; /* cleaned up on each execution command */
115
/* cleaned up on each error from within an execution command */
116
static struct cleanup *exec_error_cleanup_chain;
118
/* Pointer to what is left to do for an execution command after the
119
target stops. Used only in asynchronous mode, by targets that
120
support async execution. The finish and until commands use it. So
121
does the target extended-remote command. */
122
struct continuation *cmd_continuation;
123
struct continuation *intermediate_continuation;
125
/* Nonzero if we have job control. */
129
/* Nonzero means a quit has been requested. */
133
/* Nonzero means quit immediately if Control-C is typed now, rather
134
than waiting until QUIT is executed. Be careful in setting this;
135
code which executes with immediate_quit set has to be very careful
136
about being able to deal with being interrupted at any time. It is
137
almost always better to use QUIT; the only exception I can think of
138
is being able to quit out of a system call (using EINTR loses if
139
the SIGINT happens between the previous QUIT and the system call).
140
To immediately quit in the case in which a SIGINT happens between
141
the previous QUIT and setting immediate_quit (desirable anytime we
142
expect to block), call QUIT after setting immediate_quit. */
146
/* Nonzero means that encoded C++/ObjC names should be printed out in their
147
C++/ObjC form rather than raw. */
151
/* Nonzero means that encoded C++/ObjC names should be printed out in their
152
C++/ObjC form even in assembler language displays. If this is set, but
153
DEMANGLE is zero, names are printed raw, i.e. DEMANGLE controls. */
155
int asm_demangle = 0;
157
/* Nonzero means that strings with character values >0x7F should be printed
158
as octal escapes. Zero means just print the value (e.g. it's an
159
international character, and the terminal or window can cope.) */
161
int sevenbit_strings = 0;
163
/* String to be printed before error messages, if any. */
165
char *error_pre_print;
167
/* String to be printed before quit messages, if any. */
169
char *quit_pre_print;
171
/* String to be printed before warning messages, if any. */
173
char *warning_pre_print = "\nwarning: ";
175
int pagination_enabled = 1;
178
/* Add a new cleanup to the cleanup_chain,
179
and return the previous chain pointer
180
to be passed later to do_cleanups or discard_cleanups.
181
Args are FUNCTION to clean up with, and ARG to pass to it. */
184
make_cleanup (make_cleanup_ftype *function, void *arg)
186
return make_my_cleanup (&cleanup_chain, function, arg);
190
make_final_cleanup (make_cleanup_ftype *function, void *arg)
192
return make_my_cleanup (&final_cleanup_chain, function, arg);
196
make_run_cleanup (make_cleanup_ftype *function, void *arg)
198
return make_my_cleanup (&run_cleanup_chain, function, arg);
202
make_exec_cleanup (make_cleanup_ftype *function, void *arg)
204
return make_my_cleanup (&exec_cleanup_chain, function, arg);
208
make_exec_error_cleanup (make_cleanup_ftype *function, void *arg)
210
return make_my_cleanup (&exec_error_cleanup_chain, function, arg);
214
do_freeargv (void *arg)
216
freeargv ((char **) arg);
220
make_cleanup_freeargv (char **arg)
222
return make_my_cleanup (&cleanup_chain, do_freeargv, arg);
226
do_bfd_close_cleanup (void *arg)
232
make_cleanup_bfd_close (bfd *abfd)
234
return make_cleanup (do_bfd_close_cleanup, abfd);
238
do_close_cleanup (void *arg)
246
make_cleanup_close (int fd)
248
int *saved_fd = xmalloc (sizeof (fd));
250
return make_cleanup (do_close_cleanup, saved_fd);
254
do_ui_file_delete (void *arg)
256
ui_file_delete (arg);
260
make_cleanup_ui_file_delete (struct ui_file *arg)
262
return make_my_cleanup (&cleanup_chain, do_ui_file_delete, arg);
266
make_my_cleanup (struct cleanup **pmy_chain, make_cleanup_ftype *function,
270
= (struct cleanup *) xmalloc (sizeof (struct cleanup));
271
struct cleanup *old_chain = *pmy_chain;
273
new->next = *pmy_chain;
274
new->function = function;
281
/* Discard cleanups and do the actions they describe
282
until we get back to the point OLD_CHAIN in the cleanup_chain. */
285
do_cleanups (struct cleanup *old_chain)
287
do_my_cleanups (&cleanup_chain, old_chain);
291
do_final_cleanups (struct cleanup *old_chain)
293
do_my_cleanups (&final_cleanup_chain, old_chain);
297
do_run_cleanups (struct cleanup *old_chain)
299
do_my_cleanups (&run_cleanup_chain, old_chain);
303
do_exec_cleanups (struct cleanup *old_chain)
305
do_my_cleanups (&exec_cleanup_chain, old_chain);
309
do_exec_error_cleanups (struct cleanup *old_chain)
311
do_my_cleanups (&exec_error_cleanup_chain, old_chain);
315
do_my_cleanups (struct cleanup **pmy_chain,
316
struct cleanup *old_chain)
319
while ((ptr = *pmy_chain) != old_chain)
321
*pmy_chain = ptr->next; /* Do this first incase recursion */
322
(*ptr->function) (ptr->arg);
327
/* Discard cleanups, not doing the actions they describe,
328
until we get back to the point OLD_CHAIN in the cleanup_chain. */
331
discard_cleanups (struct cleanup *old_chain)
333
discard_my_cleanups (&cleanup_chain, old_chain);
337
discard_final_cleanups (struct cleanup *old_chain)
339
discard_my_cleanups (&final_cleanup_chain, old_chain);
343
discard_exec_error_cleanups (struct cleanup *old_chain)
345
discard_my_cleanups (&exec_error_cleanup_chain, old_chain);
349
discard_my_cleanups (struct cleanup **pmy_chain,
350
struct cleanup *old_chain)
353
while ((ptr = *pmy_chain) != old_chain)
355
*pmy_chain = ptr->next;
360
/* Set the cleanup_chain to 0, and return the old cleanup chain. */
364
return save_my_cleanups (&cleanup_chain);
368
save_final_cleanups (void)
370
return save_my_cleanups (&final_cleanup_chain);
374
save_my_cleanups (struct cleanup **pmy_chain)
376
struct cleanup *old_chain = *pmy_chain;
382
/* Restore the cleanup chain from a previously saved chain. */
384
restore_cleanups (struct cleanup *chain)
386
restore_my_cleanups (&cleanup_chain, chain);
390
restore_final_cleanups (struct cleanup *chain)
392
restore_my_cleanups (&final_cleanup_chain, chain);
396
restore_my_cleanups (struct cleanup **pmy_chain, struct cleanup *chain)
401
/* This function is useful for cleanups.
405
old_chain = make_cleanup (free_current_contents, &foo);
407
to arrange to free the object thus allocated. */
410
free_current_contents (void *ptr)
412
void **location = ptr;
413
if (location == NULL)
414
internal_error (__FILE__, __LINE__,
415
"free_current_contents: NULL pointer");
416
if (*location != NULL)
423
/* Provide a known function that does nothing, to use as a base for
424
for a possibly long chain of cleanups. This is useful where we
425
use the cleanup chain for handling normal cleanups as well as dealing
426
with cleanups that need to be done as a result of a call to error().
427
In such cases, we may not be certain where the first cleanup is, unless
428
we have a do-nothing one to always use as the base. */
431
null_cleanup (void *arg)
435
/* Add a continuation to the continuation list, the global list
436
cmd_continuation. The new continuation will be added at the front.*/
438
add_continuation (void (*continuation_hook) (struct continuation_arg *),
439
struct continuation_arg *arg_list)
441
struct continuation *continuation_ptr;
444
(struct continuation *) xmalloc (sizeof (struct continuation));
445
continuation_ptr->continuation_hook = continuation_hook;
446
continuation_ptr->arg_list = arg_list;
447
continuation_ptr->next = cmd_continuation;
448
cmd_continuation = continuation_ptr;
451
/* Walk down the cmd_continuation list, and execute all the
452
continuations. There is a problem though. In some cases new
453
continuations may be added while we are in the middle of this
454
loop. If this happens they will be added in the front, and done
455
before we have a chance of exhausting those that were already
456
there. We need to then save the beginning of the list in a pointer
457
and do the continuations from there on, instead of using the
458
global beginning of list as our iteration pointer.*/
460
do_all_continuations (void)
462
struct continuation *continuation_ptr;
463
struct continuation *saved_continuation;
465
/* Copy the list header into another pointer, and set the global
466
list header to null, so that the global list can change as a side
467
effect of invoking the continuations and the processing of
468
the preexisting continuations will not be affected. */
469
continuation_ptr = cmd_continuation;
470
cmd_continuation = NULL;
472
/* Work now on the list we have set aside. */
473
while (continuation_ptr)
475
(continuation_ptr->continuation_hook) (continuation_ptr->arg_list);
476
saved_continuation = continuation_ptr;
477
continuation_ptr = continuation_ptr->next;
478
xfree (saved_continuation);
482
/* Walk down the cmd_continuation list, and get rid of all the
485
discard_all_continuations (void)
487
struct continuation *continuation_ptr;
489
while (cmd_continuation)
491
continuation_ptr = cmd_continuation;
492
cmd_continuation = continuation_ptr->next;
493
xfree (continuation_ptr);
497
/* Add a continuation to the continuation list, the global list
498
intermediate_continuation. The new continuation will be added at the front.*/
500
add_intermediate_continuation (void (*continuation_hook)
501
(struct continuation_arg *),
502
struct continuation_arg *arg_list)
504
struct continuation *continuation_ptr;
507
(struct continuation *) xmalloc (sizeof (struct continuation));
508
continuation_ptr->continuation_hook = continuation_hook;
509
continuation_ptr->arg_list = arg_list;
510
continuation_ptr->next = intermediate_continuation;
511
intermediate_continuation = continuation_ptr;
514
/* Walk down the cmd_continuation list, and execute all the
515
continuations. There is a problem though. In some cases new
516
continuations may be added while we are in the middle of this
517
loop. If this happens they will be added in the front, and done
518
before we have a chance of exhausting those that were already
519
there. We need to then save the beginning of the list in a pointer
520
and do the continuations from there on, instead of using the
521
global beginning of list as our iteration pointer.*/
523
do_all_intermediate_continuations (void)
525
struct continuation *continuation_ptr;
526
struct continuation *saved_continuation;
528
/* Copy the list header into another pointer, and set the global
529
list header to null, so that the global list can change as a side
530
effect of invoking the continuations and the processing of
531
the preexisting continuations will not be affected. */
532
continuation_ptr = intermediate_continuation;
533
intermediate_continuation = NULL;
535
/* Work now on the list we have set aside. */
536
while (continuation_ptr)
538
(continuation_ptr->continuation_hook) (continuation_ptr->arg_list);
539
saved_continuation = continuation_ptr;
540
continuation_ptr = continuation_ptr->next;
541
xfree (saved_continuation);
545
/* Walk down the cmd_continuation list, and get rid of all the
548
discard_all_intermediate_continuations (void)
550
struct continuation *continuation_ptr;
552
while (intermediate_continuation)
554
continuation_ptr = intermediate_continuation;
555
intermediate_continuation = continuation_ptr->next;
556
xfree (continuation_ptr);
562
/* Print a warning message. The first argument STRING is the warning
563
message, used as an fprintf format string, the second is the
564
va_list of arguments for that string. A warning is unfiltered (not
565
paginated) so that the user does not need to page through each
566
screen full of warnings when there are lots of them. */
569
vwarning (const char *string, va_list args)
572
(*warning_hook) (string, args);
575
target_terminal_ours ();
576
wrap_here (""); /* Force out any buffered output */
577
gdb_flush (gdb_stdout);
578
if (warning_pre_print)
579
fputs_unfiltered (warning_pre_print, gdb_stderr);
580
vfprintf_unfiltered (gdb_stderr, string, args);
581
fprintf_unfiltered (gdb_stderr, "\n");
586
/* Print a warning message.
587
The first argument STRING is the warning message, used as a fprintf string,
588
and the remaining args are passed as arguments to it.
589
The primary difference between warnings and errors is that a warning
590
does not force the return to command level. */
593
warning (const char *string, ...)
596
va_start (args, string);
597
vwarning (string, args);
601
/* Print an error message and return to command level.
602
The first argument STRING is the error message, used as a fprintf string,
603
and the remaining args are passed as arguments to it. */
606
verror (const char *string, va_list args)
608
struct ui_file *tmp_stream = mem_fileopen ();
609
make_cleanup_ui_file_delete (tmp_stream);
610
vfprintf_unfiltered (tmp_stream, string, args);
611
error_stream (tmp_stream);
615
error (const char *string, ...)
618
va_start (args, string);
619
verror (string, args);
624
do_write (void *data, const char *buffer, long length_buffer)
626
ui_file_write (data, buffer, length_buffer);
629
/* Cause a silent error to occur. Any error message is recorded
630
though it is not issued. */
632
error_silent (const char *string, ...)
635
struct ui_file *tmp_stream = mem_fileopen ();
636
va_start (args, string);
637
make_cleanup_ui_file_delete (tmp_stream);
638
vfprintf_unfiltered (tmp_stream, string, args);
639
/* Copy the stream into the GDB_LASTERR buffer. */
640
ui_file_rewind (gdb_lasterr);
641
ui_file_put (tmp_stream, do_write, gdb_lasterr);
644
throw_exception (RETURN_ERROR);
647
/* Output an error message including any pre-print text to gdb_stderr. */
649
error_output_message (char *pre_print, char *msg)
651
target_terminal_ours ();
652
wrap_here (""); /* Force out any buffered output */
653
gdb_flush (gdb_stdout);
654
annotate_error_begin ();
656
fputs_filtered (pre_print, gdb_stderr);
657
fputs_filtered (msg, gdb_stderr);
658
fprintf_filtered (gdb_stderr, "\n");
662
error_stream (struct ui_file *stream)
664
if (error_begin_hook)
667
/* Copy the stream into the GDB_LASTERR buffer. */
668
ui_file_rewind (gdb_lasterr);
669
ui_file_put (stream, do_write, gdb_lasterr);
671
/* Write the message plus any error_pre_print to gdb_stderr. */
672
target_terminal_ours ();
673
wrap_here (""); /* Force out any buffered output */
674
gdb_flush (gdb_stdout);
675
annotate_error_begin ();
677
fputs_filtered (error_pre_print, gdb_stderr);
678
ui_file_put (stream, do_write, gdb_stderr);
679
fprintf_filtered (gdb_stderr, "\n");
684
int console(char *, ...);
685
console("verror() called without error_hook\n");
688
throw_exception (RETURN_ERROR);
691
/* Get the last error message issued by gdb */
694
error_last_message (void)
697
return ui_file_xstrdup (gdb_lasterr, &len);
700
/* This is to be called by main() at the very beginning */
705
gdb_lasterr = mem_fileopen ();
708
/* Print a message reporting an internal error/warning. Ask the user
709
if they want to continue, dump core, or just exit. Return
710
something to indicate a quit. */
712
struct internal_problem
715
/* FIXME: cagney/2002-08-15: There should be ``maint set/show''
716
commands available for controlling these variables. */
717
enum auto_boolean should_quit;
718
enum auto_boolean should_dump_core;
721
/* Report a problem, internal to GDB, to the user. Once the problem
722
has been reported, and assuming GDB didn't quit, the caller can
723
either allow execution to resume or throw an error. */
726
internal_vproblem (struct internal_problem *problem,
727
const char *file, int line, const char *fmt, va_list ap)
734
/* Don't allow infinite error/warning recursion. */
736
static char msg[] = "Recursive internal problem.\n";
744
fputs_unfiltered (msg, gdb_stderr);
745
abort (); /* NOTE: GDB has only three calls to abort(). */
748
write (STDERR_FILENO, msg, sizeof (msg));
753
/* Try to get the message out and at the start of a new line. */
754
target_terminal_ours ();
757
/* Create a string containing the full error/warning message. Need
758
to call query with this full string, as otherwize the reason
759
(error/warning) and question become separated. Format using a
760
style similar to a compiler error message. Include extra detail
761
so that the user knows that they are living on the edge. */
764
xvasprintf (&msg, fmt, ap);
765
xasprintf (&reason, "\
767
A problem internal to GDB has been detected,\n\
768
further debugging may prove unreliable.", file, line, problem->name, msg);
770
make_cleanup (xfree, reason);
773
switch (problem->should_quit)
775
case AUTO_BOOLEAN_AUTO:
776
/* Default (yes/batch case) is to quit GDB. When in batch mode
777
this lessens the likelhood of GDB going into an infinate
779
quit_p = query ("%s\nQuit this debugging session? ", reason);
781
case AUTO_BOOLEAN_TRUE:
784
case AUTO_BOOLEAN_FALSE:
788
internal_error (__FILE__, __LINE__, "bad switch");
791
switch (problem->should_dump_core)
793
case AUTO_BOOLEAN_AUTO:
794
/* Default (yes/batch case) is to dump core. This leaves a GDB
795
`dropping' so that it is easier to see that something went
797
dump_core_p = query ("%s\nCreate a core file of GDB? ", reason);
800
case AUTO_BOOLEAN_TRUE:
803
case AUTO_BOOLEAN_FALSE:
807
internal_error (__FILE__, __LINE__, "bad switch");
813
abort (); /* NOTE: GDB has only three calls to abort(). */
822
abort (); /* NOTE: GDB has only three calls to abort(). */
829
static struct internal_problem internal_error_problem = {
830
"internal-error", AUTO_BOOLEAN_AUTO, AUTO_BOOLEAN_AUTO
834
internal_verror (const char *file, int line, const char *fmt, va_list ap)
836
internal_vproblem (&internal_error_problem, file, line, fmt, ap);
837
throw_exception (RETURN_ERROR);
841
internal_error (const char *file, int line, const char *string, ...)
844
va_start (ap, string);
845
internal_verror (file, line, string, ap);
849
static struct internal_problem internal_warning_problem = {
850
"internal-error", AUTO_BOOLEAN_AUTO, AUTO_BOOLEAN_AUTO
854
internal_vwarning (const char *file, int line, const char *fmt, va_list ap)
856
internal_vproblem (&internal_warning_problem, file, line, fmt, ap);
860
internal_warning (const char *file, int line, const char *string, ...)
863
va_start (ap, string);
864
internal_vwarning (file, line, string, ap);
868
/* The strerror() function can return NULL for errno values that are
869
out of range. Provide a "safe" version that always returns a
873
safe_strerror (int errnum)
878
msg = strerror (errnum);
881
sprintf (buf, "(undocumented errno %d)", errnum);
887
/* Print the system error message for errno, and also mention STRING
888
as the file name for which the error was encountered.
889
Then return to command level. */
892
perror_with_name (const char *string)
897
err = safe_strerror (errno);
898
combined = (char *) alloca (strlen (err) + strlen (string) + 3);
899
strcpy (combined, string);
900
strcat (combined, ": ");
901
strcat (combined, err);
903
/* I understand setting these is a matter of taste. Still, some people
904
may clear errno but not know about bfd_error. Doing this here is not
906
bfd_set_error (bfd_error_no_error);
909
error ("%s.", combined);
912
/* Print the system error message for ERRCODE, and also mention STRING
913
as the file name for which the error was encountered. */
916
print_sys_errmsg (const char *string, int errcode)
921
err = safe_strerror (errcode);
922
combined = (char *) alloca (strlen (err) + strlen (string) + 3);
923
strcpy (combined, string);
924
strcat (combined, ": ");
925
strcat (combined, err);
927
/* We want anything which was printed on stdout to come out first, before
929
gdb_flush (gdb_stdout);
930
fprintf_unfiltered (gdb_stderr, "%s.\n", combined);
933
/* Control C eventually causes this to be called, at a convenient time. */
938
struct serial *gdb_stdout_serial = serial_fdopen (1);
940
target_terminal_ours ();
942
/* We want all output to appear now, before we print "Quit". We
943
have 3 levels of buffering we have to flush (it's possible that
944
some of these should be changed to flush the lower-level ones
947
/* 1. The _filtered buffer. */
948
wrap_here ((char *) 0);
950
/* 2. The stdio buffer. */
951
gdb_flush (gdb_stdout);
952
gdb_flush (gdb_stderr);
954
/* 3. The system-level buffer. */
955
serial_drain_output (gdb_stdout_serial);
956
serial_un_fdopen (gdb_stdout_serial);
958
annotate_error_begin ();
960
/* Don't use *_filtered; we don't want to prompt the user to continue. */
962
fputs_unfiltered (quit_pre_print, gdb_stderr);
965
/* No steenking SIGINT will ever be coming our way when the
966
program is resumed. Don't lie. */
967
fprintf_unfiltered (gdb_stderr, "Quit\n");
970
/* If there is no terminal switching for this target, then we can't
971
possibly get screwed by the lack of job control. */
972
|| current_target.to_terminal_ours == NULL)
973
fprintf_unfiltered (gdb_stderr, "Quit\n");
975
fprintf_unfiltered (gdb_stderr,
976
"Quit (expect signal SIGINT when the program is resumed)\n");
978
throw_exception (RETURN_QUIT);
981
/* Control C comes here */
983
request_quit (int signo)
986
/* Restore the signal handler. Harmless with BSD-style signals, needed
987
for System V-style signals. So just always do it, rather than worrying
988
about USG defines and stuff like that. */
989
signal (signo, request_quit);
995
/* Memory management stuff (malloc friends). */
998
mmalloc (void *md, size_t size)
1000
return malloc (size); /* NOTE: GDB's only call to malloc() */
1004
mrealloc (void *md, void *ptr, size_t size)
1006
if (ptr == 0) /* Guard against old realloc's */
1007
return mmalloc (md, size);
1009
return realloc (ptr, size); /* NOTE: GDB's only call to ralloc() */
1013
mcalloc (void *md, size_t number, size_t size)
1015
return calloc (number, size); /* NOTE: GDB's only call to calloc() */
1019
mfree (void *md, void *ptr)
1021
free (ptr); /* NOTE: GDB's only call to free() */
1024
/* This used to do something interesting with USE_MMALLOC.
1025
* It can be retired any time. -- chastain 2004-01-19. */
1027
init_malloc (void *md)
1031
/* Called when a memory allocation fails, with the number of bytes of
1032
memory requested in SIZE. */
1039
internal_error (__FILE__, __LINE__,
1040
"virtual memory exhausted: can't allocate %ld bytes.",
1045
internal_error (__FILE__, __LINE__, "virtual memory exhausted.");
1049
/* The xmmalloc() family of memory management routines.
1051
These are are like the mmalloc() family except that they implement
1052
consistent semantics and guard against typical memory management
1053
problems: if a malloc fails, an internal error is thrown; if
1054
free(NULL) is called, it is ignored; if *alloc(0) is called, NULL
1057
All these routines are implemented using the mmalloc() family. */
1060
xmmalloc (void *md, size_t size)
1064
/* See libiberty/xmalloc.c. This function need's to match that's
1065
semantics. It never returns NULL. */
1069
val = mmalloc (md, size);
1077
xmrealloc (void *md, void *ptr, size_t size)
1081
/* See libiberty/xmalloc.c. This function need's to match that's
1082
semantics. It never returns NULL. */
1087
val = mrealloc (md, ptr, size);
1089
val = mmalloc (md, size);
1097
xmcalloc (void *md, size_t number, size_t size)
1101
/* See libiberty/xmalloc.c. This function need's to match that's
1102
semantics. It never returns NULL. */
1103
if (number == 0 || size == 0)
1109
mem = mcalloc (md, number, size);
1111
nomem (number * size);
1117
xmfree (void *md, void *ptr)
1123
/* The xmalloc() (libiberty.h) family of memory management routines.
1125
These are like the ISO-C malloc() family except that they implement
1126
consistent semantics and guard against typical memory management
1127
problems. See xmmalloc() above for further information.
1129
All these routines are wrappers to the xmmalloc() family. */
1131
/* NOTE: These are declared using PTR to ensure consistency with
1132
"libiberty.h". xfree() is GDB local. */
1135
xmalloc (size_t size)
1137
return xmmalloc (NULL, size);
1141
xrealloc (PTR ptr, size_t size) /* OK: PTR */
1143
return xmrealloc (NULL, ptr, size);
1147
xcalloc (size_t number, size_t size)
1149
return xmcalloc (NULL, number, size);
1159
/* Like asprintf/vasprintf but get an internal_error if the call
1163
xstrprintf (const char *format, ...)
1167
va_start (args, format);
1168
xvasprintf (&ret, format, args);
1174
xasprintf (char **ret, const char *format, ...)
1177
va_start (args, format);
1178
xvasprintf (ret, format, args);
1183
xvasprintf (char **ret, const char *format, va_list ap)
1185
int status = vasprintf (ret, format, ap);
1186
/* NULL could be returned due to a memory allocation problem; a
1187
badly format string; or something else. */
1189
internal_error (__FILE__, __LINE__,
1190
"vasprintf returned NULL buffer (errno %d)", errno);
1191
/* A negative status with a non-NULL buffer shouldn't never
1192
happen. But to be sure. */
1194
internal_error (__FILE__, __LINE__,
1195
"vasprintf call failed (errno %d)", errno);
1199
/* My replacement for the read system call.
1200
Used like `read' but keeps going if `read' returns too soon. */
1203
myread (int desc, char *addr, int len)
1210
val = read (desc, addr, len);
1214
return orglen - len;
1221
/* Make a copy of the string at PTR with SIZE characters
1222
(and add a null character at the end in the copy).
1223
Uses malloc to get the space. Returns the address of the copy. */
1226
savestring (const char *ptr, size_t size)
1228
char *p = (char *) xmalloc (size + 1);
1229
memcpy (p, ptr, size);
1235
msavestring (void *md, const char *ptr, size_t size)
1237
char *p = (char *) xmmalloc (md, size + 1);
1238
memcpy (p, ptr, size);
1244
mstrsave (void *md, const char *ptr)
1246
return (msavestring (md, ptr, strlen (ptr)));
1250
print_spaces (int n, struct ui_file *file)
1252
fputs_unfiltered (n_spaces (n), file);
1255
/* Print a host address. */
1258
gdb_print_host_address (const void *addr, struct ui_file *stream)
1261
/* We could use the %p conversion specifier to fprintf if we had any
1262
way of knowing whether this host supports it. But the following
1263
should work on the Alpha and on 32 bit machines. */
1265
fprintf_filtered (stream, "0x%lx", (unsigned long) addr);
1268
/* Ask user a y-or-n question and return 1 iff answer is yes.
1269
Takes three args which are given to printf to print the question.
1270
The first, a control string, should end in "? ".
1271
It should not say how to answer, because we do that. */
1275
query (const char *ctlstr, ...)
1282
va_start (args, ctlstr);
1286
return query_hook (ctlstr, args);
1289
/* Automatically answer "yes" if input is not from a terminal. */
1290
if (!input_from_terminal_p ())
1295
wrap_here (""); /* Flush any buffered output */
1296
gdb_flush (gdb_stdout);
1298
if (annotation_level > 1)
1299
printf_filtered ("\n\032\032pre-query\n");
1301
vfprintf_filtered (gdb_stdout, ctlstr, args);
1302
printf_filtered ("(y or n) ");
1304
if (annotation_level > 1)
1305
printf_filtered ("\n\032\032query\n");
1308
gdb_flush (gdb_stdout);
1310
answer = fgetc (stdin);
1311
clearerr (stdin); /* in case of C-d */
1312
if (answer == EOF) /* C-d */
1317
/* Eat rest of input line, to EOF or newline */
1321
ans2 = fgetc (stdin);
1324
while (ans2 != EOF && ans2 != '\n' && ans2 != '\r');
1338
printf_filtered ("Please answer y or n.\n");
1341
if (annotation_level > 1)
1342
printf_filtered ("\n\032\032post-query\n");
1347
/* This function supports the nquery() and yquery() functions.
1348
Ask user a y-or-n question and return 0 if answer is no, 1 if
1349
answer is yes, or default the answer to the specified default.
1350
DEFCHAR is either 'y' or 'n' and refers to the default answer.
1351
CTLSTR is the control string and should end in "? ". It should
1352
not say how to answer, because we do that.
1353
ARGS are the arguments passed along with the CTLSTR argument to
1357
defaulted_query (const char *ctlstr, const char defchar, va_list args)
1363
char def_answer, not_def_answer;
1364
char *y_string, *n_string;
1366
/* Set up according to which answer is the default. */
1371
not_def_answer = 'N';
1379
not_def_answer = 'Y';
1386
return query_hook (ctlstr, args);
1389
/* Automatically answer default value if input is not from a terminal. */
1390
if (!input_from_terminal_p ())
1395
wrap_here (""); /* Flush any buffered output */
1396
gdb_flush (gdb_stdout);
1398
if (annotation_level > 1)
1399
printf_filtered ("\n\032\032pre-%cquery\n", defchar);
1401
vfprintf_filtered (gdb_stdout, ctlstr, args);
1402
printf_filtered ("(%s or %s) ", y_string, n_string);
1404
if (annotation_level > 1)
1405
printf_filtered ("\n\032\032%cquery\n", defchar);
1408
gdb_flush (gdb_stdout);
1410
answer = fgetc (stdin);
1411
clearerr (stdin); /* in case of C-d */
1412
if (answer == EOF) /* C-d */
1417
/* Eat rest of input line, to EOF or newline */
1421
ans2 = fgetc (stdin);
1424
while (ans2 != EOF && ans2 != '\n' && ans2 != '\r');
1428
/* Check answer. For the non-default, the user must specify
1429
the non-default explicitly. */
1430
if (answer == not_def_answer)
1432
retval = !def_value;
1435
/* Otherwise, for the default, the user may either specify
1436
the required input or have it default by entering nothing. */
1437
if (answer == def_answer || answer == '\n' ||
1438
answer == '\r' || answer == EOF)
1443
/* Invalid entries are not defaulted and require another selection. */
1444
printf_filtered ("Please answer %s or %s.\n",
1445
y_string, n_string);
1448
if (annotation_level > 1)
1449
printf_filtered ("\n\032\032post-%cquery\n", defchar);
1454
/* Ask user a y-or-n question and return 0 if answer is no, 1 if
1455
answer is yes, or 0 if answer is defaulted.
1456
Takes three args which are given to printf to print the question.
1457
The first, a control string, should end in "? ".
1458
It should not say how to answer, because we do that. */
1461
nquery (const char *ctlstr, ...)
1465
va_start (args, ctlstr);
1466
return defaulted_query (ctlstr, 'n', args);
1470
/* Ask user a y-or-n question and return 0 if answer is no, 1 if
1471
answer is yes, or 1 if answer is defaulted.
1472
Takes three args which are given to printf to print the question.
1473
The first, a control string, should end in "? ".
1474
It should not say how to answer, because we do that. */
1477
yquery (const char *ctlstr, ...)
1481
va_start (args, ctlstr);
1482
return defaulted_query (ctlstr, 'y', args);
1486
/* Print an error message saying that we couldn't make sense of a
1487
\^mumble sequence in a string or character constant. START and END
1488
indicate a substring of some larger string that contains the
1489
erroneous backslash sequence, missing the initial backslash. */
1491
no_control_char_error (const char *start, const char *end)
1493
int len = end - start;
1494
char *copy = alloca (end - start + 1);
1496
memcpy (copy, start, len);
1499
error ("There is no control character `\\%s' in the `%s' character set.",
1500
copy, target_charset ());
1503
/* Parse a C escape sequence. STRING_PTR points to a variable
1504
containing a pointer to the string to parse. That pointer
1505
should point to the character after the \. That pointer
1506
is updated past the characters we use. The value of the
1507
escape sequence is returned.
1509
A negative value means the sequence \ newline was seen,
1510
which is supposed to be equivalent to nothing at all.
1512
If \ is followed by a null character, we return a negative
1513
value and leave the string pointer pointing at the null character.
1515
If \ is followed by 000, we return 0 and leave the string pointer
1516
after the zeros. A value of 0 does not mean end of string. */
1519
parse_escape (char **string_ptr)
1522
int c = *(*string_ptr)++;
1523
if (c_parse_backslash (c, &target_char))
1535
/* Remember where this escape sequence started, for reporting
1537
char *sequence_start_pos = *string_ptr - 1;
1539
c = *(*string_ptr)++;
1543
/* XXXCHARSET: What is `delete' in the host character set? */
1546
if (!host_char_to_target (c, &target_char))
1547
error ("There is no character corresponding to `Delete' "
1548
"in the target character set `%s'.", host_charset ());
1553
target_char = parse_escape (string_ptr);
1556
if (!host_char_to_target (c, &target_char))
1557
no_control_char_error (sequence_start_pos, *string_ptr);
1560
/* Now target_char is something like `c', and we want to find
1561
its control-character equivalent. */
1562
if (!target_char_to_control_char (target_char, &target_char))
1563
no_control_char_error (sequence_start_pos, *string_ptr);
1568
/* XXXCHARSET: we need to use isdigit and value-of-digit
1569
methods of the host character set here. */
1585
if (c >= '0' && c <= '7')
1599
if (!host_char_to_target (c, &target_char))
1601
("The escape sequence `\%c' is equivalent to plain `%c', which"
1602
" has no equivalent\n" "in the `%s' character set.", c, c,
1608
/* Print the character C on STREAM as part of the contents of a literal
1609
string whose delimiter is QUOTER. Note that this routine should only
1610
be call for printing things which are independent of the language
1611
of the program being debugged. */
1614
printchar (int c, void (*do_fputs) (const char *, struct ui_file *),
1615
void (*do_fprintf) (struct ui_file *, const char *, ...),
1616
struct ui_file *stream, int quoter)
1619
c &= 0xFF; /* Avoid sign bit follies */
1621
if (c < 0x20 || /* Low control chars */
1622
(c >= 0x7F && c < 0xA0) || /* DEL, High controls */
1623
(sevenbit_strings && c >= 0x80))
1624
{ /* high order bit set */
1628
do_fputs ("\\n", stream);
1631
do_fputs ("\\b", stream);
1634
do_fputs ("\\t", stream);
1637
do_fputs ("\\f", stream);
1640
do_fputs ("\\r", stream);
1643
do_fputs ("\\e", stream);
1646
do_fputs ("\\a", stream);
1649
do_fprintf (stream, "\\%.3o", (unsigned int) c);
1655
if (c == '\\' || c == quoter)
1656
do_fputs ("\\", stream);
1657
do_fprintf (stream, "%c", c);
1661
/* Print the character C on STREAM as part of the contents of a
1662
literal string whose delimiter is QUOTER. Note that these routines
1663
should only be call for printing things which are independent of
1664
the language of the program being debugged. */
1667
fputstr_filtered (const char *str, int quoter, struct ui_file *stream)
1670
printchar (*str++, fputs_filtered, fprintf_filtered, stream, quoter);
1674
fputstr_unfiltered (const char *str, int quoter, struct ui_file *stream)
1677
printchar (*str++, fputs_unfiltered, fprintf_unfiltered, stream, quoter);
1681
fputstrn_unfiltered (const char *str, int n, int quoter,
1682
struct ui_file *stream)
1685
for (i = 0; i < n; i++)
1686
printchar (str[i], fputs_unfiltered, fprintf_unfiltered, stream, quoter);
1690
/* Number of lines per page or UINT_MAX if paging is disabled. */
1691
static unsigned int lines_per_page;
1693
/* Number of chars per line or UINT_MAX if line folding is disabled. */
1694
static unsigned int chars_per_line;
1696
/* Current count of lines printed on this page, chars on this line. */
1697
static unsigned int lines_printed, chars_printed;
1699
/* Buffer and start column of buffered text, for doing smarter word-
1700
wrapping. When someone calls wrap_here(), we start buffering output
1701
that comes through fputs_filtered(). If we see a newline, we just
1702
spit it out and forget about the wrap_here(). If we see another
1703
wrap_here(), we spit it out and remember the newer one. If we see
1704
the end of the line, we spit out a newline, the indent, and then
1705
the buffered output. */
1707
/* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
1708
are waiting to be output (they have already been counted in chars_printed).
1709
When wrap_buffer[0] is null, the buffer is empty. */
1710
static char *wrap_buffer;
1712
/* Pointer in wrap_buffer to the next character to fill. */
1713
static char *wrap_pointer;
1715
/* String to indent by if the wrap occurs. Must not be NULL if wrap_column
1717
static char *wrap_indent;
1719
/* Column number on the screen where wrap_buffer begins, or 0 if wrapping
1720
is not in effect. */
1721
static int wrap_column;
1724
/* Inialize the number of lines per page and chars per line. */
1727
init_page_info (void)
1730
if (!tui_get_command_dimension (&chars_per_line, &lines_per_page))
1735
#if defined(__GO32__)
1736
rows = ScreenRows ();
1737
cols = ScreenCols ();
1738
lines_per_page = rows;
1739
chars_per_line = cols;
1741
/* Make sure Readline has initialized its terminal settings. */
1742
rl_reset_terminal (NULL);
1744
/* Get the screen size from Readline. */
1745
rl_get_screen_size (&rows, &cols);
1746
lines_per_page = rows;
1747
chars_per_line = cols;
1749
/* Readline should have fetched the termcap entry for us. */
1750
if (tgetnum ("li") < 0 || getenv ("EMACS"))
1752
/* The number of lines per page is not mentioned in the
1753
terminal description. This probably means that paging is
1754
not useful (e.g. emacs shell window), so disable paging. */
1755
lines_per_page = UINT_MAX;
1758
/* FIXME: Get rid of this junk. */
1759
#if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
1760
SIGWINCH_HANDLER (SIGWINCH);
1763
/* If the output is not a terminal, don't paginate it. */
1764
if (!ui_file_isatty (gdb_stdout))
1765
lines_per_page = UINT_MAX;
1773
/* Set the screen size based on LINES_PER_PAGE and CHARS_PER_LINE. */
1776
set_screen_size (void)
1778
int rows = lines_per_page;
1779
int cols = chars_per_line;
1785
rl_get_screen_size (NULL, &cols);
1787
/* Update Readline's idea of the terminal size. */
1788
rl_set_screen_size (rows, cols);
1791
/* Reinitialize WRAP_BUFFER according to the current value of
1797
if (chars_per_line == 0)
1802
wrap_buffer = (char *) xmalloc (chars_per_line + 2);
1803
wrap_buffer[0] = '\0';
1806
wrap_buffer = (char *) xrealloc (wrap_buffer, chars_per_line + 2);
1807
wrap_pointer = wrap_buffer; /* Start it at the beginning. */
1811
set_width_command (char *args, int from_tty, struct cmd_list_element *c)
1818
set_height_command (char *args, int from_tty, struct cmd_list_element *c)
1823
/* Wait, so the user can read what's on the screen. Prompt the user
1824
to continue by pressing RETURN. */
1827
prompt_for_continue (void)
1830
char cont_prompt[120];
1832
if (annotation_level > 1)
1833
printf_unfiltered ("\n\032\032pre-prompt-for-continue\n");
1835
strcpy (cont_prompt,
1836
"---Type <return> to continue, or q <return> to quit---");
1837
if (annotation_level > 1)
1838
strcat (cont_prompt, "\n\032\032prompt-for-continue\n");
1840
/* We must do this *before* we call gdb_readline, else it will eventually
1841
call us -- thinking that we're trying to print beyond the end of the
1843
reinitialize_more_filter ();
1846
/* On a real operating system, the user can quit with SIGINT.
1849
'q' is provided on all systems so users don't have to change habits
1850
from system to system, and because telling them what to do in
1851
the prompt is more user-friendly than expecting them to think of
1853
/* Call readline, not gdb_readline, because GO32 readline handles control-C
1854
whereas control-C to gdb_readline will cause the user to get dumped
1856
ignore = gdb_readline_wrapper (cont_prompt);
1858
if (annotation_level > 1)
1859
printf_unfiltered ("\n\032\032post-prompt-for-continue\n");
1864
while (*p == ' ' || *p == '\t')
1869
request_quit (SIGINT);
1871
async_request_quit (0);
1877
/* Now we have to do this again, so that GDB will know that it doesn't
1878
need to save the ---Type <return>--- line at the top of the screen. */
1879
reinitialize_more_filter ();
1881
dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
1884
/* Reinitialize filter; ie. tell it to reset to original values. */
1887
reinitialize_more_filter (void)
1893
/* Indicate that if the next sequence of characters overflows the line,
1894
a newline should be inserted here rather than when it hits the end.
1895
If INDENT is non-null, it is a string to be printed to indent the
1896
wrapped part on the next line. INDENT must remain accessible until
1897
the next call to wrap_here() or until a newline is printed through
1900
If the line is already overfull, we immediately print a newline and
1901
the indentation, and disable further wrapping.
1903
If we don't know the width of lines, but we know the page height,
1904
we must not wrap words, but should still keep track of newlines
1905
that were explicitly printed.
1907
INDENT should not contain tabs, as that will mess up the char count
1908
on the next line. FIXME.
1910
This routine is guaranteed to force out any output which has been
1911
squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
1912
used to force out output from the wrap_buffer. */
1915
wrap_here (char *indent)
1917
/* This should have been allocated, but be paranoid anyway. */
1919
internal_error (__FILE__, __LINE__, "failed internal consistency check");
1923
*wrap_pointer = '\0';
1924
fputs_unfiltered (wrap_buffer, gdb_stdout);
1926
wrap_pointer = wrap_buffer;
1927
wrap_buffer[0] = '\0';
1928
if (chars_per_line == UINT_MAX) /* No line overflow checking */
1932
else if (chars_printed >= chars_per_line)
1934
puts_filtered ("\n");
1936
puts_filtered (indent);
1941
wrap_column = chars_printed;
1945
wrap_indent = indent;
1949
/* Print input string to gdb_stdout, filtered, with wrap,
1950
arranging strings in columns of n chars. String can be
1951
right or left justified in the column. Never prints
1952
trailing spaces. String should never be longer than
1953
width. FIXME: this could be useful for the EXAMINE
1954
command, which currently doesn't tabulate very well */
1957
puts_filtered_tabular (char *string, int width, int right)
1963
gdb_assert (chars_per_line > 0);
1964
if (chars_per_line == UINT_MAX)
1966
fputs_filtered (string, gdb_stdout);
1967
fputs_filtered ("\n", gdb_stdout);
1971
if (((chars_printed - 1) / width + 2) * width >= chars_per_line)
1972
fputs_filtered ("\n", gdb_stdout);
1974
if (width >= chars_per_line)
1975
width = chars_per_line - 1;
1977
stringlen = strlen (string);
1979
if (chars_printed > 0)
1980
spaces = width - (chars_printed - 1) % width - 1;
1982
spaces += width - stringlen;
1984
spacebuf = alloca (spaces + 1);
1985
spacebuf[spaces] = '\0';
1987
spacebuf[spaces] = ' ';
1989
fputs_filtered (spacebuf, gdb_stdout);
1990
fputs_filtered (string, gdb_stdout);
1994
/* Ensure that whatever gets printed next, using the filtered output
1995
commands, starts at the beginning of the line. I.E. if there is
1996
any pending output for the current line, flush it and start a new
1997
line. Otherwise do nothing. */
2002
if (chars_printed > 0)
2004
puts_filtered ("\n");
2009
/* Like fputs but if FILTER is true, pause after every screenful.
2011
Regardless of FILTER can wrap at points other than the final
2012
character of a line.
2014
Unlike fputs, fputs_maybe_filtered does not return a value.
2015
It is OK for LINEBUFFER to be NULL, in which case just don't print
2018
Note that a longjmp to top level may occur in this routine (only if
2019
FILTER is true) (since prompt_for_continue may do so) so this
2020
routine should not be called when cleanups are not in place. */
2023
fputs_maybe_filtered (const char *linebuffer, struct ui_file *stream,
2026
const char *lineptr;
2028
if (linebuffer == 0)
2031
/* Don't do any filtering if it is disabled. */
2032
if ((stream != gdb_stdout) || !pagination_enabled
2033
|| (lines_per_page == UINT_MAX && chars_per_line == UINT_MAX))
2035
fputs_unfiltered (linebuffer, stream);
2039
/* Go through and output each character. Show line extension
2040
when this is necessary; prompt user for new page when this is
2043
lineptr = linebuffer;
2046
/* Possible new page. */
2047
if (filter && (lines_printed >= lines_per_page - 1))
2048
prompt_for_continue ();
2050
while (*lineptr && *lineptr != '\n')
2052
/* Print a single line. */
2053
if (*lineptr == '\t')
2056
*wrap_pointer++ = '\t';
2058
fputc_unfiltered ('\t', stream);
2059
/* Shifting right by 3 produces the number of tab stops
2060
we have already passed, and then adding one and
2061
shifting left 3 advances to the next tab stop. */
2062
chars_printed = ((chars_printed >> 3) + 1) << 3;
2068
*wrap_pointer++ = *lineptr;
2070
fputc_unfiltered (*lineptr, stream);
2075
if (chars_printed >= chars_per_line)
2077
unsigned int save_chars = chars_printed;
2081
/* If we aren't actually wrapping, don't output newline --
2082
if chars_per_line is right, we probably just overflowed
2083
anyway; if it's wrong, let us keep going. */
2085
fputc_unfiltered ('\n', stream);
2087
/* Possible new page. */
2088
if (lines_printed >= lines_per_page - 1)
2089
prompt_for_continue ();
2091
/* Now output indentation and wrapped string */
2094
fputs_unfiltered (wrap_indent, stream);
2095
*wrap_pointer = '\0'; /* Null-terminate saved stuff */
2096
fputs_unfiltered (wrap_buffer, stream); /* and eject it */
2097
/* FIXME, this strlen is what prevents wrap_indent from
2098
containing tabs. However, if we recurse to print it
2099
and count its chars, we risk trouble if wrap_indent is
2100
longer than (the user settable) chars_per_line.
2101
Note also that this can set chars_printed > chars_per_line
2102
if we are printing a long string. */
2103
chars_printed = strlen (wrap_indent)
2104
+ (save_chars - wrap_column);
2105
wrap_pointer = wrap_buffer; /* Reset buffer */
2106
wrap_buffer[0] = '\0';
2107
wrap_column = 0; /* And disable fancy wrap */
2112
if (*lineptr == '\n')
2115
wrap_here ((char *) 0); /* Spit out chars, cancel further wraps */
2117
fputc_unfiltered ('\n', stream);
2124
fputs_filtered (const char *linebuffer, struct ui_file *stream)
2126
fputs_maybe_filtered (linebuffer, stream, 1);
2130
putchar_unfiltered (int c)
2133
ui_file_write (gdb_stdout, &buf, 1);
2137
/* Write character C to gdb_stdout using GDB's paging mechanism and return C.
2138
May return nonlocally. */
2141
putchar_filtered (int c)
2143
return fputc_filtered (c, gdb_stdout);
2147
fputc_unfiltered (int c, struct ui_file *stream)
2150
ui_file_write (stream, &buf, 1);
2155
fputc_filtered (int c, struct ui_file *stream)
2161
fputs_filtered (buf, stream);
2165
/* puts_debug is like fputs_unfiltered, except it prints special
2166
characters in printable fashion. */
2169
puts_debug (char *prefix, char *string, char *suffix)
2173
/* Print prefix and suffix after each line. */
2174
static int new_line = 1;
2175
static int return_p = 0;
2176
static char *prev_prefix = "";
2177
static char *prev_suffix = "";
2179
if (*string == '\n')
2182
/* If the prefix is changing, print the previous suffix, a new line,
2183
and the new prefix. */
2184
if ((return_p || (strcmp (prev_prefix, prefix) != 0)) && !new_line)
2186
fputs_unfiltered (prev_suffix, gdb_stdlog);
2187
fputs_unfiltered ("\n", gdb_stdlog);
2188
fputs_unfiltered (prefix, gdb_stdlog);
2191
/* Print prefix if we printed a newline during the previous call. */
2195
fputs_unfiltered (prefix, gdb_stdlog);
2198
prev_prefix = prefix;
2199
prev_suffix = suffix;
2201
/* Output characters in a printable format. */
2202
while ((ch = *string++) != '\0')
2208
fputc_unfiltered (ch, gdb_stdlog);
2211
fprintf_unfiltered (gdb_stdlog, "\\x%02x", ch & 0xff);
2215
fputs_unfiltered ("\\\\", gdb_stdlog);
2218
fputs_unfiltered ("\\b", gdb_stdlog);
2221
fputs_unfiltered ("\\f", gdb_stdlog);
2225
fputs_unfiltered ("\\n", gdb_stdlog);
2228
fputs_unfiltered ("\\r", gdb_stdlog);
2231
fputs_unfiltered ("\\t", gdb_stdlog);
2234
fputs_unfiltered ("\\v", gdb_stdlog);
2238
return_p = ch == '\r';
2241
/* Print suffix if we printed a newline. */
2244
fputs_unfiltered (suffix, gdb_stdlog);
2245
fputs_unfiltered ("\n", gdb_stdlog);
2250
/* Print a variable number of ARGS using format FORMAT. If this
2251
information is going to put the amount written (since the last call
2252
to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
2253
call prompt_for_continue to get the users permision to continue.
2255
Unlike fprintf, this function does not return a value.
2257
We implement three variants, vfprintf (takes a vararg list and stream),
2258
fprintf (takes a stream to write on), and printf (the usual).
2260
Note also that a longjmp to top level may occur in this routine
2261
(since prompt_for_continue may do so) so this routine should not be
2262
called when cleanups are not in place. */
2265
vfprintf_maybe_filtered (struct ui_file *stream, const char *format,
2266
va_list args, int filter)
2269
struct cleanup *old_cleanups;
2271
xvasprintf (&linebuffer, format, args);
2272
old_cleanups = make_cleanup (xfree, linebuffer);
2273
fputs_maybe_filtered (linebuffer, stream, filter);
2274
do_cleanups (old_cleanups);
2279
vfprintf_filtered (struct ui_file *stream, const char *format, va_list args)
2281
vfprintf_maybe_filtered (stream, format, args, 1);
2285
vfprintf_unfiltered (struct ui_file *stream, const char *format, va_list args)
2288
struct cleanup *old_cleanups;
2290
xvasprintf (&linebuffer, format, args);
2291
old_cleanups = make_cleanup (xfree, linebuffer);
2292
fputs_unfiltered (linebuffer, stream);
2293
do_cleanups (old_cleanups);
2297
vprintf_filtered (const char *format, va_list args)
2299
vfprintf_maybe_filtered (gdb_stdout, format, args, 1);
2303
vprintf_unfiltered (const char *format, va_list args)
2305
vfprintf_unfiltered (gdb_stdout, format, args);
2309
fprintf_filtered (struct ui_file *stream, const char *format, ...)
2312
va_start (args, format);
2313
vfprintf_filtered (stream, format, args);
2318
fprintf_unfiltered (struct ui_file *stream, const char *format, ...)
2321
va_start (args, format);
2322
vfprintf_unfiltered (stream, format, args);
2326
/* Like fprintf_filtered, but prints its result indented.
2327
Called as fprintfi_filtered (spaces, stream, format, ...); */
2330
fprintfi_filtered (int spaces, struct ui_file *stream, const char *format,
2334
va_start (args, format);
2335
print_spaces_filtered (spaces, stream);
2337
vfprintf_filtered (stream, format, args);
2343
printf_filtered (const char *format, ...)
2346
va_start (args, format);
2347
vfprintf_filtered (gdb_stdout, format, args);
2353
printf_unfiltered (const char *format, ...)
2356
va_start (args, format);
2357
vfprintf_unfiltered (gdb_stdout, format, args);
2361
/* Like printf_filtered, but prints it's result indented.
2362
Called as printfi_filtered (spaces, format, ...); */
2365
printfi_filtered (int spaces, const char *format, ...)
2368
va_start (args, format);
2369
print_spaces_filtered (spaces, gdb_stdout);
2370
vfprintf_filtered (gdb_stdout, format, args);
2374
/* Easy -- but watch out!
2376
This routine is *not* a replacement for puts()! puts() appends a newline.
2377
This one doesn't, and had better not! */
2380
puts_filtered (const char *string)
2382
fputs_filtered (string, gdb_stdout);
2386
puts_unfiltered (const char *string)
2388
fputs_unfiltered (string, gdb_stdout);
2391
/* Return a pointer to N spaces and a null. The pointer is good
2392
until the next call to here. */
2397
static char *spaces = 0;
2398
static int max_spaces = -1;
2404
spaces = (char *) xmalloc (n + 1);
2405
for (t = spaces + n; t != spaces;)
2411
return spaces + max_spaces - n;
2414
/* Print N spaces. */
2416
print_spaces_filtered (int n, struct ui_file *stream)
2418
fputs_filtered (n_spaces (n), stream);
2421
/* C++/ObjC demangler stuff. */
2423
/* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2424
LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2425
If the name is not mangled, or the language for the name is unknown, or
2426
demangling is off, the name is printed in its "raw" form. */
2429
fprintf_symbol_filtered (struct ui_file *stream, char *name,
2430
enum language lang, int arg_mode)
2436
/* If user wants to see raw output, no problem. */
2439
fputs_filtered (name, stream);
2443
demangled = language_demangle (language_def (lang), name, arg_mode);
2444
fputs_filtered (demangled ? demangled : name, stream);
2445
if (demangled != NULL)
2453
/* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
2454
differences in whitespace. Returns 0 if they match, non-zero if they
2455
don't (slightly different than strcmp()'s range of return values).
2457
As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
2458
This "feature" is useful when searching for matching C++ function names
2459
(such as if the user types 'break FOO', where FOO is a mangled C++
2463
strcmp_iw (const char *string1, const char *string2)
2465
while ((*string1 != '\0') && (*string2 != '\0'))
2467
while (isspace (*string1))
2471
while (isspace (*string2))
2475
if (*string1 != *string2)
2479
if (*string1 != '\0')
2485
return (*string1 != '\0' && *string1 != '(') || (*string2 != '\0');
2488
/* This is like strcmp except that it ignores whitespace and treats
2489
'(' as the first non-NULL character in terms of ordering. Like
2490
strcmp (and unlike strcmp_iw), it returns negative if STRING1 <
2491
STRING2, 0 if STRING2 = STRING2, and positive if STRING1 > STRING2
2492
according to that ordering.
2494
If a list is sorted according to this function and if you want to
2495
find names in the list that match some fixed NAME according to
2496
strcmp_iw(LIST_ELT, NAME), then the place to start looking is right
2497
where this function would put NAME.
2499
Here are some examples of why using strcmp to sort is a bad idea:
2503
Say your partial symtab contains: "foo<char *>", "goo". Then, if
2504
we try to do a search for "foo<char*>", strcmp will locate this
2505
after "foo<char *>" and before "goo". Then lookup_partial_symbol
2506
will start looking at strings beginning with "goo", and will never
2507
see the correct match of "foo<char *>".
2509
Parenthesis example:
2511
In practice, this is less like to be an issue, but I'll give it a
2512
shot. Let's assume that '$' is a legitimate character to occur in
2513
symbols. (Which may well even be the case on some systems.) Then
2514
say that the partial symbol table contains "foo$" and "foo(int)".
2515
strcmp will put them in this order, since '$' < '('. Now, if the
2516
user searches for "foo", then strcmp will sort "foo" before "foo$".
2517
Then lookup_partial_symbol will notice that strcmp_iw("foo$",
2518
"foo") is false, so it won't proceed to the actual match of
2519
"foo(int)" with "foo". */
2522
strcmp_iw_ordered (const char *string1, const char *string2)
2524
while ((*string1 != '\0') && (*string2 != '\0'))
2526
while (isspace (*string1))
2530
while (isspace (*string2))
2534
if (*string1 != *string2)
2538
if (*string1 != '\0')
2547
/* Characters are non-equal unless they're both '\0'; we want to
2548
make sure we get the comparison right according to our
2549
comparison in the cases where one of them is '\0' or '('. */
2551
if (*string2 == '\0')
2556
if (*string2 == '\0')
2561
if (*string2 == '(')
2564
return *string1 - *string2;
2568
/* A simple comparison function with opposite semantics to strcmp. */
2571
streq (const char *lhs, const char *rhs)
2573
return !strcmp (lhs, rhs);
2579
** Answer whether string_to_compare is a full or partial match to
2580
** template_string. The partial match must be in sequence starting
2584
subset_compare (char *string_to_compare, char *template_string)
2587
if (template_string != (char *) NULL && string_to_compare != (char *) NULL
2588
&& strlen (string_to_compare) <= strlen (template_string))
2591
(template_string, string_to_compare, strlen (string_to_compare)) == 0);
2598
static void pagination_on_command (char *arg, int from_tty);
2600
pagination_on_command (char *arg, int from_tty)
2602
pagination_enabled = 1;
2605
static void pagination_on_command (char *arg, int from_tty);
2607
pagination_off_command (char *arg, int from_tty)
2609
pagination_enabled = 0;
2614
initialize_utils (void)
2616
struct cmd_list_element *c;
2618
c = add_set_cmd ("width", class_support, var_uinteger, &chars_per_line,
2619
"Set number of characters gdb thinks are in a line.",
2621
add_show_from_set (c, &showlist);
2622
set_cmd_sfunc (c, set_width_command);
2624
c = add_set_cmd ("height", class_support, var_uinteger, &lines_per_page,
2625
"Set number of lines gdb thinks are in a page.", &setlist);
2626
add_show_from_set (c, &showlist);
2627
set_cmd_sfunc (c, set_height_command);
2632
(add_set_cmd ("demangle", class_support, var_boolean,
2634
"Set demangling of encoded C++/ObjC names when displaying symbols.",
2635
&setprintlist), &showprintlist);
2638
(add_set_cmd ("pagination", class_support,
2639
var_boolean, (char *) &pagination_enabled,
2640
"Set state of pagination.", &setlist), &showlist);
2644
add_com ("am", class_support, pagination_on_command,
2645
"Enable pagination");
2646
add_com ("sm", class_support, pagination_off_command,
2647
"Disable pagination");
2651
(add_set_cmd ("sevenbit-strings", class_support, var_boolean,
2652
(char *) &sevenbit_strings,
2653
"Set printing of 8-bit characters in strings as \\nnn.",
2654
&setprintlist), &showprintlist);
2657
(add_set_cmd ("asm-demangle", class_support, var_boolean,
2658
(char *) &asm_demangle,
2659
"Set demangling of C++/ObjC names in disassembly listings.",
2660
&setprintlist), &showprintlist);
2663
/* Machine specific function to handle SIGWINCH signal. */
2665
#ifdef SIGWINCH_HANDLER_BODY
2666
SIGWINCH_HANDLER_BODY
2668
/* print routines to handle variable size regs, etc. */
2669
/* temporary storage using circular buffer */
2675
static char buf[NUMCELLS][CELLSIZE];
2676
static int cell = 0;
2677
if (++cell >= NUMCELLS)
2685
return (TARGET_ADDR_BIT / 8 * 2);
2689
paddr (CORE_ADDR addr)
2691
return phex (addr, TARGET_ADDR_BIT / 8);
2695
paddr_nz (CORE_ADDR addr)
2697
return phex_nz (addr, TARGET_ADDR_BIT / 8);
2701
decimal2str (char *paddr_str, char *sign, ULONGEST addr)
2703
/* steal code from valprint.c:print_decimal(). Should this worry
2704
about the real size of addr as the above does? */
2705
unsigned long temp[3];
2709
temp[i] = addr % (1000 * 1000 * 1000);
2710
addr /= (1000 * 1000 * 1000);
2713
while (addr != 0 && i < (sizeof (temp) / sizeof (temp[0])));
2717
sprintf (paddr_str, "%s%lu", sign, temp[0]);
2720
sprintf (paddr_str, "%s%lu%09lu", sign, temp[1], temp[0]);
2723
sprintf (paddr_str, "%s%lu%09lu%09lu", sign, temp[2], temp[1], temp[0]);
2726
internal_error (__FILE__, __LINE__,
2727
"failed internal consistency check");
2732
paddr_u (CORE_ADDR addr)
2734
char *paddr_str = get_cell ();
2735
decimal2str (paddr_str, "", addr);
2740
paddr_d (LONGEST addr)
2742
char *paddr_str = get_cell ();
2744
decimal2str (paddr_str, "-", -addr);
2746
decimal2str (paddr_str, "", addr);
2750
/* eliminate warning from compiler on 32-bit systems */
2751
static int thirty_two = 32;
2754
phex (ULONGEST l, int sizeof_l)
2761
sprintf (str, "%08lx%08lx",
2762
(unsigned long) (l >> thirty_two),
2763
(unsigned long) (l & 0xffffffff));
2767
sprintf (str, "%08lx", (unsigned long) l);
2771
sprintf (str, "%04x", (unsigned short) (l & 0xffff));
2774
str = phex (l, sizeof (l));
2781
phex_nz (ULONGEST l, int sizeof_l)
2788
unsigned long high = (unsigned long) (l >> thirty_two);
2791
sprintf (str, "%lx", (unsigned long) (l & 0xffffffff));
2793
sprintf (str, "%lx%08lx", high, (unsigned long) (l & 0xffffffff));
2798
sprintf (str, "%lx", (unsigned long) l);
2802
sprintf (str, "%x", (unsigned short) (l & 0xffff));
2805
str = phex_nz (l, sizeof (l));
2812
/* Convert a CORE_ADDR into a string. */
2814
core_addr_to_string (const CORE_ADDR addr)
2816
char *str = get_cell ();
2818
strcat (str, phex (addr, sizeof (addr)));
2823
core_addr_to_string_nz (const CORE_ADDR addr)
2825
char *str = get_cell ();
2827
strcat (str, phex_nz (addr, sizeof (addr)));
2831
/* Convert a string back into a CORE_ADDR. */
2833
string_to_core_addr (const char *my_string)
2836
if (my_string[0] == '0' && tolower (my_string[1]) == 'x')
2838
/* Assume that it is in decimal. */
2840
for (i = 2; my_string[i] != '\0'; i++)
2842
if (isdigit (my_string[i]))
2843
addr = (my_string[i] - '0') + (addr * 16);
2844
else if (isxdigit (my_string[i]))
2845
addr = (tolower (my_string[i]) - 'a' + 0xa) + (addr * 16);
2847
internal_error (__FILE__, __LINE__, "invalid hex");
2852
/* Assume that it is in decimal. */
2854
for (i = 0; my_string[i] != '\0'; i++)
2856
if (isdigit (my_string[i]))
2857
addr = (my_string[i] - '0') + (addr * 10);
2859
internal_error (__FILE__, __LINE__, "invalid decimal");
2866
gdb_realpath (const char *filename)
2868
/* Method 1: The system has a compile time upper bound on a filename
2869
path. Use that and realpath() to canonicalize the name. This is
2870
the most common case. Note that, if there isn't a compile time
2871
upper bound, you want to avoid realpath() at all costs. */
2872
#if defined(HAVE_REALPATH)
2874
# if defined (PATH_MAX)
2876
# define USE_REALPATH
2877
# elif defined (MAXPATHLEN)
2878
char buf[MAXPATHLEN];
2879
# define USE_REALPATH
2881
# if defined (USE_REALPATH)
2882
const char *rp = realpath (filename, buf);
2885
return xstrdup (rp);
2888
#endif /* HAVE_REALPATH */
2890
/* Method 2: The host system (i.e., GNU) has the function
2891
canonicalize_file_name() which malloc's a chunk of memory and
2892
returns that, use that. */
2893
#if defined(HAVE_CANONICALIZE_FILE_NAME)
2895
char *rp = canonicalize_file_name (filename);
2897
return xstrdup (filename);
2903
/* FIXME: cagney/2002-11-13:
2905
Method 2a: Use realpath() with a NULL buffer. Some systems, due
2906
to the problems described in in method 3, have modified their
2907
realpath() implementation so that it will allocate a buffer when
2908
NULL is passed in. Before this can be used, though, some sort of
2909
configure time test would need to be added. Otherwize the code
2910
will likely core dump. */
2912
/* Method 3: Now we're getting desperate! The system doesn't have a
2913
compile time buffer size and no alternative function. Query the
2914
OS, using pathconf(), for the buffer limit. Care is needed
2915
though, some systems do not limit PATH_MAX (return -1 for
2916
pathconf()) making it impossible to pass a correctly sized buffer
2917
to realpath() (it could always overflow). On those systems, we
2919
#if defined (HAVE_REALPATH) && defined (HAVE_UNISTD_H) && defined(HAVE_ALLOCA)
2921
/* Find out the max path size. */
2922
long path_max = pathconf ("/", _PC_PATH_MAX);
2925
/* PATH_MAX is bounded. */
2926
char *buf = alloca (path_max);
2927
char *rp = realpath (filename, buf);
2928
return xstrdup (rp ? rp : filename);
2933
/* This system is a lost cause, just dup the buffer. */
2934
return xstrdup (filename);
2937
/* Return a copy of FILENAME, with its directory prefix canonicalized
2941
xfullpath (const char *filename)
2943
const char *base_name = lbasename (filename);
2948
/* Extract the basename of filename, and return immediately
2949
a copy of filename if it does not contain any directory prefix. */
2950
if (base_name == filename)
2951
return xstrdup (filename);
2953
dir_name = alloca ((size_t) (base_name - filename + 2));
2954
/* Allocate enough space to store the dir_name + plus one extra
2955
character sometimes needed under Windows (see below), and
2956
then the closing \000 character */
2957
strncpy (dir_name, filename, base_name - filename);
2958
dir_name[base_name - filename] = '\000';
2960
#ifdef HAVE_DOS_BASED_FILE_SYSTEM
2961
/* We need to be careful when filename is of the form 'd:foo', which
2962
is equivalent of d:./foo, which is totally different from d:/foo. */
2963
if (strlen (dir_name) == 2 && isalpha (dir_name[0]) && dir_name[1] == ':')
2966
dir_name[3] = '\000';
2970
/* Canonicalize the directory prefix, and build the resulting
2971
filename. If the dirname realpath already contains an ending
2972
directory separator, avoid doubling it. */
2973
real_path = gdb_realpath (dir_name);
2974
if (IS_DIR_SEPARATOR (real_path[strlen (real_path) - 1]))
2975
result = concat (real_path, base_name, NULL);
2977
result = concat (real_path, SLASH_STRING, base_name, NULL);
2984
/* This is the 32-bit CRC function used by the GNU separate debug
2985
facility. An executable may contain a section named
2986
.gnu_debuglink, which holds the name of a separate executable file
2987
containing its debug info, and a checksum of that file's contents,
2988
computed using this function. */
2990
gnu_debuglink_crc32 (unsigned long crc, unsigned char *buf, size_t len)
2992
static const unsigned long crc32_table[256] = {
2993
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
2994
0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
2995
0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
2996
0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
2997
0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
2998
0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
2999
0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
3000
0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
3001
0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
3002
0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
3003
0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
3004
0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
3005
0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
3006
0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
3007
0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
3008
0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
3009
0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
3010
0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
3011
0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
3012
0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
3013
0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
3014
0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
3015
0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
3016
0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
3017
0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
3018
0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
3019
0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
3020
0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
3021
0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
3022
0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
3023
0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
3024
0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
3025
0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
3026
0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
3027
0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
3028
0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
3029
0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
3030
0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
3031
0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
3032
0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
3033
0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
3034
0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
3035
0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
3036
0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
3037
0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
3038
0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
3039
0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
3040
0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
3041
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
3042
0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
3043
0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
3048
crc = ~crc & 0xffffffff;
3049
for (end = buf + len; buf < end; ++buf)
3050
crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
3051
return ~crc & 0xffffffff;;
3055
align_up (ULONGEST v, int n)
3057
/* Check that N is really a power of two. */
3058
gdb_assert (n && (n & (n-1)) == 0);
3059
return (v + n - 1) & -n;
3063
align_down (ULONGEST v, int n)
3065
/* Check that N is really a power of two. */
3066
gdb_assert (n && (n & (n-1)) == 0);