Fredrik Fornwall
9 years ago
23 changed files with 2917 additions and 49 deletions
File diff suppressed because it is too large
@ -0,0 +1,11 @@ |
|||
diff -u -r ../elfutils-0.166/config.h.in ./config.h.in
|
|||
--- ../elfutils-0.166/config.h.in 2016-03-31 04:59:09.000000000 -0400
|
|||
+++ ./config.h.in 2016-05-04 13:36:44.002345307 -0400
|
|||
@@ -1,4 +1,7 @@
|
|||
/* config.h.in. Generated from configure.ac by autoheader. */ |
|||
+#include <libgen.h> /* for basename(3) */
|
|||
+#include <stdio_ext.h> /* for fputc_unlocked(3) */
|
|||
+#define DL_CALL_FCT(f, args) ((*(f)) args)
|
|||
|
|||
/* Building with -fsanitize=undefined or not */ |
|||
#undef CHECK_UNDEFINED |
|||
@ -0,0 +1,22 @@ |
|||
diff -u -r ../elfutils-0.166/libdwfl/dwfl_error.c ./libdwfl/dwfl_error.c
|
|||
--- ../elfutils-0.166/libdwfl/dwfl_error.c 2015-11-27 08:36:29.000000000 -0500
|
|||
+++ ./libdwfl/dwfl_error.c 2016-05-04 13:15:42.522820139 -0400
|
|||
@@ -140,6 +140,7 @@
|
|||
const char * |
|||
dwfl_errmsg (int error) |
|||
{ |
|||
+ char* error_msg;
|
|||
if (error == 0 || error == -1) |
|||
{ |
|||
int last_error = global_error; |
|||
@@ -154,7 +155,9 @@
|
|||
switch (error &~ 0xffff) |
|||
{ |
|||
case OTHER_ERROR (ERRNO): |
|||
- return strerror_r (error & 0xffff, "bad", 0);
|
|||
+ error_msg = malloc(256);
|
|||
+ strerror_r (error & 0xffff, error_msg, 256);
|
|||
+ return error_msg;
|
|||
case OTHER_ERROR (LIBELF): |
|||
return elf_errmsg (error & 0xffff); |
|||
case OTHER_ERROR (LIBDW): |
|||
@ -0,0 +1,15 @@ |
|||
diff -u -r ../elfutils-0.166/libebl/eblwstrtab.c ./libebl/eblwstrtab.c
|
|||
--- ../elfutils-0.166/libebl/eblwstrtab.c 2015-08-21 08:22:37.000000000 -0400
|
|||
+++ ./libebl/eblwstrtab.c 2016-05-04 13:11:26.834934000 -0400
|
|||
@@ -294,6 +294,11 @@
|
|||
return newstr; |
|||
} |
|||
|
|||
+static wchar_t* wmempcpy(wchar_t* s1, const wchar_t* s2, size_t n)
|
|||
+{
|
|||
+ size_t bytes = n * sizeof(wchar_t);
|
|||
+ return (wchar_t *) (memcpy((char *) s1, (char *) s2, bytes) + bytes);
|
|||
+}
|
|||
|
|||
static void |
|||
copystrings (struct Ebl_WStrent *nodep, wchar_t **freep, size_t *offsetp) |
|||
@ -1,12 +1,12 @@ |
|||
diff -u -r ../elfutils-0.159/libelf/elf_getaroff.c ./libelf/elf_getaroff.c
|
|||
--- ../elfutils-0.159/libelf/elf_getaroff.c 2014-02-05 01:21:44.000000000 +0100
|
|||
+++ ./libelf/elf_getaroff.c 2014-05-30 15:05:42.226191850 +0200
|
|||
diff -u -r ../elfutils-0.166/libelf/elf_getaroff.c ./libelf/elf_getaroff.c
|
|||
--- ../elfutils-0.166/libelf/elf_getaroff.c 2015-11-27 08:36:29.000000000 -0500
|
|||
+++ ./libelf/elf_getaroff.c 2016-05-04 13:07:06.547288608 -0400
|
|||
@@ -38,7 +38,7 @@
|
|||
#include "libelfP.h" |
|||
|
|||
|
|||
-off_t
|
|||
+loff_t
|
|||
elf_getaroff (elf) |
|||
Elf *elf; |
|||
elf_getaroff (Elf *elf) |
|||
{ |
|||
/* Be gratious, the specs demand it. */ |
|||
|
|||
@ -1,12 +0,0 @@ |
|||
diff -u -r ../elfutils-0.159/libelf/elf_getbase.c ./libelf/elf_getbase.c
|
|||
--- ../elfutils-0.159/libelf/elf_getbase.c 2014-02-05 01:21:44.000000000 +0100
|
|||
+++ ./libelf/elf_getbase.c 2014-05-30 14:42:12.766230381 +0200
|
|||
@@ -37,7 +37,7 @@
|
|||
#include "libelfP.h" |
|||
|
|||
|
|||
-off_t
|
|||
+loff_t
|
|||
elf_getbase (elf) |
|||
Elf *elf; |
|||
{ |
|||
@ -1,12 +1,11 @@ |
|||
diff -u -r ../elfutils-0.159/libelf/elf_update.c ./libelf/elf_update.c
|
|||
--- ../elfutils-0.159/libelf/elf_update.c 2014-05-18 16:32:15.000000000 +0200
|
|||
+++ ./libelf/elf_update.c 2014-05-30 14:56:42.806206596 +0200
|
|||
@@ -123,7 +123,7 @@
|
|||
} |
|||
diff -u -r ../elfutils-0.166/libelf/elf_update.c ./libelf/elf_update.c
|
|||
--- ../elfutils-0.166/libelf/elf_update.c 2015-11-27 08:36:29.000000000 -0500
|
|||
+++ ./libelf/elf_update.c 2016-05-04 13:06:15.836140729 -0400
|
|||
@@ -39,6 +39,7 @@
|
|||
|
|||
#include "libelfP.h" |
|||
|
|||
-off_t
|
|||
+loff_t
|
|||
elf_update (elf, cmd) |
|||
Elf *elf; |
|||
Elf_Cmd cmd; |
|||
+#define off_t loff_t
|
|||
|
|||
static off_t |
|||
write_file (Elf *elf, off_t size, int change_bo, size_t shnum) |
|||
|
|||
@ -0,0 +1,12 @@ |
|||
diff -u -r ../elfutils-0.166/src/elfcompress.c ./src/elfcompress.c
|
|||
--- ../elfutils-0.166/src/elfcompress.c 2016-03-02 11:25:38.000000000 -0500
|
|||
+++ ./src/elfcompress.c 2016-05-04 14:33:03.812183632 -0400
|
|||
@@ -166,7 +166,7 @@
|
|||
struct section_pattern *pattern = patterns; |
|||
while (pattern != NULL) |
|||
{ |
|||
- if (fnmatch (pattern->pattern, name, FNM_EXTMATCH) == 0)
|
|||
+ if (fnmatch (pattern->pattern, name, 0) == 0)
|
|||
return true; |
|||
pattern = pattern->next; |
|||
} |
|||
@ -0,0 +1,25 @@ |
|||
#include <stdarg.h> |
|||
#include <stdio.h> |
|||
#include <stdlib.h> |
|||
|
|||
/* program_invocation_short_name GNU extension - http://linux.die.net/man/3/program_invocation_short_name */ |
|||
extern char* __progname; |
|||
#define program_invocation_short_name __progname |
|||
|
|||
/* error(3) GNU extension - http://man7.org/linux/man-pages/man3/error.3.html */ |
|||
unsigned int error_message_count; |
|||
static inline void error(int status, int errnum, const char* format, ...) { |
|||
error_message_count++; |
|||
va_list myargs; |
|||
va_start(myargs, format); |
|||
vfprintf(stderr, format, myargs); |
|||
va_end(myargs); |
|||
exit(status); |
|||
} |
|||
|
|||
/* strchrnul(3) GNU extension - http://man7.org/linux/man-pages/man3/strchr.3.html */ |
|||
static inline char* strchrnul(char const* s, int c) |
|||
{ |
|||
char* result = strchr(s, c); |
|||
return (result == NULL) ? (char*)(s + strlen(s)) : result; |
|||
} |
|||
@ -0,0 +1,60 @@ |
|||
diff -u -r ../elfutils-0.166/src/ldgeneric.c ./src/ldgeneric.c
|
|||
--- ../elfutils-0.166/src/ldgeneric.c 2015-08-21 08:22:37.000000000 -0400
|
|||
+++ ./src/ldgeneric.c 2016-05-04 15:20:09.029651147 -0400
|
|||
@@ -1747,7 +1747,13 @@
|
|||
|
|||
/* The content of the file is available in memory. Read the |
|||
memory region as a stream. */ |
|||
+#ifdef __ANDROID__
|
|||
+ ldin = tmpfile();
|
|||
+ fwrite(content, 1, contentsize, ldin);
|
|||
+ rewind(ldin);
|
|||
+#else
|
|||
ldin = fmemopen (content, contentsize, "r"); |
|||
+#endif
|
|||
} |
|||
|
|||
/* No need for locking. */ |
|||
@@ -2631,9 +2637,9 @@
|
|||
/* Callback function registered with on_exit to make sure the temporary |
|||
files gets removed if something goes wrong. */ |
|||
static void |
|||
-remove_tempfile (int status, void *arg)
|
|||
+remove_tempfile ()
|
|||
{ |
|||
- if (status != 0 && ld_state.tempfname != NULL)
|
|||
+ if (ld_state.tempfname != NULL)
|
|||
unlink (ld_state.tempfname); |
|||
} |
|||
|
|||
@@ -2680,7 +2686,7 @@
|
|||
|
|||
/* Make sure we remove the temporary file in case something goes |
|||
wrong. */ |
|||
- on_exit (remove_tempfile, NULL);
|
|||
+ atexit (remove_tempfile);
|
|||
|
|||
/* Create the ELF file data for the output file. */ |
|||
Elf *elf = ld_state.outelf = elf_begin (fd, |
|||
@@ -3352,6 +3358,7 @@
|
|||
struct id_list search; |
|||
struct id_list *verp; |
|||
bool result = ld_state.default_bind_local; |
|||
+ size_t substr_len;
|
|||
|
|||
if (XELF_ST_BIND (sym->st_info) == STB_LOCAL || sym->st_shndx == SHN_UNDEF) |
|||
/* We don't have to do anything to local symbols here. */ |
|||
@@ -3367,7 +3374,12 @@
|
|||
version = strchr (str, VER_CHR); |
|||
if (version != NULL) |
|||
{ |
|||
- search.id = strndupa (str, version - str);
|
|||
+ substr_len = version - str;
|
|||
+ char* tmp = alloca(substr_len+1);
|
|||
+ strncpy(tmp, str, substr_len);
|
|||
+ tmp[substr_len] = 0;
|
|||
+ search.id = tmp;
|
|||
+
|
|||
if (*++version == VER_CHR) |
|||
/* Skip the second '@' signaling a default definition. */ |
|||
++version; |
|||
@ -0,0 +1,14 @@ |
|||
diff -u -r ../elfutils-0.166/libdwfl/libdwflP.h ./libdwfl/libdwflP.h
|
|||
--- ../elfutils-0.166/libdwfl/libdwflP.h 2016-01-12 07:49:19.000000000 -0500
|
|||
+++ ./libdwfl/libdwflP.h 2016-05-04 13:21:07.997599838 -0400
|
|||
@@ -771,5 +771,10 @@
|
|||
/* The default used by dwfl_standard_find_debuginfo. */ |
|||
#define DEFAULT_DEBUGINFO_PATH ":.debug:/usr/lib/debug" |
|||
|
|||
+ /* canonicalize_file_name GNU extension - http://man7.org/linux/man-pages/man3/canonicalize_file_name.3.html */
|
|||
+inline static char* canonicalize_file_name(const char *path)
|
|||
+{
|
|||
+ return realpath(path, NULL);
|
|||
+}
|
|||
|
|||
#endif /* libdwflP.h */ |
|||
@ -0,0 +1,12 @@ |
|||
diff -u -r ../elfutils-0.166/libelf/elf_getbase.c ./libelf/elf_getbase.c
|
|||
--- ../elfutils-0.166/libelf/elf_getbase.c 2015-11-27 08:36:29.000000000 -0500
|
|||
+++ ./libelf/elf_getbase.c 2016-05-04 13:01:52.776589425 -0400
|
|||
@@ -37,7 +37,7 @@
|
|||
#include "libelfP.h" |
|||
|
|||
|
|||
-off_t
|
|||
+loff_t
|
|||
elf_getbase (Elf *elf) |
|||
{ |
|||
return elf == NULL ? (off_t) -1 : elf->start_offset; |
|||
@ -0,0 +1,12 @@ |
|||
diff -u -r ../elfutils-0.166/libelf/elf_getdata_rawchunk.c ./libelf/elf_getdata_rawchunk.c
|
|||
--- ../elfutils-0.166/libelf/elf_getdata_rawchunk.c 2015-11-27 08:36:29.000000000 -0500
|
|||
+++ ./libelf/elf_getdata_rawchunk.c 2016-05-04 13:03:35.578844420 -0400
|
|||
@@ -41,7 +41,7 @@
|
|||
#include "common.h" |
|||
|
|||
Elf_Data * |
|||
-elf_getdata_rawchunk (Elf *elf, off_t offset, size_t size, Elf_Type type)
|
|||
+elf_getdata_rawchunk (Elf *elf, loff_t offset, size_t size, Elf_Type type)
|
|||
{ |
|||
if (unlikely (elf == NULL)) |
|||
return NULL; |
|||
@ -0,0 +1,794 @@ |
|||
/* obstack.h - object stack macros
|
|||
Copyright (C) 1988-1994,1996-1999,2003,2004,2005,2009,2011,2012 |
|||
Free Software Foundation, Inc. |
|||
This file is part of the GNU C Library. |
|||
|
|||
The GNU C Library is free software; you can redistribute it and/or |
|||
modify it under the terms of the GNU Lesser General Public |
|||
License as published by the Free Software Foundation; either |
|||
version 2.1 of the License, or (at your option) any later version. |
|||
|
|||
The GNU C Library 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 |
|||
Lesser General Public License for more details. |
|||
|
|||
You should have received a copy of the GNU Lesser General Public |
|||
License along with the GNU C Library; if not, see |
|||
<http://www.gnu.org/licenses/>. */
|
|||
|
|||
/* 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 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 <stddef.h>'s symbols. Otherwise, include <stddef.h> |
|||
and use ptrdiff_t. */ |
|||
|
|||
#ifdef __PTRDIFF_TYPE__ |
|||
# define PTR_INT_TYPE __PTRDIFF_TYPE__ |
|||
#else |
|||
# include <stddef.h> |
|||
# define PTR_INT_TYPE ptrdiff_t |
|||
#endif |
|||
|
|||
/* If B is the base of an object addressed by P, return the result of
|
|||
aligning P to the next multiple of A + 1. B and P must be of type |
|||
char *. A + 1 must be a power of 2. */ |
|||
|
|||
#define __BPTR_ALIGN(B, P, A) ((B) + (((P) - (B) + (A)) & ~(A))) |
|||
|
|||
/* Similiar 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 |
|||
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, \ |
|||
P, A) |
|||
|
|||
#include <string.h> |
|||
|
|||
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 */ |
|||
union |
|||
{ |
|||
PTR_INT_TYPE tempint; |
|||
void *tempptr; |
|||
} 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); |
|||
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 */ |
|||
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. */ |
|||
}; |
|||
|
|||
static void _obstack_newchunk (struct obstack *h, int length); |
|||
|
|||
/* 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) ((void *) (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. */ |
|||
#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)) |
|||
|
|||
#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__ |
|||
/* 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 const *__o = (OBSTACK); \ |
|||
(unsigned) (__o->next_free - __o->object_base); }) |
|||
|
|||
# define obstack_room(OBSTACK) \ |
|||
__extension__ \ |
|||
({ struct obstack const *__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 const *__o = (OBSTACK); \ |
|||
(__o->chunk->prev == 0 \ |
|||
&& __o->next_free == __PTR_ALIGN ((char *) __o->chunk, \ |
|||
__o->chunk->contents, \ |
|||
__o->alignment_mask)); }) |
|||
|
|||
# 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); \ |
|||
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); \ |
|||
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 = (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->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 = (OBJ); \ |
|||
if (__obj > (void *)__o->chunk && __obj < (void *)__o->chunk_limit) \ |
|||
__o->next_free = __o->object_base = (char *)__obj; \ |
|||
else (obstack_free_func) (__o, __obj); }) |
|||
|
|||
#else /* not __GNUC__ */ |
|||
|
|||
# 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 == __PTR_ALIGN ((char *) (h)->chunk, \ |
|||
(h)->chunk->contents, \ |
|||
(h)->alignment_mask)) |
|||
|
|||
/* 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.tempint = (length), \ |
|||
(((h)->next_free + (h)->temp.tempint > (h)->chunk_limit) \ |
|||
? (_obstack_newchunk ((h), (h)->temp.tempint), 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) |
|||
|
|||
# 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)->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] = (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)) |
|||
|
|||
# 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.tempptr = (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) \ |
|||
? ((h)->next_free = (h)->chunk_limit) : 0), \ |
|||
(h)->object_base = (h)->next_free, \ |
|||
(h)->temp.tempptr) |
|||
|
|||
# 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)) \ |
|||
? (((h)->next_free = (h)->object_base \ |
|||
= (h)->temp.tempint + (char *) (h)->chunk), 0) \ |
|||
: ((obstack_free_func) ((h), (h)->temp.tempint + (char *) (h)->chunk), 0))) |
|||
|
|||
#endif /* not __GNUC__ */ |
|||
|
|||
/* START LOCAL ADDITION */ |
|||
static inline int obstack_printf(struct obstack *obst, const char *fmt, ...) |
|||
{ |
|||
char buf[1024]; |
|||
va_list ap; |
|||
int len; |
|||
|
|||
va_start(ap, fmt); |
|||
len = vsnprintf(buf, sizeof(buf), fmt, ap); |
|||
obstack_grow(obst, buf, len); |
|||
va_end(ap); |
|||
|
|||
return len; |
|||
} |
|||
/* Determine default alignment. */ |
|||
union fooround |
|||
{ |
|||
uintmax_t i; |
|||
long double d; |
|||
void *p; |
|||
}; |
|||
struct fooalign |
|||
{ |
|||
char c; |
|||
union fooround u; |
|||
}; |
|||
/* If malloc were really smart, it would round addresses to DEFAULT_ALIGNMENT.
|
|||
But in fact it might be less smart and round addresses to as much as |
|||
DEFAULT_ROUNDING. So we prepare for it to do that. */ |
|||
enum |
|||
{ |
|||
DEFAULT_ALIGNMENT = offsetof (struct fooalign, u), |
|||
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 |
|||
# 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 void print_and_abort (void); |
|||
|
|||
# ifdef _LIBC |
|||
# 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 |
|||
library still exports it because somebody might use it. */ |
|||
struct obstack *_obstack_compat; |
|||
compat_symbol (libc, _obstack_compat, _obstack, GLIBC_2_0); |
|||
# endif |
|||
# endif |
|||
|
|||
/* Define a macro that either calls functions with the traditional malloc/free
|
|||
calling interface, or calls functions with the mmalloc/mfree interface |
|||
(that adds an extra first argument), based on the state of use_extra_arg. |
|||
For free, do not use ?:, since some compilers, like the MIPS compilers, |
|||
do not allow (expr) ? void : void. */ |
|||
|
|||
# define CALL_CHUNKFUN(h, size) \ |
|||
(((h) -> use_extra_arg) \ |
|||
? (*(h)->chunkfun) ((h)->extra_arg, (size)) \ |
|||
: (*(struct _obstack_chunk *(*) (long)) (h)->chunkfun) ((size))) |
|||
|
|||
# define CALL_FREEFUN(h, old_chunk) \ |
|||
do { \ |
|||
if ((h) -> use_extra_arg) \ |
|||
(*(h)->freefun) ((h)->extra_arg, (old_chunk)); \ |
|||
else \ |
|||
(*(void (*) (void *)) (h)->freefun) ((old_chunk)); \ |
|||
} while (0) |
|||
|
|||
|
|||
/* Initialize an obstack H for use. Specify chunk size SIZE (0 means default).
|
|||
Objects start on multiples of ALIGNMENT (0 means use default). |
|||
CHUNKFUN is the function to use to allocate chunks, |
|||
and FREEFUN the function to free them. |
|||
Return nonzero if successful, calls obstack_alloc_failed_handler if |
|||
allocation fails. */ |
|||
|
|||
static int _obstack_begin (struct obstack *h, |
|||
int size, int alignment, |
|||
void *(*chunkfun) (long), |
|||
void (*freefun) (void *)) |
|||
{ |
|||
register 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. */ |
|||
{ |
|||
/* 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; |
|||
} |
|||
|
|||
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->use_extra_arg = 0; |
|||
|
|||
chunk = h->chunk = CALL_CHUNKFUN (h, h -> chunk_size); |
|||
if (!chunk) print_and_abort(); |
|||
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; |
|||
} |
|||
|
|||
static int _obstack_begin_1 (struct obstack *h, int size, int alignment, |
|||
void *(*chunkfun) (void *, long), |
|||
void (*freefun) (void *, void *), |
|||
void *arg) |
|||
{ |
|||
register 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. */ |
|||
{ |
|||
/* 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; |
|||
} |
|||
|
|||
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) print_and_abort(); |
|||
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; |
|||
} |
|||
|
|||
/* Allocate a new current chunk for the obstack *H
|
|||
on the assumption that LENGTH bytes need to be added |
|||
to the current object, or a new object of length LENGTH allocated. |
|||
Copies any partial object from the end of the old chunk |
|||
to the beginning of the new one. */ |
|||
|
|||
static void _obstack_newchunk (struct obstack *h, int length) |
|||
{ |
|||
register struct _obstack_chunk *old_chunk = h->chunk; |
|||
register struct _obstack_chunk *new_chunk; |
|||
register long new_size; |
|||
register long obj_size = h->next_free - h->object_base; |
|||
register long i; |
|||
long already; |
|||
char *object_base; |
|||
|
|||
/* Compute size for new chunk. */ |
|||
new_size = (obj_size + length) + (obj_size >> 3) + h->alignment_mask + 100; |
|||
if (new_size < h->chunk_size) |
|||
new_size = h->chunk_size; |
|||
|
|||
/* Allocate and initialize the new chunk. */ |
|||
new_chunk = CALL_CHUNKFUN (h, new_size); |
|||
if (!new_chunk) print_and_abort(); |
|||
h->chunk = new_chunk; |
|||
new_chunk->prev = old_chunk; |
|||
new_chunk->limit = h->chunk_limit = (char *) new_chunk + new_size; |
|||
|
|||
/* Compute an aligned object_base in the new chunk */ |
|||
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]; |
|||
|
|||
/* If the object just copied was the only data in OLD_CHUNK,
|
|||
free that chunk and remove it from the chain. |
|||
But not if that chunk might contain an empty object. */ |
|||
if (! h->maybe_empty_object |
|||
&& (h->object_base |
|||
== __PTR_ALIGN ((char *) old_chunk, old_chunk->contents, |
|||
h->alignment_mask))) |
|||
{ |
|||
new_chunk->prev = old_chunk->prev; |
|||
CALL_FREEFUN (h, old_chunk); |
|||
} |
|||
|
|||
h->object_base = object_base; |
|||
h->next_free = h->object_base + obj_size; |
|||
/* The new chunk certainly contains no empty object yet. */ |
|||
h->maybe_empty_object = 0; |
|||
} |
|||
|
|||
/* Return nonzero if object OBJ has been allocated from obstack H.
|
|||
This is here for debugging. |
|||
If you use it in a program, you are probably losing. */ |
|||
|
|||
/* Free objects in obstack H, including OBJ and everything allocate
|
|||
more recently than OBJ. If OBJ is zero, free everything in H. */ |
|||
static void obstack_free_func (struct obstack *h, void *obj) |
|||
{ |
|||
register struct _obstack_chunk *lp; /* below addr of any objects in this chunk */ |
|||
register struct _obstack_chunk *plp; /* point to previous chunk if any */ |
|||
|
|||
lp = h->chunk; |
|||
/* We use >= because there cannot be an object at the beginning of a chunk.
|
|||
But there can be an empty object at that address |
|||
at the end of another chunk. */ |
|||
while (lp != 0 && ((void *) lp >= obj || (void *) (lp)->limit < obj)) |
|||
{ |
|||
plp = lp->prev; |
|||
CALL_FREEFUN (h, lp); |
|||
lp = plp; |
|||
/* If we switch chunks, we can't tell whether the new current
|
|||
chunk contains an empty object, so assume that it may. */ |
|||
h->maybe_empty_object = 1; |
|||
} |
|||
if (lp) |
|||
{ |
|||
h->object_base = h->next_free = (char *) (obj); |
|||
h->chunk_limit = lp->limit; |
|||
h->chunk = lp; |
|||
} |
|||
else if (obj != 0) |
|||
/* obj is not in any of the chunks! */ |
|||
abort (); |
|||
} |
|||
|
|||
static int _obstack_memory_used (struct obstack *h) |
|||
{ |
|||
register struct _obstack_chunk* lp; |
|||
register int nbytes = 0; |
|||
|
|||
for (lp = h->chunk; lp != 0; lp = lp->prev) |
|||
{ |
|||
nbytes += lp->limit - (char *) lp; |
|||
} |
|||
return nbytes; |
|||
} |
|||
|
|||
static void __attribute__ ((noreturn)) print_and_abort (void) |
|||
{ |
|||
fprintf(stderr, "%s\n", "memory exhausted"); |
|||
exit(1); |
|||
} |
|||
|
|||
/* END LOCAL ADDITION */ |
|||
|
|||
#ifdef __cplusplus |
|||
} /* C++ */ |
|||
#endif |
|||
|
|||
#endif /* obstack.h */ |
|||
@ -0,0 +1,195 @@ |
|||
/* https://raw.githubusercontent.com/android/platform_bionic/master/libc/upstream-freebsd/lib/libc/stdlib/qsort.c */ |
|||
|
|||
#define I_AM_QSORT_R |
|||
|
|||
/*-
|
|||
* Copyright (c) 1992, 1993 |
|||
* The Regents of the University of California. All rights reserved. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* 1. Redistributions of source code must retain the above copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in the |
|||
* documentation and/or other materials provided with the distribution. |
|||
* 3. Neither the name of the University nor the names of its contributors |
|||
* may be used to endorse or promote products derived from this software |
|||
* without specific prior written permission. |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND |
|||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|||
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE |
|||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|||
* SUCH DAMAGE. |
|||
*/ |
|||
|
|||
#include <sys/cdefs.h> |
|||
#include <stdlib.h> |
|||
|
|||
#ifdef I_AM_QSORT_R |
|||
typedef int cmp_t(void *, const void *, const void *); |
|||
#else |
|||
typedef int cmp_t(const void *, const void *); |
|||
#endif |
|||
static inline char *med3(char *, char *, char *, cmp_t *, void *); |
|||
static inline void swapfunc(char *, char *, int, int); |
|||
|
|||
#define min(a, b) (a) < (b) ? a : b |
|||
|
|||
/*
|
|||
* Qsort routine from Bentley & McIlroy's "Engineering a Sort Function". |
|||
*/ |
|||
#define swapcode(TYPE, parmi, parmj, n) { \ |
|||
long i = (n) / sizeof (TYPE); \ |
|||
TYPE *pi = (TYPE *) (parmi); \ |
|||
TYPE *pj = (TYPE *) (parmj); \ |
|||
do { \ |
|||
TYPE t = *pi; \ |
|||
*pi++ = *pj; \ |
|||
*pj++ = t; \ |
|||
} while (--i > 0); \ |
|||
} |
|||
|
|||
#define SWAPINIT(a, es) swaptype = ((char *)a - (char *)0) % sizeof(long) || \ |
|||
es % sizeof(long) ? 2 : es == sizeof(long)? 0 : 1; |
|||
|
|||
static inline void |
|||
swapfunc(a, b, n, swaptype) |
|||
char *a, *b; |
|||
int n, swaptype; |
|||
{ |
|||
if(swaptype <= 1) |
|||
swapcode(long, a, b, n) |
|||
else |
|||
swapcode(char, a, b, n) |
|||
} |
|||
|
|||
#define swap(a, b) \ |
|||
if (swaptype == 0) { \ |
|||
long t = *(long *)(a); \ |
|||
*(long *)(a) = *(long *)(b); \ |
|||
*(long *)(b) = t; \ |
|||
} else \ |
|||
swapfunc(a, b, es, swaptype) |
|||
|
|||
#define vecswap(a, b, n) if ((n) > 0) swapfunc(a, b, n, swaptype) |
|||
|
|||
#ifdef I_AM_QSORT_R |
|||
#define CMP(t, x, y) (cmp((t), (x), (y))) |
|||
#else |
|||
#define CMP(t, x, y) (cmp((x), (y))) |
|||
#endif |
|||
|
|||
static inline char * |
|||
med3(char *a, char *b, char *c, cmp_t *cmp, void *thunk |
|||
#ifndef I_AM_QSORT_R |
|||
__unused |
|||
#endif |
|||
) |
|||
{ |
|||
return CMP(thunk, a, b) < 0 ? |
|||
(CMP(thunk, b, c) < 0 ? b : (CMP(thunk, a, c) < 0 ? c : a )) |
|||
:(CMP(thunk, b, c) > 0 ? b : (CMP(thunk, a, c) < 0 ? a : c )); |
|||
} |
|||
|
|||
#ifdef I_AM_QSORT_R |
|||
void |
|||
qsort_r(void *a, size_t n, size_t es, void *thunk, cmp_t *cmp) |
|||
#else |
|||
#define thunk NULL |
|||
void |
|||
qsort(void *a, size_t n, size_t es, cmp_t *cmp) |
|||
#endif |
|||
{ |
|||
char *pa, *pb, *pc, *pd, *pl, *pm, *pn; |
|||
size_t d, r; |
|||
int cmp_result; |
|||
int swaptype, swap_cnt; |
|||
|
|||
loop: SWAPINIT(a, es); |
|||
swap_cnt = 0; |
|||
if (n < 7) { |
|||
for (pm = (char *)a + es; pm < (char *)a + n * es; pm += es) |
|||
for (pl = pm; |
|||
pl > (char *)a && CMP(thunk, pl - es, pl) > 0; |
|||
pl -= es) |
|||
swap(pl, pl - es); |
|||
return; |
|||
} |
|||
pm = (char *)a + (n / 2) * es; |
|||
if (n > 7) { |
|||
pl = a; |
|||
pn = (char *)a + (n - 1) * es; |
|||
if (n > 40) { |
|||
d = (n / 8) * es; |
|||
pl = med3(pl, pl + d, pl + 2 * d, cmp, thunk); |
|||
pm = med3(pm - d, pm, pm + d, cmp, thunk); |
|||
pn = med3(pn - 2 * d, pn - d, pn, cmp, thunk); |
|||
} |
|||
pm = med3(pl, pm, pn, cmp, thunk); |
|||
} |
|||
swap(a, pm); |
|||
pa = pb = (char *)a + es; |
|||
|
|||
pc = pd = (char *)a + (n - 1) * es; |
|||
for (;;) { |
|||
while (pb <= pc && (cmp_result = CMP(thunk, pb, a)) <= 0) { |
|||
if (cmp_result == 0) { |
|||
swap_cnt = 1; |
|||
swap(pa, pb); |
|||
pa += es; |
|||
} |
|||
pb += es; |
|||
} |
|||
while (pb <= pc && (cmp_result = CMP(thunk, pc, a)) >= 0) { |
|||
if (cmp_result == 0) { |
|||
swap_cnt = 1; |
|||
swap(pc, pd); |
|||
pd -= es; |
|||
} |
|||
pc -= es; |
|||
} |
|||
if (pb > pc) |
|||
break; |
|||
swap(pb, pc); |
|||
swap_cnt = 1; |
|||
pb += es; |
|||
pc -= es; |
|||
} |
|||
if (swap_cnt == 0) { /* Switch to insertion sort */ |
|||
for (pm = (char *)a + es; pm < (char *)a + n * es; pm += es) |
|||
for (pl = pm; |
|||
pl > (char *)a && CMP(thunk, pl - es, pl) > 0; |
|||
pl -= es) |
|||
swap(pl, pl - es); |
|||
return; |
|||
} |
|||
|
|||
pn = (char *)a + n * es; |
|||
r = min(pa - (char *)a, pb - pa); |
|||
vecswap(a, pb - r, r); |
|||
r = min(pd - pc, pn - pd - es); |
|||
vecswap(pb, pn - r, r); |
|||
if ((r = pb - pa) > es) |
|||
#ifdef I_AM_QSORT_R |
|||
qsort_r(a, r / es, es, thunk, cmp); |
|||
#else |
|||
qsort(a, r / es, es, cmp); |
|||
#endif |
|||
if ((r = pd - pc) > es) { |
|||
/* Iterate rather than recurse to save stack space */ |
|||
a = pn - r; |
|||
n = r / es; |
|||
goto loop; |
|||
} |
|||
/* qsort(pn - r, r / es, es, cmp);*/ |
|||
} |
|||
|
|||
@ -0,0 +1,15 @@ |
|||
diff -u -r ../elfutils-0.166/src/ranlib.c ./src/ranlib.c
|
|||
--- ../elfutils-0.166/src/ranlib.c 2015-11-27 08:36:29.000000000 -0500
|
|||
+++ ./src/ranlib.c 2016-05-04 14:18:56.314550152 -0400
|
|||
@@ -138,11 +138,6 @@
|
|||
|
|||
assert (off + n <= len); |
|||
|
|||
- /* Tell the kernel we will read all the pages sequentially. */
|
|||
- size_t ps = sysconf (_SC_PAGESIZE);
|
|||
- if (n > 2 * ps)
|
|||
- posix_madvise (rawfile + (off & ~(ps - 1)), n, POSIX_MADV_SEQUENTIAL);
|
|||
-
|
|||
return write_retry (newfd, rawfile + off, n) != (ssize_t) n; |
|||
} |
|||
|
|||
@ -0,0 +1,38 @@ |
|||
diff -u -r ../elfutils-0.166/src/readelf.c ./src/readelf.c
|
|||
--- ../elfutils-0.166/src/readelf.c 2016-03-02 11:25:38.000000000 -0500
|
|||
+++ ./src/readelf.c 2016-05-04 14:13:42.967553723 -0400
|
|||
@@ -43,6 +43,7 @@
|
|||
#include <sys/param.h> |
|||
#include <sys/stat.h> |
|||
#include <signal.h> |
|||
+#include <qsort_r.h>
|
|||
|
|||
#include <system.h> |
|||
#include "../libelf/libelfP.h" |
|||
@@ -6128,7 +6129,7 @@
|
|||
|
|||
printf (" %*s%-20s (%s) %s\n", |
|||
(int) (level * 2), "", dwarf_attr_name (attr), |
|||
- dwarf_form_name (form), nl_langinfo (flag ? YESSTR : NOSTR));
|
|||
+ dwarf_form_name (form), flag ? "yes" : "no");
|
|||
break; |
|||
|
|||
case DW_FORM_flag_present: |
|||
@@ -6136,7 +6137,7 @@
|
|||
break; |
|||
printf (" %*s%-20s (%s) %s\n", |
|||
(int) (level * 2), "", dwarf_attr_name (attr), |
|||
- dwarf_form_name (form), nl_langinfo (YESSTR));
|
|||
+ dwarf_form_name (form), "yes");
|
|||
break; |
|||
|
|||
case DW_FORM_exprloc: |
|||
@@ -7646,7 +7647,7 @@
|
|||
if (readp + 1 > readendp) |
|||
goto invalid_data; |
|||
val = *readp++; |
|||
- printf (" %s", nl_langinfo (val != 0 ? YESSTR : NOSTR));
|
|||
+ printf (" %s", val != 0 ? "yes" : "no");
|
|||
break; |
|||
|
|||
case DW_FORM_string: |
|||
@ -0,0 +1,47 @@ |
|||
#ifndef STDIO_EXT_H_INCLUDED |
|||
#define STDIO_EXT_H_INCLUDED |
|||
|
|||
#include <stdio.h> |
|||
|
|||
/* http://linux.die.net/man/3/__fsetlocking */ |
|||
#define FSETLOCKING_INTERNAL 1 |
|||
#define FSETLOCKING_BYCALLER 2 |
|||
#define FSETLOCKING_QUERY 3 |
|||
static inline int __fsetlocking(FILE *stream, int type) |
|||
{ |
|||
(void) stream; |
|||
(void) type; |
|||
return FSETLOCKING_INTERNAL; |
|||
} |
|||
|
|||
static inline int feof_unlocked(FILE *stream) |
|||
{ |
|||
return feof(stream); |
|||
} |
|||
|
|||
static inline int ferror_unlocked(FILE *stream) |
|||
{ |
|||
return ferror(stream); |
|||
} |
|||
|
|||
static inline int fputs_unlocked(const char *s, FILE *stream) |
|||
{ |
|||
return fputs(s, stream); |
|||
} |
|||
|
|||
static inline int fputc_unlocked(int c, FILE *stream) |
|||
{ |
|||
return fputc(c, stream); |
|||
} |
|||
|
|||
static inline size_t fread_unlocked(void *data, size_t size, size_t count, FILE *stream) |
|||
{ |
|||
return fread(data, size, count, stream); |
|||
} |
|||
|
|||
static inline size_t fwrite_unlocked(const void *data, size_t size, size_t count, FILE *stream) |
|||
{ |
|||
return fwrite(data, size, count, stream); |
|||
} |
|||
|
|||
#endif |
|||
@ -0,0 +1,11 @@ |
|||
diff -u -r ../elfutils-0.166/src/strings.c ./src/strings.c
|
|||
--- ../elfutils-0.166/src/strings.c 2015-11-27 08:36:29.000000000 -0500
|
|||
+++ ./src/strings.c 2016-05-04 14:19:55.593602311 -0400
|
|||
@@ -494,7 +494,6 @@
|
|||
if (mem != MAP_FAILED) |
|||
{ |
|||
/* We will go through the mapping sequentially. */ |
|||
- (void) posix_madvise (mem, map_size, POSIX_MADV_SEQUENTIAL);
|
|||
break; |
|||
} |
|||
if (errno != EINVAL && errno != ENOMEM) |
|||
@ -0,0 +1,20 @@ |
|||
diff -u -r ../elfutils-0.166/src/strip.c ./src/strip.c
|
|||
--- ../elfutils-0.166/src/strip.c 2016-03-02 11:25:38.000000000 -0500
|
|||
+++ ./src/strip.c 2016-05-04 14:03:53.052913249 -0400
|
|||
@@ -323,8 +323,14 @@
|
|||
|
|||
/* If we have to preserve the timestamp, we need it in the |
|||
format utimes() understands. */ |
|||
- tv[0] = pre_st.st_atim;
|
|||
- tv[1] = pre_st.st_mtim;
|
|||
+ struct timespec atime;
|
|||
+ atime.tv_sec = pre_st.st_atime;
|
|||
+ atime.tv_nsec = pre_st.st_atime_nsec;
|
|||
+ struct timespec mtime;
|
|||
+ mtime.tv_sec = pre_st.st_mtime;
|
|||
+ mtime.tv_nsec = pre_st.st_mtime_nsec;
|
|||
+ tv[0] = atime;
|
|||
+ tv[1] = mtime;
|
|||
} |
|||
|
|||
/* Open the file. */ |
|||
@ -1,13 +0,0 @@ |
|||
diff -u -r ../elfutils-0.159/lib/system.h ./lib/system.h
|
|||
--- ../elfutils-0.159/lib/system.h 2014-02-05 01:21:43.000000000 +0100
|
|||
+++ ./lib/system.h 2014-05-30 15:10:19.914184259 +0200
|
|||
@@ -29,7 +29,9 @@
|
|||
#ifndef LIB_SYSTEM_H |
|||
#define LIB_SYSTEM_H 1 |
|||
|
|||
+#ifndef __ANDROID__
|
|||
#include <argp.h> |
|||
+#endif
|
|||
#include <stddef.h> |
|||
#include <stdint.h> |
|||
#include <endian.h> |
|||
@ -0,0 +1,24 @@ |
|||
diff -u -r ../elfutils-0.166/src/unstrip.c ./src/unstrip.c
|
|||
--- ../elfutils-0.166/src/unstrip.c 2016-01-12 07:49:19.000000000 -0500
|
|||
+++ ./src/unstrip.c 2016-05-04 15:22:24.975567076 -0400
|
|||
@@ -294,6 +294,7 @@
|
|||
static void |
|||
make_directories (const char *path) |
|||
{ |
|||
+ size_t substr_len;
|
|||
const char *lastslash = strrchr (path, '/'); |
|||
if (lastslash == NULL) |
|||
return; |
|||
@@ -303,7 +304,11 @@
|
|||
if (lastslash == path) |
|||
return; |
|||
|
|||
- char *dir = strndupa (path, lastslash - path);
|
|||
+ substr_len = lastslash - path;
|
|||
+ char *dir = alloca(substr_len+1);
|
|||
+ strncpy(dir, path, substr_len);
|
|||
+ dir[substr_len] = 0;
|
|||
+
|
|||
while (mkdir (dir, 0777) < 0 && errno != EEXIST) |
|||
if (errno == ENOENT) |
|||
make_directories (dir); |
|||
Loading…
Reference in new issue