--- glibc-current/malloc/obstack.h 2014-07-12 13:18:12.805934386 +0930 +++ binutils-gdb/include/obstack.h 2014-07-13 19:52:15.560418673 +0930 @@ -104,16 +104,62 @@ #ifndef _OBSTACK_H #define _OBSTACK_H 1 +#ifndef __OBSTACK_INTERFACE_VERSION +# define __OBSTACK_INTERFACE_VERSION 2 +#endif + +/* Comment out all the obstack.c code if we are using the GNU C + Library, and are not actually compiling the library itself, and the + installed library supports the same library interface we do. This + code is part of the GNU C Library, but also included in many other + GNU distributions. Compiling and linking in obstack.c code is a + waste when using the GNU C library (especially if it is a shared + library). Rather than having every GNU program understand + 'configure --with-gnu-libc' and omit the object files, it is + simpler to just do this in the source for each such file. */ + +#include /* Random thing to get __GNU_LIBRARY__. */ +#if !defined (_LIBC) && defined (__GNU_LIBRARY__) && __GNU_LIBRARY__ > 1 +# include +# if (_GNU_OBSTACK_INTERFACE_VERSION == __OBSTACK_INTERFACE_VERSION \ + || (_GNU_OBSTACK_INTERFACE_VERSION == 1 \ + && __OBSTACK_INTERFACE_VERSION >= 2 \ + && defined SIZEOF_INT && defined SIZEOF_SIZE_T \ + && SIZEOF_INT == SIZEOF_SIZE_T)) +# define __OBSTACK_ELIDE_CODE +# endif +#endif + +#if __OBSTACK_INTERFACE_VERSION == 1 +# define __OBSTACK_SIZE_T unsigned int +# define __CHUNK_SIZE_T unsigned long +#else +# define __OBSTACK_SIZE_T size_t +# define __CHUNK_SIZE_T size_t + +/* The version 2 functions in obstack.c are renamed so old shared + libraries that want version 1 code won't accidentally be linked + against functions with an incompatible ABI. */ +# if !defined __OBSTACK_ELIDE_CODE || _GNU_OBSTACK_INTERFACE_VERSION >= 2 +# define _obstack_allocated_p _obstack2_allocated_p +# define _obstack_begin _obstack2_begin +# define _obstack_begin_1 _obstack2_begin_1 +# define _obstack_free _obstack2_free +# define _obstack_memory_used _obstack2_memory_used +# define _obstack_newchunk _obstack2_newchunk +# endif +#endif + /* We need the type of a pointer subtraction. If __PTRDIFF_TYPE__ is defined, as with GNU C, use that; that way we don't pollute the namespace with 's symbols. Otherwise, include and use ptrdiff_t. */ #ifdef __PTRDIFF_TYPE__ -# define PTR_INT_TYPE __PTRDIFF_TYPE__ +# define __PTR_INT_TYPE __PTRDIFF_TYPE__ #else # include -# define PTR_INT_TYPE ptrdiff_t +# define __PTR_INT_TYPE ptrdiff_t #endif /* If B is the base of an object addressed by P, return the result of @@ -122,21 +168,28 @@ #define __BPTR_ALIGN(B, P, A) ((B) + (((P) - (B) + (A)) & ~(A))) -/* Similar to _BPTR_ALIGN (B, P, A), except optimize the common case +/* Similar to __BPTR_ALIGN (B, P, A), except optimize the common case where pointers can be converted to integers, aligned as integers, - and converted back again. If PTR_INT_TYPE is narrower than a + and converted back again. If __PTR_INT_TYPE is narrower than a pointer (e.g., the AS/400), play it safe and compute the alignment relative to B. Otherwise, use the faster strategy of computing the alignment relative to 0. */ #define __PTR_ALIGN(B, P, A) \ - __BPTR_ALIGN (sizeof (PTR_INT_TYPE) < sizeof (void *) ? (B) : (char *) 0, \ + __BPTR_ALIGN (sizeof (__PTR_INT_TYPE) < sizeof (void *) ? (B) : (char *) 0, \ P, A) +#if defined _LIBC || defined HAVE_STRING_H #include +#endif +/* Attribute 'pure' was valid as of gcc 3.0. */ #ifndef __attribute_pure__ -# define __attribute_pure__ _GL_ATTRIBUTE_PURE +# if defined __GNUC__ && __GNUC__ >= 3 +# define __attribute_pure__ __attribute__ ((__pure__)) +# else +# define __attribute_pure__ +# endif #endif #ifdef __cplusplus @@ -152,21 +205,21 @@ struct obstack /* control current object in current chunk */ { - long chunk_size; /* preferred size to allocate chunks in */ + __CHUNK_SIZE_T 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 */ union { - PTR_INT_TYPE tempint; - void *tempptr; + __OBSTACK_SIZE_T i; + void *p; } temp; /* Temporary for some macros. */ int alignment_mask; /* Mask of alignment for each object. */ /* 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); + struct _obstack_chunk *(*chunkfun) (void *, size_t); void (*freefun) (void *, struct _obstack_chunk *); void *extra_arg; /* first arg for chunk alloc/dealloc funcs */ unsigned use_extra_arg : 1; /* chunk alloc/dealloc funcs take extra arg */ @@ -181,18 +234,19 @@ /* Declare the external functions we use; they are in obstack.c. */ -extern void _obstack_newchunk (struct obstack *, int); -extern int _obstack_begin (struct obstack *, int, int, - void *(*)(long), void (*)(void *)); -extern int _obstack_begin_1 (struct obstack *, int, int, - void *(*)(void *, long), +extern void _obstack_newchunk (struct obstack *, __OBSTACK_SIZE_T); +extern int _obstack_begin (struct obstack *, __CHUNK_SIZE_T, int, + void *(*) (size_t), void (*) (void *)); +extern int _obstack_begin_1 (struct obstack *, __CHUNK_SIZE_T, int, + void *(*) (void *, size_t), void (*)(void *, void *), void *); -extern int _obstack_memory_used (struct obstack *) __attribute_pure__; +extern __OBSTACK_SIZE_T _obstack_memory_used (struct obstack *) + __attribute_pure__; -/* The default name of the function for freeing a chunk is 'obstack_free', +/* The default name of the function for freeing a chunk is '_obstack_free', but gnulib users can override this by defining '__obstack_free'. */ #ifndef __obstack_free -# define __obstack_free obstack_free +# define __obstack_free _obstack_free #endif extern void __obstack_free (struct obstack *, void *); @@ -227,26 +281,26 @@ /* To prevent prototype warnings provide complete argument list. */ #define obstack_init(h) \ _obstack_begin ((h), 0, 0, \ - (void *(*)(long))obstack_chunk_alloc, \ + (void *(*) (size_t)) obstack_chunk_alloc, \ (void (*)(void *))obstack_chunk_free) #define obstack_begin(h, size) \ _obstack_begin ((h), (size), 0, \ - (void *(*)(long))obstack_chunk_alloc, \ + (void *(*) (size_t)) 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 *(*) (size_t)) (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 *, size_t)) (chunkfun), \ (void (*)(void *, void *))(freefun), (arg)) #define obstack_chunkfun(h, newchunkfun) \ - ((h)->chunkfun = (struct _obstack_chunk *(*)(void *, long))(newchunkfun)) + ((h)->chunkfun = (struct _obstack_chunk *(*)(void *, size_t)) (newchunkfun)) #define obstack_freefun(h, newfreefun) \ ((h)->freefun = (void (*)(void *, struct _obstack_chunk *))(newfreefun)) @@ -258,7 +312,7 @@ #define obstack_memory_used(h) _obstack_memory_used (h) #if defined __GNUC__ -# if ! (2 < __GNUC__ + (8 <= __GNUC_MINOR__)) +# if !defined __GNUC_MINOR__ || __GNUC__ * 1000 + __GNUC_MINOR__ < 2008 # define __extension__ # endif @@ -270,18 +324,20 @@ # define obstack_object_size(OBSTACK) \ __extension__ \ ({ struct obstack const *__o = (OBSTACK); \ - (unsigned) (__o->next_free - __o->object_base); }) + (__OBSTACK_SIZE_T) (__o->next_free - __o->object_base); }) +/* The local variable is named __o1 to avoid a shadowed variable + warning when invoked from other obstack macros. */ # define obstack_room(OBSTACK) \ __extension__ \ - ({ struct obstack const *__o = (OBSTACK); \ - (unsigned) (__o->chunk_limit - __o->next_free); }) + ({ struct obstack const *__o1 = (OBSTACK); \ + (__OBSTACK_SIZE_T) (__o1->chunk_limit - __o1->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_SIZE_T __len = (length); \ + if (obstack_room (__o) < __len) \ _obstack_newchunk (__o, __len); \ (void) 0; }) @@ -296,8 +352,8 @@ # define obstack_grow(OBSTACK, where, length) \ __extension__ \ ({ struct obstack *__o = (OBSTACK); \ - int __len = (length); \ - if (__o->next_free + __len > __o->chunk_limit) \ + __OBSTACK_SIZE_T __len = (length); \ + if (obstack_room (__o) < __len) \ _obstack_newchunk (__o, __len); \ memcpy (__o->next_free, where, __len); \ __o->next_free += __len; \ @@ -306,8 +362,8 @@ # define obstack_grow0(OBSTACK, where, length) \ __extension__ \ ({ struct obstack *__o = (OBSTACK); \ - int __len = (length); \ - if (__o->next_free + __len + 1 > __o->chunk_limit) \ + __OBSTACK_SIZE_T __len = (length); \ + if (obstack_room (__o) < __len + 1) \ _obstack_newchunk (__o, __len + 1); \ memcpy (__o->next_free, where, __len); \ __o->next_free += __len; \ @@ -317,7 +373,7 @@ # define obstack_1grow(OBSTACK, datum) \ __extension__ \ ({ struct obstack *__o = (OBSTACK); \ - if (__o->next_free + 1 > __o->chunk_limit) \ + if (obstack_room (__o) < 1) \ _obstack_newchunk (__o, 1); \ obstack_1grow_fast (__o, datum); \ (void) 0; }) @@ -329,14 +385,14 @@ # define obstack_ptr_grow(OBSTACK, datum) \ __extension__ \ ({ struct obstack *__o = (OBSTACK); \ - if (__o->next_free + sizeof (void *) > __o->chunk_limit) \ + if (obstack_room (__o) < sizeof (void *)) \ _obstack_newchunk (__o, sizeof (void *)); \ - obstack_ptr_grow_fast (__o, datum); }) \ + 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) \ + if (obstack_room (__o) < sizeof (int)) \ _obstack_newchunk (__o, sizeof (int)); \ obstack_int_grow_fast (__o, datum); }) @@ -359,8 +415,8 @@ # define obstack_blank(OBSTACK, length) \ __extension__ \ ({ struct obstack *__o = (OBSTACK); \ - int __len = (length); \ - if (__o->chunk_limit - __o->next_free < __len) \ + __OBSTACK_SIZE_T __len = (length); \ + if (obstack_room (__o) < __len) \ _obstack_newchunk (__o, __len); \ obstack_blank_fast (__o, __len); \ (void) 0; }) @@ -383,19 +439,16 @@ 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 = (void *) __o1->object_base; \ if (__o1->next_free == __value) \ __o1->maybe_empty_object = 1; \ - __o1->next_free \ - = __PTR_ALIGN (__o1->object_base, __o1->next_free, \ + __o1->next_free = __PTR_ALIGN (__o1->object_base, __o1->next_free, \ __o1->alignment_mask); \ - if (__o1->next_free - (char *) __o1->chunk \ - > __o1->chunk_limit - (char *) __o1->chunk) \ + if ((size_t) (__o1->next_free - (char *) __o1->chunk) \ + > (size_t) (__o1->chunk_limit - (char *) __o1->chunk)) \ __o1->next_free = __o1->chunk_limit; \ __o1->object_base = __o1->next_free; \ __value; }) @@ -403,18 +456,20 @@ # define obstack_free(OBSTACK, OBJ) \ __extension__ \ ({ struct obstack *__o = (OBSTACK); \ - void *__obj = (OBJ); \ - if (__obj > (void *) __o->chunk && __obj < (void *) __o->chunk_limit) \ + 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 \ + __obstack_free (__o, __obj); }) #else /* not __GNUC__ */ # define obstack_object_size(h) \ - (unsigned) ((h)->next_free - (h)->object_base) + ((__OBSTACK_SIZE_T) ((h)->next_free - (h)->object_base)) # define obstack_room(h) \ - (unsigned) ((h)->chunk_limit - (h)->next_free) + ((__OBSTACK_SIZE_T) ((h)->chunk_limit - (h)->next_free)) # define obstack_empty_p(h) \ ((h)->chunk->prev == 0 \ @@ -427,29 +482,28 @@ 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.tempint = (length), \ - (((h)->next_free + (h)->temp.tempint > (h)->chunk_limit) \ - ? (_obstack_newchunk ((h), (h)->temp.tempint), 0) : 0)) + ((h)->temp.i = (length), \ + ((obstack_room (h) < (h)->temp.i) \ + ? (_obstack_newchunk ((h), (h)->temp.i), 0) : 0)) # define obstack_grow(h, where, length) \ - ((h)->temp.tempint = (length), \ - (((h)->next_free + (h)->temp.tempint > (h)->chunk_limit) \ - ? (_obstack_newchunk ((h), (h)->temp.tempint), 0) : 0), \ - memcpy ((h)->next_free, where, (h)->temp.tempint), \ - (h)->next_free += (h)->temp.tempint) + ((h)->temp.i = (length), \ + ((obstack_room (h) < (h)->temp.i) \ + ? (_obstack_newchunk ((h), (h)->temp.i), 0) : 0), \ + memcpy ((h)->next_free, where, (h)->temp.i), \ + (h)->next_free += (h)->temp.i) # define obstack_grow0(h, where, length) \ - ((h)->temp.tempint = (length), \ - (((h)->next_free + (h)->temp.tempint + 1 > (h)->chunk_limit) \ - ? (_obstack_newchunk ((h), (h)->temp.tempint + 1), 0) : 0), \ - memcpy ((h)->next_free, where, (h)->temp.tempint), \ - (h)->next_free += (h)->temp.tempint, \ + ((h)->temp.i = (length), \ + ((obstack_room (h) < (h)->temp.i + 1) \ + ? (_obstack_newchunk ((h), (h)->temp.i + 1), 0) : 0), \ + memcpy ((h)->next_free, where, (h)->temp.i), \ + (h)->next_free += (h)->temp.i, \ *((h)->next_free)++ = 0) # define obstack_1grow(h, datum) \ - ((((h)->next_free + 1 > (h)->chunk_limit) \ + (((obstack_room (h) < 1) \ ? (_obstack_newchunk ((h), 1), 0) : 0), \ obstack_1grow_fast (h, datum)) @@ -459,7 +513,7 @@ obstack_ptr_grow_fast (h, datum)) # define obstack_int_grow(h, datum) \ - ((((h)->next_free + sizeof (int) > (h)->chunk_limit) \ + (((obstack_room (h) < sizeof (int)) \ ? (_obstack_newchunk ((h), sizeof (int)), 0) : 0), \ obstack_int_grow_fast (h, datum)) @@ -470,10 +524,10 @@ (((int *) ((h)->next_free += sizeof (int)))[-1] = (aint)) # define obstack_blank(h, length) \ - ((h)->temp.tempint = (length), \ - (((h)->chunk_limit - (h)->next_free < (h)->temp.tempint) \ - ? (_obstack_newchunk ((h), (h)->temp.tempint), 0) : 0), \ - obstack_blank_fast (h, (h)->temp.tempint)) + ((h)->temp.i = (length), \ + ((obstack_room (h) < (h)->temp.i) \ + ? (_obstack_newchunk ((h), (h)->temp.i), 0) : 0), \ + obstack_blank_fast (h, (h)->temp.i)) # define obstack_alloc(h, length) \ (obstack_blank ((h), (length)), obstack_finish ((h))) @@ -488,23 +542,21 @@ (((h)->next_free == (h)->object_base \ ? (((h)->maybe_empty_object = 1), 0) \ : 0), \ - (h)->temp.tempptr = (h)->object_base, \ - (h)->next_free \ - = __PTR_ALIGN ((h)->object_base, (h)->next_free, \ + (h)->temp.p = (h)->object_base, \ + (h)->next_free = __PTR_ALIGN ((h)->object_base, (h)->next_free, \ (h)->alignment_mask), \ - (((h)->next_free - (char *) (h)->chunk \ - > (h)->chunk_limit - (char *) (h)->chunk) \ + (((size_t) ((h)->next_free - (char *) (h)->chunk) \ + > (size_t) ((h)->chunk_limit - (char *) (h)->chunk)) \ ? ((h)->next_free = (h)->chunk_limit) : 0), \ (h)->object_base = (h)->next_free, \ - (h)->temp.tempptr) + (h)->temp.p) # define obstack_free(h, obj) \ - ((h)->temp.tempint = (char *) (obj) - (char *) (h)->chunk, \ - ((((h)->temp.tempint > 0 \ - && (h)->temp.tempint < (h)->chunk_limit - (char *) (h)->chunk)) \ - ? (void) ((h)->next_free = (h)->object_base \ - = (h)->temp.tempint + (char *) (h)->chunk) \ - : (__obstack_free) (h, (h)->temp.tempint + (char *) (h)->chunk))) + ((h)->temp.p = (void *) (obj), \ + (((h)->temp.p > (void *) (h)->chunk \ + && (h)->temp.p < (void *) (h)->chunk_limit) \ + ? (void) ((h)->next_free = (h)->object_base = (char *) (h)->temp.p) \ + : __obstack_free ((h), (h)->temp.p))) #endif /* not __GNUC__ */ @@ -512,4 +564,4 @@ } /* C++ */ #endif -#endif /* obstack.h */ +#endif /* _OBSTACK_H */ --- glibc-current/malloc/obstack.c 2014-07-12 13:18:12.805934386 +0930 +++ binutils-gdb/libiberty/obstack.c 2014-07-13 19:52:15.560418673 +0930 @@ -21,37 +21,19 @@ # include # include #else -# include +# ifdef HAVE_CONFIG_H +# include "config.h" +# endif # include "obstack.h" #endif -/* NOTE BEFORE MODIFYING THIS FILE: This version number must be - incremented whenever callers compiled using an old obstack.h can no - longer properly call the functions in this obstack.c. */ -#define OBSTACK_INTERFACE_VERSION 1 - -/* Comment out all this code if we are using the GNU C Library, and are not - actually compiling the library itself, and the installed library - supports the same library interface we do. This code is part of the GNU - C Library, but also included in many other GNU distributions. Compiling - and linking in this code is a waste when using the GNU C library - (especially if it is a shared library). Rather than having every GNU - program understand 'configure --with-gnu-libc' and omit the object - files, it is simpler to just do this in the source for each such file. */ +/* NOTE BEFORE MODIFYING THIS FILE: __OBSTACK_INTERFACE_VERSION in + obstack.h must be incremented whenever callers compiled using an old + obstack.h can no longer properly call the functions in this file. */ -#include /* Random thing to get __GNU_LIBRARY__. */ -#if !defined _LIBC && defined __GNU_LIBRARY__ && __GNU_LIBRARY__ > 1 -# include -# if _GNU_OBSTACK_INTERFACE_VERSION == OBSTACK_INTERFACE_VERSION -# define ELIDE_CODE -# endif -#endif +#ifndef __OBSTACK_ELIDE_CODE #include - -#ifndef ELIDE_CODE - - # include /* Determine default alignment. */ @@ -75,34 +57,44 @@ DEFAULT_ROUNDING = sizeof (union fooround) }; -/* When we copy a long block of data, this is the unit to do it with. - On some machines, copying successive ints does not work; - in such a case, redefine COPYING_UNIT to 'long' (if that works) - or 'char' as a last resort. */ -# ifndef COPYING_UNIT -# define COPYING_UNIT int +# ifdef _LIBC +# include # endif - /* The functions allocating more room by calling 'obstack_chunk_alloc' jump to the handler pointed to by 'obstack_alloc_failed_handler'. This can be set to a user defined function which should either abort gracefully or use longjump - but shouldn't return. This variable by default points to the internal function 'print_and_abort'. */ -static _Noreturn void print_and_abort (void); + +# if (!defined _LIBC \ + || _GNU_OBSTACK_INTERFACE_VERSION == __OBSTACK_INTERFACE_VERSION) + +#ifndef __attribute_noreturn__ +# if (defined __GNUC__ && defined __GNUC_MINOR__ \ + && __GNUC__ * 1000 + __GNUC_MINOR__ >= 2007) +# define __attribute_noreturn__ __attribute__ ((__noreturn__)) +# else +# define __attribute_noreturn__ +# endif +#endif +static void __attribute_noreturn__ print_and_abort (void); void (*obstack_alloc_failed_handler) (void) = print_and_abort; /* Exit value used when 'print_and_abort' is used. */ # include +# ifndef EXIT_FAILURE +# define EXIT_FAILURE 1 +# endif # ifdef _LIBC int obstack_exit_failure = EXIT_FAILURE; # else -# include "exitfail.h" -# define obstack_exit_failure exit_failure +# define obstack_exit_failure EXIT_FAILURE +# endif # endif -# ifdef _LIBC +# if defined _LIBC && __OBSTACK_INTERFACE_VERSION == 1 # if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_3_4) /* A looong time ago (before 1994, anyway; we're not sure) this global variable was used by non-GNU-C macros to avoid multiple evaluation. The GNU C @@ -121,7 +113,7 @@ # define CALL_CHUNKFUN(h, size) \ (((h)->use_extra_arg) \ ? (*(h)->chunkfun)((h)->extra_arg, (size)) \ - : (*(struct _obstack_chunk *(*)(long))(h)->chunkfun)((size))) + : (*(struct _obstack_chunk *(*) (size_t)) (h)->chunkfun) ((size))) # define CALL_FREEFUN(h, old_chunk) \ do { \ @@ -140,11 +132,14 @@ Return nonzero if successful, calls obstack_alloc_failed_handler if allocation fails. */ -int -_obstack_begin (struct obstack *h, - int size, int alignment, - void *(*chunkfun) (long), - void (*freefun) (void *)) +typedef struct _obstack_chunk * (*chunkfun_t) (void *, size_t); +typedef void (*freefun_t) (void *, struct _obstack_chunk *); + +static int +_obstack_begin_worker (struct obstack *h, + __CHUNK_SIZE_T size, int alignment, + chunkfun_t chunkfun, freefun_t freefun, + void *arg, int use_extra_arg) { struct _obstack_chunk *chunk; /* points to new chunk */ @@ -167,19 +162,19 @@ size = 4096 - extra; } - h->chunkfun = (struct _obstack_chunk * (*) (void *, long)) chunkfun; - h->freefun = (void (*) (void *, struct _obstack_chunk *)) freefun; + h->chunkfun = chunkfun; + h->freefun = freefun; h->chunk_size = size; h->alignment_mask = alignment - 1; - h->use_extra_arg = 0; + h->extra_arg = arg; + h->use_extra_arg = use_extra_arg; chunk = h->chunk = CALL_CHUNKFUN (h, h->chunk_size); if (!chunk) (*obstack_alloc_failed_handler) (); h->next_free = h->object_base = __PTR_ALIGN ((char *) chunk, chunk->contents, alignment - 1); - h->chunk_limit = chunk->limit - = (char *) chunk + h->chunk_size; + h->chunk_limit = chunk->limit = (char *) chunk + h->chunk_size; chunk->prev = 0; /* The initial chunk now contains no empty object. */ h->maybe_empty_object = 0; @@ -188,51 +183,26 @@ } int -_obstack_begin_1 (struct obstack *h, int size, int alignment, - void *(*chunkfun) (void *, long), - void (*freefun) (void *, void *), - void *arg) -{ - struct _obstack_chunk *chunk; /* points to new chunk */ - - if (alignment == 0) - alignment = DEFAULT_ALIGNMENT; - if (size == 0) - /* Default size is what GNU malloc can fit in a 4096-byte block. */ +_obstack_begin (struct obstack *h, + __CHUNK_SIZE_T size, int alignment, + void *(*chunkfun) (size_t), + void (*freefun) (void *)) { - /* 12 is sizeof (mhead) and 4 is EXTRA from GNU malloc. - Use the values for range checking, because if range checking is off, - the extra bytes won't be missed terribly, but if range checking is on - and we used a larger request, a whole extra 4096 bytes would be - allocated. - - These number are irrelevant to the new GNU malloc. I suspect it is - less sensitive to the size of the request. */ - int extra = ((((12 + DEFAULT_ROUNDING - 1) & ~(DEFAULT_ROUNDING - 1)) - + 4 + DEFAULT_ROUNDING - 1) - & ~(DEFAULT_ROUNDING - 1)); - size = 4096 - extra; + return _obstack_begin_worker (h, size, alignment, + (chunkfun_t) chunkfun, (freefun_t) freefun, + NULL, 0); } - h->chunkfun = (struct _obstack_chunk * (*)(void *,long)) chunkfun; - h->freefun = (void (*) (void *, struct _obstack_chunk *)) freefun; - h->chunk_size = size; - h->alignment_mask = alignment - 1; - h->extra_arg = arg; - h->use_extra_arg = 1; - - chunk = h->chunk = CALL_CHUNKFUN (h, h->chunk_size); - if (!chunk) - (*obstack_alloc_failed_handler) (); - h->next_free = h->object_base = __PTR_ALIGN ((char *) chunk, chunk->contents, - alignment - 1); - h->chunk_limit = chunk->limit - = (char *) chunk + h->chunk_size; - chunk->prev = 0; - /* The initial chunk now contains no empty object. */ - h->maybe_empty_object = 0; - h->alloc_failed = 0; - return 1; +int +_obstack_begin_1 (struct obstack *h, + __CHUNK_SIZE_T size, int alignment, + void *(*chunkfun) (void *, size_t), + void (*freefun) (void *, void *), + void *arg) +{ + return _obstack_begin_worker (h, size, alignment, + (chunkfun_t) chunkfun, (freefun_t) freefun, + arg, 1); } /* Allocate a new current chunk for the obstack *H @@ -242,14 +212,12 @@ to the beginning of the new one. */ void -_obstack_newchunk (struct obstack *h, int length) +_obstack_newchunk (struct obstack *h, __OBSTACK_SIZE_T length) { struct _obstack_chunk *old_chunk = h->chunk; struct _obstack_chunk *new_chunk; - long new_size; - long obj_size = h->next_free - h->object_base; - long i; - long already; + size_t new_size; + size_t obj_size = h->next_free - h->object_base; char *object_base; /* Compute size for new chunk. */ @@ -269,25 +237,8 @@ object_base = __PTR_ALIGN ((char *) new_chunk, new_chunk->contents, h->alignment_mask); - /* Move the existing object to the new chunk. - Word at a time is fast and is safe if the object - is sufficiently aligned. */ - if (h->alignment_mask + 1 >= DEFAULT_ALIGNMENT) - { - for (i = obj_size / sizeof (COPYING_UNIT) - 1; - i >= 0; i--) - ((COPYING_UNIT *) object_base)[i] - = ((COPYING_UNIT *) h->object_base)[i]; - /* We used to copy the odd few remaining bytes as one extra COPYING_UNIT, - but that can cross a page boundary on a machine - which does not do strict alignment for COPYING_UNITS. */ - already = obj_size / sizeof (COPYING_UNIT) * sizeof (COPYING_UNIT); - } - else - already = 0; - /* Copy remaining bytes one by one. */ - for (i = already; i < obj_size; i++) - object_base[i] = h->object_base[i]; + /* Move the existing object to the new chunk. */ + memcpy (object_base, h->object_base, obj_size); /* If the object just copied was the only data in OLD_CHUNK, free that chunk and remove it from the chain. @@ -371,40 +322,43 @@ abort (); } -# ifdef _LIBC -/* Older versions of libc used a function _obstack_free intended to be - called by non-GCC compilers. */ -strong_alias (obstack_free, _obstack_free) +# if defined _LIBC && __OBSTACK_INTERFACE_VERSION == 1 +/* Older versions of libc declared both _obstack_free and obstack_free. */ +strong_alias (__obstack_free, obstack_free) # endif -int +__OBSTACK_SIZE_T _obstack_memory_used (struct obstack *h) { struct _obstack_chunk *lp; - int nbytes = 0; + __OBSTACK_SIZE_T nbytes = 0; for (lp = h->chunk; lp != 0; lp = lp->prev) - { nbytes += lp->limit - (char *) lp; - } + return nbytes; } +# if (!defined _LIBC \ + || _GNU_OBSTACK_INTERFACE_VERSION == __OBSTACK_INTERFACE_VERSION) /* Define the error handler. */ -# ifdef _LIBC +# if (HAVE_LIBINTL_H && ENABLE_NLS) || defined _LIBC # include -# else -# include "gettext.h" +# ifndef _ +# define _(Str) gettext (Str) # endif +# else # ifndef _ -# define _(msgid) gettext (msgid) +# define _(Str) (Str) +# endif # endif # ifdef _LIBC # include # endif -static _Noreturn void +static void +__attribute_noreturn__ print_and_abort (void) { /* Don't change any of these strings. Yes, it would be possible to add @@ -419,5 +373,6 @@ # endif exit (obstack_exit_failure); } +# endif -#endif /* !ELIDE_CODE */ +#endif /* !__OBSTACK_ELIDE_CODE */