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
|
diff -u -r ../elfutils-0.166/libelf/elf_getaroff.c ./libelf/elf_getaroff.c
|
||||
--- ../elfutils-0.159/libelf/elf_getaroff.c 2014-02-05 01:21:44.000000000 +0100
|
--- ../elfutils-0.166/libelf/elf_getaroff.c 2015-11-27 08:36:29.000000000 -0500
|
||||
+++ ./libelf/elf_getaroff.c 2014-05-30 15:05:42.226191850 +0200
|
+++ ./libelf/elf_getaroff.c 2016-05-04 13:07:06.547288608 -0400
|
||||
@@ -38,7 +38,7 @@
|
@@ -38,7 +38,7 @@
|
||||
#include "libelfP.h" |
#include "libelfP.h" |
||||
|
|
||||
|
|
||||
-off_t
|
-off_t
|
||||
+loff_t
|
+loff_t
|
||||
elf_getaroff (elf) |
elf_getaroff (Elf *elf) |
||||
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
|
diff -u -r ../elfutils-0.166/libelf/elf_update.c ./libelf/elf_update.c
|
||||
--- ../elfutils-0.159/libelf/elf_update.c 2014-05-18 16:32:15.000000000 +0200
|
--- ../elfutils-0.166/libelf/elf_update.c 2015-11-27 08:36:29.000000000 -0500
|
||||
+++ ./libelf/elf_update.c 2014-05-30 14:56:42.806206596 +0200
|
+++ ./libelf/elf_update.c 2016-05-04 13:06:15.836140729 -0400
|
||||
@@ -123,7 +123,7 @@
|
@@ -39,6 +39,7 @@
|
||||
} |
|
||||
|
|
||||
|
#include "libelfP.h" |
||||
|
|
||||
-off_t
|
+#define off_t loff_t
|
||||
+loff_t
|
|
||||
elf_update (elf, cmd) |
static off_t |
||||
Elf *elf; |
write_file (Elf *elf, off_t size, int change_bo, size_t shnum) |
||||
Elf_Cmd cmd; |
|
||||
|
|||||
@ -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