From d6fc3fc506e37e103c4cd6b37927324266724675 Mon Sep 17 00:00:00 2001 From: anderson Date: Thu, 3 Mar 2005 16:53:39 +0000 Subject: [PATCH] updates for gcc 4 build. --- crash.patch | 930 ++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 907 insertions(+), 23 deletions(-) diff --git a/crash.patch b/crash.patch index 5b70043..2ece5fd 100644 --- a/crash.patch +++ b/crash.patch @@ -1,4 +1,639 @@ ---- crash/memory.c.orig 2005-02-09 16:13:25.000000000 -0500 +--- crash/gdb-6.0/gdb/symtab.c.orig 2005-03-03 11:36:20.000000000 -0500 ++++ crash/gdb-6.0/gdb/symtab.c 2005-03-02 16:19:09.000000000 -0500 +@@ -889,7 +889,9 @@ + doesn't affect these calls since they are looking for a known + variable and thus can probably assume it will never hit the C++ + code). */ +- ++#ifdef CRASH_MERGE ++static void gdb_bait_and_switch(char *, struct symbol *); ++#endif + struct symbol * + lookup_symbol (const char *name, const struct block *block, + const domain_enum domain, int *is_a_field_of_this, +@@ -936,7 +938,6 @@ + + #ifdef CRASH_MERGE + if (returnval && (domain == VAR_DOMAIN)) { +- static void gdb_bait_and_switch(char *, struct symbol *); + gdb_bait_and_switch((char *)modified_name, returnval); + } + #endif +--- crash/gdb-6.0/include/obstack.h.orig 2005-03-03 11:36:20.000000000 -0500 ++++ crash/gdb-6.0/include/obstack.h 2005-03-02 16:39:05.000000000 -0500 +@@ -0,0 +1,611 @@ ++/* obstack.h - object stack macros ++ Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1996, 1997, 1998, ++ 1999, 2000 ++ Free Software Foundation, Inc. ++ ++ ++ NOTE: The canonical source of this file is maintained with the GNU C Library. ++ Bugs can be reported to bug-glibc@gnu.org. ++ ++ This program is free software; you can redistribute it and/or modify it ++ under the terms of the GNU General Public License as published by the ++ Free Software Foundation; either version 2, or (at your option) any ++ later version. ++ ++ This program is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ GNU General Public License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with this program; if not, write to the Free Software ++ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, ++ USA. */ ++ ++/* Summary: ++ ++All the apparent functions defined here are macros. The idea ++is that you would use these pre-tested macros to solve a ++very specific set of problems, and they would run fast. ++Caution: no side-effects in arguments please!! They may be ++evaluated MANY times!! ++ ++These macros operate a stack of objects. Each object starts life ++small, and may grow to maturity. (Consider building a word syllable ++by syllable.) An object can move while it is growing. Once it has ++been "finished" it never changes address again. So the "top of the ++stack" is typically an immature growing object, while the rest of the ++stack is of mature, fixed size and fixed address objects. ++ ++These routines grab large chunks of memory, using a function you ++supply, called `obstack_chunk_alloc'. On occasion, they free chunks, ++by calling `obstack_chunk_free'. You must define them and declare ++them before using any obstack macros. ++ ++Each independent stack is represented by a `struct obstack'. ++Each of the obstack macros expects a pointer to such a structure ++as the first argument. ++ ++One motivation for this package is the problem of growing char strings ++in symbol tables. Unless you are "fascist pig with a read-only mind" ++--Gosper's immortal quote from HAKMEM item 154, out of context--you ++would not like to put any arbitrary upper limit on the length of your ++symbols. ++ ++In practice this often means you will build many short symbols and a ++few long symbols. At the time you are reading a symbol you don't know ++how long it is. One traditional method is to read a symbol into a ++buffer, realloc()ating the buffer every time you try to read a symbol ++that is longer than the buffer. This is beaut, but you still will ++want to copy the symbol from the buffer to a more permanent ++symbol-table entry say about half the time. ++ ++With obstacks, you can work differently. Use one obstack for all symbol ++names. As you read a symbol, grow the name in the obstack gradually. ++When the name is complete, finalize it. Then, if the symbol exists already, ++free the newly read name. ++ ++The way we do this is to take a large chunk, allocating memory from ++low addresses. When you want to build a symbol in the chunk you just ++add chars above the current "high water mark" in the chunk. When you ++have finished adding chars, because you got to the end of the symbol, ++you know how long the chars are, and you can create a new object. ++Mostly the chars will not burst over the highest address of the chunk, ++because you would typically expect a chunk to be (say) 100 times as ++long as an average object. ++ ++In case that isn't clear, when we have enough chars to make up ++the object, THEY ARE ALREADY CONTIGUOUS IN THE CHUNK (guaranteed) ++so we just point to it where it lies. No moving of chars is ++needed and this is the second win: potentially long strings need ++never be explicitly shuffled. Once an object is formed, it does not ++change its address during its lifetime. ++ ++When the chars burst over a chunk boundary, we allocate a larger ++chunk, and then copy the partly formed object from the end of the old ++chunk to the beginning of the new larger chunk. We then carry on ++accreting characters to the end of the object as we normally would. ++ ++A special macro is provided to add a single char at a time to a ++growing object. This allows the use of register variables, which ++break the ordinary 'growth' macro. ++ ++Summary: ++ We allocate large chunks. ++ We carve out one object at a time from the current chunk. ++ Once carved, an object never moves. ++ We are free to append data of any size to the currently ++ growing object. ++ Exactly one object is growing in an obstack at any one time. ++ You can run one obstack per control block. ++ You may have as many control blocks as you dare. ++ Because of the way we do it, you can `unwind' an obstack ++ back to a previous state. (You may remove objects much ++ as you would with a stack.) ++*/ ++ ++ ++/* Don't do the contents of this file more than once. */ ++ ++#ifndef _OBSTACK_H ++#define _OBSTACK_H 1 ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/* We use subtraction of (char *) 0 instead of casting to int ++ because on word-addressable machines a simple cast to int ++ may ignore the byte-within-word field of the pointer. */ ++ ++#ifndef __PTR_TO_INT ++# define __PTR_TO_INT(P) ((P) - (char *) 0) ++#endif ++ ++#ifndef __INT_TO_PTR ++# define __INT_TO_PTR(P) ((P) + (char *) 0) ++#endif ++ ++/* We need the type of the resulting object. If __PTRDIFF_TYPE__ is ++ defined, as with GNU C, use that; that way we don't pollute the ++ namespace with 's symbols. Otherwise, if is ++ available, include it and use ptrdiff_t. In traditional C, long is ++ the best that we can do. */ ++ ++#ifdef __PTRDIFF_TYPE__ ++# define PTR_INT_TYPE __PTRDIFF_TYPE__ ++#else ++# ifdef HAVE_STDDEF_H ++# include ++# define PTR_INT_TYPE ptrdiff_t ++# else ++# define PTR_INT_TYPE long ++# endif ++#endif ++ ++#if defined _LIBC || defined HAVE_STRING_H ++# include ++# if defined __STDC__ && __STDC__ ++# define _obstack_memcpy(To, From, N) memcpy ((To), (From), (N)) ++# else ++# define _obstack_memcpy(To, From, N) memcpy ((To), (char *)(From), (N)) ++# endif ++#else ++# ifdef memcpy ++# define _obstack_memcpy(To, From, N) memcpy ((To), (char *)(From), (N)) ++# else ++# define _obstack_memcpy(To, From, N) bcopy ((char *)(From), (To), (N)) ++# endif ++#endif ++ ++struct _obstack_chunk /* Lives at front of each chunk. */ ++{ ++ char *limit; /* 1 past end of this chunk */ ++ struct _obstack_chunk *prev; /* address of prior chunk or NULL */ ++ char contents[4]; /* objects begin here */ ++}; ++ ++struct obstack /* control current object in current chunk */ ++{ ++ long chunk_size; /* preferred size to allocate chunks in */ ++ struct _obstack_chunk *chunk; /* address of current struct obstack_chunk */ ++ char *object_base; /* address of object we are building */ ++ char *next_free; /* where to add next char to current object */ ++ char *chunk_limit; /* address of char after current chunk */ ++ PTR_INT_TYPE temp; /* Temporary for some macros. */ ++ int alignment_mask; /* Mask of alignment for each object. */ ++#if defined __STDC__ && __STDC__ ++ /* These prototypes vary based on `use_extra_arg', and we use ++ casts to the prototypeless function type in all assignments, ++ but having prototypes here quiets -Wstrict-prototypes. */ ++ struct _obstack_chunk *(*chunkfun) (void *, long); ++ void (*freefun) (void *, struct _obstack_chunk *); ++ void *extra_arg; /* first arg for chunk alloc/dealloc funcs */ ++#else ++ struct _obstack_chunk *(*chunkfun) (); /* User's fcn to allocate a chunk. */ ++ void (*freefun) (); /* User's function to free a chunk. */ ++ char *extra_arg; /* first arg for chunk alloc/dealloc funcs */ ++#endif ++ unsigned use_extra_arg:1; /* chunk alloc/dealloc funcs take extra arg */ ++ unsigned maybe_empty_object:1;/* There is a possibility that the current ++ chunk contains a zero-length object. This ++ prevents freeing the chunk if we allocate ++ a bigger chunk to replace it. */ ++ unsigned alloc_failed:1; /* No longer used, as we now call the failed ++ handler on error, but retained for binary ++ compatibility. */ ++}; ++ ++/* Declare the external functions we use; they are in obstack.c. */ ++ ++#if defined __STDC__ && __STDC__ ++extern void _obstack_newchunk (struct obstack *, int); ++extern void _obstack_free (struct obstack *, void *); ++extern int _obstack_begin (struct obstack *, int, int, ++ void *(*) (long), void (*) (void *)); ++extern int _obstack_begin_1 (struct obstack *, int, int, ++ void *(*) (void *, long), ++ void (*) (void *, void *), void *); ++extern int _obstack_memory_used (struct obstack *); ++#else ++extern void _obstack_newchunk (); ++extern void _obstack_free (); ++extern int _obstack_begin (); ++extern int _obstack_begin_1 (); ++extern int _obstack_memory_used (); ++#endif ++ ++#if defined __STDC__ && __STDC__ ++ ++/* Do the function-declarations after the structs ++ but before defining the macros. */ ++ ++void obstack_init (struct obstack *obstack); ++ ++void * obstack_alloc (struct obstack *obstack, int size); ++ ++void * obstack_copy (struct obstack *obstack, void *address, int size); ++void * obstack_copy0 (struct obstack *obstack, void *address, int size); ++ ++void obstack_free (struct obstack *obstack, void *block); ++ ++void obstack_blank (struct obstack *obstack, int size); ++ ++void obstack_grow (struct obstack *obstack, void *data, int size); ++void obstack_grow0 (struct obstack *obstack, void *data, int size); ++ ++void obstack_1grow (struct obstack *obstack, int data_char); ++void obstack_ptr_grow (struct obstack *obstack, void *data); ++void obstack_int_grow (struct obstack *obstack, int data); ++ ++void * obstack_finish (struct obstack *obstack); ++ ++int obstack_object_size (struct obstack *obstack); ++ ++int obstack_room (struct obstack *obstack); ++void obstack_make_room (struct obstack *obstack, int size); ++void obstack_1grow_fast (struct obstack *obstack, int data_char); ++void obstack_ptr_grow_fast (struct obstack *obstack, void *data); ++void obstack_int_grow_fast (struct obstack *obstack, int data); ++void obstack_blank_fast (struct obstack *obstack, int size); ++ ++void * obstack_base (struct obstack *obstack); ++void * obstack_next_free (struct obstack *obstack); ++int obstack_alignment_mask (struct obstack *obstack); ++int obstack_chunk_size (struct obstack *obstack); ++int obstack_memory_used (struct obstack *obstack); ++ ++#endif /* __STDC__ */ ++ ++/* Non-ANSI C cannot really support alternative functions for these macros, ++ so we do not declare them. */ ++ ++/* Error handler called when `obstack_chunk_alloc' failed to allocate ++ more memory. This can be set to a user defined function. The ++ default action is to print a message and abort. */ ++#if defined __STDC__ && __STDC__ ++extern void (*obstack_alloc_failed_handler) (void); ++#else ++extern void (*obstack_alloc_failed_handler) (); ++#endif ++ ++/* Exit value used when `print_and_abort' is used. */ ++extern int obstack_exit_failure; ++ ++/* Pointer to beginning of object being allocated or to be allocated next. ++ Note that this might not be the final address of the object ++ because a new chunk might be needed to hold the final size. */ ++ ++#define obstack_base(h) ((h)->object_base) ++ ++/* Size for allocating ordinary chunks. */ ++ ++#define obstack_chunk_size(h) ((h)->chunk_size) ++ ++/* Pointer to next byte not yet allocated in current chunk. */ ++ ++#define obstack_next_free(h) ((h)->next_free) ++ ++/* Mask specifying low bits that should be clear in address of an object. */ ++ ++#define obstack_alignment_mask(h) ((h)->alignment_mask) ++ ++/* To prevent prototype warnings provide complete argument list in ++ standard C version. */ ++#if defined __STDC__ && __STDC__ ++ ++# define obstack_init(h) \ ++ _obstack_begin ((h), 0, 0, \ ++ (void *(*) (long)) obstack_chunk_alloc, (void (*) (void *)) obstack_chunk_free) ++ ++# define obstack_begin(h, size) \ ++ _obstack_begin ((h), (size), 0, \ ++ (void *(*) (long)) obstack_chunk_alloc, (void (*) (void *)) obstack_chunk_free) ++ ++# define obstack_specify_allocation(h, size, alignment, chunkfun, freefun) \ ++ _obstack_begin ((h), (size), (alignment), \ ++ (void *(*) (long)) (chunkfun), (void (*) (void *)) (freefun)) ++ ++# define obstack_specify_allocation_with_arg(h, size, alignment, chunkfun, freefun, arg) \ ++ _obstack_begin_1 ((h), (size), (alignment), \ ++ (void *(*) (void *, long)) (chunkfun), \ ++ (void (*) (void *, void *)) (freefun), (arg)) ++ ++# define obstack_chunkfun(h, newchunkfun) \ ++ ((h) -> chunkfun = (struct _obstack_chunk *(*)(void *, long)) (newchunkfun)) ++ ++# define obstack_freefun(h, newfreefun) \ ++ ((h) -> freefun = (void (*)(void *, struct _obstack_chunk *)) (newfreefun)) ++ ++#else ++ ++# define obstack_init(h) \ ++ _obstack_begin ((h), 0, 0, \ ++ (void *(*) ()) obstack_chunk_alloc, (void (*) ()) obstack_chunk_free) ++ ++# define obstack_begin(h, size) \ ++ _obstack_begin ((h), (size), 0, \ ++ (void *(*) ()) obstack_chunk_alloc, (void (*) ()) obstack_chunk_free) ++ ++# define obstack_specify_allocation(h, size, alignment, chunkfun, freefun) \ ++ _obstack_begin ((h), (size), (alignment), \ ++ (void *(*) ()) (chunkfun), (void (*) ()) (freefun)) ++ ++# define obstack_specify_allocation_with_arg(h, size, alignment, chunkfun, freefun, arg) \ ++ _obstack_begin_1 ((h), (size), (alignment), \ ++ (void *(*) ()) (chunkfun), (void (*) ()) (freefun), (arg)) ++ ++# define obstack_chunkfun(h, newchunkfun) \ ++ ((h) -> chunkfun = (struct _obstack_chunk *(*)()) (newchunkfun)) ++ ++# define obstack_freefun(h, newfreefun) \ ++ ((h) -> freefun = (void (*)()) (newfreefun)) ++ ++#endif ++ ++#define obstack_1grow_fast(h,achar) (*((h)->next_free)++ = (achar)) ++ ++#define obstack_blank_fast(h,n) ((h)->next_free += (n)) ++ ++#define obstack_memory_used(h) _obstack_memory_used (h) ++ ++#if defined __GNUC__ && defined __STDC__ && __STDC__ ++/* NextStep 2.0 cc is really gcc 1.93 but it defines __GNUC__ = 2 and ++ does not implement __extension__. But that compiler doesn't define ++ __GNUC_MINOR__. */ ++# if __GNUC__ < 2 || (__NeXT__ && !__GNUC_MINOR__) ++# define __extension__ ++# endif ++ ++/* For GNU C, if not -traditional, ++ we can define these macros to compute all args only once ++ without using a global variable. ++ Also, we can avoid using the `temp' slot, to make faster code. */ ++ ++# define obstack_object_size(OBSTACK) \ ++ __extension__ \ ++ ({ struct obstack *__o = (OBSTACK); \ ++ (unsigned) (__o->next_free - __o->object_base); }) ++ ++# define obstack_room(OBSTACK) \ ++ __extension__ \ ++ ({ struct obstack *__o = (OBSTACK); \ ++ (unsigned) (__o->chunk_limit - __o->next_free); }) ++ ++# define obstack_make_room(OBSTACK,length) \ ++__extension__ \ ++({ struct obstack *__o = (OBSTACK); \ ++ int __len = (length); \ ++ if (__o->chunk_limit - __o->next_free < __len) \ ++ _obstack_newchunk (__o, __len); \ ++ (void) 0; }) ++ ++# define obstack_empty_p(OBSTACK) \ ++ __extension__ \ ++ ({ struct obstack *__o = (OBSTACK); \ ++ (__o->chunk->prev == 0 && __o->next_free - __o->chunk->contents == 0); }) ++ ++# define obstack_grow(OBSTACK,where,length) \ ++__extension__ \ ++({ struct obstack *__o = (OBSTACK); \ ++ int __len = (length); \ ++ if (__o->next_free + __len > __o->chunk_limit) \ ++ _obstack_newchunk (__o, __len); \ ++ _obstack_memcpy (__o->next_free, (where), __len); \ ++ __o->next_free += __len; \ ++ (void) 0; }) ++ ++# define obstack_grow0(OBSTACK,where,length) \ ++__extension__ \ ++({ struct obstack *__o = (OBSTACK); \ ++ int __len = (length); \ ++ if (__o->next_free + __len + 1 > __o->chunk_limit) \ ++ _obstack_newchunk (__o, __len + 1); \ ++ _obstack_memcpy (__o->next_free, (where), __len); \ ++ __o->next_free += __len; \ ++ *(__o->next_free)++ = 0; \ ++ (void) 0; }) ++ ++# define obstack_1grow(OBSTACK,datum) \ ++__extension__ \ ++({ struct obstack *__o = (OBSTACK); \ ++ if (__o->next_free + 1 > __o->chunk_limit) \ ++ _obstack_newchunk (__o, 1); \ ++ obstack_1grow_fast (__o, datum); \ ++ (void) 0; }) ++ ++/* These assume that the obstack alignment is good enough for pointers or ints, ++ and that the data added so far to the current object ++ shares that much alignment. */ ++ ++# define obstack_ptr_grow(OBSTACK,datum) \ ++__extension__ \ ++({ struct obstack *__o = (OBSTACK); \ ++ if (__o->next_free + sizeof (void *) > __o->chunk_limit) \ ++ _obstack_newchunk (__o, sizeof (void *)); \ ++ obstack_ptr_grow_fast (__o, datum); }) ++ ++# define obstack_int_grow(OBSTACK,datum) \ ++__extension__ \ ++({ struct obstack *__o = (OBSTACK); \ ++ if (__o->next_free + sizeof (int) > __o->chunk_limit) \ ++ _obstack_newchunk (__o, sizeof (int)); \ ++ obstack_int_grow_fast (__o, datum); }) ++ ++# define obstack_ptr_grow_fast(OBSTACK,aptr) \ ++__extension__ \ ++({ struct obstack *__o1 = (OBSTACK); \ ++ *(const void **) __o1->next_free = (aptr); \ ++ __o1->next_free += sizeof (const void *); \ ++ (void) 0; }) ++ ++# define obstack_int_grow_fast(OBSTACK,aint) \ ++__extension__ \ ++({ struct obstack *__o1 = (OBSTACK); \ ++ *(int *) __o1->next_free = (aint); \ ++ __o1->next_free += sizeof (int); \ ++ (void) 0; }) ++ ++# define obstack_blank(OBSTACK,length) \ ++__extension__ \ ++({ struct obstack *__o = (OBSTACK); \ ++ int __len = (length); \ ++ if (__o->chunk_limit - __o->next_free < __len) \ ++ _obstack_newchunk (__o, __len); \ ++ obstack_blank_fast (__o, __len); \ ++ (void) 0; }) ++ ++# define obstack_alloc(OBSTACK,length) \ ++__extension__ \ ++({ struct obstack *__h = (OBSTACK); \ ++ obstack_blank (__h, (length)); \ ++ obstack_finish (__h); }) ++ ++# define obstack_copy(OBSTACK,where,length) \ ++__extension__ \ ++({ struct obstack *__h = (OBSTACK); \ ++ obstack_grow (__h, (where), (length)); \ ++ obstack_finish (__h); }) ++ ++# define obstack_copy0(OBSTACK,where,length) \ ++__extension__ \ ++({ struct obstack *__h = (OBSTACK); \ ++ obstack_grow0 (__h, (where), (length)); \ ++ obstack_finish (__h); }) ++ ++/* The local variable is named __o1 to avoid a name conflict ++ when obstack_blank is called. */ ++# define obstack_finish(OBSTACK) \ ++__extension__ \ ++({ struct obstack *__o1 = (OBSTACK); \ ++ void *value; \ ++ value = (void *) __o1->object_base; \ ++ if (__o1->next_free == value) \ ++ __o1->maybe_empty_object = 1; \ ++ __o1->next_free \ ++ = __INT_TO_PTR ((__PTR_TO_INT (__o1->next_free)+__o1->alignment_mask)\ ++ & ~ (__o1->alignment_mask)); \ ++ if (__o1->next_free - (char *)__o1->chunk \ ++ > __o1->chunk_limit - (char *)__o1->chunk) \ ++ __o1->next_free = __o1->chunk_limit; \ ++ __o1->object_base = __o1->next_free; \ ++ value; }) ++ ++# define obstack_free(OBSTACK, OBJ) \ ++__extension__ \ ++({ struct obstack *__o = (OBSTACK); \ ++ void *__obj = (void *) (OBJ); \ ++ if (__obj > (void *)__o->chunk && __obj < (void *)__o->chunk_limit) \ ++ __o->next_free = __o->object_base = (char *) __obj; \ ++ else (obstack_free) (__o, __obj); }) ++ ++#else /* not __GNUC__ or not __STDC__ */ ++ ++# define obstack_object_size(h) \ ++ (unsigned) ((h)->next_free - (h)->object_base) ++ ++# define obstack_room(h) \ ++ (unsigned) ((h)->chunk_limit - (h)->next_free) ++ ++# define obstack_empty_p(h) \ ++ ((h)->chunk->prev == 0 && (h)->next_free - (h)->chunk->contents == 0) ++ ++/* Note that the call to _obstack_newchunk is enclosed in (..., 0) ++ so that we can avoid having void expressions ++ in the arms of the conditional expression. ++ Casting the third operand to void was tried before, ++ but some compilers won't accept it. */ ++ ++# define obstack_make_room(h,length) \ ++( (h)->temp = (length), \ ++ (((h)->next_free + (h)->temp > (h)->chunk_limit) \ ++ ? (_obstack_newchunk ((h), (h)->temp), 0) : 0)) ++ ++# define obstack_grow(h,where,length) \ ++( (h)->temp = (length), \ ++ (((h)->next_free + (h)->temp > (h)->chunk_limit) \ ++ ? (_obstack_newchunk ((h), (h)->temp), 0) : 0), \ ++ _obstack_memcpy ((h)->next_free, (where), (h)->temp), \ ++ (h)->next_free += (h)->temp) ++ ++# define obstack_grow0(h,where,length) \ ++( (h)->temp = (length), \ ++ (((h)->next_free + (h)->temp + 1 > (h)->chunk_limit) \ ++ ? (_obstack_newchunk ((h), (h)->temp + 1), 0) : 0), \ ++ _obstack_memcpy ((h)->next_free, (where), (h)->temp), \ ++ (h)->next_free += (h)->temp, \ ++ *((h)->next_free)++ = 0) ++ ++# define obstack_1grow(h,datum) \ ++( (((h)->next_free + 1 > (h)->chunk_limit) \ ++ ? (_obstack_newchunk ((h), 1), 0) : 0), \ ++ obstack_1grow_fast (h, datum)) ++ ++# define obstack_ptr_grow(h,datum) \ ++( (((h)->next_free + sizeof (char *) > (h)->chunk_limit) \ ++ ? (_obstack_newchunk ((h), sizeof (char *)), 0) : 0), \ ++ obstack_ptr_grow_fast (h, datum)) ++ ++# define obstack_int_grow(h,datum) \ ++( (((h)->next_free + sizeof (int) > (h)->chunk_limit) \ ++ ? (_obstack_newchunk ((h), sizeof (int)), 0) : 0), \ ++ obstack_int_grow_fast (h, datum)) ++ ++# define obstack_ptr_grow_fast(h,aptr) \ ++ (((const void **) ((h)->next_free += sizeof (void *)))[-1] = (aptr)) ++ ++# define obstack_int_grow_fast(h,aint) \ ++ (((int *) ((h)->next_free += sizeof (int)))[-1] = (aptr)) ++ ++# define obstack_blank(h,length) \ ++( (h)->temp = (length), \ ++ (((h)->chunk_limit - (h)->next_free < (h)->temp) \ ++ ? (_obstack_newchunk ((h), (h)->temp), 0) : 0), \ ++ obstack_blank_fast (h, (h)->temp)) ++ ++# define obstack_alloc(h,length) \ ++ (obstack_blank ((h), (length)), obstack_finish ((h))) ++ ++# define obstack_copy(h,where,length) \ ++ (obstack_grow ((h), (where), (length)), obstack_finish ((h))) ++ ++# define obstack_copy0(h,where,length) \ ++ (obstack_grow0 ((h), (where), (length)), obstack_finish ((h))) ++ ++# define obstack_finish(h) \ ++( ((h)->next_free == (h)->object_base \ ++ ? (((h)->maybe_empty_object = 1), 0) \ ++ : 0), \ ++ (h)->temp = __PTR_TO_INT ((h)->object_base), \ ++ (h)->next_free \ ++ = __INT_TO_PTR ((__PTR_TO_INT ((h)->next_free)+(h)->alignment_mask) \ ++ & ~ ((h)->alignment_mask)), \ ++ (((h)->next_free - (char *) (h)->chunk \ ++ > (h)->chunk_limit - (char *) (h)->chunk) \ ++ ? ((h)->next_free = (h)->chunk_limit) : 0), \ ++ (h)->object_base = (h)->next_free, \ ++ __INT_TO_PTR ((h)->temp)) ++ ++# if defined __STDC__ && __STDC__ ++# define obstack_free(h,obj) \ ++( (h)->temp = (char *) (obj) - (char *) (h)->chunk, \ ++ (((h)->temp > 0 && (h)->temp < (h)->chunk_limit - (char *) (h)->chunk)\ ++ ? (int) ((h)->next_free = (h)->object_base \ ++ = (h)->temp + (char *) (h)->chunk) \ ++ : (((obstack_free) ((h), (h)->temp + (char *) (h)->chunk), 0), 0))) ++# else ++# define obstack_free(h,obj) \ ++( (h)->temp = (char *) (obj) - (char *) (h)->chunk, \ ++ (((h)->temp > 0 && (h)->temp < (h)->chunk_limit - (char *) (h)->chunk)\ ++ ? (int) ((h)->next_free = (h)->object_base \ ++ = (h)->temp + (char *) (h)->chunk) \ ++ : (_obstack_free ((h), (h)->temp + (char *) (h)->chunk), 0))) ++# endif ++ ++#endif /* not __GNUC__ or not __STDC__ */ ++ ++#ifdef __cplusplus ++} /* C++ */ ++#endif ++ ++#endif /* obstack.h */ +--- crash/memory.c.orig 2005-03-03 11:36:20.000000000 -0500 +++ crash/memory.c 2005-01-06 14:56:46.000000000 -0500 @@ -88,7 +88,9 @@ static void kmem_search(struct meminfo *); @@ -696,7 +1331,18 @@ si->found = KMEM_BUFCTL_ADDR; else si->found = KMEM_SLAB_ADDR; ---- crash/help.c.orig 2005-02-09 16:13:25.000000000 -0500 +--- crash/filesys.c.orig 2005-03-03 11:36:20.000000000 -0500 ++++ crash/filesys.c 2005-03-02 16:19:05.000000000 -0500 +@@ -3457,7 +3457,7 @@ + "unexpected length of radix_tree_node structure\n"); + + ilen = ARRAY_LENGTH(height_to_maxindex); +- height_to_maxindex = (ulong *)GETBUF(ilen * sizeof(long)); ++ height_to_maxindex = (long *)GETBUF(ilen * sizeof(long)); + readmem(symbol_value("height_to_maxindex"), KVADDR, + height_to_maxindex, ilen*sizeof(long), + "height_to_maxindex array", FAULT_ON_ERROR); +--- crash/help.c.orig 2005-03-03 11:36:20.000000000 -0500 +++ crash/help.c 2005-01-28 15:26:13.000000000 -0500 @@ -3578,8 +3578,9 @@ " -li walks through the inactive_list and verifies nr_inactive_pages.", @@ -721,7 +1367,7 @@ "", " o One size fits all -- the utility can be run on any Linux kernel version ", " from 2.2.5-15 through 2.6.*.", ---- crash/task.c.orig 2005-02-09 16:13:25.000000000 -0500 +--- crash/task.c.orig 2005-03-03 11:36:20.000000000 -0500 +++ crash/task.c 2005-01-28 15:26:13.000000000 -0500 @@ -2842,6 +2842,10 @@ fprintf(fp, "(HARDWARE RESET)"); @@ -734,7 +1380,7 @@ else if (tc->task == tt->panic_task) fprintf(fp, "(PANIC)"); else ---- crash/kernel.c.orig 2005-02-09 16:13:25.000000000 -0500 +--- crash/kernel.c.orig 2005-03-03 11:36:20.000000000 -0500 +++ crash/kernel.c 2005-01-28 15:26:13.000000000 -0500 @@ -3252,6 +3252,9 @@ for (i = 0; i < NR_CPUS; i++) @@ -746,8 +1392,78 @@ fprintf(fp, "\n"); } ---- crash/ia64.c.orig 2005-02-09 16:13:25.000000000 -0500 -+++ crash/ia64.c 2005-02-09 16:12:05.000000000 -0500 +--- crash/gdb_interface.c.orig 2005-03-03 11:36:20.000000000 -0500 ++++ crash/gdb_interface.c 2005-03-02 16:19:05.000000000 -0500 +@@ -755,7 +755,8 @@ + { + case SIZEOF_8BIT: + p1 = (char *)buf; +- if ((memtype == KVADDR) && text_value_cache_byte(addr, p1)) ++ if ((memtype == KVADDR) && ++ text_value_cache_byte(addr, (unsigned char *)p1)) + return TRUE; + + if (readmem(addr, memtype, locbuf, SIZEOF_32BIT, +@@ -788,7 +789,7 @@ + /* + * Used by gdb_interface() to catch gdb-related errors, if desired. + */ +-volatile void ++void + gdb_error_hook(void) + { + char buf1[BUFSIZE]; +--- crash/alpha.c.orig 2005-03-03 11:36:20.000000000 -0500 ++++ crash/alpha.c 2005-03-02 14:24:46.000000000 -0500 +@@ -2602,6 +2602,8 @@ + int + alpha_get_smp_cpus(void) + { ++ int cpus; ++ + if ((cpus = get_cpus_online())) + return cpus; + else +--- crash/x86.c.orig 2005-03-03 11:36:20.000000000 -0500 ++++ crash/x86.c 2005-03-02 16:19:05.000000000 -0500 +@@ -487,7 +487,8 @@ + else + GET_STACK_DATA(addr, data, size); + } else { +- if ((size == sizeof(int)) && text_value_cache(addr, 0, &value)) ++ if ((size == sizeof(int)) && ++ text_value_cache(addr, 0, (uint32_t *)&value)) + return value; + + if (!readmem(addr, KVADDR, data, size, "db_get_value", +@@ -2939,6 +2940,25 @@ + value_to_symstr(value, buf2, pc->output_radix)); + + sprintf(p1, buf1); ++ } else if (STREQ(argv[argc-2], "call") && ++ hexadecimal(argv[argc-1], 0)) { ++ /* ++ * Update module code of the form: ++ * ++ * call 0xe081e1e0 ++ * ++ * to show a bracketed direct call target. ++ */ ++ p1 = &LASTCHAR(inbuf); ++ ++ if (extract_hex(argv[argc-1], &value, NULLCHAR, TRUE)) { ++ sprintf(buf1, " <%s>\n", ++ value_to_symstr(value, buf2, ++ pc->output_radix)); ++ if (IS_MODULE_VADDR(value) && ++ !strstr(buf2, "+")) ++ sprintf(p1, buf1); ++ } + } + + if (CRASHDEBUG(1)) +--- crash/ia64.c.orig 2005-03-03 11:36:20.000000000 -0500 ++++ crash/ia64.c 2005-02-14 08:57:07.000000000 -0500 @@ -56,6 +56,7 @@ static struct line_number_hook ia64_line_number_hooks[]; static ulong ia64_get_stackbase(ulong); @@ -1009,8 +1725,8 @@ } /* ---- crash/x86_64.c.orig 2005-02-09 16:13:25.000000000 -0500 -+++ crash/x86_64.c 2005-01-28 15:26:13.000000000 -0500 +--- crash/x86_64.c.orig 2005-03-03 11:36:20.000000000 -0500 ++++ crash/x86_64.c 2005-02-14 16:59:44.000000000 -0500 @@ -64,6 +64,7 @@ static void x86_64_init_kernel_pgd(void); static void x86_64_cpu_pda_init(void); @@ -1230,7 +1946,135 @@ break; } ---- crash/unwind.c.orig 2005-02-09 16:13:26.000000000 -0500 +@@ -2277,7 +2381,27 @@ + value_to_symstr(value, buf2, pc->output_radix)); + + sprintf(p1, buf1); +- } ++ ++ } else if (STREQ(argv[argc-2], "callq") && ++ hexadecimal(argv[argc-1], 0)) { ++ /* ++ * Update module code of the form: ++ * ++ * callq 0xffffffffa0017aa0 ++ * ++ * to show a bracketed direct call target. ++ */ ++ p1 = &LASTCHAR(inbuf); ++ ++ if (extract_hex(argv[argc-1], &value, NULLCHAR, TRUE)) { ++ sprintf(buf1, " <%s>\n", ++ value_to_symstr(value, buf2, ++ pc->output_radix)); ++ if (IS_MODULE_VADDR(value) && ++ !strstr(buf2, "+")) ++ sprintf(p1, buf1); ++ } ++ } + + console(" %s", inbuf); + +--- crash/remote.c.orig 2005-03-03 11:36:20.000000000 -0500 ++++ crash/remote.c 2005-03-02 16:19:05.000000000 -0500 +@@ -2134,7 +2134,7 @@ + + optlen = sizeof(rcvbuf); + if (getsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, (char *)&rcvbuf, +- &optlen) < 0) { ++ (socklen_t *)&optlen) < 0) { + error(INFO, "SO_RCVBUF getsockopt error\n"); + return; + } +@@ -2159,7 +2159,7 @@ + + optlen = sizeof(rcvbuf); + if (getsockopt(sockfd, SOL_SOCKET, SO_RCVLOWAT, (char *)&rcvbuf, +- &optlen) < 0) { ++ (socklen_t *)&optlen) < 0) { + error(INFO, "SO_RCVLOWAT getsockopt error\n"); + return; + } +--- crash/symbols.c.orig 2005-03-03 11:36:20.000000000 -0500 ++++ crash/symbols.c 2005-03-02 16:19:05.000000000 -0500 +@@ -411,7 +411,8 @@ + #if defined(GDB_5_3) + file_crc = calc_crc32(file_crc, buffer, count); + #elif defined(GDB_6_0) || defined(GDB_6_1) +- file_crc = gnu_debuglink_crc32(file_crc, buffer, count); ++ file_crc = gnu_debuglink_crc32(file_crc, ++ (unsigned char *)buffer, count); + #else + file_crc = 0xdeadbeef; /* can't get here */ + #endif +--- crash/lkcd_common.c.orig 2005-03-03 11:36:20.000000000 -0500 ++++ crash/lkcd_common.c 2005-03-02 16:19:05.000000000 -0500 +@@ -1085,7 +1085,8 @@ + case LKCD_DUMP_COMPRESS_GZIP: + if (!lkcd_uncompress_gzip((unsigned char *) + lkcd->page_cache_hdr[i].pg_bufptr, lkcd->page_size, +- lkcd->compressed_page, lkcd->get_dp_size())) { ++ (unsigned char *)lkcd->compressed_page, ++ lkcd->get_dp_size())) { + lkcd_print("uncompress of page "); + lkcd_print(BITS32() ? + "%llx failed!\n" : "%lx failed!\n", +--- crash/lkcd_x86_trace.c.orig 2005-03-03 11:36:20.000000000 -0500 ++++ crash/lkcd_x86_trace.c 2005-03-02 16:19:05.000000000 -0500 +@@ -4803,7 +4803,7 @@ + instrbuf.addr = pc; + instrbuf.size = 256; + #ifdef REDHAT +- fill_instr_cache(pc, instrbuf.buf); ++ fill_instr_cache(pc, (char *)instrbuf.buf); + #else + GET_BLOCK(pc, 256, instrbuf.buf); + #endif +--- crash/netdump.c.orig 2005-03-03 11:36:20.000000000 -0500 ++++ crash/netdump.c 2005-02-17 10:48:56.000000000 -0500 +@@ -111,7 +111,7 @@ + default: + goto bailout; + } +- nd->flags |= NETDUMP_ELF32; ++ nd->flags |= NETDUMP_ELF32; + load32 = (Elf32_Phdr *) + &header[sizeof(Elf32_Ehdr)+sizeof(Elf32_Phdr)]; + size = (size_t)load32->p_offset; +@@ -127,14 +127,23 @@ + if ((elf64->e_ident[EI_DATA] == ELFDATA2LSB) && + STREQ(MACHINE_TYPE, "IA64")) + break; ++ else ++ goto bailout; ++ + case EM_PPC64: + if ((elf64->e_ident[EI_DATA] == ELFDATA2MSB) && + STREQ(MACHINE_TYPE, "PPC64")) + break; ++ else ++ goto bailout; ++ + case EM_X86_64: + if ((elf64->e_ident[EI_DATA] == ELFDATA2LSB) && + STREQ(MACHINE_TYPE, "X86_64")) + break; ++ else ++ goto bailout; ++ + default: + goto bailout; + } +@@ -226,7 +235,7 @@ + + offset = (off_t)paddr + (off_t)nd->header_size; + +- if (lseek(nd->ndfd, offset, SEEK_SET) != offset) ++ if (lseek(nd->ndfd, offset, SEEK_SET) == -1) + return SEEK_ERROR; + + if (read(nd->ndfd, bufptr, cnt) != cnt) +--- crash/unwind.c.orig 2005-03-03 11:36:20.000000000 -0500 +++ crash/unwind.c 2005-02-07 16:02:44.000000000 -0500 @@ -31,6 +31,10 @@ * unwind_v[123].o object files. @@ -1562,8 +2406,8 @@ break; } } ---- crash/defs.h.orig 2005-02-09 16:13:26.000000000 -0500 -+++ crash/defs.h 2005-01-28 15:26:12.000000000 -0500 +--- crash/defs.h.orig 2005-03-03 11:36:20.000000000 -0500 ++++ crash/defs.h 2005-03-02 16:19:05.000000000 -0500 @@ -62,7 +62,7 @@ #include #include @@ -1573,7 +2417,19 @@ #undef TRUE #undef FALSE -@@ -446,6 +446,8 @@ +@@ -103,8 +103,9 @@ + + #define HIST_BLKSIZE (4096) + +-#define STREQ(A, B) (A && B && (strcmp(A, B) == 0)) +-#define STRNEQ(A, B) (A && B && (strncmp(A, B, strlen(B)) == 0)) ++#define STREQ(A, B) (A && B && (strcmp((char *)(A), (char *)(B)) == 0)) ++#define STRNEQ(A, B) (A && B && \ ++ (strncmp((char *)(A), (char *)(B), strlen((char *)(B))) == 0)) + #define BZERO(S, N) (memset(S, NULLCHAR, N)) + #define BCOPY(S, D, C) (memcpy(D, S, C)) + #define BNEG(S, N) (memset(S, 0xff, N)) +@@ -446,6 +447,8 @@ long __rq_idx[NR_CPUS]; long __cpu_idx[NR_CPUS]; long __per_cpu_offset[NR_CPUS]; @@ -1582,7 +2438,7 @@ }; /* -@@ -674,6 +676,7 @@ +@@ -674,6 +677,7 @@ #define FRAMESIZE_DEBUG (0x10000000) #define MACHDEP_BT_TEXT (0x8000000) #define DEVMEMRD (0x4000000) @@ -1590,7 +2446,7 @@ #define SYSRQ_TASK(X) ((machdep->flags & SYSRQ) && is_task_active(X)) extern struct machdep_table *machdep; -@@ -2030,6 +2033,9 @@ +@@ -2030,6 +2034,9 @@ #define UNKNOWN_PHYS_START ((ulong)(-1)) #define DEFAULT_PHYS_START (KERNEL_TR_PAGE_SIZE * 1) @@ -1600,7 +2456,7 @@ #endif /* IA64 */ #ifdef PPC64 -@@ -3106,6 +3112,7 @@ +@@ -3106,6 +3113,7 @@ #define BT_IRQSTACK (0x200000000ULL) #define BT_DUMPFILE_SEARCH (0x400000000ULL) #define BT_EFRAME_SEARCH2 (0x800000000ULL) @@ -1608,7 +2464,7 @@ #define BT_REF_HEXVAL (0x1) #define BT_REF_SYMBOL (0x2) -@@ -3229,6 +3236,8 @@ +@@ -3229,6 +3237,8 @@ int isize; }; @@ -1617,7 +2473,7 @@ struct machine_specific { char *pml4; char *irqstack; -@@ -3318,6 +3327,7 @@ +@@ -3318,6 +3328,7 @@ int ia64_IS_VMALLOC_ADDR(ulong); #define display_idt_table() \ error(FATAL, "-d option TBD on ia64 architecture\n"); @@ -1625,7 +2481,7 @@ #define OLD_UNWIND (0x1) /* CONFIG_IA64_NEW_UNWIND not turned on */ #define NEW_UNWIND (0x2) /* CONFIG_IA64_NEW_UNWIND turned on */ -@@ -3359,8 +3369,10 @@ +@@ -3359,8 +3370,10 @@ void (*unwind)(struct bt_info *); void (*dump_unwind_stats)(void); int (*unwind_debug)(ulong); @@ -1636,14 +2492,42 @@ /* * unwind.c */ ---- crash/Makefile.orig 2005-02-09 16:13:26.000000000 -0500 -+++ crash/Makefile 2005-02-09 16:13:25.000000000 -0500 -@@ -153,10 +153,10 @@ +@@ -3769,7 +3782,7 @@ + void gdb_interface(struct gnu_request *); + int gdb_pass_through(char *, FILE *, ulong); + int gdb_readmem_callback(ulong, void *, int, int); +-volatile void gdb_error_hook(void); ++void gdb_error_hook(void); + void restore_gdb_sanity(void); + int is_gdb_command(int, ulong); + char *gdb_command_string(int, char *, int); +@@ -3784,7 +3797,7 @@ + * gdb/top.c + */ + extern void (*command_loop_hook)(void); +-extern volatile void (*error_hook)(void); ++extern void (*error_hook)(void); + extern void execute_command (char *, int); + + /* +--- crash/Makefile.orig 2005-03-03 11:36:20.000000000 -0500 ++++ crash/Makefile 2005-03-03 11:36:20.000000000 -0500 +@@ -144,7 +144,7 @@ + ${GDB}/gdb/symfile.c ${GDB}/gdb/elfread.c \ + ${GDB}/gdb/ui-file.c ${GDB}/gdb/utils.c \ + ${GDB}/gdb/ppc-linux-tdep.c ${GDB}/sim/ppc/ppc-instructions \ +- ${GDB}/bfd/simple.c ++ ${GDB}/bfd/simple.c ${GDB}/include/obstack.h + GDB_6.0_OFILES=${GDB}/gdb/main.o ${GDB}/gdb/symtab.o \ + ${GDB}/gdb/target.o ${GDB}/gdb/symfile.o ${GDB}/gdb/elfread.o \ + ${GDB}/gdb/ui-file.o ${GDB}/gdb/utils.o \ +@@ -153,10 +153,11 @@ GDB_6.1_FILES=${GDB}/gdb/Makefile.in ${GDB}/Makefile.in \ ${GDB}/gdb/main.c ${GDB}/gdb/symtab.c ${GDB}/gdb/target.c \ ${GDB}/gdb/symfile.c ${GDB}/gdb/elfread.c \ - ${GDB}/gdb/ui-file.c ${GDB}/gdb/utils.c -+ ${GDB}/gdb/ui-file.c ${GDB}/gdb/utils.c ${GDB}/gdb/dwarf2read.c ++ ${GDB}/gdb/ui-file.c ${GDB}/gdb/utils.c ${GDB}/gdb/dwarf2read.c \ ++ ${GDB}/include/obstack.h GDB_6.1_OFILES=${GDB}/gdb/main.o ${GDB}/gdb/symtab.o \ ${GDB}/gdb/target.o ${GDB}/gdb/symfile.o ${GDB}/gdb/elfread.o \ - ${GDB}/gdb/ui-file.o ${GDB}/gdb/utils.o @@ -1651,7 +2535,7 @@ # # GDB_FLAGS is passed up from the gdb Makefile. ---- crash/crash.8.orig 2005-02-09 16:13:26.000000000 -0500 +--- crash/crash.8.orig 2005-03-03 11:36:20.000000000 -0500 +++ crash/crash.8 2005-01-31 10:55:43.000000000 -0500 @@ -104,9 +104,8 @@ .TP