[rtems-tools commit] elftoolchain: Add libelftc.
Chris Johns
chrisj at rtems.org
Tue Jun 19 03:44:14 UTC 2018
Module: rtems-tools
Branch: master
Commit: 1f1a10f4716e8d9b166f9c4741554fbbfa26fe66
Changeset: http://git.rtems.org/rtems-tools/commit/?id=1f1a10f4716e8d9b166f9c4741554fbbfa26fe66
Author: Chris Johns <chrisj at rtems.org>
Date: Wed May 23 20:39:54 2018 +1200
elftoolchain: Add libelftc.
---
rtemstoolkit/elftoolchain/libelftc/Makefile | 60 +
rtemstoolkit/elftoolchain/libelftc/_libelftc.h | 95 +
rtemstoolkit/elftoolchain/libelftc/elftc.3 | 83 +
.../elftoolchain/libelftc/elftc_bfd_find_target.3 | 200 +
.../elftoolchain/libelftc/elftc_bfdtarget.c | 73 +
.../elftoolchain/libelftc/elftc_copyfile.3 | 73 +
.../elftoolchain/libelftc/elftc_copyfile.c | 113 +
.../elftoolchain/libelftc/elftc_demangle.3 | 116 +
.../elftoolchain/libelftc/elftc_demangle.c | 107 +
.../elftoolchain/libelftc/elftc_reloc_type_str.3 | 72 +
.../elftoolchain/libelftc/elftc_reloc_type_str.c | 832 ++++
.../elftoolchain/libelftc/elftc_set_timestamps.3 | 84 +
.../elftoolchain/libelftc/elftc_set_timestamps.c | 85 +
.../elftoolchain/libelftc/elftc_string_table.c | 392 ++
.../libelftc/elftc_string_table_create.3 | 227 ++
.../elftoolchain/libelftc/elftc_timestamp.3 | 79 +
.../elftoolchain/libelftc/elftc_timestamp.c | 55 +
rtemstoolkit/elftoolchain/libelftc/elftc_version.3 | 79 +
rtemstoolkit/elftoolchain/libelftc/elftc_version.c | 10 +
rtemstoolkit/elftoolchain/libelftc/libelftc.h | 100 +
.../elftoolchain/libelftc/libelftc_bfdtarget.c | 463 +++
.../elftoolchain/libelftc/libelftc_dem_arm.c | 1216 ++++++
.../elftoolchain/libelftc/libelftc_dem_gnu2.c | 1365 +++++++
.../elftoolchain/libelftc/libelftc_dem_gnu3.c | 3991 ++++++++++++++++++++
rtemstoolkit/elftoolchain/libelftc/libelftc_hash.c | 70 +
rtemstoolkit/elftoolchain/libelftc/libelftc_vstr.c | 359 ++
.../elftoolchain/libelftc/make-toolchain-version | 110 +
rtemstoolkit/elftoolchain/libelftc/os.FreeBSD.mk | 7 +
rtemstoolkit/elftoolchain/libelftc/os.Linux.mk | 3 +
rtemstoolkit/elftoolchain/libelftc/os.NetBSD.mk | 2 +
rtemstoolkit/wscript | 24 +
31 files changed, 10545 insertions(+)
diff --git a/rtemstoolkit/elftoolchain/libelftc/Makefile b/rtemstoolkit/elftoolchain/libelftc/Makefile
new file mode 100644
index 0000000..cf4efc0
--- /dev/null
+++ b/rtemstoolkit/elftoolchain/libelftc/Makefile
@@ -0,0 +1,60 @@
+# $Id: Makefile 3601 2018-04-12 16:58:53Z jkoshy $
+
+TOP= ..
+
+LIB= elftc
+
+SRCS= elftc_bfdtarget.c \
+ elftc_copyfile.c \
+ elftc_demangle.c \
+ elftc_reloc_type_str.c \
+ elftc_set_timestamps.c \
+ elftc_string_table.c \
+ elftc_timestamp.c \
+ elftc_version.c \
+ libelftc_bfdtarget.c \
+ libelftc_dem_arm.c \
+ libelftc_dem_gnu2.c \
+ libelftc_dem_gnu3.c \
+ libelftc_hash.c \
+ libelftc_vstr.c
+
+INCS= libelftc.h
+INCSDIR= /usr/include
+
+RELEASE= HEAD # Change this on release branches.
+
+SHLIB_MAJOR= 1
+
+WARNS?= 6
+
+ELFTC_VERSION_FILE= ${.OBJDIR}/elftc_version.c
+CLEANFILES+= ${ELFTC_VERSION_FILE}
+
+LDADD+= -lelf
+
+MAN= elftc.3 \
+ elftc_bfd_find_target.3 \
+ elftc_copyfile.3 \
+ elftc_demangle.3 \
+ elftc_reloc_type_str.3 \
+ elftc_set_timestamps.3 \
+ elftc_string_table_create.3 \
+ elftc_version.3
+
+MLINKS= elftc_bfd_find_target.3 elftc_bfd_target_byteorder.3 \
+ elftc_bfd_find_target.3 elftc_bfd_target_class.3 \
+ elftc_bfd_find_target.3 elftc_bfd_target_flavor.3 \
+ elftc_string_table_create.3 elftc_string_table_from_section.3 \
+ elftc_string_table_create.3 elftc_string_table_destroy.3 \
+ elftc_string_table_create.3 elftc_string_table_image.3 \
+ elftc_string_table_create.3 elftc_string_table_insert.3 \
+ elftc_string_table_create.3 elftc_string_table_lookup.3
+
+.if !make(clean) && !make(clobber) && !make(obj)
+.BEGIN: .SILENT
+ ${.CURDIR}/make-toolchain-version -t ${.CURDIR}/${TOP} \
+ -r ${RELEASE} -h ${OS_HOST} -o ${ELFTC_VERSION_FILE}
+.endif
+
+.include "${TOP}/mk/elftoolchain.lib.mk"
diff --git a/rtemstoolkit/elftoolchain/libelftc/_libelftc.h b/rtemstoolkit/elftoolchain/libelftc/_libelftc.h
new file mode 100644
index 0000000..a56e29e
--- /dev/null
+++ b/rtemstoolkit/elftoolchain/libelftc/_libelftc.h
@@ -0,0 +1,95 @@
+/*-
+ * Copyright (c) 2009 Kai Wang
+ * Copyright (c) 2007,2008 Hyogeol Lee <hyogeollee at gmail.com>
+ * 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
+ * in this position and unchanged.
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``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 AUTHOR 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.
+ *
+ * $Id: _libelftc.h 3531 2017-06-05 05:08:43Z kaiwang27 $
+ */
+
+#ifndef __LIBELFTC_H_
+#define __LIBELFTC_H_
+
+#include <stdbool.h>
+
+#include "_elftc.h"
+
+struct _Elftc_Bfd_Target {
+ const char *bt_name; /* target name. */
+ unsigned int bt_type; /* target type. */
+ unsigned int bt_byteorder; /* elf target byteorder. */
+ unsigned int bt_elfclass; /* elf target class (32/64bit). */
+ unsigned int bt_machine; /* elf target arch. */
+ unsigned int bt_osabi; /* elf target abi. */
+};
+
+extern struct _Elftc_Bfd_Target _libelftc_targets[];
+
+/** @brief Dynamic vector data for string. */
+struct vector_str {
+ /** Current size */
+ size_t size;
+ /** Total capacity */
+ size_t capacity;
+ /** String array */
+ char **container;
+};
+
+#define BUFFER_GROWFACTOR 1.618
+
+#define ELFTC_FAILURE 0
+#define ELFTC_ISDIGIT(C) (isdigit((C) & 0xFF))
+#define ELFTC_SUCCESS 1
+
+#define VECTOR_DEF_CAPACITY 8
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+char *cpp_demangle_ARM(const char *_org);
+char *cpp_demangle_gnu2(const char *_org);
+char *cpp_demangle_gnu3(const char *_org);
+bool is_cpp_mangled_ARM(const char *_org);
+bool is_cpp_mangled_gnu2(const char *_org);
+bool is_cpp_mangled_gnu3(const char *_org);
+unsigned int libelftc_hash_string(const char *);
+void vector_str_dest(struct vector_str *_vec);
+int vector_str_find(const struct vector_str *_vs, const char *_str,
+ size_t _len);
+char *vector_str_get_flat(const struct vector_str *_vs, size_t *_len);
+bool vector_str_init(struct vector_str *_vs);
+bool vector_str_pop(struct vector_str *_vs);
+bool vector_str_push(struct vector_str *_vs, const char *_str,
+ size_t _len);
+bool vector_str_push_vector(struct vector_str *_dst,
+ struct vector_str *_org);
+bool vector_str_push_vector_head(struct vector_str *_dst,
+ struct vector_str *_org);
+char *vector_str_substr(const struct vector_str *_vs, size_t _begin,
+ size_t _end, size_t *_rlen);
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __LIBELFTC_H */
diff --git a/rtemstoolkit/elftoolchain/libelftc/elftc.3 b/rtemstoolkit/elftoolchain/libelftc/elftc.3
new file mode 100644
index 0000000..bbf5173
--- /dev/null
+++ b/rtemstoolkit/elftoolchain/libelftc/elftc.3
@@ -0,0 +1,83 @@
+.\" Copyright (c) 2012 Joseph Koshy. 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.
+.\"
+.\" This software is provided by Joseph Koshy ``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 Joseph Koshy 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.
+.\"
+.\" $Id: elftc.3 2818 2012-12-24 12:32:48Z jkoshy $
+.\"
+.Dd December 24, 2012
+.Os
+.Dt ELFTC 3
+.Sh NAME
+.Nm elftc
+.Nd support routines used in the Elftoolchain project
+.Sh LIBRARY
+.Lb libelftc
+.Sh SYNOPSIS
+.In libelftc.h
+.Sh DESCRIPTION
+The
+.Lb libelftc
+provides support routines used for developing the utilities in the
+Elftoolchain source tree.
+.Pp
+This manual page serves as an overview of the functionality in this
+library.
+Additional reference information may be found in the individual
+manual pages for the functions listed below.
+.Ss Functional Grouping
+.Bl -tag -width indent
+.It "Binary Object Handling"
+.Bl -tag -compact
+.It Fn elftc_bfd_find_target
+Locate a binary object descriptor.
+.It Fn elftc_bfd_target_class
+Query the ELF class for a binary object descriptor.
+.It Fn elftc_bfd_target_byteorder
+Query the byte order for a binary object descriptor.
+.It Fn elftc_bfd_target_flavor
+Query the object format for a binary object descriptor.
+.It Fn elftc_bfd_target_machine
+Query the target machine for a binary object descriptor.
+.El
+.It "C++ support"
+.Bl -tag -compact
+.It Fn elftc_demangle
+Decodes a symbol name encoded according to the encoding rules for the
+C++ language.
+.El
+.It "Programming conveniences"
+.Bl -tag -compact
+.It Fn elftc_copyfile
+Copies the contents of a file to another.
+.It Fn elftc_set_timestamp
+Portably set the time stamps on a file.
+.El
+.It "Project Configuration"
+.Bl -tag -compact
+.It Fn elftc_version
+Returns a project-wide identifier string that encodes the source
+revision of the source tree.
+.El
+.El
+.Sh SEE ALSO
+.Xr dwarf 3 ,
+.Xr elf 3
diff --git a/rtemstoolkit/elftoolchain/libelftc/elftc_bfd_find_target.3 b/rtemstoolkit/elftoolchain/libelftc/elftc_bfd_find_target.3
new file mode 100644
index 0000000..302c319
--- /dev/null
+++ b/rtemstoolkit/elftoolchain/libelftc/elftc_bfd_find_target.3
@@ -0,0 +1,200 @@
+.\" Copyright (c) 2010-2011 Joseph Koshy. 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.
+.\"
+.\" This software is provided by Joseph Koshy ``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 Joseph Koshy 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.
+.\"
+.\" $Id: elftc_bfd_find_target.3 3516 2017-02-10 02:33:08Z emaste $
+.\"
+.Dd November 30, 2011
+.Os
+.Dt ELFTC_BFD_FIND_TARGET
+.Sh NAME
+.Nm elftc_bfd_find_target ,
+.Nm elftc_bfd_target_byteorder ,
+.Nm elftc_bfd_target_class ,
+.Nm elftc_bfd_target_flavor ,
+.Nm elftc_bfd_target_machine
+.Nd binary object descriptor handling
+.Sh LIBRARY
+.Lb libelftc
+.Sh SYNOPSIS
+.In libelftc.h
+.Vt struct Elftc_Bfd_Target;
+.Ft "Elftc_Bfd_Target *"
+.Fn elftc_bfd_find_target "const char *target_name"
+.Ft "unsigned int"
+.Fn elftc_bfd_target_class "Elftc_Bfd_Target *target"
+.Ft "unsigned int"
+.Fn elftc_bfd_target_byteorder "Elftc_Bfd_Target *target"
+.Ft Elftc_Bfd_Target_Flavor
+.Fn elftc_bfd_target_flavor "Elftc_Bfd_Target *target"
+.Ft "unsigned int"
+.Fn elftc_bfd_target_machine "Elftc_Bfd_Target *target"
+.Sh DESCRIPTION
+Function
+.Fn elftc_bfd_find_target
+locates a binary object descriptor corresponding to the descriptor
+name in argument
+.Ar "target_name" .
+Binary object descriptors encapsulate properties of an object format
+such as its file representation, ELF class, and byte endianness.
+.Pp
+Known descriptor names and their properties include:
+.Bl -column -offset "XXXX" ".Li elf32-x86-64-freebsd" "Object format" "Byte Order" "Bit Width"
+.It Em Name Ta Em "Object Format" Ta Em "Byte Order" Ta Em "Bit Width"
+.It Li binary Ta Binary Ta - Ta -
+.It Li efi-app-ia32 Ta PE Ta LSB Ta 32
+.It Li efi-app-x86_64 Ta PE Ta LSB Ta 64
+.It Li elf32-avr Ta ELF Ta LSB Ta 32
+.It Li elf32-big Ta ELF Ta MSB Ta 32
+.It Li elf32-bigarm Ta ELF Ta MSB Ta 32
+.It Li elf32-bigmips Ta ELF Ta MSB Ta 32
+.It Li elf32-i386 Ta ELF Ta LSB Ta 32
+.It Li elf32-i386-freebsd Ta ELF Ta LSB Ta 32
+.It Li elf32-ia64-big Ta ELF Ta MSB Ta 32
+.It Li elf32-little Ta ELF Ta LSB Ta 32
+.It Li elf32-littlearm Ta ELF Ta LSB Ta 32
+.It Li elf32-littlemips Ta ELF Ta LSB Ta 32
+.It Li elf32-powerpc Ta ELF Ta MSB Ta 32
+.It Li elf32-powerpc-freebsd Ta ELF Ta MSB Ta 32
+.It Li elf32-powerpcle Ta ELF Ta LSB Ta 32
+.It Li elf32-sh Ta ELF Ta MSB Ta 32
+.It Li elf32-shl Ta ELF Ta LSB Ta 32
+.It Li elf32-sh-nbsd Ta ELF Ta MSB Ta 32
+.It Li elf32-shl-nbsd Ta ELF Ta LSB Ta 32
+.It Li elf32-shbig-linux Ta ELF Ta MSB Ta 32
+.It Li elf32-shl-linux Ta ELF Ta LSB Ta 32
+.It Li elf32-sparc Ta ELF Ta MSB Ta 32
+.It Li elf32-tradbigmips Ta ELF Ta MSB Ta 32
+.It Li elf32-tradlittlemips Ta ELF Ta LSB Ta 32
+.It Li elf64-alpha Ta ELF Ta LSB Ta 64
+.It Li elf64-alpha-freebsd Ta ELF Ta LSB Ta 64
+.It Li elf64-big Ta ELF Ta MSB Ta 64
+.It Li elf64-bigmips Ta ELF Ta MSB Ta 64
+.It Li elf64-ia64-big Ta ELF Ta MSB Ta 64
+.It Li elf64-ia64-little Ta ELF Ta LSB Ta 64
+.It Li elf64-little Ta ELF Ta LSB Ta 64
+.It Li elf64-littleaarch64 Ta ELF Ta LSB Ta 64
+.It Li elf64-littlemips Ta ELF Ta LSB Ta 64
+.It Li elf64-powerpc Ta ELF Ta MSB Ta 64
+.It Li elf64-powerpc-freebsd Ta ELF Ta MSB Ta 64
+.It Li elf64-powerpcle Ta ELF Ta LSB Ta 64
+.It Li elf64-sh64 Ta ELF Ta MSB Ta 64
+.It Li elf64-sh64l Ta ELF Ta LSB Ta 64
+.It Li elf64-sh64-nbsd Ta ELF Ta MSB Ta 64
+.It Li elf64-sh64l-nbsd Ta ELF Ta LSB Ta 64
+.It Li elf64-sh64big-linux Ta ELF Ta MSB Ta 64
+.It Li elf64-sh64-linux Ta ELF Ta LSB Ta 64
+.It Li elf64-sparc Ta ELF Ta MSB Ta 64
+.It Li elf64-sparc-freebsd Ta ELF Ta MSB Ta 64
+.It Li elf64-tradbigmips Ta ELF Ta MSB Ta 64
+.It Li elf64-tradlittlemips Ta ELF Ta LSB Ta 64
+.It Li elf64-x86-64 Ta ELF Ta LSB Ta 64
+.It Li elf64-x86-64-freebsd Ta ELF Ta LSB Ta 64
+.It Li ihex Ta IHEX Ta - Ta -
+.It Li pei-i386 Ta PE Ta LSB Ta 32
+.It Li pei-x86-64 Ta PE Ta LSB Ta 64
+.It Li srec Ta SREC Ta - Ta -
+.It Li symbolsrec Ta SREC Ta - Ta -
+.El
+.Pp
+Function
+.Fn elftc_bfd_target_byteorder
+returns the ELF byte order associated with target descriptor
+.Ar target .
+.Pp
+Function
+.Fn elftc_bfd_target_class
+returns the ELF class associated with target descriptor
+.Ar target .
+.Pp
+Function
+.Fn elftc_bfd_target_flavor
+returns the object format associated with target descriptor
+.Ar target .
+The known object formats are:
+.Bl -tag -offset "XXXX" -width ".Dv ETF_BINARY" -compact
+.It Dv ETF_ELF
+An ELF object.
+.It Dv ETF_BINARY
+Raw binary.
+.It Dv ETF_IHEX
+An object encoded in
+.Tn Intel
+hex format.
+.It Dv ETF_NONE
+An unknown object format.
+.It Dv ETF_SREC
+An object encoded as S-records.
+.El
+.Sh RETURN VALUES
+Function
+.Fn elftc_bfd_find_target
+returns a valid pointer to an opaque binary target descriptor if
+successful, or NULL in case of an error.
+.Pp
+Function
+.Fn elftc_bfd_target_byteorder
+returns the ELF byte order associated with the target descriptor; one of
+.Dv ELFDATA2MSB
+or
+.Dv ELFDATA2LSB .
+.Pp
+Function
+.Fn elftc_bfd_target_class
+returns the ELF class associated with the target descriptor; one of
+.Dv ELFCLASS32
+or
+.Dv ELFCLASS64 .
+.Pp
+Function
+.Fn elftc_bfd_target_machine
+returns the ELF architecture associated with the target descriptor.
+.Pp
+Function
+.Fn elftc_bfd_target_flavor
+returns one of
+.Dv ETF_BINARY ,
+.Dv ETF_ELF ,
+.Dv ETF_IHEX
+or
+.Dv ETF_SREC
+if successful or
+.Dv ETF_NONE
+in case of error.
+.Sh EXAMPLES
+To return descriptor information associated with target name
+.Dq elf64-big
+use:
+.Bd -literal -offset indent
+struct Elftc_Bfd_Target *t;
+
+if ((t = elftc_bfd_find_target("elf64-big")) == NULL)
+ errx(EXIT_FAILURE, "Cannot find target descriptor");
+
+printf("Class: %s\\n", elftc_bfd_target_class(t) == ELFCLASS32 ?
+ "ELFCLASS32" : "ELFCLASS64");
+printf("Byteorder: %s\\n",
+ elftc_bfd_target_byteorder(t) == ELFDATA2LSB ? "LSB" : "MSB");
+printf("Flavor: %d\\n", elftc_bfd_target_flavor(t));
+.Ed
+.Sh SEE ALSO
+.Xr elf 3
diff --git a/rtemstoolkit/elftoolchain/libelftc/elftc_bfdtarget.c b/rtemstoolkit/elftoolchain/libelftc/elftc_bfdtarget.c
new file mode 100644
index 0000000..a5ae1a6
--- /dev/null
+++ b/rtemstoolkit/elftoolchain/libelftc/elftc_bfdtarget.c
@@ -0,0 +1,73 @@
+/*-
+ * Copyright (c) 2008,2009 Kai Wang
+ * 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
+ * in this position and unchanged.
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``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 AUTHOR(S) 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/param.h>
+#include <string.h>
+#include <libelftc.h>
+
+#include "_libelftc.h"
+
+ELFTC_VCSID("$Id: elftc_bfdtarget.c 3174 2015-03-27 17:13:41Z emaste $");
+
+Elftc_Bfd_Target *
+elftc_bfd_find_target(const char *tgt_name)
+{
+ Elftc_Bfd_Target *tgt;
+
+ for (tgt = _libelftc_targets; tgt->bt_name; tgt++)
+ if (!strcmp(tgt_name, tgt->bt_name))
+ return (tgt);
+
+ return (NULL); /* not found */
+}
+
+Elftc_Bfd_Target_Flavor
+elftc_bfd_target_flavor(Elftc_Bfd_Target *tgt)
+{
+
+ return (tgt->bt_type);
+}
+
+unsigned int
+elftc_bfd_target_byteorder(Elftc_Bfd_Target *tgt)
+{
+
+ return (tgt->bt_byteorder);
+}
+
+unsigned int
+elftc_bfd_target_class(Elftc_Bfd_Target *tgt)
+{
+
+ return (tgt->bt_elfclass);
+}
+
+unsigned int
+elftc_bfd_target_machine(Elftc_Bfd_Target *tgt)
+{
+
+ return (tgt->bt_machine);
+}
diff --git a/rtemstoolkit/elftoolchain/libelftc/elftc_copyfile.3 b/rtemstoolkit/elftoolchain/libelftc/elftc_copyfile.3
new file mode 100644
index 0000000..4520433
--- /dev/null
+++ b/rtemstoolkit/elftoolchain/libelftc/elftc_copyfile.3
@@ -0,0 +1,73 @@
+.\" Copyright (c) 2011 Joseph Koshy. 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.
+.\"
+.\" This software is provided by Joseph Koshy ``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 Joseph Koshy 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.
+.\"
+.\" $Id: elftc_copyfile.3 2315 2011-12-11 09:28:55Z jkoshy $
+.\"
+.Dd December 11, 2011
+.Os
+.Dt ELFTC_COPYFILE 3
+.Sh NAME
+.Nm elftc_copyfile
+.Nd convenience function to copy data
+.Sh LIBRARY
+.Lb libelftc
+.Sh SYNOPSIS
+.In libelftc.h
+.Ft in
+.Fn elftc_copyfile "int ifd" "int ofd"
+.Sh DESCRIPTION
+The function
+.Fn elftc_copyfile
+copies the contents of the file referenced by argument
+.Ar ifd
+to the file referenced by argument
+.Ar ofd .
+.Pp
+The argument
+.Ar ifd
+should contain a file descriptor opened for reading, with its file
+offset at the beginning of the file.
+.Pp
+The argument
+.Ar ofd
+should contain a file descriptor opened for writing.
+.Sh RETURN VALUE
+.Rv -std
+.Sh ERRORS
+The function
+.Fn elftc_copyfile
+may fail with any of the errors returned by
+.Xr fstat 2 ,
+.Xr malloc 3 ,
+.Xr mmap 2 ,
+.Xr munmap 2 ,
+.Xr read 2
+or
+.Xr write 2 .
+.Sh SEE ALSO
+.Xr fstat 2 ,
+.Xr malloc 3 ,
+.Xr mmap 2 ,
+.Xr munmap 2 ,
+.Xr read 2 ,
+.Xr write 2
diff --git a/rtemstoolkit/elftoolchain/libelftc/elftc_copyfile.c b/rtemstoolkit/elftoolchain/libelftc/elftc_copyfile.c
new file mode 100644
index 0000000..dac9c14
--- /dev/null
+++ b/rtemstoolkit/elftoolchain/libelftc/elftc_copyfile.c
@@ -0,0 +1,113 @@
+/*-
+ * Copyright (c) 2011, Joseph Koshy
+ * 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
+ * in this position and unchanged.
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``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 AUTHOR(S) 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/types.h>
+#include <sys/stat.h>
+
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "libelftc.h"
+#include "_libelftc.h"
+
+#if ELFTC_HAVE_MMAP
+#include <sys/mman.h>
+#endif
+
+ELFTC_VCSID("$Id: elftc_copyfile.c 3297 2016-01-09 15:26:34Z jkoshy $");
+
+/*
+ * Copy the contents referenced by 'ifd' to 'ofd'. Returns 0 on
+ * success and -1 on error.
+ */
+
+int
+elftc_copyfile(int ifd, int ofd)
+{
+ size_t file_size, n;
+ int buf_mmapped;
+ struct stat sb;
+ char *b, *buf;
+ ssize_t nr, nw;
+
+ /* Determine the input file's size. */
+ if (fstat(ifd, &sb) < 0)
+ return (-1);
+
+ /* Skip files without content. */
+ if (sb.st_size == 0)
+ return (0);
+
+ buf = NULL;
+ buf_mmapped = 0;
+ file_size = (size_t) sb.st_size;
+
+#if ELFTC_HAVE_MMAP
+ /*
+ * Prefer mmap() if it is available.
+ */
+ buf = mmap(NULL, file_size, PROT_READ, MAP_SHARED, ifd, (off_t) 0);
+ if (buf != MAP_FAILED)
+ buf_mmapped = 1;
+ else
+ buf = NULL;
+#endif
+
+ /*
+ * If mmap() is not available, or if the mmap() operation
+ * failed, allocate a buffer, and read in input data.
+ */
+ if (buf_mmapped == false) {
+ if ((buf = malloc(file_size)) == NULL)
+ return (-1);
+ b = buf;
+ for (n = file_size; n > 0; n -= (size_t) nr, b += nr) {
+ if ((nr = read(ifd, b, n)) < 0) {
+ free(buf);
+ return (-1);
+ }
+ }
+ }
+
+ /*
+ * Write data to the output file descriptor.
+ */
+ for (n = file_size, b = buf; n > 0; n -= (size_t) nw, b += nw)
+ if ((nw = write(ofd, b, n)) <= 0)
+ break;
+
+ /* Release the input buffer. */
+#if ELFTC_HAVE_MMAP
+ if (buf_mmapped && munmap(buf, file_size) < 0)
+ return (-1);
+#endif
+
+ if (!buf_mmapped)
+ free(buf);
+
+ return (n > 0 ? -1 : 0);
+}
+
diff --git a/rtemstoolkit/elftoolchain/libelftc/elftc_demangle.3 b/rtemstoolkit/elftoolchain/libelftc/elftc_demangle.3
new file mode 100644
index 0000000..44cf007
--- /dev/null
+++ b/rtemstoolkit/elftoolchain/libelftc/elftc_demangle.3
@@ -0,0 +1,116 @@
+.\" Copyright (c) 2009,2011 Joseph Koshy. 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.
+.\"
+.\" This software is provided by Joseph Koshy ``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 Joseph Koshy 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.
+.\"
+.\" $Id: elftc_demangle.3 3182 2015-04-10 16:08:10Z emaste $
+.\"
+.Dd August 24, 2011
+.Os
+.Dt ELFTC_DEMANGLE 3
+.Sh NAME
+.Nm elftc_demangle
+.Nd demangle a C++ name
+.Sh LIBRARY
+.Lb libelftc
+.Sh SYNOPSIS
+.In libelftc.h
+.Ft int
+.Fo elftc_demangle
+.Fa "const char *encodedname"
+.Fa "char *buffer"
+.Fa "size_t bufsize"
+.Fa "unsigned int flags"
+.Fc
+.Sh DESCRIPTION
+Function
+.Fn elftc_demangle
+decodes a symbol name encoded according to the type encoding rules
+for the C++ language and returns a string denoting an equivalent
+C++ prototype.
+.Pp
+Argument
+.Ar encodedname
+specifies the encoded symbol name.
+Argument
+.Ar buffer
+denotes a programmer-specified area to place the prototype string in.
+Argument
+.Ar bufsize
+specifies the size of the programmer-specified area.
+Argument
+.Ar flags
+specifies the encoding style in use for argument
+.Ar encodedname .
+Supported encoding styles are:
+.Bl -tag -width ".Dv ELFTC_DEM_GNU3"
+.It Dv ELFTC_DEM_ARM
+The encoding style used by compilers adhering to the conventions of the
+C++ Annotated Reference Manual.
+.It Dv ELFTC_DEM_GNU2
+The encoding style by GNU C++ version 2.
+.It Dv ELFTC_DEM_GNU3
+The encoding style by GNU C++ version 3 and later.
+.El
+.Pp
+Argument
+.Ar flags
+may be zero, in which case the function will attempt to guess the
+encoding scheme from the contents of
+.Ar encodedname .
+.Sh RETURN VALUE
+Function
+.Fn elftc_demangle
+returns 0 on success.
+In case of an error it returns -1 and sets the
+.Va errno
+variable.
+.Sh EXAMPLES
+To decode a name that uses an unknown encoding style use:
+.Bd -literal -offset indent
+char buffer[1024];
+const char *funcname;
+
+funcname = ...; /* points to string to be demangled */
+if (elftc_demangle(funcname, buffer, sizeof(buffer), 0) == 0)
+ printf("Demangled name: %\\n", buffer);
+else
+ perror("Cannot demangle %s", funcname);
+.Ed
+.Sh ERRORS
+Function
+.Fn elftc_demangle
+may fail with the following errors:
+.Bl -tag -width ".Bq Er ENAMETOOLONG"
+.It Bq Er EINVAL
+Argument
+.Ar encodedname
+was not a valid encoded name.
+.It Bq Er ENAMETOOLONG
+The output buffer specified by arguments
+.Ar buffer
+and
+.Ar bufsize
+was too small to hold the decoded function prototype.
+.El
+.Sh SEE ALSO
+.Xr elf 3 ,
+.Xr elf_strptr 3
diff --git a/rtemstoolkit/elftoolchain/libelftc/elftc_demangle.c b/rtemstoolkit/elftoolchain/libelftc/elftc_demangle.c
new file mode 100644
index 0000000..945f777
--- /dev/null
+++ b/rtemstoolkit/elftoolchain/libelftc/elftc_demangle.c
@@ -0,0 +1,107 @@
+/*-
+ * Copyright (c) 2009 Kai Wang
+ * 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
+ * in this position and unchanged.
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``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 AUTHOR(S) 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/param.h>
+#include <assert.h>
+#include <errno.h>
+#include <libelftc.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "_libelftc.h"
+
+ELFTC_VCSID("$Id: elftc_demangle.c 3296 2016-01-09 14:17:28Z jkoshy $");
+
+static unsigned int
+is_mangled(const char *s, unsigned int style)
+{
+
+ switch (style) {
+ case ELFTC_DEM_ARM: return (is_cpp_mangled_ARM(s) ? style : 0);
+ case ELFTC_DEM_GNU2: return (is_cpp_mangled_gnu2(s) ? style : 0);
+ case ELFTC_DEM_GNU3: return (is_cpp_mangled_gnu3(s) ? style : 0);
+ }
+
+ /* No style or invalid style spcified, try to guess. */
+ if (is_cpp_mangled_gnu3(s))
+ return (ELFTC_DEM_GNU3);
+ if (is_cpp_mangled_gnu2(s))
+ return (ELFTC_DEM_GNU2);
+ if (is_cpp_mangled_ARM(s))
+ return (ELFTC_DEM_ARM);
+
+ /* Cannot be demangled. */
+ return (0);
+}
+
+static char *
+demangle(const char *s, unsigned int style, unsigned int rc)
+{
+
+ (void) rc; /* XXX */
+ switch (style) {
+ case ELFTC_DEM_ARM: return (cpp_demangle_ARM(s));
+ case ELFTC_DEM_GNU2: return (cpp_demangle_gnu2(s));
+ case ELFTC_DEM_GNU3: return (cpp_demangle_gnu3(s));
+ default:
+ assert(0);
+ return (NULL);
+ }
+}
+
+int
+elftc_demangle(const char *mangledname, char *buffer, size_t bufsize,
+ unsigned int flags)
+{
+ unsigned int style, rc;
+ char *rlt;
+
+ style = flags & 0xFFFF;
+ rc = flags >> 16;
+
+ if (mangledname == NULL ||
+ ((style = is_mangled(mangledname, style)) == 0)) {
+ errno = EINVAL;
+ return (-1);
+ }
+
+ if ((rlt = demangle(mangledname, style, rc)) == NULL) {
+ errno = EINVAL;
+ return (-1);
+ }
+
+ if (buffer == NULL || bufsize < strlen(rlt) + 1) {
+ free(rlt);
+ errno = ENAMETOOLONG;
+ return (-1);
+ }
+
+ strncpy(buffer, rlt, bufsize);
+ buffer[bufsize - 1] = '\0';
+ free(rlt);
+
+ return (0);
+}
diff --git a/rtemstoolkit/elftoolchain/libelftc/elftc_reloc_type_str.3 b/rtemstoolkit/elftoolchain/libelftc/elftc_reloc_type_str.3
new file mode 100644
index 0000000..5cd08a6
--- /dev/null
+++ b/rtemstoolkit/elftoolchain/libelftc/elftc_reloc_type_str.3
@@ -0,0 +1,72 @@
+.\" Copyright (c) 2016 The FreeBSD Foundation. All rights reserved.
+.\"
+.\" This documentation was written by Ed Maste under sponsorship of
+.\" the FreeBSD Foundation.
+.\"
+.\" 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.
+.\"
+.\" This software is provided by the author 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 author 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.
+.\"
+.\" $Id$
+.\"
+.Dd February 19, 2016
+.Os
+.Dt ELFTC_RELOC_TYPE_STR 3
+.Sh NAME
+.Nm elftc_reloc_type_str
+.Nd return the type name for an ELF relocation
+.Sh LIBRARY
+.Lb libelftc
+.Sh SYNOPSIS
+.In libelftc.h
+.Ft const char *
+.Fo elftc_reloc_type_str
+.Fa "unsigned int mach"
+.Fa "unsigned int type"
+.Fc
+.Sh DESCRIPTION
+Function
+.Fn elftc_reloc_type_str
+returns the name for specified relocation type.
+.Pp
+Argument
+.Ar mach
+specifies the machine (architecture) type.
+Argument
+.Ar type
+specifies the relocation value.
+.Sh RETURN VALUE
+Function
+.Fn elftc_program_version
+returns a pointer to a string constant, or to an internal character buffer
+if the relocation type is unknown.
+.Sh EXAMPLES
+To print ARM relocation type 7, use:
+.Bd -literal -offset indent
+#include <sys/types.h>
+#include <libelftc.h>
+#include <stdio.h>
+
+(void) printf("%s\en", elftc_reloc_type_str(EM_ARM, 7));
+.Ed
+.Sh ERRORS
+Function
+.Fn elftc_reloc_type_str
+always succeeds.
diff --git a/rtemstoolkit/elftoolchain/libelftc/elftc_reloc_type_str.c b/rtemstoolkit/elftoolchain/libelftc/elftc_reloc_type_str.c
new file mode 100644
index 0000000..fdad9a6
--- /dev/null
+++ b/rtemstoolkit/elftoolchain/libelftc/elftc_reloc_type_str.c
@@ -0,0 +1,832 @@
+/*-
+ * Copyright (c) 2009-2015 Kai Wang
+ * Copyright (c) 2016 The FreeBSD Foundation
+ * All rights reserved.
+ *
+ * Portions of this software were developed by Ed Maste under sponsorship
+ * of the FreeBSD Foundation.
+ *
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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 <libelftc.h>
+#include <stdio.h>
+
+const char *
+elftc_reloc_type_str(unsigned int mach, unsigned int type)
+{
+ static char s_type[32];
+
+ switch(mach) {
+ case EM_386:
+ case EM_IAMCU:
+ switch(type) {
+ case 0: return "R_386_NONE";
+ case 1: return "R_386_32";
+ case 2: return "R_386_PC32";
+ case 3: return "R_386_GOT32";
+ case 4: return "R_386_PLT32";
+ case 5: return "R_386_COPY";
+ case 6: return "R_386_GLOB_DAT";
+ case 7: return "R_386_JUMP_SLOT";
+ case 8: return "R_386_RELATIVE";
+ case 9: return "R_386_GOTOFF";
+ case 10: return "R_386_GOTPC";
+ case 11: return "R_386_32PLT"; /* Not in psabi */
+ case 14: return "R_386_TLS_TPOFF";
+ case 15: return "R_386_TLS_IE";
+ case 16: return "R_386_TLS_GOTIE";
+ case 17: return "R_386_TLS_LE";
+ case 18: return "R_386_TLS_GD";
+ case 19: return "R_386_TLS_LDM";
+ case 20: return "R_386_16";
+ case 21: return "R_386_PC16";
+ case 22: return "R_386_8";
+ case 23: return "R_386_PC8";
+ case 24: return "R_386_TLS_GD_32";
+ case 25: return "R_386_TLS_GD_PUSH";
+ case 26: return "R_386_TLS_GD_CALL";
+ case 27: return "R_386_TLS_GD_POP";
+ case 28: return "R_386_TLS_LDM_32";
+ case 29: return "R_386_TLS_LDM_PUSH";
+ case 30: return "R_386_TLS_LDM_CALL";
+ case 31: return "R_386_TLS_LDM_POP";
+ case 32: return "R_386_TLS_LDO_32";
+ case 33: return "R_386_TLS_IE_32";
+ case 34: return "R_386_TLS_LE_32";
+ case 35: return "R_386_TLS_DTPMOD32";
+ case 36: return "R_386_TLS_DTPOFF32";
+ case 37: return "R_386_TLS_TPOFF32";
+ case 38: return "R_386_SIZE32";
+ case 39: return "R_386_TLS_GOTDESC";
+ case 40: return "R_386_TLS_DESC_CALL";
+ case 41: return "R_386_TLS_DESC";
+ case 42: return "R_386_IRELATIVE";
+ case 43: return "R_386_GOT32X";
+ }
+ break;
+ case EM_AARCH64:
+ switch(type) {
+ case 0: return "R_AARCH64_NONE";
+ case 257: return "R_AARCH64_ABS64";
+ case 258: return "R_AARCH64_ABS32";
+ case 259: return "R_AARCH64_ABS16";
+ case 260: return "R_AARCH64_PREL64";
+ case 261: return "R_AARCH64_PREL32";
+ case 262: return "R_AARCH64_PREL16";
+ case 263: return "R_AARCH64_MOVW_UABS_G0";
+ case 264: return "R_AARCH64_MOVW_UABS_G0_NC";
+ case 265: return "R_AARCH64_MOVW_UABS_G1";
+ case 266: return "R_AARCH64_MOVW_UABS_G1_NC";
+ case 267: return "R_AARCH64_MOVW_UABS_G2";
+ case 268: return "R_AARCH64_MOVW_UABS_G2_NC";
+ case 269: return "R_AARCH64_MOVW_UABS_G3";
+ case 270: return "R_AARCH64_MOVW_SABS_G0";
+ case 271: return "R_AARCH64_MOVW_SABS_G1";
+ case 272: return "R_AARCH64_MOVW_SABS_G2";
+ case 273: return "R_AARCH64_LD_PREL_LO19";
+ case 274: return "R_AARCH64_ADR_PREL_LO21";
+ case 275: return "R_AARCH64_ADR_PREL_PG_HI21";
+ case 276: return "R_AARCH64_ADR_PREL_PG_HI21_NC";
+ case 277: return "R_AARCH64_ADD_ABS_LO12_NC";
+ case 278: return "R_AARCH64_LDST8_ABS_LO12_NC";
+ case 279: return "R_AARCH64_TSTBR14";
+ case 280: return "R_AARCH64_CONDBR19";
+ case 282: return "R_AARCH64_JUMP26";
+ case 283: return "R_AARCH64_CALL26";
+ case 284: return "R_AARCH64_LDST16_ABS_LO12_NC";
+ case 285: return "R_AARCH64_LDST32_ABS_LO12_NC";
+ case 286: return "R_AARCH64_LDST64_ABS_LO12_NC";
+ case 287: return "R_AARCH64_MOVW_PREL_G0";
+ case 288: return "R_AARCH64_MOVW_PREL_G0_NC";
+ case 289: return "R_AARCH64_MOVW_PREL_G1";
+ case 290: return "R_AARCH64_MOVW_PREL_G1_NC";
+ case 291: return "R_AARCH64_MOVW_PREL_G2";
+ case 292: return "R_AARCH64_MOVW_PREL_G2_NC";
+ case 293: return "R_AARCH64_MOVW_PREL_G3";
+ case 299: return "R_AARCH64_LDST128_ABS_LO12_NC";
+ case 300: return "R_AARCH64_MOVW_GOTOFF_G0";
+ case 301: return "R_AARCH64_MOVW_GOTOFF_G0_NC";
+ case 302: return "R_AARCH64_MOVW_GOTOFF_G1";
+ case 303: return "R_AARCH64_MOVW_GOTOFF_G1_NC";
+ case 304: return "R_AARCH64_MOVW_GOTOFF_G2";
+ case 305: return "R_AARCH64_MOVW_GOTOFF_G2_NC";
+ case 306: return "R_AARCH64_MOVW_GOTOFF_G3";
+ case 307: return "R_AARCH64_GOTREL64";
+ case 308: return "R_AARCH64_GOTREL32";
+ case 309: return "R_AARCH64_GOT_LD_PREL19";
+ case 310: return "R_AARCH64_LD64_GOTOFF_LO15";
+ case 311: return "R_AARCH64_ADR_GOT_PAGE";
+ case 312: return "R_AARCH64_LD64_GOT_LO12_NC";
+ case 313: return "R_AARCH64_LD64_GOTPAGE_LO15";
+ case 560: return "R_AARCH64_TLSDESC_LD_PREL19";
+ case 561: return "R_AARCH64_TLSDESC_ADR_PREL21";
+ case 562: return "R_AARCH64_TLSDESC_ADR_PAGE21";
+ case 563: return "R_AARCH64_TLSDESC_LD64_LO12";
+ case 564: return "R_AARCH64_TLSDESC_ADD_LO12";
+ case 565: return "R_AARCH64_TLSDESC_OFF_G1";
+ case 566: return "R_AARCH64_TLSDESC_OFF_G0_NC";
+ case 567: return "R_AARCH64_TLSDESC_LDR";
+ case 568: return "R_AARCH64_TLSDESC_ADD";
+ case 569: return "R_AARCH64_TLSDESC_CALL";
+ case 1024: return "R_AARCH64_COPY";
+ case 1025: return "R_AARCH64_GLOB_DAT";
+ case 1026: return "R_AARCH64_JUMP_SLOT";
+ case 1027: return "R_AARCH64_RELATIVE";
+ case 1028: return "R_AARCH64_TLS_DTPREL64";
+ case 1029: return "R_AARCH64_TLS_DTPMOD64";
+ case 1030: return "R_AARCH64_TLS_TPREL64";
+ case 1031: return "R_AARCH64_TLSDESC";
+ case 1032: return "R_AARCH64_IRELATIVE";
+ }
+ break;
+ case EM_ARM:
+ switch(type) {
+ case 0: return "R_ARM_NONE";
+ case 1: return "R_ARM_PC24"; /* Deprecated */
+ case 2: return "R_ARM_ABS32";
+ case 3: return "R_ARM_REL32";
+ case 4: return "R_ARM_LDR_PC_G0"; /* Also R_ARM_PC13 */
+ case 5: return "R_ARM_ABS16";
+ case 6: return "R_ARM_ABS12";
+ case 7: return "R_ARM_THM_ABS5";
+ case 8: return "R_ARM_ABS8";
+ case 9: return "R_ARM_SBREL32";
+ case 10: return "R_ARM_THM_CALL"; /* Also R_ARM_THM_PC22 */
+ case 11: return "R_ARM_THM_PC8";
+ case 12: return "R_ARM_BREL_ADJ"; /* Also R_ARM_AMP_VCALL9 */
+ case 13: return "R_ARM_TLS_DESC"; /* Also R_ARM_SWI24 */
+ case 14: return "R_ARM_THM_SWI8"; /* Obsolete */
+ case 15: return "R_ARM_XPC25"; /* Obsolete */
+ case 16: return "R_ARM_THM_XPC22"; /* Obsolete */
+ case 17: return "R_ARM_TLS_DTPMOD32";
+ case 18: return "R_ARM_TLS_DTPOFF32";
+ case 19: return "R_ARM_TLS_TPOFF32";
+ case 20: return "R_ARM_COPY";
+ case 21: return "R_ARM_GLOB_DAT";
+ case 22: return "R_ARM_JUMP_SLOT";
+ case 23: return "R_ARM_RELATIVE";
+ case 24: return "R_ARM_GOTOFF32"; /* Also R_ARM_GOTOFF */
+ case 25: return "R_ARM_BASE_PREL"; /* GNU R_ARM_GOTPC */
+ case 26: return "R_ARM_GOT_BREL"; /* GNU R_ARM_GOT32 */
+ case 27: return "R_ARM_PLT32"; /* Deprecated */
+ case 28: return "R_ARM_CALL";
+ case 29: return "R_ARM_JUMP24";
+ case 30: return "R_ARM_THM_JUMP24";
+ case 31: return "R_ARM_BASE_ABS";
+ case 32: return "R_ARM_ALU_PCREL_7_0"; /* Obsolete */
+ case 33: return "R_ARM_ALU_PCREL_15_8"; /* Obsolete */
+ case 34: return "R_ARM_ALU_PCREL_23_15"; /* Obsolete */
+ case 35: return "R_ARM_LDR_SBREL_11_0_NC"; /* Deprecated */
+ case 36: return "R_ARM_ALU_SBREL_19_12_NC"; /* Deprecated */
+ case 37: return "R_ARM_ALU_SBREL_27_20_CK"; /* Deprecated */
+ case 38: return "R_ARM_TARGET1";
+ case 39: return "R_ARM_SBREL31"; /* Deprecated. */
+ case 40: return "R_ARM_V4BX";
+ case 41: return "R_ARM_TARGET2";
+ case 42: return "R_ARM_PREL31";
+ case 43: return "R_ARM_MOVW_ABS_NC";
+ case 44: return "R_ARM_MOVT_ABS";
+ case 45: return "R_ARM_MOVW_PREL_NC";
+ case 46: return "R_ARM_MOVT_PREL";
+ case 47: return "R_ARM_THM_MOVW_ABS_NC";
+ case 48: return "R_ARM_THM_MOVT_ABS";
+ case 49: return "R_ARM_THM_MOVW_PREL_NC";
+ case 50: return "R_ARM_THM_MOVT_PREL";
+ case 51: return "R_ARM_THM_JUMP19";
+ case 52: return "R_ARM_THM_JUMP6";
+ case 53: return "R_ARM_THM_ALU_PREL_11_0";
+ case 54: return "R_ARM_THM_PC12";
+ case 55: return "R_ARM_ABS32_NOI";
+ case 56: return "R_ARM_REL32_NOI";
+ case 57: return "R_ARM_ALU_PC_G0_NC";
+ case 58: return "R_ARM_ALU_PC_G0";
+ case 59: return "R_ARM_ALU_PC_G1_NC";
+ case 60: return "R_ARM_ALU_PC_G1";
+ case 61: return "R_ARM_ALU_PC_G2";
+ case 62: return "R_ARM_LDR_PC_G1";
+ case 63: return "R_ARM_LDR_PC_G2";
+ case 64: return "R_ARM_LDRS_PC_G0";
+ case 65: return "R_ARM_LDRS_PC_G1";
+ case 66: return "R_ARM_LDRS_PC_G2";
+ case 67: return "R_ARM_LDC_PC_G0";
+ case 68: return "R_ARM_LDC_PC_G1";
+ case 69: return "R_ARM_LDC_PC_G2";
+ case 70: return "R_ARM_ALU_SB_G0_NC";
+ case 71: return "R_ARM_ALU_SB_G0";
+ case 72: return "R_ARM_ALU_SB_G1_NC";
+ case 73: return "R_ARM_ALU_SB_G1";
+ case 74: return "R_ARM_ALU_SB_G2";
+ case 75: return "R_ARM_LDR_SB_G0";
+ case 76: return "R_ARM_LDR_SB_G1";
+ case 77: return "R_ARM_LDR_SB_G2";
+ case 78: return "R_ARM_LDRS_SB_G0";
+ case 79: return "R_ARM_LDRS_SB_G1";
+ case 80: return "R_ARM_LDRS_SB_G2";
+ case 81: return "R_ARM_LDC_SB_G0";
+ case 82: return "R_ARM_LDC_SB_G1";
+ case 83: return "R_ARM_LDC_SB_G2";
+ case 84: return "R_ARM_MOVW_BREL_NC";
+ case 85: return "R_ARM_MOVT_BREL";
+ case 86: return "R_ARM_MOVW_BREL";
+ case 87: return "R_ARM_THM_MOVW_BREL_NC";
+ case 88: return "R_ARM_THM_MOVT_BREL";
+ case 89: return "R_ARM_THM_MOVW_BREL";
+ case 90: return "R_ARM_TLS_GOTDESC";
+ case 91: return "R_ARM_TLS_CALL";
+ case 92: return "R_ARM_TLS_DESCSEQ";
+ case 93: return "R_ARM_THM_TLS_CALL";
+ case 94: return "R_ARM_PLT32_ABS";
+ case 95: return "R_ARM_GOT_ABS";
+ case 96: return "R_ARM_GOT_PREL";
+ case 97: return "R_ARM_GOT_BREL12";
+ case 98: return "R_ARM_GOTOFF12";
+ case 99: return "R_ARM_GOTRELAX";
+ case 100: return "R_ARM_GNU_VTENTRY";
+ case 101: return "R_ARM_GNU_VTINHERIT";
+ case 102: return "R_ARM_THM_JUMP11"; /* Also R_ARM_THM_PC11 */
+ case 103: return "R_ARM_THM_JUMP8"; /* Also R_ARM_THM_PC9 */
+ case 104: return "R_ARM_TLS_GD32";
+ case 105: return "R_ARM_TLS_LDM32";
+ case 106: return "R_ARM_TLS_LDO32";
+ case 107: return "R_ARM_TLS_IE32";
+ case 108: return "R_ARM_TLS_LE32";
+ case 109: return "R_ARM_TLS_LDO12";
+ case 110: return "R_ARM_TLS_LE12";
+ case 111: return "R_ARM_TLS_IE12GP";
+ /* 112-127 R_ARM_PRIVATE_<n> */
+ case 128: return "R_ARM_ME_TOO"; /* Obsolete */
+ case 129: return "R_ARM_THM_TLS_DESCSEQ16";
+ case 130: return "R_ARM_THM_TLS_DESCSEQ32";
+ case 131: return "R_ARM_THM_GOT_BREL12";
+ case 132: return "R_ARM_THM_ALU_ABS_G0_NC";
+ case 133: return "R_ARM_THM_ALU_ABS_G1_NC";
+ case 134: return "R_ARM_THM_ALU_ABS_G2_NC";
+ case 135: return "R_ARM_THM_ALU_ABS_G3";
+ /* 136-159 Reserved for future allocation. */
+ case 160: return "R_ARM_IRELATIVE";
+ /* 161-255 Reserved for future allocation. */
+ case 249: return "R_ARM_RXPC25";
+ case 250: return "R_ARM_RSBREL32";
+ case 251: return "R_ARM_THM_RPC22";
+ case 252: return "R_ARM_RREL32";
+ case 253: return "R_ARM_RABS32";
+ case 254: return "R_ARM_RPC24";
+ case 255: return "R_ARM_RBASE";
+ }
+ break;
+ case EM_IA_64:
+ switch(type) {
+ case 0: return "R_IA_64_NONE";
+ case 33: return "R_IA_64_IMM14";
+ case 34: return "R_IA_64_IMM22";
+ case 35: return "R_IA_64_IMM64";
+ case 36: return "R_IA_64_DIR32MSB";
+ case 37: return "R_IA_64_DIR32LSB";
+ case 38: return "R_IA_64_DIR64MSB";
+ case 39: return "R_IA_64_DIR64LSB";
+ case 42: return "R_IA_64_GPREL22";
+ case 43: return "R_IA_64_GPREL64I";
+ case 44: return "R_IA_64_GPREL32MSB";
+ case 45: return "R_IA_64_GPREL32LSB";
+ case 46: return "R_IA_64_GPREL64MSB";
+ case 47: return "R_IA_64_GPREL64LSB";
+ case 50: return "R_IA_64_LTOFF22";
+ case 51: return "R_IA_64_LTOFF64I";
+ case 58: return "R_IA_64_PLTOFF22";
+ case 59: return "R_IA_64_PLTOFF64I";
+ case 62: return "R_IA_64_PLTOFF64MSB";
+ case 63: return "R_IA_64_PLTOFF64LSB";
+ case 67: return "R_IA_64_FPTR64I";
+ case 68: return "R_IA_64_FPTR32MSB";
+ case 69: return "R_IA_64_FPTR32LSB";
+ case 70: return "R_IA_64_FPTR64MSB";
+ case 71: return "R_IA_64_FPTR64LSB";
+ case 72: return "R_IA_64_PCREL60B";
+ case 73: return "R_IA_64_PCREL21B";
+ case 74: return "R_IA_64_PCREL21M";
+ case 75: return "R_IA_64_PCREL21F";
+ case 76: return "R_IA_64_PCREL32MSB";
+ case 77: return "R_IA_64_PCREL32LSB";
+ case 78: return "R_IA_64_PCREL64MSB";
+ case 79: return "R_IA_64_PCREL64LSB";
+ case 82: return "R_IA_64_LTOFF_FPTR22";
+ case 83: return "R_IA_64_LTOFF_FPTR64I";
+ case 84: return "R_IA_64_LTOFF_FPTR32MSB";
+ case 85: return "R_IA_64_LTOFF_FPTR32LSB";
+ case 86: return "R_IA_64_LTOFF_FPTR64MSB";
+ case 87: return "R_IA_64_LTOFF_FPTR64LSB";
+ case 92: return "R_IA_64_SEGREL32MSB";
+ case 93: return "R_IA_64_SEGREL32LSB";
+ case 94: return "R_IA_64_SEGREL64MSB";
+ case 95: return "R_IA_64_SEGREL64LSB";
+ case 100: return "R_IA_64_SECREL32MSB";
+ case 101: return "R_IA_64_SECREL32LSB";
+ case 102: return "R_IA_64_SECREL64MSB";
+ case 103: return "R_IA_64_SECREL64LSB";
+ case 108: return "R_IA_64_REL32MSB";
+ case 109: return "R_IA_64_REL32LSB";
+ case 110: return "R_IA_64_REL64MSB";
+ case 111: return "R_IA_64_REL64LSB";
+ case 116: return "R_IA_64_LTV32MSB";
+ case 117: return "R_IA_64_LTV32LSB";
+ case 118: return "R_IA_64_LTV64MSB";
+ case 119: return "R_IA_64_LTV64LSB";
+ case 121: return "R_IA_64_PCREL21BI";
+ case 122: return "R_IA_64_PCREL22";
+ case 123: return "R_IA_64_PCREL64I";
+ case 128: return "R_IA_64_IPLTMSB";
+ case 129: return "R_IA_64_IPLTLSB";
+ case 133: return "R_IA_64_SUB";
+ case 134: return "R_IA_64_LTOFF22X";
+ case 135: return "R_IA_64_LDXMOV";
+ case 145: return "R_IA_64_TPREL14";
+ case 146: return "R_IA_64_TPREL22";
+ case 147: return "R_IA_64_TPREL64I";
+ case 150: return "R_IA_64_TPREL64MSB";
+ case 151: return "R_IA_64_TPREL64LSB";
+ case 154: return "R_IA_64_LTOFF_TPREL22";
+ case 166: return "R_IA_64_DTPMOD64MSB";
+ case 167: return "R_IA_64_DTPMOD64LSB";
+ case 170: return "R_IA_64_LTOFF_DTPMOD22";
+ case 177: return "R_IA_64_DTPREL14";
+ case 178: return "R_IA_64_DTPREL22";
+ case 179: return "R_IA_64_DTPREL64I";
+ case 180: return "R_IA_64_DTPREL32MSB";
+ case 181: return "R_IA_64_DTPREL32LSB";
+ case 182: return "R_IA_64_DTPREL64MSB";
+ case 183: return "R_IA_64_DTPREL64LSB";
+ case 186: return "R_IA_64_LTOFF_DTPREL22";
+ }
+ break;
+ case EM_MIPS:
+ switch(type) {
+ case 0: return "R_MIPS_NONE";
+ case 1: return "R_MIPS_16";
+ case 2: return "R_MIPS_32";
+ case 3: return "R_MIPS_REL32";
+ case 4: return "R_MIPS_26";
+ case 5: return "R_MIPS_HI16";
+ case 6: return "R_MIPS_LO16";
+ case 7: return "R_MIPS_GPREL16";
+ case 8: return "R_MIPS_LITERAL";
+ case 9: return "R_MIPS_GOT16";
+ case 10: return "R_MIPS_PC16";
+ case 11: return "R_MIPS_CALL16";
+ case 12: return "R_MIPS_GPREL32";
+ case 16: return "R_MIPS_SHIFT5";
+ case 17: return "R_MIPS_SHIFT6";
+ case 18: return "R_MIPS_64";
+ case 19: return "R_MIPS_GOT_DISP";
+ case 20: return "R_MIPS_GOT_PAGE";
+ case 21: return "R_MIPS_GOT_OFST";
+ case 22: return "R_MIPS_GOT_HI16";
+ case 23: return "R_MIPS_GOT_LO16";
+ case 24: return "R_MIPS_SUB";
+ case 30: return "R_MIPS_CALLHI16";
+ case 31: return "R_MIPS_CALLLO16";
+ case 37: return "R_MIPS_JALR";
+ case 38: return "R_MIPS_TLS_DTPMOD32";
+ case 39: return "R_MIPS_TLS_DTPREL32";
+ case 40: return "R_MIPS_TLS_DTPMOD64";
+ case 41: return "R_MIPS_TLS_DTPREL64";
+ case 42: return "R_MIPS_TLS_GD";
+ case 43: return "R_MIPS_TLS_LDM";
+ case 44: return "R_MIPS_TLS_DTPREL_HI16";
+ case 45: return "R_MIPS_TLS_DTPREL_LO16";
+ case 46: return "R_MIPS_TLS_GOTTPREL";
+ case 47: return "R_MIPS_TLS_TPREL32";
+ case 48: return "R_MIPS_TLS_TPREL64";
+ case 49: return "R_MIPS_TLS_TPREL_HI16";
+ case 50: return "R_MIPS_TLS_TPREL_LO16";
+ }
+ break;
+ case EM_PPC:
+ switch(type) {
+ case 0: return "R_PPC_NONE";
+ case 1: return "R_PPC_ADDR32";
+ case 2: return "R_PPC_ADDR24";
+ case 3: return "R_PPC_ADDR16";
+ case 4: return "R_PPC_ADDR16_LO";
+ case 5: return "R_PPC_ADDR16_HI";
+ case 6: return "R_PPC_ADDR16_HA";
+ case 7: return "R_PPC_ADDR14";
+ case 8: return "R_PPC_ADDR14_BRTAKEN";
+ case 9: return "R_PPC_ADDR14_BRNTAKEN";
+ case 10: return "R_PPC_REL24";
+ case 11: return "R_PPC_REL14";
+ case 12: return "R_PPC_REL14_BRTAKEN";
+ case 13: return "R_PPC_REL14_BRNTAKEN";
+ case 14: return "R_PPC_GOT16";
+ case 15: return "R_PPC_GOT16_LO";
+ case 16: return "R_PPC_GOT16_HI";
+ case 17: return "R_PPC_GOT16_HA";
+ case 18: return "R_PPC_PLTREL24";
+ case 19: return "R_PPC_COPY";
+ case 20: return "R_PPC_GLOB_DAT";
+ case 21: return "R_PPC_JMP_SLOT";
+ case 22: return "R_PPC_RELATIVE";
+ case 23: return "R_PPC_LOCAL24PC";
+ case 24: return "R_PPC_UADDR32";
+ case 25: return "R_PPC_UADDR16";
+ case 26: return "R_PPC_REL32";
+ case 27: return "R_PPC_PLT32";
+ case 28: return "R_PPC_PLTREL32";
+ case 29: return "R_PPC_PLT16_LO";
+ case 30: return "R_PPC_PLT16_HI";
+ case 31: return "R_PPC_PLT16_HA";
+ case 32: return "R_PPC_SDAREL16";
+ case 33: return "R_PPC_SECTOFF";
+ case 34: return "R_PPC_SECTOFF_LO";
+ case 35: return "R_PPC_SECTOFF_HI";
+ case 36: return "R_PPC_SECTOFF_HA";
+ case 67: return "R_PPC_TLS";
+ case 68: return "R_PPC_DTPMOD32";
+ case 69: return "R_PPC_TPREL16";
+ case 70: return "R_PPC_TPREL16_LO";
+ case 71: return "R_PPC_TPREL16_HI";
+ case 72: return "R_PPC_TPREL16_HA";
+ case 73: return "R_PPC_TPREL32";
+ case 74: return "R_PPC_DTPREL16";
+ case 75: return "R_PPC_DTPREL16_LO";
+ case 76: return "R_PPC_DTPREL16_HI";
+ case 77: return "R_PPC_DTPREL16_HA";
+ case 78: return "R_PPC_DTPREL32";
+ case 79: return "R_PPC_GOT_TLSGD16";
+ case 80: return "R_PPC_GOT_TLSGD16_LO";
+ case 81: return "R_PPC_GOT_TLSGD16_HI";
+ case 82: return "R_PPC_GOT_TLSGD16_HA";
+ case 83: return "R_PPC_GOT_TLSLD16";
+ case 84: return "R_PPC_GOT_TLSLD16_LO";
+ case 85: return "R_PPC_GOT_TLSLD16_HI";
+ case 86: return "R_PPC_GOT_TLSLD16_HA";
+ case 87: return "R_PPC_GOT_TPREL16";
+ case 88: return "R_PPC_GOT_TPREL16_LO";
+ case 89: return "R_PPC_GOT_TPREL16_HI";
+ case 90: return "R_PPC_GOT_TPREL16_HA";
+ case 101: return "R_PPC_EMB_NADDR32";
+ case 102: return "R_PPC_EMB_NADDR16";
+ case 103: return "R_PPC_EMB_NADDR16_LO";
+ case 104: return "R_PPC_EMB_NADDR16_HI";
+ case 105: return "R_PPC_EMB_NADDR16_HA";
+ case 106: return "R_PPC_EMB_SDAI16";
+ case 107: return "R_PPC_EMB_SDA2I16";
+ case 108: return "R_PPC_EMB_SDA2REL";
+ case 109: return "R_PPC_EMB_SDA21";
+ case 110: return "R_PPC_EMB_MRKREF";
+ case 111: return "R_PPC_EMB_RELSEC16";
+ case 112: return "R_PPC_EMB_RELST_LO";
+ case 113: return "R_PPC_EMB_RELST_HI";
+ case 114: return "R_PPC_EMB_RELST_HA";
+ case 115: return "R_PPC_EMB_BIT_FLD";
+ case 116: return "R_PPC_EMB_RELSDA";
+ }
+ break;
+ case EM_PPC64:
+ switch(type) {
+ case 0: return "R_PPC64_NONE";
+ case 1: return "R_PPC64_ADDR32";
+ case 2: return "R_PPC64_ADDR24";
+ case 3: return "R_PPC64_ADDR16";
+ case 4: return "R_PPC64_ADDR16_LO";
+ case 5: return "R_PPC64_ADDR16_HI";
+ case 6: return "R_PPC64_ADDR16_HA";
+ case 7: return "R_PPC64_ADDR14";
+ case 8: return "R_PPC64_ADDR14_BRTAKEN";
+ case 9: return "R_PPC64_ADDR14_BRNTAKEN";
+ case 10: return "R_PPC64_REL24";
+ case 11: return "R_PPC64_REL14";
+ case 12: return "R_PPC64_REL14_BRTAKEN";
+ case 13: return "R_PPC64_REL14_BRNTAKEN";
+ case 14: return "R_PPC64_GOT16";
+ case 15: return "R_PPC64_GOT16_LO";
+ case 16: return "R_PPC64_GOT16_HI";
+ case 17: return "R_PPC64_GOT16_HA";
+ case 19: return "R_PPC64_COPY";
+ case 20: return "R_PPC64_GLOB_DAT";
+ case 21: return "R_PPC64_JMP_SLOT";
+ case 22: return "R_PPC64_RELATIVE";
+ case 24: return "R_PPC64_UADDR32";
+ case 25: return "R_PPC64_UADDR16";
+ case 26: return "R_PPC64_REL32";
+ case 27: return "R_PPC64_PLT32";
+ case 28: return "R_PPC64_PLTREL32";
+ case 29: return "R_PPC64_PLT16_LO";
+ case 30: return "R_PPC64_PLT16_HI";
+ case 31: return "R_PPC64_PLT16_HA";
+ case 33: return "R_PPC64_SECTOFF";
+ case 34: return "R_PPC64_SECTOFF_LO";
+ case 35: return "R_PPC64_SECTOFF_HI";
+ case 36: return "R_PPC64_SECTOFF_HA";
+ case 37: return "R_PPC64_ADDR30";
+ case 38: return "R_PPC64_ADDR64";
+ case 39: return "R_PPC64_ADDR16_HIGHER";
+ case 40: return "R_PPC64_ADDR16_HIGHERA";
+ case 41: return "R_PPC64_ADDR16_HIGHEST";
+ case 42: return "R_PPC64_ADDR16_HIGHESTA";
+ case 43: return "R_PPC64_UADDR64";
+ case 44: return "R_PPC64_REL64";
+ case 45: return "R_PPC64_PLT64";
+ case 46: return "R_PPC64_PLTREL64";
+ case 47: return "R_PPC64_TOC16";
+ case 48: return "R_PPC64_TOC16_LO";
+ case 49: return "R_PPC64_TOC16_HI";
+ case 50: return "R_PPC64_TOC16_HA";
+ case 51: return "R_PPC64_TOC";
+ case 52: return "R_PPC64_PLTGOT16";
+ case 53: return "R_PPC64_PLTGOT16_LO";
+ case 54: return "R_PPC64_PLTGOT16_HI";
+ case 55: return "R_PPC64_PLTGOT16_HA";
+ case 56: return "R_PPC64_ADDR16_DS";
+ case 57: return "R_PPC64_ADDR16_LO_DS";
+ case 58: return "R_PPC64_GOT16_DS";
+ case 59: return "R_PPC64_GOT16_LO_DS";
+ case 60: return "R_PPC64_PLT16_LO_DS";
+ case 61: return "R_PPC64_SECTOFF_DS";
+ case 62: return "R_PPC64_SECTOFF_LO_DS";
+ case 63: return "R_PPC64_TOC16_DS";
+ case 64: return "R_PPC64_TOC16_LO_DS";
+ case 65: return "R_PPC64_PLTGOT16_DS";
+ case 66: return "R_PPC64_PLTGOT16_LO_DS";
+ case 67: return "R_PPC64_TLS";
+ case 68: return "R_PPC64_DTPMOD64";
+ case 69: return "R_PPC64_TPREL16";
+ case 70: return "R_PPC64_TPREL16_LO";
+ case 71: return "R_PPC64_TPREL16_HI";
+ case 72: return "R_PPC64_TPREL16_HA";
+ case 73: return "R_PPC64_TPREL64";
+ case 74: return "R_PPC64_DTPREL16";
+ case 75: return "R_PPC64_DTPREL16_LO";
+ case 76: return "R_PPC64_DTPREL16_HI";
+ case 77: return "R_PPC64_DTPREL16_HA";
+ case 78: return "R_PPC64_DTPREL64";
+ case 79: return "R_PPC64_GOT_TLSGD16";
+ case 80: return "R_PPC64_GOT_TLSGD16_LO";
+ case 81: return "R_PPC64_GOT_TLSGD16_HI";
+ case 82: return "R_PPC64_GOT_TLSGD16_HA";
+ case 83: return "R_PPC64_GOT_TLSLD16";
+ case 84: return "R_PPC64_GOT_TLSLD16_LO";
+ case 85: return "R_PPC64_GOT_TLSLD16_HI";
+ case 86: return "R_PPC64_GOT_TLSLD16_HA";
+ case 87: return "R_PPC64_GOT_TPREL16_DS";
+ case 88: return "R_PPC64_GOT_TPREL16_LO_DS";
+ case 89: return "R_PPC64_GOT_TPREL16_HI";
+ case 90: return "R_PPC64_GOT_TPREL16_HA";
+ case 91: return "R_PPC64_GOT_DTPREL16_DS";
+ case 92: return "R_PPC64_GOT_DTPREL16_LO_DS";
+ case 93: return "R_PPC64_GOT_DTPREL16_HI";
+ case 94: return "R_PPC64_GOT_DTPREL16_HA";
+ case 95: return "R_PPC64_TPREL16_DS";
+ case 96: return "R_PPC64_TPREL16_LO_DS";
+ case 97: return "R_PPC64_TPREL16_HIGHER";
+ case 98: return "R_PPC64_TPREL16_HIGHERA";
+ case 99: return "R_PPC64_TPREL16_HIGHEST";
+ case 100: return "R_PPC64_TPREL16_HIGHESTA";
+ case 101: return "R_PPC64_DTPREL16_DS";
+ case 102: return "R_PPC64_DTPREL16_LO_DS";
+ case 103: return "R_PPC64_DTPREL16_HIGHER";
+ case 104: return "R_PPC64_DTPREL16_HIGHERA";
+ case 105: return "R_PPC64_DTPREL16_HIGHEST";
+ case 106: return "R_PPC64_DTPREL16_HIGHESTA";
+ case 107: return "R_PPC64_TLSGD";
+ case 108: return "R_PPC64_TLSLD";
+ case 249: return "R_PPC64_REL16";
+ case 250: return "R_PPC64_REL16_LO";
+ case 251: return "R_PPC64_REL16_HI";
+ case 252: return "R_PPC64_REL16_HA";
+ }
+ break;
+ case EM_RISCV:
+ switch(type) {
+ case 0: return "R_RISCV_NONE";
+ case 1: return "R_RISCV_32";
+ case 2: return "R_RISCV_64";
+ case 3: return "R_RISCV_RELATIVE";
+ case 4: return "R_RISCV_COPY";
+ case 5: return "R_RISCV_JUMP_SLOT";
+ case 6: return "R_RISCV_TLS_DTPMOD32";
+ case 7: return "R_RISCV_TLS_DTPMOD64";
+ case 8: return "R_RISCV_TLS_DTPREL32";
+ case 9: return "R_RISCV_TLS_DTPREL64";
+ case 10: return "R_RISCV_TLS_TPREL32";
+ case 11: return "R_RISCV_TLS_TPREL64";
+ case 16: return "R_RISCV_BRANCH";
+ case 17: return "R_RISCV_JAL";
+ case 18: return "R_RISCV_CALL";
+ case 19: return "R_RISCV_CALL_PLT";
+ case 20: return "R_RISCV_GOT_HI20";
+ case 21: return "R_RISCV_TLS_GOT_HI20";
+ case 22: return "R_RISCV_TLS_GD_HI20";
+ case 23: return "R_RISCV_PCREL_HI20";
+ case 24: return "R_RISCV_PCREL_LO12_I";
+ case 25: return "R_RISCV_PCREL_LO12_S";
+ case 26: return "R_RISCV_HI20";
+ case 27: return "R_RISCV_LO12_I";
+ case 28: return "R_RISCV_LO12_S";
+ case 29: return "R_RISCV_TPREL_HI20";
+ case 30: return "R_RISCV_TPREL_LO12_I";
+ case 31: return "R_RISCV_TPREL_LO12_S";
+ case 32: return "R_RISCV_TPREL_ADD";
+ case 33: return "R_RISCV_ADD8";
+ case 34: return "R_RISCV_ADD16";
+ case 35: return "R_RISCV_ADD32";
+ case 36: return "R_RISCV_ADD64";
+ case 37: return "R_RISCV_SUB8";
+ case 38: return "R_RISCV_SUB16";
+ case 39: return "R_RISCV_SUB32";
+ case 40: return "R_RISCV_SUB64";
+ case 41: return "R_RISCV_GNU_VTINHERIT";
+ case 42: return "R_RISCV_GNU_VTENTRY";
+ case 43: return "R_RISCV_ALIGN";
+ case 44: return "R_RISCV_RVC_BRANCH";
+ case 45: return "R_RISCV_RVC_JUMP";
+ case 46: return "R_RISCV_RVC_LUI";
+ case 47: return "R_RISCV_GPREL_I";
+ case 48: return "R_RISCV_GPREL_S";
+ }
+ break;
+ case EM_S390:
+ switch (type) {
+ case 0: return "R_390_NONE";
+ case 1: return "R_390_8";
+ case 2: return "R_390_12";
+ case 3: return "R_390_16";
+ case 4: return "R_390_32";
+ case 5: return "R_390_PC32";
+ case 6: return "R_390_GOT12";
+ case 7: return "R_390_GOT32";
+ case 8: return "R_390_PLT32";
+ case 9: return "R_390_COPY";
+ case 10: return "R_390_GLOB_DAT";
+ case 11: return "R_390_JMP_SLOT";
+ case 12: return "R_390_RELATIVE";
+ case 13: return "R_390_GOTOFF";
+ case 14: return "R_390_GOTPC";
+ case 15: return "R_390_GOT16";
+ case 16: return "R_390_PC16";
+ case 17: return "R_390_PC16DBL";
+ case 18: return "R_390_PLT16DBL";
+ case 19: return "R_390_PC32DBL";
+ case 20: return "R_390_PLT32DBL";
+ case 21: return "R_390_GOTPCDBL";
+ case 22: return "R_390_64";
+ case 23: return "R_390_PC64";
+ case 24: return "R_390_GOT64";
+ case 25: return "R_390_PLT64";
+ case 26: return "R_390_GOTENT";
+ }
+ break;
+ case EM_SPARC:
+ case EM_SPARCV9:
+ switch(type) {
+ case 0: return "R_SPARC_NONE";
+ case 1: return "R_SPARC_8";
+ case 2: return "R_SPARC_16";
+ case 3: return "R_SPARC_32";
+ case 4: return "R_SPARC_DISP8";
+ case 5: return "R_SPARC_DISP16";
+ case 6: return "R_SPARC_DISP32";
+ case 7: return "R_SPARC_WDISP30";
+ case 8: return "R_SPARC_WDISP22";
+ case 9: return "R_SPARC_HI22";
+ case 10: return "R_SPARC_22";
+ case 11: return "R_SPARC_13";
+ case 12: return "R_SPARC_LO10";
+ case 13: return "R_SPARC_GOT10";
+ case 14: return "R_SPARC_GOT13";
+ case 15: return "R_SPARC_GOT22";
+ case 16: return "R_SPARC_PC10";
+ case 17: return "R_SPARC_PC22";
+ case 18: return "R_SPARC_WPLT30";
+ case 19: return "R_SPARC_COPY";
+ case 20: return "R_SPARC_GLOB_DAT";
+ case 21: return "R_SPARC_JMP_SLOT";
+ case 22: return "R_SPARC_RELATIVE";
+ case 23: return "R_SPARC_UA32";
+ case 24: return "R_SPARC_PLT32";
+ case 25: return "R_SPARC_HIPLT22";
+ case 26: return "R_SPARC_LOPLT10";
+ case 27: return "R_SPARC_PCPLT32";
+ case 28: return "R_SPARC_PCPLT22";
+ case 29: return "R_SPARC_PCPLT10";
+ case 30: return "R_SPARC_10";
+ case 31: return "R_SPARC_11";
+ case 32: return "R_SPARC_64";
+ case 33: return "R_SPARC_OLO10";
+ case 34: return "R_SPARC_HH22";
+ case 35: return "R_SPARC_HM10";
+ case 36: return "R_SPARC_LM22";
+ case 37: return "R_SPARC_PC_HH22";
+ case 38: return "R_SPARC_PC_HM10";
+ case 39: return "R_SPARC_PC_LM22";
+ case 40: return "R_SPARC_WDISP16";
+ case 41: return "R_SPARC_WDISP19";
+ case 42: return "R_SPARC_GLOB_JMP";
+ case 43: return "R_SPARC_7";
+ case 44: return "R_SPARC_5";
+ case 45: return "R_SPARC_6";
+ case 46: return "R_SPARC_DISP64";
+ case 47: return "R_SPARC_PLT64";
+ case 48: return "R_SPARC_HIX22";
+ case 49: return "R_SPARC_LOX10";
+ case 50: return "R_SPARC_H44";
+ case 51: return "R_SPARC_M44";
+ case 52: return "R_SPARC_L44";
+ case 53: return "R_SPARC_REGISTER";
+ case 54: return "R_SPARC_UA64";
+ case 55: return "R_SPARC_UA16";
+ case 56: return "R_SPARC_TLS_GD_HI22";
+ case 57: return "R_SPARC_TLS_GD_LO10";
+ case 58: return "R_SPARC_TLS_GD_ADD";
+ case 59: return "R_SPARC_TLS_GD_CALL";
+ case 60: return "R_SPARC_TLS_LDM_HI22";
+ case 61: return "R_SPARC_TLS_LDM_LO10";
+ case 62: return "R_SPARC_TLS_LDM_ADD";
+ case 63: return "R_SPARC_TLS_LDM_CALL";
+ case 64: return "R_SPARC_TLS_LDO_HIX22";
+ case 65: return "R_SPARC_TLS_LDO_LOX10";
+ case 66: return "R_SPARC_TLS_LDO_ADD";
+ case 67: return "R_SPARC_TLS_IE_HI22";
+ case 68: return "R_SPARC_TLS_IE_LO10";
+ case 69: return "R_SPARC_TLS_IE_LD";
+ case 70: return "R_SPARC_TLS_IE_LDX";
+ case 71: return "R_SPARC_TLS_IE_ADD";
+ case 72: return "R_SPARC_TLS_LE_HIX22";
+ case 73: return "R_SPARC_TLS_LE_LOX10";
+ case 74: return "R_SPARC_TLS_DTPMOD32";
+ case 75: return "R_SPARC_TLS_DTPMOD64";
+ case 76: return "R_SPARC_TLS_DTPOFF32";
+ case 77: return "R_SPARC_TLS_DTPOFF64";
+ case 78: return "R_SPARC_TLS_TPOFF32";
+ case 79: return "R_SPARC_TLS_TPOFF64";
+ }
+ break;
+ case EM_X86_64:
+ switch(type) {
+ case 0: return "R_X86_64_NONE";
+ case 1: return "R_X86_64_64";
+ case 2: return "R_X86_64_PC32";
+ case 3: return "R_X86_64_GOT32";
+ case 4: return "R_X86_64_PLT32";
+ case 5: return "R_X86_64_COPY";
+ case 6: return "R_X86_64_GLOB_DAT";
+ case 7: return "R_X86_64_JUMP_SLOT";
+ case 8: return "R_X86_64_RELATIVE";
+ case 9: return "R_X86_64_GOTPCREL";
+ case 10: return "R_X86_64_32";
+ case 11: return "R_X86_64_32S";
+ case 12: return "R_X86_64_16";
+ case 13: return "R_X86_64_PC16";
+ case 14: return "R_X86_64_8";
+ case 15: return "R_X86_64_PC8";
+ case 16: return "R_X86_64_DTPMOD64";
+ case 17: return "R_X86_64_DTPOFF64";
+ case 18: return "R_X86_64_TPOFF64";
+ case 19: return "R_X86_64_TLSGD";
+ case 20: return "R_X86_64_TLSLD";
+ case 21: return "R_X86_64_DTPOFF32";
+ case 22: return "R_X86_64_GOTTPOFF";
+ case 23: return "R_X86_64_TPOFF32";
+ case 24: return "R_X86_64_PC64";
+ case 25: return "R_X86_64_GOTOFF64";
+ case 26: return "R_X86_64_GOTPC32";
+ case 27: return "R_X86_64_GOT64";
+ case 28: return "R_X86_64_GOTPCREL64";
+ case 29: return "R_X86_64_GOTPC64";
+ case 30: return "R_X86_64_GOTPLT64";
+ case 31: return "R_X86_64_PLTOFF64";
+ case 32: return "R_X86_64_SIZE32";
+ case 33: return "R_X86_64_SIZE64";
+ case 34: return "R_X86_64_GOTPC32_TLSDESC";
+ case 35: return "R_X86_64_TLSDESC_CALL";
+ case 36: return "R_X86_64_TLSDESC";
+ case 37: return "R_X86_64_IRELATIVE";
+ case 38: return "R_X86_64_RELATIVE64";
+ case 41: return "R_X86_64_GOTPCRELX";
+ case 42: return "R_X86_64_REX_GOTPCRELX";
+ }
+ break;
+ }
+
+ snprintf(s_type, sizeof(s_type), "<unknown: %#x>", type);
+ return (s_type);
+}
diff --git a/rtemstoolkit/elftoolchain/libelftc/elftc_set_timestamps.3 b/rtemstoolkit/elftoolchain/libelftc/elftc_set_timestamps.3
new file mode 100644
index 0000000..115fe92
--- /dev/null
+++ b/rtemstoolkit/elftoolchain/libelftc/elftc_set_timestamps.3
@@ -0,0 +1,84 @@
+.\" Copyright (c) 2011 Joseph Koshy. 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.
+.\"
+.\" This software is provided by Joseph Koshy ``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 Joseph Koshy 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.
+.\"
+.\" $Id$
+.\"
+.Dd December 15, 2011
+.Os
+.Dt ELFTC_SET_TIMESTAMPS 3
+.Sh NAME
+.Nm elftc_set_timestamps
+.Nd set file timestamps
+.Sh LIBRARY
+.Lb libelftc
+.Sh SYNOPSIS
+.In libelftc.h
+.Ft int
+.Fn elftc_set_timestamps "const char *filename" "struct stat *sb"
+.Sh DESCRIPTION
+The
+.Fn elftc_set_timestamps
+function is used to set the access and modified time stamps on a file
+based on the contents of a
+.Vt "struct stat"
+descriptor.
+.Pp
+Argument
+.Ar filename
+names an existing file in the file system.
+.Pp
+Argument
+.Ar sb
+points to structure of type
+.Vt "struct stat"
+populated by a prior call to
+.Xr fstat 2
+or
+.Xr stat 2 .
+.Sh IMPLEMENTATION NOTES
+This function will invoke the high-resolution
+.Xr utimes 2
+system call if the underlying operating system supports it.
+On operating systems lacking support for
+.Xr utimes 2 ,
+the function will use lower resolution
+.Xr utime 2
+system call.
+.Sh EXAMPLES
+To set the access and modified times for a new file to those of an
+existing file, use:
+.Bd -literal -offset indent
+struct stat sb;
+const char *existing_filename, *new_filename;
+
+if (stat(existing_filename, &sb) < 0)
+ err(EXIT_FAILURE, "stat failed");
+
+if (elftc_set_timestamps(new_filename, &sb) < 0)
+ err(EXIT_FAILURE, "timestamps could not be set");
+.Ed
+.Sh SEE ALSO
+.Xr fstat 2 ,
+.Xr stat 2 ,
+.Xr utime 2 ,
+.Xr utimes 2 .
diff --git a/rtemstoolkit/elftoolchain/libelftc/elftc_set_timestamps.c b/rtemstoolkit/elftoolchain/libelftc/elftc_set_timestamps.c
new file mode 100644
index 0000000..cb28c35
--- /dev/null
+++ b/rtemstoolkit/elftoolchain/libelftc/elftc_set_timestamps.c
@@ -0,0 +1,85 @@
+/*-
+ * Copyright (c) 2011 Joseph Koshy
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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/types.h>
+
+#include "libelftc.h"
+
+#include "_libelftc.h"
+
+ELFTC_VCSID("$Id$");
+
+/*
+ * Determine the field name for the timestamp fields inside a 'struct
+ * stat'.
+ */
+
+#if defined(__FreeBSD__) || defined(__NetBSD__)
+#define ATIME st_atimespec
+#define MTIME st_mtimespec
+#define LIBELFTC_HAVE_UTIMES 1
+#endif
+
+#if defined(__DragonFly__) || defined(__linux__) || defined(__OpenBSD__)
+#define ATIME st_atim
+#define MTIME st_mtim
+#define LIBELFTC_HAVE_UTIMES 1
+#endif
+
+#if LIBELFTC_HAVE_UTIMES
+#include <sys/time.h>
+#else
+#include <utime.h>
+#endif
+
+int
+elftc_set_timestamps(const char *fn, struct stat *sb)
+{
+#if LIBELFTC_HAVE_UTIMES
+ /*
+ * The BSD utimes() system call offers timestamps
+ * 1-microsecond granularity.
+ */
+ struct timeval tv[2];
+
+ tv[0].tv_sec = sb->ATIME.tv_sec;
+ tv[0].tv_usec = sb->ATIME.tv_nsec / 1000;
+ tv[1].tv_sec = sb->MTIME.tv_sec;
+ tv[1].tv_usec = sb->MTIME.tv_nsec / 1000;
+
+ return (utimes(fn, tv));
+#else
+ /*
+ * On OSes without utimes(), fall back to the POSIX utime()
+ * call, which offers 1-second granularity.
+ */
+ struct utimbuf utb;
+
+ utb.actime = sb->st_atime;
+ utb.modtime = sb->st_mtime;
+ return (utime(fn, &utb));
+#endif
+}
diff --git a/rtemstoolkit/elftoolchain/libelftc/elftc_string_table.c b/rtemstoolkit/elftoolchain/libelftc/elftc_string_table.c
new file mode 100644
index 0000000..bba9ac6
--- /dev/null
+++ b/rtemstoolkit/elftoolchain/libelftc/elftc_string_table.c
@@ -0,0 +1,392 @@
+/*-
+ * Copyright (c) 2013, Joseph Koshy
+ * 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
+ * in this position and unchanged.
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``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 AUTHOR(S) 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/param.h>
+#include <sys/queue.h>
+
+#include <assert.h>
+#include <errno.h>
+#include <gelf.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "libelftc.h"
+#include "_libelftc.h"
+
+ELFTC_VCSID("$Id: elftc_string_table.c 2869 2013-01-06 13:29:18Z jkoshy $");
+
+#define ELFTC_STRING_TABLE_DEFAULT_SIZE (4*1024)
+#define ELFTC_STRING_TABLE_EXPECTED_STRING_SIZE 16
+#define ELFTC_STRING_TABLE_EXPECTED_CHAIN_LENGTH 8
+#define ELFTC_STRING_TABLE_POOL_SIZE_INCREMENT (4*1024)
+
+struct _Elftc_String_Table_Entry {
+ int ste_idx;
+ SLIST_ENTRY(_Elftc_String_Table_Entry) ste_next;
+};
+
+#define ELFTC_STRING_TABLE_COMPACTION_FLAG 0x1
+#define ELFTC_STRING_TABLE_LENGTH(st) ((st)->st_len >> 1)
+#define ELFTC_STRING_TABLE_CLEAR_COMPACTION_FLAG(st) do { \
+ (st)->st_len &= ~ELFTC_STRING_TABLE_COMPACTION_FLAG; \
+ } while (0)
+#define ELFTC_STRING_TABLE_SET_COMPACTION_FLAG(st) do { \
+ (st)->st_len |= ELFTC_STRING_TABLE_COMPACTION_FLAG; \
+ } while (0)
+#define ELFTC_STRING_TABLE_UPDATE_LENGTH(st, len) do { \
+ (st)->st_len = \
+ ((st)->st_len & \
+ ELFTC_STRING_TABLE_COMPACTION_FLAG) | \
+ ((len) << 1); \
+ } while (0)
+
+struct _Elftc_String_Table {
+ unsigned int st_len; /* length and flags */
+ int st_nbuckets;
+ int st_string_pool_size;
+ char *st_string_pool;
+ SLIST_HEAD(_Elftc_String_Table_Bucket,
+ _Elftc_String_Table_Entry) st_buckets[];
+};
+
+static struct _Elftc_String_Table_Entry *
+elftc_string_table_find_hash_entry(Elftc_String_Table *st, const char *string,
+ int *rhashindex)
+{
+ struct _Elftc_String_Table_Entry *ste;
+ int hashindex;
+ char *s;
+
+ hashindex = libelftc_hash_string(string) % st->st_nbuckets;
+
+ if (rhashindex)
+ *rhashindex = hashindex;
+
+ SLIST_FOREACH(ste, &st->st_buckets[hashindex], ste_next) {
+ s = st->st_string_pool + abs(ste->ste_idx);
+
+ assert(s > st->st_string_pool &&
+ s < st->st_string_pool + st->st_string_pool_size);
+
+ if (strcmp(s, string) == 0)
+ return (ste);
+ }
+
+ return (NULL);
+}
+
+static int
+elftc_string_table_add_to_pool(Elftc_String_Table *st, const char *string)
+{
+ char *newpool;
+ int len, newsize, stlen;
+
+ len = strlen(string) + 1; /* length, including the trailing NUL */
+ stlen = ELFTC_STRING_TABLE_LENGTH(st);
+
+ /* Resize the pool, if needed. */
+ if (stlen + len >= st->st_string_pool_size) {
+ newsize = roundup(st->st_string_pool_size +
+ ELFTC_STRING_TABLE_POOL_SIZE_INCREMENT,
+ ELFTC_STRING_TABLE_POOL_SIZE_INCREMENT);
+ if ((newpool = realloc(st->st_string_pool, newsize)) ==
+ NULL)
+ return (0);
+ st->st_string_pool = newpool;
+ st->st_string_pool_size = newsize;
+ }
+
+ strcpy(st->st_string_pool + stlen, string);
+ ELFTC_STRING_TABLE_UPDATE_LENGTH(st, stlen + len);
+
+ return (stlen);
+}
+
+Elftc_String_Table *
+elftc_string_table_create(int sizehint)
+{
+ int n, nbuckets, tablesize;
+ struct _Elftc_String_Table *st;
+
+ if (sizehint < ELFTC_STRING_TABLE_DEFAULT_SIZE)
+ sizehint = ELFTC_STRING_TABLE_DEFAULT_SIZE;
+
+ nbuckets = sizehint / (ELFTC_STRING_TABLE_EXPECTED_CHAIN_LENGTH *
+ ELFTC_STRING_TABLE_EXPECTED_STRING_SIZE);
+
+ tablesize = sizeof(struct _Elftc_String_Table) +
+ nbuckets * sizeof(struct _Elftc_String_Table_Bucket);
+
+ if ((st = malloc(tablesize)) == NULL)
+ return (NULL);
+ if ((st->st_string_pool = malloc(sizehint)) == NULL) {
+ free(st);
+ return (NULL);
+ }
+
+ for (n = 0; n < nbuckets; n++)
+ SLIST_INIT(&st->st_buckets[n]);
+
+ st->st_len = 0;
+ st->st_nbuckets = nbuckets;
+ st->st_string_pool_size = sizehint;
+ *st->st_string_pool = '\0';
+ ELFTC_STRING_TABLE_UPDATE_LENGTH(st, 1);
+
+ return (st);
+}
+
+void
+elftc_string_table_destroy(Elftc_String_Table *st)
+{
+ int n;
+ struct _Elftc_String_Table_Entry *s, *t;
+
+ for (n = 0; n < st->st_nbuckets; n++)
+ SLIST_FOREACH_SAFE(s, &st->st_buckets[n], ste_next, t)
+ free(s);
+ free(st->st_string_pool);
+ free(st);
+
+ return;
+}
+
+Elftc_String_Table *
+elftc_string_table_from_section(Elf_Scn *scn, int sizehint)
+{
+ int len;
+ Elf_Data *d;
+ GElf_Shdr sh;
+ const char *s, *end;
+ Elftc_String_Table *st;
+
+ /* Verify the type of the section passed in. */
+ if (gelf_getshdr(scn, &sh) == NULL ||
+ sh.sh_type != SHT_STRTAB) {
+ errno = EINVAL;
+ return (NULL);
+ }
+
+ if ((d = elf_getdata(scn, NULL)) == NULL ||
+ d->d_size == 0) {
+ errno = EINVAL;
+ return (NULL);
+ }
+
+ if ((st = elftc_string_table_create(sizehint)) == NULL)
+ return (NULL);
+
+ s = d->d_buf;
+
+ /*
+ * Verify that the first byte of the data buffer is '\0'.
+ */
+ if (*s != '\0') {
+ errno = EINVAL;
+ goto fail;
+ }
+
+ end = s + d->d_size;
+
+ /*
+ * Skip the first '\0' and insert the strings in the buffer,
+ * in order.
+ */
+ for (s += 1; s < end; s += len) {
+ if (elftc_string_table_insert(st, s) == 0)
+ goto fail;
+
+ len = strlen(s) + 1; /* Include space for the trailing NUL. */
+ }
+
+ return (st);
+
+fail:
+ if (st)
+ (void) elftc_string_table_destroy(st);
+
+ return (NULL);
+}
+
+const char *
+elftc_string_table_image(Elftc_String_Table *st, size_t *size)
+{
+ char *r, *s, *end;
+ struct _Elftc_String_Table_Entry *ste;
+ struct _Elftc_String_Table_Bucket *head;
+ int copied, hashindex, offset, length, newsize;
+
+ /*
+ * For the common case of a string table has not seen
+ * a string deletion, we can just export the current
+ * pool.
+ */
+ if ((st->st_len & ELFTC_STRING_TABLE_COMPACTION_FLAG) == 0) {
+ if (size)
+ *size = ELFTC_STRING_TABLE_LENGTH(st);
+ return (st->st_string_pool);
+ }
+
+ /*
+ * Otherwise, compact the string table in-place.
+ */
+ assert(*st->st_string_pool == '\0');
+
+ newsize = 1;
+ end = st->st_string_pool + ELFTC_STRING_TABLE_LENGTH(st);
+
+ for (r = s = st->st_string_pool + 1;
+ s < end;
+ s += length, r += copied) {
+
+ copied = 0;
+ length = strlen(s) + 1;
+
+ ste = elftc_string_table_find_hash_entry(st, s,
+ &hashindex);
+ head = &st->st_buckets[hashindex];
+
+ assert(ste != NULL);
+
+ /* Ignore deleted strings. */
+ if (ste->ste_idx < 0) {
+ SLIST_REMOVE(head, ste, _Elftc_String_Table_Entry,
+ ste_next);
+ free(ste);
+ continue;
+ }
+
+ /* Move 'live' strings up. */
+ offset = newsize;
+ newsize += length;
+ copied = length;
+
+ if (r == s) /* Nothing removed yet. */
+ continue;
+
+ memmove(r, s, copied);
+
+ /* Update the index for this entry. */
+ ste->ste_idx = offset;
+ }
+
+ ELFTC_STRING_TABLE_CLEAR_COMPACTION_FLAG(st);
+ ELFTC_STRING_TABLE_UPDATE_LENGTH(st, newsize);
+
+ if (size)
+ *size = newsize;
+
+ return (st->st_string_pool);
+}
+
+size_t
+elftc_string_table_insert(Elftc_String_Table *st, const char *string)
+{
+ int hashindex, idx;
+ struct _Elftc_String_Table_Entry *ste;
+
+ hashindex = 0;
+
+ ste = elftc_string_table_find_hash_entry(st, string, &hashindex);
+
+ assert(hashindex >= 0 && hashindex < st->st_nbuckets);
+
+ if (ste == NULL) {
+ if ((ste = malloc(sizeof(*ste))) == NULL)
+ return (0);
+ if ((ste->ste_idx = elftc_string_table_add_to_pool(st,
+ string)) == 0) {
+ free(ste);
+ return (0);
+ }
+
+ SLIST_INSERT_HEAD(&st->st_buckets[hashindex], ste, ste_next);
+ }
+
+ idx = ste->ste_idx;
+ if (idx < 0) /* Undelete. */
+ ste->ste_idx = idx = (- idx);
+
+ return (idx);
+}
+
+size_t
+elftc_string_table_lookup(Elftc_String_Table *st, const char *string)
+{
+ int hashindex, idx;
+ struct _Elftc_String_Table_Entry *ste;
+
+ ste = elftc_string_table_find_hash_entry(st, string, &hashindex);
+
+ assert(hashindex >= 0 && hashindex < st->st_nbuckets);
+
+ if (ste == NULL || (idx = ste->ste_idx) < 0)
+ return (0);
+
+ return (idx);
+}
+
+int
+elftc_string_table_remove(Elftc_String_Table *st, const char *string)
+{
+ int idx;
+ struct _Elftc_String_Table_Entry *ste;
+
+ ste = elftc_string_table_find_hash_entry(st, string, NULL);
+
+ if (ste == NULL || (idx = ste->ste_idx) < 0)
+ return (ELFTC_FAILURE);
+
+ assert(idx > 0 && idx < (int) ELFTC_STRING_TABLE_LENGTH(st));
+
+ ste->ste_idx = (- idx);
+
+ ELFTC_STRING_TABLE_SET_COMPACTION_FLAG(st);
+
+ return (ELFTC_SUCCESS);
+}
+
+const char *
+elftc_string_table_to_string(Elftc_String_Table *st, size_t offset)
+{
+ const char *s;
+
+ s = st->st_string_pool + offset;
+
+ /*
+ * Check for:
+ * - An offset value within pool bounds.
+ * - A non-NUL byte at the specified offset.
+ * - The end of the prior string at offset - 1.
+ */
+ if (offset == 0 || offset >= ELFTC_STRING_TABLE_LENGTH(st) ||
+ *s == '\0' || *(s - 1) != '\0') {
+ errno = EINVAL;
+ return (NULL);
+ }
+
+ return (s);
+}
diff --git a/rtemstoolkit/elftoolchain/libelftc/elftc_string_table_create.3 b/rtemstoolkit/elftoolchain/libelftc/elftc_string_table_create.3
new file mode 100644
index 0000000..e11e73c
--- /dev/null
+++ b/rtemstoolkit/elftoolchain/libelftc/elftc_string_table_create.3
@@ -0,0 +1,227 @@
+.\" Copyright (c) 2012-2013 Joseph Koshy.
+.\" 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.
+.\"
+.\" This software is provided by Joseph Koshy ``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 Joseph Koshy 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.
+.\"
+.\" $Id: elftc_string_table_create.3 2866 2013-01-06 03:20:14Z jkoshy $
+.\"
+.Dd January 5, 2013
+.Os
+.Dt ELFTC_STRING_TABLE_CREATE 3
+.Sh NAME
+.Nm elftc_string_table_create ,
+.Nm elftc_string_table_destroy ,
+.Nm elftc_string_table_from_section ,
+.Nm elftc_string_table_image ,
+.Nm elftc_string_table_insert ,
+.Nm elftc_string_table_lookup ,
+.Nm elftc_string_table_remove ,
+.Nm elftc_string_table_to_string
+.Nd convenience routines for handling ELF string tables
+.Sh SYNOPSIS
+.In libelftc.h
+.Ft "Elftc_String_Table *"
+.Fn elftc_string_table_create "int sizehint"
+.Ft int
+.Fn elftc_string_table_destroy "Elftc_String_Table *table"
+.Ft "Elftc_String_Table *"
+.Fn elftc_string_table_from_section "Elf_Scn *scn" "int sizehint"
+.Ft "const char *"
+.Fo elftc_string_table_image
+.Fa "Elftc_String_Table *table"
+.Fa "size_t *size"
+.Fc
+.Ft size_t
+.Fo elftc_string_table_insert
+.Fa "Elftc_String_Table *table"
+.Fa "const char *string"
+.Fc
+.Ft size_t
+.Fo elftc_string_table_lookup
+.Fa "Elftc_String_Table *table"
+.Fa "const char *string"
+.Fc
+.Ft int
+.Fo elftc_string_table_remove
+.Fa "Elftc_String_Table *table"
+.Fa "const char *string"
+.Fc
+.Ft "const char *"
+.Fo elftc_string_table_to_string
+.Fa "Elftc_String_Table *table"
+.Fa "size_t offset"
+.Fc
+.Sh DESCRIPTION
+This manual page documents convenience routines for handling ELF
+string tables.
+.Pp
+Function
+.Fn elftc_string_table_create
+creates a new, empty string table.
+The argument
+.Ar sizehint
+provides a hint about the expected number of bytes of string data in
+the table.
+If the argument
+.Ar sizehint
+is zero, an implementation-defined default will be used instead.
+.Pp
+Function
+.Fn elftc_string_table_destroy
+destroys the previously allocated string table specified by
+argument
+.Ar table ,
+and frees the internal resources allocated for it.
+.Pp
+Function
+.Fn elftc_string_table_from_section
+creates a new string table and initializes it based on the
+contents of the section specified by argument
+.Ar scn .
+This section must be of type
+.Dv SHT_STRTAB .
+The argument
+.Ar sizehint
+provides a hint about expected number of bytes of string data in the
+table.
+If the value of
+.Ar sizehint
+is zero, an implementation-default will be used instead.
+.Pp
+Function
+.Fn elftc_string_table_image
+returns a pointer to the ELF representation of the contents of the
+string table specified by argument
+.Ar table .
+If argument
+.Ar size
+is not NULL, the size of the ELF representation of the string table is
+stored in the location pointed to by argument
+.Ar size .
+The function
+.Fn elftc_string_table_image
+will compact the string table if the table contains deleted strings.
+The string offsets returned by prior calls to
+.Fn elftc_string_table_insert
+and
+.Fn elftc_string_table_lookup
+should be treated as invalid after a call to this function.
+.Pp
+Function
+.Fn elftc_string_table_insert
+inserts the NUL-terminated string pointed to by argument
+.Ar string
+into the string table specified by argument
+.Ar table ,
+and returns an offset value usable in ELF data structures.
+Multiple insertions of the same content will return the same offset.
+The offset returned will remain valid until the next call to
+.Fn elftc_string_table_image .
+.Pp
+Function
+.Fn elftc_string_table_lookup
+looks up the string referenced by argument
+.Ar string
+in the string table specified by argument
+.Ar table ,
+and if found, returns the offset associated with the string.
+The returned offset will be valid till the next call to function
+.Fn elftc_string_table_image .
+.Pp
+Function
+.Fn elftc_string_table_remove
+removes the string pointed by argument
+.Ar string
+from the string table referenced by argument
+.Ar table ,
+if it is present in the string table.
+.Pp
+Function
+.Fn elftc_string_table_to_string
+returns a pointer to the NUL-terminated string residing at argument
+.Ar offset
+in the string table specified by argument
+.Ar table .
+The value of argument
+.Ar offset
+should be one returned by a prior call to
+.Fn elftc_string_table_insert
+or
+.Fn elftc_string_table_lookup .
+The returned pointer will remain valid until the next call to
+.Fn elftc_string_table_insert
+or
+.Fn elftc_string_table_image .
+.Ss Memory Management
+The
+.Lb libelftc
+library manages its own memory allocations.
+The application should not free the pointers returned by the string
+table functions.
+.El
+.Sh IMPLEMENTATION NOTES
+The current implementation is optimized for the case where strings are
+added to a string table, but rarely removed from it.
+.Pp
+The functions
+.Fn elftc_string_table_insert ,
+.Fn elftc_string_table_lookup ,
+.Fn elftc_string_table_remove
+and
+.Fn elftc_string_table_to_string
+have O(1) asymptotic behavior.
+The function
+.Fn elftc_string_table_image
+can have O(size) asymptotic behavior, where
+.Ar size
+denotes the size of the string table.
+.Sh RETURN VALUES
+Functions
+.Fn elftc_string_table_create
+and
+.Fn elftc_string_table_from_section
+return a valid pointer to an opaque structure of type
+.Vt Elftc_String_Table
+on success, or NULL in case of an error.
+.Pp
+The function
+.Fn elftc_string_table_image
+returns a pointer to an in-memory representation of an ELF string
+table on success, or NULL in case of an error.
+.Pp
+Functions
+.Fn elftc_string_table_insert
+and
+.Fn elftc_string_table_lookup
+return a non-zero offset on success, or zero in case of an error.
+.Pp
+Function
+.Fn elftc_string_table_remove
+returns a positive value on success, or zero in case of an error.
+.Pp
+Function
+.Fn elftc_string_table_to_string
+returns a valid pointer on success, or NULL in case of an error.
+.Sh SEE ALSO
+.Xr dwarf 3 ,
+.Xr elf 3 ,
+.Xr elftc 3
diff --git a/rtemstoolkit/elftoolchain/libelftc/elftc_timestamp.3 b/rtemstoolkit/elftoolchain/libelftc/elftc_timestamp.3
new file mode 100644
index 0000000..3c56f2f
--- /dev/null
+++ b/rtemstoolkit/elftoolchain/libelftc/elftc_timestamp.3
@@ -0,0 +1,79 @@
+.\" Copyright (c) 2016 The FreeBSD Foundation. All rights reserved.
+.\"
+.\" This documentation was written by Ed Maste under sponsorship of
+.\" the FreeBSD Foundation.
+.\"
+.\" 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.
+.\"
+.\" This software is provided by the author 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 author 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.
+.\"
+.\" $Id$
+.\"
+.Dd August 24, 2016
+.Os
+.Dt ELFTC_TIMESTAMP 3
+.Sh NAME
+.Nm elftc_timestamp
+.Nd return the current or environment-provided timestamp
+.Sh LIBRARY
+.Lb libelftc
+.Sh SYNOPSIS
+.In libelftc.h
+.Ft int
+.Fo elftc_timestamp
+.Fa "time_t *timestamp"
+.Fc
+.Sh DESCRIPTION
+The
+.Fn elftc_timestamp
+function returns a timestamp supplied by the
+.Ev SOURCE_DATE_EPOCH
+environment variable, or the current time provided by
+.Xr time 3
+if the environment variable is not set.
+.Pp
+The
+.Ar timestamp
+argument specifies a pointer to the location where the timestamp will be
+stored.
+.Sh RETURN VALUE
+Function
+.Fn elftc_timestamp
+returns 0 on success, and -1 in the event of an error.
+.Sh ERRORS
+The
+.Fn elftc_timestamp
+function may fail with the following errors:
+.Bl -tag -width ".Bq Er ERANGE"
+.It Bq Er EINVAL
+.Ev SOURCE_DATE_EPOCH
+contains invalid characters.
+.It Bq Er ERANGE
+.Ev SOURCE_DATE_EPOCH
+specifies a negative value or a value that cannot be stored in a
+time_t.
+.El
+The
+.Fn elftc_timestamp
+function may also fail for any of the reasons described in
+.Xr strtoll 3 .
+.Sh SEE ALSO
+.Xr strtoll 3 ,
+.Xr time 3
diff --git a/rtemstoolkit/elftoolchain/libelftc/elftc_timestamp.c b/rtemstoolkit/elftoolchain/libelftc/elftc_timestamp.c
new file mode 100644
index 0000000..ccf482f
--- /dev/null
+++ b/rtemstoolkit/elftoolchain/libelftc/elftc_timestamp.c
@@ -0,0 +1,55 @@
+/*-
+ * Copyright (c) 2016 The FreeBSD Foundation
+ * All rights reserved.
+ *
+ * This software was developed by Ed Maste under sponsorship
+ * of the FreeBSD Foundation.
+ *
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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 <errno.h>
+#include <stdlib.h>
+#include <time.h>
+#include <libelftc.h>
+
+int
+elftc_timestamp(time_t *timestamp)
+{
+ long long source_date_epoch;
+ char *env, *eptr;
+
+ if ((env = getenv("SOURCE_DATE_EPOCH")) != NULL) {
+ errno = 0;
+ source_date_epoch = strtoll(env, &eptr, 10);
+ if (*eptr != '\0')
+ errno = EINVAL;
+ if (source_date_epoch < 0)
+ errno = ERANGE;
+ if (errno != 0)
+ return (-1);
+ *timestamp = source_date_epoch;
+ return (0);
+ }
+ *timestamp = time(NULL);
+ return (0);
+}
diff --git a/rtemstoolkit/elftoolchain/libelftc/elftc_version.3 b/rtemstoolkit/elftoolchain/libelftc/elftc_version.3
new file mode 100644
index 0000000..f7018a5
--- /dev/null
+++ b/rtemstoolkit/elftoolchain/libelftc/elftc_version.3
@@ -0,0 +1,79 @@
+.\" Copyright (c) 2011,2012 Joseph Koshy. 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.
+.\"
+.\" This software is provided by Joseph Koshy ``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 Joseph Koshy 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.
+.\"
+.\" $Id: elftc_version.3 2828 2012-12-30 04:41:27Z jkoshy $
+.\"
+.Dd December 30, 2012
+.Os
+.Dt ELFTC_VERSION 3
+.Sh NAME
+.Nm elftc_version
+.Nd return a project-wide version identifier string
+.Sh LIBRARY
+.Lb libelftc
+.Sh SYNOPSIS
+.In libelftc.h
+.Ft const char *
+.Fn elftc_version void
+.Sh DESCRIPTION
+Function
+.Fn elftc_version
+returns a project-wide identifier string that encodes the source
+revision of the project source tree.
+.Pp
+The returned identifier has four space-separated fields:
+.Bl -tag -width ".Em Project Branch"
+.It Em "Project-Name"
+This is always
+.Dq elftoolchain .
+.It Em "Project-Branch"
+The branch name for the project source tree.
+.It Em "Build-OS"
+The operating system that the tool chain was compiled for.
+.It Em "Version-Number"
+A tree-wide version number extracted from the version control
+system in use.
+.El
+.Sh RETURN VALUE
+Function
+.Fn elftc_program_version
+returns a pointer to an internal character buffer.
+.Sh EXAMPLES
+To retrieve and print the current toolchain version identifier, use:
+.Bd -literal -offset indent
+#include <sys/types.h>
+#include <libelftc.h>
+
+(void) printf("%s\en", elftc_version());
+.Ed
+.Pp
+On the HEAD branch of the project's sources, when checked out using
+Subversion and compiled on a NetBSD host, this would print:
+.D1 Dq elftoolchain HEAD NetBSD svn: Ns Em REVINFO
+where
+.Em REVINFO
+would be the current revision information for the project source tree.
+.Sh ERRORS
+Function
+.Fn elftc_program_version
+always succeeds.
diff --git a/rtemstoolkit/elftoolchain/libelftc/elftc_version.c b/rtemstoolkit/elftoolchain/libelftc/elftc_version.c
new file mode 100644
index 0000000..5c41c1b
--- /dev/null
+++ b/rtemstoolkit/elftoolchain/libelftc/elftc_version.c
@@ -0,0 +1,10 @@
+/* WARNING: Generated by "make-toolchain-version". */
+
+#include <sys/types.h>
+#include <libelftc.h>
+
+const char *
+elftc_version(void)
+{
+ return "elftoolchain HEAD RTEMS git:heads/covoar-dwarf-0-g9b49665-dirty";
+}
diff --git a/rtemstoolkit/elftoolchain/libelftc/libelftc.h b/rtemstoolkit/elftoolchain/libelftc/libelftc.h
new file mode 100644
index 0000000..a235097
--- /dev/null
+++ b/rtemstoolkit/elftoolchain/libelftc/libelftc.h
@@ -0,0 +1,100 @@
+/*-
+ * Copyright (c) 2009 Kai Wang
+ * 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
+ * in this position and unchanged.
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``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 AUTHOR(S) 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.
+ *
+ * $FreeBSD: users/kaiwang27/elftc/libelftc.h 392 2009-05-31 19:17:46Z kaiwang27 $
+ * $Id: libelftc.h 3489 2016-08-31 00:12:15Z emaste $
+ */
+
+#ifndef _LIBELFTC_H_
+#define _LIBELFTC_H_
+
+#include <sys/stat.h>
+
+#include <libelf.h>
+
+/*
+ * Types meant to be opaque to the consumers of these APIs.
+ */
+typedef struct _Elftc_Bfd_Target Elftc_Bfd_Target;
+typedef struct _Elftc_String_Table Elftc_String_Table;
+
+/* Target types. */
+typedef enum {
+ ETF_NONE,
+ ETF_ELF,
+ ETF_BINARY,
+ ETF_SREC,
+ ETF_IHEX,
+ ETF_PE,
+ ETF_EFI,
+} Elftc_Bfd_Target_Flavor;
+
+/*
+ * Demangler flags.
+ */
+
+/* Name mangling style. */
+#define ELFTC_DEM_UNKNOWN 0x00000000U /* Not specified. */
+#define ELFTC_DEM_ARM 0x00000001U /* C++ Ann. Ref. Manual. */
+#define ELFTC_DEM_GNU2 0x00000002U /* GNU version 2. */
+#define ELFTC_DEM_GNU3 0x00000004U /* GNU version 3. */
+
+/* Demangling behaviour control. */
+#define ELFTC_DEM_NOPARAM 0x00010000U
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+Elftc_Bfd_Target *elftc_bfd_find_target(const char *_tgt_name);
+Elftc_Bfd_Target_Flavor elftc_bfd_target_flavor(Elftc_Bfd_Target *_tgt);
+unsigned int elftc_bfd_target_byteorder(Elftc_Bfd_Target *_tgt);
+unsigned int elftc_bfd_target_class(Elftc_Bfd_Target *_tgt);
+unsigned int elftc_bfd_target_machine(Elftc_Bfd_Target *_tgt);
+int elftc_copyfile(int _srcfd, int _dstfd);
+int elftc_demangle(const char *_mangledname, char *_buffer,
+ size_t _bufsize, unsigned int _flags);
+const char *elftc_reloc_type_str(unsigned int mach, unsigned int type);
+int elftc_set_timestamps(const char *_filename, struct stat *_sb);
+Elftc_String_Table *elftc_string_table_create(int _hint);
+void elftc_string_table_destroy(Elftc_String_Table *_table);
+Elftc_String_Table *elftc_string_table_from_section(Elf_Scn *_scn,
+ int _hint);
+const char *elftc_string_table_image(Elftc_String_Table *_table,
+ size_t *_sz);
+size_t elftc_string_table_insert(Elftc_String_Table *_table,
+ const char *_string);
+size_t elftc_string_table_lookup(Elftc_String_Table *_table,
+ const char *_string);
+int elftc_string_table_remove(Elftc_String_Table *_table,
+ const char *_string);
+const char *elftc_string_table_to_string(Elftc_String_Table *_table,
+ size_t offset);
+int elftc_timestamp(time_t *_timestamp);
+const char *elftc_version(void);
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _LIBELFTC_H_ */
diff --git a/rtemstoolkit/elftoolchain/libelftc/libelftc_bfdtarget.c b/rtemstoolkit/elftoolchain/libelftc/libelftc_bfdtarget.c
new file mode 100644
index 0000000..48b67a0
--- /dev/null
+++ b/rtemstoolkit/elftoolchain/libelftc/libelftc_bfdtarget.c
@@ -0,0 +1,463 @@
+/*-
+ * Copyright (c) 2008,2009 Kai Wang
+ * 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
+ * in this position and unchanged.
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``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 AUTHOR(S) 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/param.h>
+#include <libelf.h>
+#include <libelftc.h>
+
+#include "_libelftc.h"
+
+ELFTC_VCSID("$Id: libelftc_bfdtarget.c 3516 2017-02-10 02:33:08Z emaste $");
+
+struct _Elftc_Bfd_Target _libelftc_targets[] = {
+
+ {
+ .bt_name = "binary",
+ .bt_type = ETF_BINARY,
+ },
+
+ {
+ .bt_name = "elf32-avr",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2LSB,
+ .bt_elfclass = ELFCLASS32,
+ .bt_machine = EM_AVR,
+ },
+
+ {
+ .bt_name = "elf32-big",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2MSB,
+ .bt_elfclass = ELFCLASS32,
+ },
+
+ {
+ .bt_name = "elf32-bigarm",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2MSB,
+ .bt_elfclass = ELFCLASS32,
+ .bt_machine = EM_ARM,
+ },
+
+ {
+ .bt_name = "elf32-bigmips",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2MSB,
+ .bt_elfclass = ELFCLASS32,
+ .bt_machine = EM_MIPS,
+ },
+
+ {
+ .bt_name = "elf32-i386",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2LSB,
+ .bt_elfclass = ELFCLASS32,
+ .bt_machine = EM_386,
+ },
+
+ {
+ .bt_name = "elf32-i386-freebsd",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2LSB,
+ .bt_elfclass = ELFCLASS32,
+ .bt_machine = EM_386,
+ .bt_osabi = ELFOSABI_FREEBSD,
+ },
+
+ {
+ .bt_name = "elf32-ia64-big",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2MSB,
+ .bt_elfclass = ELFCLASS32,
+ .bt_machine = EM_IA_64,
+ },
+
+ {
+ .bt_name = "elf32-little",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2LSB,
+ .bt_elfclass = ELFCLASS32,
+ },
+
+ {
+ .bt_name = "elf32-littlearm",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2LSB,
+ .bt_elfclass = ELFCLASS32,
+ .bt_machine = EM_ARM,
+ },
+
+ {
+ .bt_name = "elf32-littlemips",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2LSB,
+ .bt_elfclass = ELFCLASS32,
+ .bt_machine = EM_MIPS,
+ },
+
+ {
+ .bt_name = "elf32-powerpc",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2MSB,
+ .bt_elfclass = ELFCLASS32,
+ .bt_machine = EM_PPC,
+ },
+
+ {
+ .bt_name = "elf32-powerpc-freebsd",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2MSB,
+ .bt_elfclass = ELFCLASS32,
+ .bt_machine = EM_PPC,
+ .bt_osabi = ELFOSABI_FREEBSD,
+ },
+
+ {
+ .bt_name = "elf32-powerpcle",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2LSB,
+ .bt_elfclass = ELFCLASS32,
+ .bt_machine = EM_PPC,
+ },
+
+ {
+ .bt_name = "elf32-sh",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2MSB,
+ .bt_elfclass = ELFCLASS32,
+ .bt_machine = EM_SH,
+ },
+
+ {
+ .bt_name = "elf32-shl",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2LSB,
+ .bt_elfclass = ELFCLASS32,
+ .bt_machine = EM_SH,
+ },
+
+ {
+ .bt_name = "elf32-sh-nbsd",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2MSB,
+ .bt_elfclass = ELFCLASS32,
+ .bt_machine = EM_SH,
+ .bt_osabi = ELFOSABI_NETBSD,
+ },
+
+ {
+ .bt_name = "elf32-shl-nbsd",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2LSB,
+ .bt_elfclass = ELFCLASS32,
+ .bt_machine = EM_SH,
+ .bt_osabi = ELFOSABI_NETBSD,
+ },
+
+ {
+ .bt_name = "elf32-shbig-linux",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2MSB,
+ .bt_elfclass = ELFCLASS32,
+ .bt_machine = EM_SH,
+ .bt_osabi = ELFOSABI_LINUX,
+ },
+
+ {
+ .bt_name = "elf32-sh-linux",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2LSB,
+ .bt_elfclass = ELFCLASS32,
+ .bt_machine = EM_SH,
+ .bt_osabi = ELFOSABI_LINUX,
+ },
+
+ {
+ .bt_name = "elf32-sparc",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2MSB,
+ .bt_elfclass = ELFCLASS32,
+ .bt_machine = EM_SPARC,
+ },
+
+ {
+ .bt_name = "elf32-tradbigmips",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2MSB,
+ .bt_elfclass = ELFCLASS32,
+ .bt_machine = EM_MIPS,
+ },
+
+ {
+ .bt_name = "elf32-tradlittlemips",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2LSB,
+ .bt_elfclass = ELFCLASS32,
+ .bt_machine = EM_MIPS,
+ },
+
+ {
+ .bt_name = "elf64-alpha",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2LSB,
+ .bt_elfclass = ELFCLASS64,
+ .bt_machine = EM_ALPHA,
+ },
+
+ {
+ .bt_name = "elf64-alpha-freebsd",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2LSB,
+ .bt_elfclass = ELFCLASS64,
+ .bt_machine = EM_ALPHA,
+ .bt_osabi = ELFOSABI_FREEBSD
+ },
+
+ {
+ .bt_name = "elf64-big",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2MSB,
+ .bt_elfclass = ELFCLASS64,
+ },
+
+ {
+ .bt_name = "elf64-bigmips",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2MSB,
+ .bt_elfclass = ELFCLASS64,
+ .bt_machine = EM_MIPS,
+ },
+
+ {
+ .bt_name = "elf64-ia64-big",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2MSB,
+ .bt_elfclass = ELFCLASS64,
+ .bt_machine = EM_IA_64,
+ },
+
+ {
+ .bt_name = "elf64-ia64-little",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2LSB,
+ .bt_elfclass = ELFCLASS64,
+ .bt_machine = EM_IA_64,
+ },
+
+ {
+ .bt_name = "elf64-little",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2LSB,
+ .bt_elfclass = ELFCLASS64,
+ },
+
+ {
+ .bt_name = "elf64-littleaarch64",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2LSB,
+ .bt_elfclass = ELFCLASS64,
+ .bt_machine = EM_AARCH64,
+ },
+
+ {
+ .bt_name = "elf64-littlemips",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2LSB,
+ .bt_elfclass = ELFCLASS64,
+ .bt_machine = EM_MIPS,
+ },
+
+ {
+ .bt_name = "elf64-powerpc",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2MSB,
+ .bt_elfclass = ELFCLASS64,
+ .bt_machine = EM_PPC64,
+ },
+
+ {
+ .bt_name = "elf64-powerpc-freebsd",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2MSB,
+ .bt_elfclass = ELFCLASS64,
+ .bt_machine = EM_PPC64,
+ .bt_osabi = ELFOSABI_FREEBSD,
+ },
+
+ {
+ .bt_name = "elf64-powerpcle",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2LSB,
+ .bt_elfclass = ELFCLASS64,
+ .bt_machine = EM_PPC64,
+ },
+
+ {
+ .bt_name = "elf64-sh64",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2MSB,
+ .bt_elfclass = ELFCLASS64,
+ .bt_machine = EM_SH,
+ },
+
+ {
+ .bt_name = "elf64-sh64l",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2LSB,
+ .bt_elfclass = ELFCLASS64,
+ .bt_machine = EM_SH,
+ },
+
+ {
+ .bt_name = "elf64-sh64-nbsd",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2MSB,
+ .bt_elfclass = ELFCLASS64,
+ .bt_machine = EM_SH,
+ .bt_osabi = ELFOSABI_NETBSD,
+ },
+
+ {
+ .bt_name = "elf64-sh64l-nbsd",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2LSB,
+ .bt_elfclass = ELFCLASS64,
+ .bt_machine = EM_SH,
+ .bt_osabi = ELFOSABI_NETBSD,
+ },
+
+ {
+ .bt_name = "elf64-sh64big-linux",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2MSB,
+ .bt_elfclass = ELFCLASS64,
+ .bt_machine = EM_SH,
+ .bt_osabi = ELFOSABI_LINUX,
+ },
+
+ {
+ .bt_name = "elf64-sh64-linux",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2LSB,
+ .bt_elfclass = ELFCLASS64,
+ .bt_machine = EM_SH,
+ .bt_osabi = ELFOSABI_LINUX,
+ },
+
+ {
+ .bt_name = "elf64-sparc",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2MSB,
+ .bt_elfclass = ELFCLASS64,
+ .bt_machine = EM_SPARCV9,
+ },
+
+ {
+ .bt_name = "elf64-sparc-freebsd",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2MSB,
+ .bt_elfclass = ELFCLASS64,
+ .bt_machine = EM_SPARCV9,
+ .bt_osabi = ELFOSABI_FREEBSD
+ },
+
+ {
+ .bt_name = "elf64-tradbigmips",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2MSB,
+ .bt_elfclass = ELFCLASS64,
+ .bt_machine = EM_MIPS,
+ },
+
+ {
+ .bt_name = "elf64-tradlittlemips",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2LSB,
+ .bt_elfclass = ELFCLASS64,
+ .bt_machine = EM_MIPS,
+ },
+
+ {
+ .bt_name = "elf64-x86-64",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2LSB,
+ .bt_elfclass = ELFCLASS64,
+ .bt_machine = EM_X86_64,
+ },
+
+ {
+ .bt_name = "elf64-x86-64-freebsd",
+ .bt_type = ETF_ELF,
+ .bt_byteorder = ELFDATA2LSB,
+ .bt_elfclass = ELFCLASS64,
+ .bt_machine = EM_X86_64,
+ .bt_osabi = ELFOSABI_FREEBSD
+ },
+
+ {
+ .bt_name = "ihex",
+ .bt_type = ETF_IHEX,
+ },
+
+ {
+ .bt_name = "srec",
+ .bt_type = ETF_SREC,
+ },
+
+ {
+ .bt_name = "symbolsrec",
+ .bt_type = ETF_SREC,
+ },
+
+ {
+ .bt_name = "efi-app-ia32",
+ .bt_type = ETF_EFI,
+ .bt_machine = EM_386,
+ },
+
+ {
+ .bt_name = "efi-app-x86_64",
+ .bt_type = ETF_EFI,
+ .bt_machine = EM_X86_64,
+ },
+
+ {
+ .bt_name = "pei-i386",
+ .bt_type = ETF_PE,
+ .bt_machine = EM_386,
+ },
+
+ {
+ .bt_name = "pei-x86-64",
+ .bt_type = ETF_PE,
+ .bt_machine = EM_X86_64,
+ },
+
+ {
+ .bt_name = NULL,
+ .bt_type = ETF_NONE,
+ },
+};
diff --git a/rtemstoolkit/elftoolchain/libelftc/libelftc_dem_arm.c b/rtemstoolkit/elftoolchain/libelftc/libelftc_dem_arm.c
new file mode 100644
index 0000000..5550505
--- /dev/null
+++ b/rtemstoolkit/elftoolchain/libelftc/libelftc_dem_arm.c
@@ -0,0 +1,1216 @@
+/*-
+ * Copyright (c) 2008 Hyogeol Lee <hyogeollee at gmail.com>
+ * 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
+ * in this position and unchanged.
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``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 AUTHOR 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/types.h>
+#include <assert.h>
+#include <ctype.h>
+#include <errno.h>
+#include <libelftc.h>
+#include <limits.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "_libelftc.h"
+
+ELFTC_VCSID("$Id: libelftc_dem_arm.c 3513 2016-12-29 07:04:22Z kaiwang27 $");
+
+/**
+ * @file cpp_demangle_arm.c
+ * @brief Decode function name encoding in ARM.
+ *
+ * Function name encoding in "The Annotated C++ Reference Manual".
+ *
+ * Ref : "The Annotated C++ Reference Manual", Margaet A.Ellis,
+ * Bjarne Stroustrup, AT&T Bell Laboratories 1990, pp 122-126.
+ */
+
+enum encode_type {
+ ENCODE_FUNC, ENCODE_OP, ENCODE_OP_CT, ENCODE_OP_DT, ENCODE_OP_USER
+};
+
+struct cstring {
+ char *buf;
+ size_t size;
+};
+
+struct demangle_data {
+ bool ptr, ref, cnst, array;
+ struct cstring array_str;
+ const char *p;
+ enum encode_type type;
+ struct vector_str vec;
+ struct vector_str arg;
+};
+
+#define SIMPLE_HASH(x,y) (64 * x + y)
+#define VEC_PUSH_STR(d,s) vector_str_push((d), (s), strlen((s)))
+#define CPP_DEMANGLE_ARM_TRY 128
+
+static void dest_cstring(struct cstring *);
+static void dest_demangle_data(struct demangle_data *);
+static bool init_cstring(struct cstring *, size_t);
+static bool init_demangle_data(struct demangle_data *);
+static bool push_CTDT(const char *, size_t, struct vector_str *);
+static bool read_array(struct demangle_data *);
+static bool read_class(struct demangle_data *);
+static bool read_func(struct demangle_data *);
+static bool read_func_name(struct demangle_data *);
+static bool read_func_ptr(struct demangle_data *);
+static bool read_memptr(struct demangle_data *);
+static bool read_op(struct demangle_data *);
+static bool read_op_user(struct demangle_data *);
+static bool read_qual_name(struct demangle_data *);
+static int read_subst(struct demangle_data *);
+static int read_subst_iter(struct demangle_data *);
+static bool read_type(struct demangle_data *);
+
+/**
+ * @brief Decode the input string by the ARM style.
+ *
+ * @return New allocated demangled string or NULL if failed.
+ */
+char *
+cpp_demangle_ARM(const char *org)
+{
+ struct demangle_data d;
+ size_t arg_begin, arg_len;
+ unsigned int try;
+ char *rtn, *arg;
+
+ if (org == NULL)
+ return (NULL);
+
+ if (init_demangle_data(&d) == false)
+ return (NULL);
+
+ try = 0;
+ rtn = NULL;
+
+ d.p = org;
+ if (read_func_name(&d) == false)
+ goto clean;
+
+ if (d.type == ENCODE_OP_CT) {
+ if (push_CTDT("::", 2, &d.vec) == false)
+ goto clean;
+
+ goto flat;
+ }
+
+ if (d.type == ENCODE_OP_DT) {
+ if (push_CTDT("::~", 3, &d.vec) == false)
+ goto clean;
+
+ goto flat;
+ }
+
+ if (d.type == ENCODE_OP_USER)
+ goto flat;
+
+ /* function type */
+ if (*d.p != 'F')
+ goto clean;
+ ++d.p;
+
+ /* start argument types */
+ if (VEC_PUSH_STR(&d.vec, "(") == false)
+ goto clean;
+
+ for (;;) {
+ if (*d.p == 'T') {
+ const int rtn_subst = read_subst(&d);
+
+ if (rtn_subst == -1)
+ goto clean;
+ else if (rtn_subst == 1)
+ break;
+
+ continue;
+ }
+
+ if (*d.p == 'N') {
+ const int rtn_subst_iter = read_subst_iter(&d);
+
+ if (rtn_subst_iter == -1)
+ goto clean;
+ else if(rtn_subst_iter == 1)
+ break;
+
+ continue;
+ }
+
+ arg_begin = d.vec.size;
+
+ if (read_type(&d) == false)
+ goto clean;
+
+ if (d.ptr == true) {
+ if (VEC_PUSH_STR(&d.vec, "*") == false)
+ goto clean;
+
+ d.ptr = false;
+ }
+
+ if (d.ref == true) {
+ if (VEC_PUSH_STR(&d.vec, "&") == false)
+ goto clean;
+
+ d.ref = false;
+ }
+
+ if (d.cnst == true) {
+ if (VEC_PUSH_STR(&d.vec, " const") == false)
+ goto clean;
+
+ d.cnst = false;
+ }
+
+ if (d.array == true) {
+ if (vector_str_push(&d.vec, d.array_str.buf,
+ d.array_str.size) == false)
+ goto clean;
+
+ dest_cstring(&d.array_str);
+ d.array = false;
+ }
+
+ if (*d.p == '\0')
+ break;
+
+ if ((arg = vector_str_substr(&d.vec, arg_begin, d.vec.size - 1,
+ &arg_len)) == NULL)
+ goto clean;
+
+ if (vector_str_push(&d.arg, arg, arg_len) == false)
+ goto clean;
+
+ free(arg);
+
+ if (VEC_PUSH_STR(&d.vec, ", ") == false)
+ goto clean;
+
+ if (++try > CPP_DEMANGLE_ARM_TRY)
+ goto clean;
+ }
+
+ /* end argument types */
+ if (VEC_PUSH_STR(&d.vec, ")") == false)
+ goto clean;
+
+flat:
+ rtn = vector_str_get_flat(&d.vec, NULL);
+clean:
+ dest_demangle_data(&d);
+
+ return (rtn);
+}
+
+/**
+ * @brief Test input string is encoded by the ARM style.
+ *
+ * @return True if input string is encoded by the ARM style.
+ */
+bool
+is_cpp_mangled_ARM(const char *org)
+{
+
+ if (org == NULL)
+ return (false);
+
+ return (strstr(org, "__") != NULL);
+}
+
+static void
+dest_cstring(struct cstring *s)
+{
+
+ if (s == NULL)
+ return;
+
+ free(s->buf);
+ s->buf = NULL;
+ s->size = 0;
+}
+
+static void
+dest_demangle_data(struct demangle_data *d)
+{
+
+ if (d != NULL) {
+ vector_str_dest(&d->arg);
+ vector_str_dest(&d->vec);
+
+ dest_cstring(&d->array_str);
+ }
+}
+
+static bool
+init_cstring(struct cstring *s, size_t len)
+{
+
+ if (s == NULL || len <= 1)
+ return (false);
+
+ if ((s->buf = malloc(sizeof(char) * len)) == NULL)
+ return (false);
+
+ s->size = len - 1;
+
+ return (true);
+}
+
+static bool
+init_demangle_data(struct demangle_data *d)
+{
+
+ if (d == NULL)
+ return (false);
+
+ d->ptr = false;
+ d->ref = false;
+ d->cnst = false;
+ d->array = false;
+
+ d->array_str.buf = NULL;
+ d->array_str.size = 0;
+
+ d->type = ENCODE_FUNC;
+
+ if (vector_str_init(&d->vec) == false)
+ return (false);
+
+ if (vector_str_init(&d->arg) == false) {
+ vector_str_dest(&d->vec);
+
+ return (false);
+ }
+
+ return (true);
+}
+
+static bool
+push_CTDT(const char *s, size_t l, struct vector_str *v)
+{
+
+ if (s == NULL || l == 0 || v == NULL)
+ return (false);
+
+ if (vector_str_push(v, s, l) == false)
+ return (false);
+
+ assert(v->size > 1);
+ if (VEC_PUSH_STR(v, v->container[v->size - 2]) == false)
+ return (false);
+
+ if (VEC_PUSH_STR(v, "()") == false)
+ return (false);
+
+ return (true);
+}
+
+static bool
+read_array(struct demangle_data *d)
+{
+ size_t len;
+ const char *end;
+
+ if (d == NULL || d->p == NULL)
+ return (false);
+
+ end = d->p;
+ assert(end != NULL);
+
+ for (;;) {
+ if (*end == '\0')
+ return (false);
+
+ if (ELFTC_ISDIGIT(*end) == 0)
+ break;
+
+ ++end;
+ }
+
+ if (*end != '_')
+ return (false);
+
+ len = end - d->p;
+ assert(len > 0);
+
+ dest_cstring(&d->array_str);
+ if (init_cstring(&d->array_str, len + 3) == false)
+ return (false);
+
+ strncpy(d->array_str.buf + 1, d->p, len);
+ *d->array_str.buf = '[';
+ *(d->array_str.buf + len + 1) = ']';
+
+ d->array = true;
+ d->p = end + 1;
+
+ return (true);
+}
+
+static bool
+read_class(struct demangle_data *d)
+{
+ size_t len;
+ char *str;
+
+ if (d == NULL)
+ return (false);
+
+ len = strtol(d->p, &str, 10);
+ if (len == 0 && (errno == EINVAL || errno == ERANGE))
+ return (false);
+
+ assert(len > 0);
+ assert(str != NULL);
+
+ if (vector_str_push(&d->vec, str, len) == false)
+ return (false);
+
+ d->p = str + len;
+
+ return (true);
+}
+
+static bool
+read_func(struct demangle_data *d)
+{
+ size_t len;
+ const char *name;
+ char *delim;
+
+ if (d == NULL)
+ return (false);
+
+ assert(d->p != NULL && "d->p (org str) is NULL");
+ if ((delim = strstr(d->p, "__")) == NULL)
+ return (false);
+
+ len = delim - d->p;
+ assert(len != 0);
+
+ name = d->p;
+
+ d->p = delim + 2;
+
+ if (*d->p == 'Q' && ELFTC_ISDIGIT(*(d->p + 1))) {
+ ++d->p;
+
+ if (read_qual_name(d) == false)
+ return (false);
+ } else if (ELFTC_ISDIGIT(*d->p)) {
+ if (read_class(d) == false)
+ return (false);
+
+ if (VEC_PUSH_STR(&d->vec, "::") == false)
+ return (false);
+ }
+
+ if (vector_str_push(&d->vec, name, len) == false)
+ return (false);
+
+ return (true);
+}
+
+static bool
+read_func_name(struct demangle_data *d)
+{
+ size_t len;
+ bool rtn;
+ char *op_name;
+
+ if (d == NULL)
+ return (false);
+
+ rtn = false;
+ op_name = NULL;
+
+ assert(d->p != NULL && "d->p (org str) is NULL");
+
+ if (*d->p == '_' && *(d->p + 1) == '_') {
+ d->p += 2;
+
+ d->type = ENCODE_OP;
+ if (read_op(d) == false)
+ return (false);
+
+ if (d->type == ENCODE_OP_CT || d->type == ENCODE_OP_DT ||
+ d->type == ENCODE_OP_USER)
+ return (true);
+
+ /* skip "__" */
+ d->p += 2;
+
+ /* assume delimiter is removed */
+ if (*d->p == 'Q' && ELFTC_ISDIGIT(*(d->p + 1))) {
+ ++d->p;
+
+ assert(d->vec.size > 0);
+
+ len = strlen(d->vec.container[d->vec.size - 1]);
+ if ((op_name = malloc(sizeof(char) * (len + 1)))
+ == NULL)
+ return (false);
+
+ snprintf(op_name, len + 1, "%s",
+ d->vec.container[d->vec.size - 1]);
+ vector_str_pop(&d->vec);
+
+ if (read_qual_name(d) == false)
+ goto clean;
+
+ if (VEC_PUSH_STR(&d->vec, "::") == false)
+ goto clean;
+
+ if (vector_str_push(&d->vec, op_name, len) == false)
+ goto clean;
+
+ rtn = true;
+ } else if (ELFTC_ISDIGIT(*d->p)) {
+ assert(d->vec.size > 0);
+
+ len = strlen(d->vec.container[d->vec.size - 1]);
+ if ((op_name = malloc(sizeof(char) * (len + 1)))
+ == NULL)
+ return (false);
+
+ snprintf(op_name, len + 1, "%s",
+ d->vec.container[d->vec.size - 1]);
+ vector_str_pop(&d->vec);
+
+ if (read_class(d) == false)
+ goto clean;
+
+ if (VEC_PUSH_STR(&d->vec, "::") == false)
+ goto clean;
+
+ if (vector_str_push(&d->vec, op_name, len) == false)
+ goto clean;
+
+ rtn = true;
+ }
+ } else
+ return (read_func(d));
+
+clean:
+ free(op_name);
+
+ return (rtn);
+}
+
+/* Read function ptr type */
+static bool
+read_func_ptr(struct demangle_data *d)
+{
+ struct demangle_data fptr;
+ size_t arg_len, rtn_len;
+ char *arg_type, *rtn_type;
+ int lim;
+
+ if (d == NULL)
+ return (false);
+
+ if (init_demangle_data(&fptr) == false)
+ return (false);
+
+ fptr.p = d->p + 1;
+ lim = 0;
+ arg_type = NULL;
+ rtn_type = NULL;
+
+ for (;;) {
+ if (read_type(&fptr) == false) {
+ dest_demangle_data(&fptr);
+
+ return (false);
+ }
+
+ if (fptr.ptr == true) {
+ if (VEC_PUSH_STR(&fptr.vec, "*") == false) {
+ dest_demangle_data(&fptr);
+
+ return (false);
+ }
+
+ fptr.ptr = false;
+ }
+
+ if (fptr.ref == true) {
+ if (VEC_PUSH_STR(&fptr.vec, "&") == false) {
+ dest_demangle_data(&fptr);
+
+ return (false);
+ }
+
+ fptr.ref = false;
+ }
+
+ if (fptr.cnst == true) {
+ if (VEC_PUSH_STR(&fptr.vec, " const") == false) {
+ dest_demangle_data(&fptr);
+
+ return (false);
+ }
+
+ fptr.cnst = false;
+ }
+
+ if (*fptr.p == '_')
+ break;
+
+ if (VEC_PUSH_STR(&fptr.vec, ", ") == false) {
+ dest_demangle_data(&fptr);
+
+ return (false);
+ }
+
+ if (++lim > CPP_DEMANGLE_ARM_TRY) {
+
+ dest_demangle_data(&fptr);
+
+ return (false);
+ }
+ }
+
+ arg_type = vector_str_get_flat(&fptr.vec, &arg_len);
+ /* skip '_' */
+ d->p = fptr.p + 1;
+
+ dest_demangle_data(&fptr);
+
+ if (init_demangle_data(&fptr) == false) {
+ free(arg_type);
+
+ return (false);
+ }
+
+ fptr.p = d->p;
+ lim = 0;
+
+ if (read_type(&fptr) == false) {
+ free(arg_type);
+ dest_demangle_data(&fptr);
+
+ return (false);
+ }
+
+ rtn_type = vector_str_get_flat(&fptr.vec, &rtn_len);
+ d->p = fptr.p;
+
+
+ dest_demangle_data(&fptr);
+
+ if (vector_str_push(&d->vec, rtn_type, rtn_len) == false) {
+ free(rtn_type);
+ free(arg_type);
+
+ return (false);
+ }
+
+ free(rtn_type);
+
+ if (VEC_PUSH_STR(&d->vec, " (*)(") == false) {
+ free(arg_type);
+
+ return (false);
+ }
+
+ if (vector_str_push(&d->vec, arg_type, arg_len) == false) {
+ free(arg_type);
+
+ return (false);
+ }
+
+ free(arg_type);
+
+ return (VEC_PUSH_STR(&d->vec, ")"));
+}
+
+static bool
+read_memptr(struct demangle_data *d)
+{
+ struct demangle_data mptr;
+ size_t len;
+ bool rtn;
+ char *mptr_str;
+
+ if (d == NULL || d->p == NULL)
+ return (false);
+
+ if (init_demangle_data(&mptr) == false)
+ return (false);
+
+ rtn = false;
+ mptr_str = NULL;
+
+ mptr.p = d->p;
+ if (*mptr.p == 'Q') {
+ ++mptr.p;
+
+ if (read_qual_name(&mptr) == false)
+ goto clean;
+ } else {
+ if (read_class(&mptr) == false)
+ goto clean;
+ }
+
+ d->p = mptr.p;
+
+ if ((mptr_str = vector_str_get_flat(&mptr.vec, &len)) == NULL)
+ goto clean;
+
+ if (vector_str_push(&d->vec, mptr_str, len) == false)
+ goto clean;
+
+ if (VEC_PUSH_STR(&d->vec, "::*") == false)
+ goto clean;
+
+ rtn = true;
+clean:
+ free(mptr_str);
+ dest_demangle_data(&mptr);
+
+ return (rtn);
+}
+
+static bool
+read_op(struct demangle_data *d)
+{
+
+ if (d == NULL)
+ return (false);
+
+ assert(d->p != NULL && "d->p (org str) is NULL");
+
+ switch (SIMPLE_HASH(*(d->p), *(d->p+1))) {
+ case SIMPLE_HASH('m', 'l') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator*"));
+ case SIMPLE_HASH('d', 'v') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator/"));
+ case SIMPLE_HASH('m', 'd') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator%"));
+ case SIMPLE_HASH('p', 'l') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator+"));
+ case SIMPLE_HASH('m', 'i') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator-"));
+ case SIMPLE_HASH('l', 's') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator<<"));
+ case SIMPLE_HASH('r', 's') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator>>"));
+ case SIMPLE_HASH('e', 'q') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator=="));
+ case SIMPLE_HASH('n', 'e') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator!="));
+ case SIMPLE_HASH('l', 't') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator<"));
+ case SIMPLE_HASH('g', 't') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator>"));
+ case SIMPLE_HASH('l', 'e') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator<="));
+ case SIMPLE_HASH('g', 'e') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator>="));
+ case SIMPLE_HASH('a', 'd') :
+ d->p += 2;
+ if (*d->p == 'v') {
+ ++d->p;
+ return (VEC_PUSH_STR(&d->vec, "operator/="));
+ } else
+ return (VEC_PUSH_STR(&d->vec, "operator&"));
+ case SIMPLE_HASH('o', 'r') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator|"));
+ case SIMPLE_HASH('e', 'r') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator^"));
+ case SIMPLE_HASH('a', 'a') :
+ d->p += 2;
+ if (*d->p == 'd') {
+ ++d->p;
+ return (VEC_PUSH_STR(&d->vec, "operator&="));
+ } else
+ return (VEC_PUSH_STR(&d->vec, "operator&&"));
+ case SIMPLE_HASH('o', 'o') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator||"));
+ case SIMPLE_HASH('n', 't') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator!"));
+ case SIMPLE_HASH('c', 'o') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator~"));
+ case SIMPLE_HASH('p', 'p') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator++"));
+ case SIMPLE_HASH('m', 'm') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator--"));
+ case SIMPLE_HASH('a', 's') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator="));
+ case SIMPLE_HASH('r', 'f') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator->"));
+ case SIMPLE_HASH('a', 'p') :
+ /* apl */
+ if (*(d->p + 2) != 'l')
+ return (false);
+
+ d->p += 3;
+ return (VEC_PUSH_STR(&d->vec, "operator+="));
+ case SIMPLE_HASH('a', 'm') :
+ d->p += 2;
+ if (*d->p == 'i') {
+ ++d->p;
+ return (VEC_PUSH_STR(&d->vec, "operator-="));
+ } else if (*d->p == 'u') {
+ ++d->p;
+ return (VEC_PUSH_STR(&d->vec, "operator*="));
+ } else if (*d->p == 'd') {
+ ++d->p;
+ return (VEC_PUSH_STR(&d->vec, "operator%="));
+ }
+
+ return (false);
+ case SIMPLE_HASH('a', 'l') :
+ /* als */
+ if (*(d->p + 2) != 's')
+ return (false);
+
+ d->p += 3;
+ return (VEC_PUSH_STR(&d->vec, "operator<<="));
+ case SIMPLE_HASH('a', 'r') :
+ /* ars */
+ if (*(d->p + 2) != 's')
+ return (false);
+
+ d->p += 3;
+ return (VEC_PUSH_STR(&d->vec, "operator>>="));
+ case SIMPLE_HASH('a', 'o') :
+ /* aor */
+ if (*(d->p + 2) != 'r')
+ return (false);
+
+ d->p += 3;
+ return (VEC_PUSH_STR(&d->vec, "operator|="));
+ case SIMPLE_HASH('a', 'e') :
+ /* aer */
+ if (*(d->p + 2) != 'r')
+ return (false);
+
+ d->p += 3;
+ return (VEC_PUSH_STR(&d->vec, "operator^="));
+ case SIMPLE_HASH('c', 'm') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator,"));
+ case SIMPLE_HASH('r', 'm') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator->*"));
+ case SIMPLE_HASH('c', 'l') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "()"));
+ case SIMPLE_HASH('v', 'c') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "[]"));
+ case SIMPLE_HASH('c', 't') :
+ d->p += 4;
+ d->type = ENCODE_OP_CT;
+
+ if (*d->p == 'Q' && ELFTC_ISDIGIT(*(d->p + 1))) {
+ ++d->p;
+
+ return (read_qual_name(d));
+ } else if (ELFTC_ISDIGIT(*d->p))
+ return (read_class(d));
+
+ return (false);
+ case SIMPLE_HASH('d', 't') :
+ d->p += 4;
+ d->type = ENCODE_OP_DT;
+
+ if (*d->p == 'Q' && ELFTC_ISDIGIT(*(d->p + 1))) {
+ ++d->p;
+
+ return (read_qual_name(d));
+ } else if (ELFTC_ISDIGIT(*d->p))
+ return (read_class(d));
+
+ return (false);
+ case SIMPLE_HASH('n', 'w') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator new()"));
+ case SIMPLE_HASH('d', 'l') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator delete()"));
+ case SIMPLE_HASH('o', 'p') :
+ /* __op<TO_TYPE>__<FROM_TYPE> */
+ d->p += 2;
+
+ d->type = ENCODE_OP_USER;
+
+ return (read_op_user(d));
+ default :
+ return (false);
+ };
+}
+
+static bool
+read_op_user(struct demangle_data *d)
+{
+ struct demangle_data from, to;
+ size_t from_len, to_len;
+ bool rtn;
+ char *from_str, *to_str;
+
+ if (d == NULL)
+ return (false);
+
+ if (init_demangle_data(&from) == false)
+ return (false);
+
+ rtn = false;
+ from_str = NULL;
+ to_str = NULL;
+ if (init_demangle_data(&to) == false)
+ goto clean;
+
+ to.p = d->p;
+ if (*to.p == 'Q') {
+ ++to.p;
+
+ if (read_qual_name(&to) == false)
+ goto clean;
+
+ /* pop last '::' */
+ if (vector_str_pop(&to.vec) == false)
+ goto clean;
+ } else {
+ if (read_class(&to) == false)
+ goto clean;
+
+ /* skip '__' */
+ to.p += 2;
+ }
+
+ if ((to_str = vector_str_get_flat(&to.vec, &to_len)) == NULL)
+ goto clean;
+
+ from.p = to.p;
+ if (*from.p == 'Q') {
+ ++from.p;
+
+ if (read_qual_name(&from) == false)
+ goto clean;
+
+ /* pop last '::' */
+ if (vector_str_pop(&from.vec) == false)
+ goto clean;
+ } else {
+ if (read_class(&from) == false)
+ goto clean;
+ }
+
+ if ((from_str = vector_str_get_flat(&from.vec, &from_len)) == NULL)
+ goto clean;
+
+ if (vector_str_push(&d->vec, from_str, from_len) == false)
+ goto clean;
+
+ if (VEC_PUSH_STR(&d->vec, "::operator ") == false)
+ return (false);
+
+ if (vector_str_push(&d->vec, to_str, to_len) == false)
+ goto clean;
+
+ rtn = VEC_PUSH_STR(&d->vec, "()");
+clean:
+ free(to_str);
+ free(from_str);
+ dest_demangle_data(&to);
+ dest_demangle_data(&from);
+
+ return (rtn);
+}
+
+/* single digit + class names */
+static bool
+read_qual_name(struct demangle_data *d)
+{
+ int i;
+ char num;
+
+ if (d == NULL)
+ return (false);
+
+ assert(d->p != NULL && "d->p (org str) is NULL");
+ assert(*d->p > 48 && *d->p < 58 && "*d->p not in ASCII numeric range");
+
+ num = *d->p - 48;
+
+ assert(num > 0);
+
+ ++d->p;
+ for (i = 0; i < num ; ++i) {
+ if (read_class(d) == false)
+ return (false);
+
+ if (VEC_PUSH_STR(&d->vec, "::") == false)
+ return (false);
+ }
+
+ if (*d->p != '\0')
+ d->p = d->p + 2;
+
+ return (true);
+}
+
+/* Return -1 at fail, 0 at success, and 1 at end */
+static int
+read_subst(struct demangle_data *d)
+{
+ size_t idx;
+ char *str;
+
+ if (d == NULL)
+ return (-1);
+
+ idx = strtol(d->p + 1, &str, 10);
+ if (idx == 0 && (errno == EINVAL || errno == ERANGE))
+ return (-1);
+
+ assert(idx > 0);
+ assert(str != NULL);
+
+ d->p = str;
+
+ if (VEC_PUSH_STR(&d->vec, d->arg.container[idx - 1]) == false)
+ return (-1);
+
+ if (VEC_PUSH_STR(&d->arg, d->arg.container[idx - 1]) == false)
+ return (-1);
+
+ if (*d->p == '\0')
+ return (1);
+
+ return (0);
+}
+
+static int
+read_subst_iter(struct demangle_data *d)
+{
+ int i;
+ size_t idx;
+ char repeat;
+ char *str;
+
+ if (d == NULL)
+ return (-1);
+
+ ++d->p;
+ assert(*d->p > 48 && *d->p < 58 && "*d->p not in ASCII numeric range");
+
+ repeat = *d->p - 48;
+
+ assert(repeat > 1);
+
+ ++d->p;
+
+ idx = strtol(d->p, &str, 10);
+ if (idx == 0 && (errno == EINVAL || errno == ERANGE))
+ return (-1);
+
+ assert(idx > 0);
+ assert(str != NULL);
+
+ d->p = str;
+
+ for (i = 0; i < repeat ; ++i) {
+ if (VEC_PUSH_STR(&d->vec, d->arg.container[idx - 1]) == false)
+ return (-1);
+
+ if (VEC_PUSH_STR(&d->arg, d->arg.container[idx - 1]) == false)
+ return (-1);
+
+ if (i != repeat - 1 &&
+ VEC_PUSH_STR(&d->vec, ", ") == false)
+ return (-1);
+ }
+
+ if (*d->p == '\0')
+ return (1);
+
+ return (0);
+}
+
+static bool
+read_type(struct demangle_data *d)
+{
+
+ if (d == NULL)
+ return (false);
+
+ assert(d->p != NULL && "d->p (org str) is NULL");
+
+ while (*d->p == 'U' || *d->p == 'C' || *d->p == 'V' || *d->p == 'S' ||
+ *d->p == 'P' || *d->p == 'R' || *d->p == 'A' || *d->p == 'F' ||
+ *d->p == 'M') {
+ switch (*d->p) {
+ case 'U' :
+ ++d->p;
+
+ if (VEC_PUSH_STR(&d->vec, "unsigned ") == false)
+ return (false);
+
+ break;
+ case 'C' :
+ ++d->p;
+
+ if (*d->p == 'P')
+ d->cnst = true;
+ else {
+ if (VEC_PUSH_STR(&d->vec, "const ") ==
+ false)
+ return (false);
+ }
+
+ break;
+ case 'V' :
+ ++d->p;
+
+ if (VEC_PUSH_STR(&d->vec, "volatile ") == false)
+ return (false);
+
+ break;
+ case 'S' :
+ ++d->p;
+
+ if (VEC_PUSH_STR(&d->vec, "signed ") == false)
+ return (false);
+
+ break;
+ case 'P' :
+ ++d->p;
+
+ if (*d->p == 'F')
+ return (read_func_ptr(d));
+ else
+ d->ptr = true;
+
+ break;
+ case 'R' :
+ ++d->p;
+
+ d->ref = true;
+
+ break;
+ case 'F' :
+ break;
+ case 'A' :
+ ++d->p;
+
+ if (read_array(d) == false)
+ return (false);
+
+ break;
+ case 'M' :
+ ++d->p;
+
+ if (read_memptr(d) == false)
+ return (false);
+
+ break;
+ default :
+ break;
+ }
+ }
+
+ if (ELFTC_ISDIGIT(*d->p))
+ return (read_class(d));
+
+ switch (*d->p) {
+ case 'Q' :
+ ++d->p;
+
+ return (read_qual_name(d));
+ case 'v' :
+ ++d->p;
+
+ return (VEC_PUSH_STR(&d->vec, "void"));
+ case 'c' :
+ ++d->p;
+
+ return (VEC_PUSH_STR(&d->vec, "char"));
+ case 's' :
+ ++d->p;
+
+ return (VEC_PUSH_STR(&d->vec, "short"));
+ case 'i' :
+ ++d->p;
+
+ return (VEC_PUSH_STR(&d->vec, "int"));
+ case 'l' :
+ ++d->p;
+
+ return (VEC_PUSH_STR(&d->vec, "long"));
+ case 'f' :
+ ++d->p;
+
+ return (VEC_PUSH_STR(&d->vec, "float"));
+ case 'd':
+ ++d->p;
+
+ return (VEC_PUSH_STR(&d->vec, "double"));
+ case 'r':
+ ++d->p;
+
+ return (VEC_PUSH_STR(&d->vec, "long double"));
+ case 'e':
+ ++d->p;
+
+ return (VEC_PUSH_STR(&d->vec, "..."));
+ default:
+ return (false);
+ };
+
+ /* NOTREACHED */
+ return (false);
+}
diff --git a/rtemstoolkit/elftoolchain/libelftc/libelftc_dem_gnu2.c b/rtemstoolkit/elftoolchain/libelftc/libelftc_dem_gnu2.c
new file mode 100644
index 0000000..5c77b67
--- /dev/null
+++ b/rtemstoolkit/elftoolchain/libelftc/libelftc_dem_gnu2.c
@@ -0,0 +1,1365 @@
+/*-
+ * Copyright (c) 2008 Hyogeol Lee <hyogeollee at gmail.com>
+ * 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
+ * in this position and unchanged.
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``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 AUTHOR 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/types.h>
+#include <assert.h>
+#include <ctype.h>
+#include <errno.h>
+#include <libelftc.h>
+#include <limits.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "_libelftc.h"
+
+ELFTC_VCSID("$Id: libelftc_dem_gnu2.c 3513 2016-12-29 07:04:22Z kaiwang27 $");
+
+/**
+ * @file cpp_demangle_gnu2.c
+ * @brief Decode function name encoding in GNU 2.
+ *
+ * Function name encoding in GNU 2 based on ARM style.
+ */
+
+enum encode_type {
+ ENCODE_FUNC, ENCODE_OP, ENCODE_OP_CT, ENCODE_OP_DT, ENCODE_OP_USER,
+ ENCODE_OP_TF, ENCODE_OP_TI, ENCODE_OP_VT
+};
+
+struct cstring {
+ char *buf;
+ size_t size;
+};
+
+struct demangle_data {
+ bool ptr, ref, cnst, array, cnst_fn, class_name;
+ struct cstring array_str;
+ const char *p;
+ enum encode_type type;
+ struct vector_str vec;
+ struct vector_str arg;
+};
+
+#define SIMPLE_HASH(x,y) (64 * x + y)
+#define VEC_PUSH_STR(d,s) vector_str_push((d), (s), strlen((s)))
+#define CPP_DEMANGLE_GNU2_TRY 128
+
+static void dest_cstring(struct cstring *);
+static void dest_demangle_data(struct demangle_data *);
+static bool init_cstring(struct cstring *, size_t);
+static bool init_demangle_data(struct demangle_data *);
+static bool push_CTDT(const char *, size_t, struct vector_str *);
+static bool read_array(struct demangle_data *);
+static bool read_class(struct demangle_data *);
+static bool read_func(struct demangle_data *);
+static bool read_func_name(struct demangle_data *);
+static bool read_func_ptr(struct demangle_data *);
+static bool read_memptr(struct demangle_data *);
+static bool read_op(struct demangle_data *);
+static bool read_op_user(struct demangle_data *);
+static bool read_qual_name(struct demangle_data *);
+static int read_subst(struct demangle_data *);
+static int read_subst_iter(struct demangle_data *);
+static bool read_type(struct demangle_data *);
+
+/**
+ * @brief Decode the input string by the GNU 2 style.
+ *
+ * @return New allocated demangled string or NULL if failed.
+ */
+char *
+cpp_demangle_gnu2(const char *org)
+{
+ struct demangle_data d;
+ size_t arg_begin, arg_len;
+ unsigned int try;
+ char *rtn, *arg;
+
+ if (org == NULL)
+ return (NULL);
+
+ if (init_demangle_data(&d) == false)
+ return (NULL);
+
+ try = 0;
+ rtn = NULL;
+
+ d.p = org;
+ if (read_func_name(&d) == false)
+ goto clean;
+
+ switch (d.type) {
+ case ENCODE_FUNC :
+ case ENCODE_OP :
+ break;
+
+ case ENCODE_OP_CT :
+ if (push_CTDT("::", 2, &d.vec) == false)
+ goto clean;
+
+ break;
+ case ENCODE_OP_DT :
+ if (push_CTDT("::~", 3, &d.vec) == false)
+ goto clean;
+
+ if (VEC_PUSH_STR(&d.vec, "(void)") == false)
+ goto clean;
+
+ goto flat;
+ case ENCODE_OP_USER :
+ case ENCODE_OP_TF :
+ case ENCODE_OP_TI :
+ case ENCODE_OP_VT :
+ goto flat;
+ }
+
+ if (*d.p == 'F')
+ ++d.p;
+ else if (*d.p == '\0') {
+ if (d.class_name == true) {
+ if (VEC_PUSH_STR(&d.vec, "(void)") == false)
+ goto clean;
+
+ goto flat;
+ } else
+ goto clean;
+ }
+
+ /* start argument types */
+ if (VEC_PUSH_STR(&d.vec, "(") == false)
+ goto clean;
+
+ for (;;) {
+ if (*d.p == 'T') {
+ const int rtn_subst = read_subst(&d);
+
+ if (rtn_subst == -1)
+ goto clean;
+ else if (rtn_subst == 1)
+ break;
+
+ continue;
+ }
+
+ if (*d.p == 'N') {
+ const int rtn_subst_iter = read_subst_iter(&d);
+
+ if (rtn_subst_iter == -1)
+ goto clean;
+ else if(rtn_subst_iter == 1)
+ break;
+
+ continue;
+ }
+
+ arg_begin = d.vec.size;
+
+ if (read_type(&d) == false)
+ goto clean;
+
+ if (d.ptr == true) {
+ if (VEC_PUSH_STR(&d.vec, "*") == false)
+ goto clean;
+
+ d.ptr = false;
+ }
+
+ if (d.ref == true) {
+ if (VEC_PUSH_STR(&d.vec, "&") == false)
+ goto clean;
+
+ d.ref = false;
+ }
+
+ if (d.cnst == true) {
+ if (VEC_PUSH_STR(&d.vec, " const") == false)
+ goto clean;
+
+ d.cnst = false;
+ }
+
+ if (d.array == true) {
+ if (vector_str_push(&d.vec, d.array_str.buf,
+ d.array_str.size) == false)
+ goto clean;
+
+ dest_cstring(&d.array_str);
+ d.array = false;
+ }
+
+ if (*d.p == '\0')
+ break;
+
+ if ((arg = vector_str_substr(&d.vec, arg_begin, d.vec.size - 1,
+ &arg_len)) == NULL)
+ goto clean;
+
+ if (vector_str_push(&d.arg, arg, arg_len) == false)
+ goto clean;
+
+ free(arg);
+
+ if (VEC_PUSH_STR(&d.vec, ", ") == false)
+ goto clean;
+
+ if (++try > CPP_DEMANGLE_GNU2_TRY)
+ goto clean;
+ }
+
+ /* end argument types */
+ if (VEC_PUSH_STR(&d.vec, ")") == false)
+ goto clean;
+flat:
+ if (d.cnst_fn == true && VEC_PUSH_STR(&d.vec, " const") == false)
+ goto clean;
+
+ rtn = vector_str_get_flat(&d.vec, NULL);
+clean:
+ dest_demangle_data(&d);
+
+ return (rtn);
+}
+
+/**
+ * @brief Test input string is encoded by the GNU 2 style.
+ *
+ * @return True if input string is encoded by the GNU 2 style.
+ */
+bool
+is_cpp_mangled_gnu2(const char *org)
+{
+ char *str;
+ bool rtn = false;
+
+ if (org == NULL)
+ return (false);
+
+ /* search valid text to end */
+ str = strstr(org, "__");
+ while (str != NULL) {
+ if (*(str + 2) != '\0') {
+ if (*(str + 2) == 'C' ||
+ *(str + 2) == 'F' ||
+ *(str + 2) == 'Q' ||
+ ELFTC_ISDIGIT(*(str + 2))) {
+ rtn |= true;
+
+ break;
+ }
+
+ if (*(str + 3) != '\0') {
+ switch (SIMPLE_HASH(*(str + 2), *(str + 3))) {
+ case SIMPLE_HASH('m', 'l') :
+ case SIMPLE_HASH('d', 'v') :
+ case SIMPLE_HASH('m', 'd') :
+ case SIMPLE_HASH('p', 'l') :
+ case SIMPLE_HASH('m', 'i') :
+ case SIMPLE_HASH('l', 's') :
+ case SIMPLE_HASH('r', 's') :
+ case SIMPLE_HASH('e', 'q') :
+ case SIMPLE_HASH('n', 'e') :
+ case SIMPLE_HASH('l', 't') :
+ case SIMPLE_HASH('g', 't') :
+ case SIMPLE_HASH('l', 'e') :
+ case SIMPLE_HASH('g', 'e') :
+ case SIMPLE_HASH('a', 'd') :
+ case SIMPLE_HASH('o', 'r') :
+ case SIMPLE_HASH('e', 'r') :
+ case SIMPLE_HASH('a', 'a') :
+ case SIMPLE_HASH('o', 'o') :
+ case SIMPLE_HASH('n', 't') :
+ case SIMPLE_HASH('c', 'o') :
+ case SIMPLE_HASH('p', 'p') :
+ case SIMPLE_HASH('m', 'm') :
+ case SIMPLE_HASH('a', 's') :
+ case SIMPLE_HASH('r', 'f') :
+ case SIMPLE_HASH('a', 'p') :
+ case SIMPLE_HASH('a', 'm') :
+ case SIMPLE_HASH('a', 'l') :
+ case SIMPLE_HASH('a', 'r') :
+ case SIMPLE_HASH('a', 'o') :
+ case SIMPLE_HASH('a', 'e') :
+ case SIMPLE_HASH('c', 'm') :
+ case SIMPLE_HASH('r', 'm') :
+ case SIMPLE_HASH('c', 'l') :
+ case SIMPLE_HASH('v', 'c') :
+ case SIMPLE_HASH('n', 'w') :
+ case SIMPLE_HASH('d', 'l') :
+ case SIMPLE_HASH('o', 'p') :
+ case SIMPLE_HASH('t', 'f') :
+ case SIMPLE_HASH('t', 'i') :
+ rtn |= true;
+
+ break;
+ }
+ }
+ }
+
+ str = strstr(str + 2, "__");
+ }
+
+ rtn |= strstr(org, "_$_") != NULL;
+ rtn |= strstr(org, "_vt$") != NULL;
+
+ return (rtn);
+}
+
+static void
+dest_cstring(struct cstring *s)
+{
+
+ if (s == NULL)
+ return;
+
+ free(s->buf);
+ s->buf = NULL;
+ s->size = 0;
+}
+
+static void
+dest_demangle_data(struct demangle_data *d)
+{
+
+ if (d != NULL) {
+ vector_str_dest(&d->arg);
+ vector_str_dest(&d->vec);
+
+ dest_cstring(&d->array_str);
+ }
+}
+
+static bool
+init_cstring(struct cstring *s, size_t len)
+{
+
+ if (s == NULL || len <= 1)
+ return (false);
+
+ if ((s->buf = malloc(sizeof(char) * len)) == NULL)
+ return (false);
+
+ s->size = len - 1;
+
+ return (true);
+}
+
+static bool
+init_demangle_data(struct demangle_data *d)
+{
+
+ if (d == NULL)
+ return (false);
+
+ d->ptr = false;
+ d->ref = false;
+ d->cnst = false;
+ d->array = false;
+ d->cnst_fn = false;
+ d->class_name = false;
+
+ d->array_str.buf = NULL;
+ d->array_str.size = 0;
+
+ d->type = ENCODE_FUNC;
+
+ if (vector_str_init(&d->vec) == false)
+ return (false);
+
+ if (vector_str_init(&d->arg) == false) {
+ vector_str_dest(&d->vec);
+
+ return (false);
+ }
+
+ return (true);
+}
+
+static bool
+push_CTDT(const char *s, size_t l, struct vector_str *v)
+{
+
+ if (s == NULL || l == 0 || v == NULL)
+ return (false);
+
+ if (vector_str_push(v, s, l) == false)
+ return (false);
+
+ assert(v->size > 1);
+
+ return (VEC_PUSH_STR(v, v->container[v->size - 2]));
+}
+
+static bool
+read_array(struct demangle_data *d)
+{
+ size_t len;
+ const char *end;
+
+ if (d == NULL || d->p == NULL)
+ return (false);
+
+ end = d->p;
+ assert(end != NULL);
+
+ for (;;) {
+ if (*end == '\0')
+ return (false);
+
+ if (ELFTC_ISDIGIT(*end) == 0)
+ break;
+
+ ++end;
+ }
+
+ if (*end != '_')
+ return (false);
+
+ len = end - d->p;
+ assert(len > 0);
+
+ dest_cstring(&d->array_str);
+ if (init_cstring(&d->array_str, len + 3) == false)
+ return (false);
+
+ strncpy(d->array_str.buf + 1, d->p, len);
+ *d->array_str.buf = '[';
+ *(d->array_str.buf + len + 1) = ']';
+
+ d->array = true;
+ d->p = end + 1;
+
+ return (true);
+}
+
+static bool
+read_class(struct demangle_data *d)
+{
+ size_t len;
+ char *str;
+
+ if (d == NULL)
+ return (false);
+
+ len = strtol(d->p, &str, 10);
+ if (len == 0 && (errno == EINVAL || errno == ERANGE))
+ return (false);
+
+ assert(len > 0);
+ assert(str != NULL);
+
+ if (vector_str_push(&d->vec, str, len) == false)
+ return (false);
+
+ d->p = str + len;
+
+ d->class_name = true;
+
+ return (true);
+}
+
+static bool
+read_func(struct demangle_data *d)
+{
+ size_t len;
+ const char *name;
+ char *delim;
+
+ if (d == NULL)
+ return (false);
+
+ assert(d->p != NULL && "d->p (org str) is NULL");
+ if ((delim = strstr(d->p, "__")) == NULL)
+ return (false);
+
+ len = delim - d->p;
+ assert(len != 0);
+
+ name = d->p;
+
+ d->p = delim + 2;
+
+ if (*d->p == 'C') {
+ ++d->p;
+
+ d->cnst_fn = true;
+ }
+
+ if (*d->p == 'Q' && ELFTC_ISDIGIT(*(d->p + 1))) {
+ ++d->p;
+
+ if (read_qual_name(d) == false)
+ return (false);
+ } else if (ELFTC_ISDIGIT(*d->p)) {
+ if (read_class(d) == false)
+ return (false);
+
+ if (VEC_PUSH_STR(&d->vec, "::") == false)
+ return (false);
+ }
+
+ return (vector_str_push(&d->vec, name, len));
+}
+
+static bool
+read_func_name(struct demangle_data *d)
+{
+ size_t len;
+ bool rtn;
+ char *op_name;
+
+ if (d == NULL)
+ return (false);
+
+ rtn = false;
+ op_name = NULL;
+
+ assert(d->p != NULL && "d->p (org str) is NULL");
+
+ if (*d->p == '_' && *(d->p + 1) == '_') {
+ d->p += 2;
+
+ /* CTOR */
+ if (*d->p == 'Q' && ELFTC_ISDIGIT(*(d->p + 1))) {
+ ++d->p;
+ d->type = ENCODE_OP_CT;
+
+ if (read_qual_name(d) == false)
+ return (false);
+
+ return (vector_str_pop(&d->vec));
+ } else if (ELFTC_ISDIGIT(*d->p)) {
+ d->type = ENCODE_OP_CT;
+
+ return (read_class(d));
+ }
+
+ d->type = ENCODE_OP;
+ if (read_op(d) == false) {
+ /* not good condition, start function name with '__' */
+ d->type = ENCODE_FUNC;
+
+ if (VEC_PUSH_STR(&d->vec, "__") == false)
+ return (false);
+
+ return (read_func(d));
+ }
+
+ if (d->type == ENCODE_OP_USER ||
+ d->type == ENCODE_OP_TF ||
+ d->type == ENCODE_OP_TI)
+ return (true);
+
+ /* skip "__" */
+ d->p += 2;
+
+ if (*d->p == 'C') {
+ ++d->p;
+
+ d->cnst_fn = true;
+ }
+
+ /* assume delimiter is removed */
+ if (*d->p == 'Q' && ELFTC_ISDIGIT(*(d->p + 1))) {
+ ++d->p;
+
+ assert(d->vec.size > 0);
+
+ len = strlen(d->vec.container[d->vec.size - 1]);
+ if ((op_name = malloc(sizeof(char) * (len + 1)))
+ == NULL)
+ return (false);
+
+ snprintf(op_name, len + 1, "%s",
+ d->vec.container[d->vec.size - 1]);
+ vector_str_pop(&d->vec);
+
+ if (read_qual_name(d) == false)
+ goto clean;
+
+ if (VEC_PUSH_STR(&d->vec, "::") == false)
+ goto clean;
+
+ if (vector_str_push(&d->vec, op_name, len) == false)
+ goto clean;
+
+ rtn = true;
+ } else if (ELFTC_ISDIGIT(*d->p)) {
+ assert(d->vec.size > 0);
+
+ len = strlen(d->vec.container[d->vec.size - 1]);
+ if ((op_name = malloc(sizeof(char) * (len + 1)))
+ == NULL)
+ return (false);
+
+ snprintf(op_name, len + 1, "%s",
+ d->vec.container[d->vec.size - 1]);
+ vector_str_pop(&d->vec);
+
+ if (read_class(d) == false)
+ goto clean;
+
+ if (VEC_PUSH_STR(&d->vec, "::") == false)
+ goto clean;
+
+ if (vector_str_push(&d->vec, op_name, len) == false)
+ goto clean;
+
+ rtn = true;
+ }
+ } else if (memcmp(d->p, "_$_", 3) == 0) {
+ /* DTOR */
+ d->p += 3;
+ d->type = ENCODE_OP_DT;
+
+ if (*d->p == 'Q' && ELFTC_ISDIGIT(*(d->p + 1))) {
+ ++d->p;
+
+ if (read_qual_name(d) == false)
+ return (false);
+
+ return (vector_str_pop(&d->vec));
+ } else if (ELFTC_ISDIGIT(*d->p))
+ return (read_class(d));
+
+ return (false);
+ } else if (memcmp(d->p, "_vt$", 4) == 0) {
+ /* vtable */
+ d->p += 4;
+ d->type = ENCODE_OP_VT;
+
+ if (*d->p == 'Q' && ELFTC_ISDIGIT(*(d->p + 1))) {
+ ++d->p;
+
+ if (read_qual_name(d) == false)
+ return (false);
+
+ if (vector_str_pop(&d->vec) == false)
+ return (false);
+ } else if (ELFTC_ISDIGIT(*d->p)) {
+ if (read_class(d) == false)
+ return (false);
+ }
+
+ return (VEC_PUSH_STR(&d->vec, " virtual table"));
+ } else
+ return (read_func(d));
+clean:
+ free(op_name);
+
+ return (rtn);
+}
+
+/* Read function ptr type */
+static bool
+read_func_ptr(struct demangle_data *d)
+{
+ struct demangle_data fptr;
+ size_t arg_len, rtn_len;
+ char *arg_type, *rtn_type;
+ int lim;
+
+ if (d == NULL)
+ return (false);
+
+ if (init_demangle_data(&fptr) == false)
+ return (false);
+
+ fptr.p = d->p + 1;
+ lim = 0;
+ arg_type = NULL;
+ rtn_type = NULL;
+
+ for (;;) {
+ if (read_type(&fptr) == false) {
+ dest_demangle_data(&fptr);
+
+ return (false);
+ }
+
+ if (fptr.ptr == true) {
+ if (VEC_PUSH_STR(&fptr.vec, "*") == false) {
+ dest_demangle_data(&fptr);
+
+ return (false);
+ }
+
+ fptr.ptr = false;
+ }
+
+ if (fptr.ref == true) {
+ if (VEC_PUSH_STR(&fptr.vec, "&") == false) {
+ dest_demangle_data(&fptr);
+
+ return (false);
+ }
+
+ fptr.ref = false;
+ }
+
+ if (fptr.cnst == true) {
+ if (VEC_PUSH_STR(&fptr.vec, " const") == false) {
+ dest_demangle_data(&fptr);
+
+ return (false);
+ }
+
+ fptr.cnst = false;
+ }
+
+ if (*fptr.p == '_')
+ break;
+
+ if (VEC_PUSH_STR(&fptr.vec, ", ") == false) {
+ dest_demangle_data(&fptr);
+
+ return (false);
+ }
+
+ if (++lim > CPP_DEMANGLE_GNU2_TRY) {
+
+ dest_demangle_data(&fptr);
+
+ return (false);
+ }
+ }
+
+ arg_type = vector_str_get_flat(&fptr.vec, &arg_len);
+ /* skip '_' */
+ d->p = fptr.p + 1;
+
+ dest_demangle_data(&fptr);
+
+ if (init_demangle_data(&fptr) == false) {
+ free(arg_type);
+
+ return (false);
+ }
+
+ fptr.p = d->p;
+ lim = 0;
+
+ if (read_type(&fptr) == false) {
+ free(arg_type);
+ dest_demangle_data(&fptr);
+
+ return (false);
+ }
+
+ rtn_type = vector_str_get_flat(&fptr.vec, &rtn_len);
+ d->p = fptr.p;
+
+
+ dest_demangle_data(&fptr);
+
+ if (vector_str_push(&d->vec, rtn_type, rtn_len) == false) {
+ free(rtn_type);
+ free(arg_type);
+
+ return (false);
+ }
+
+ free(rtn_type);
+
+ if (VEC_PUSH_STR(&d->vec, " (*)(") == false) {
+ free(arg_type);
+
+ return (false);
+ }
+
+ if (vector_str_push(&d->vec, arg_type, arg_len) == false) {
+ free(arg_type);
+
+ return (false);
+ }
+
+ free(arg_type);
+
+ return (VEC_PUSH_STR(&d->vec, ")"));
+}
+
+static bool
+read_memptr(struct demangle_data *d)
+{
+ struct demangle_data mptr;
+ size_t len;
+ bool rtn;
+ char *mptr_str;
+
+ if (d == NULL || d->p == NULL)
+ return (false);
+
+ if (init_demangle_data(&mptr) == false)
+ return (false);
+
+ rtn = false;
+ mptr_str = NULL;
+
+ mptr.p = d->p;
+ if (*mptr.p == 'Q') {
+ ++mptr.p;
+
+ if (read_qual_name(&mptr) == false)
+ goto clean;
+ } else if (read_class(&mptr) == false)
+ goto clean;
+
+ d->p = mptr.p;
+
+ if ((mptr_str = vector_str_get_flat(&mptr.vec, &len)) == NULL)
+ goto clean;
+
+ if (vector_str_push(&d->vec, mptr_str, len) == false)
+ goto clean;
+
+ if (VEC_PUSH_STR(&d->vec, "::*") == false)
+ goto clean;
+
+ rtn = true;
+clean:
+ free(mptr_str);
+ dest_demangle_data(&mptr);
+
+ return (rtn);
+}
+
+static bool
+read_op(struct demangle_data *d)
+{
+
+ if (d == NULL)
+ return (false);
+
+ assert(d->p != NULL && "d->p (org str) is NULL");
+
+ switch (SIMPLE_HASH(*(d->p), *(d->p+1))) {
+ case SIMPLE_HASH('m', 'l') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator*"));
+ case SIMPLE_HASH('d', 'v') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator/"));
+ case SIMPLE_HASH('m', 'd') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator%"));
+ case SIMPLE_HASH('p', 'l') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator+"));
+ case SIMPLE_HASH('m', 'i') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator-"));
+ case SIMPLE_HASH('l', 's') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator<<"));
+ case SIMPLE_HASH('r', 's') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator>>"));
+ case SIMPLE_HASH('e', 'q') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator=="));
+ case SIMPLE_HASH('n', 'e') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator!="));
+ case SIMPLE_HASH('l', 't') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator<"));
+ case SIMPLE_HASH('g', 't') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator>"));
+ case SIMPLE_HASH('l', 'e') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator<="));
+ case SIMPLE_HASH('g', 'e') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator>="));
+ case SIMPLE_HASH('a', 'd') :
+ d->p += 2;
+ if (*d->p == 'v') {
+ ++d->p;
+ return (VEC_PUSH_STR(&d->vec, "operator/="));
+ } else
+ return (VEC_PUSH_STR(&d->vec, "operator&"));
+ case SIMPLE_HASH('o', 'r') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator|"));
+ case SIMPLE_HASH('e', 'r') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator^"));
+ case SIMPLE_HASH('a', 'a') :
+ d->p += 2;
+ if (*d->p == 'd') {
+ ++d->p;
+ return (VEC_PUSH_STR(&d->vec, "operator&="));
+ } else
+ return (VEC_PUSH_STR(&d->vec, "operator&&"));
+ case SIMPLE_HASH('o', 'o') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator||"));
+ case SIMPLE_HASH('n', 't') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator!"));
+ case SIMPLE_HASH('c', 'o') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator~"));
+ case SIMPLE_HASH('p', 'p') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator++"));
+ case SIMPLE_HASH('m', 'm') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator--"));
+ case SIMPLE_HASH('a', 's') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator="));
+ case SIMPLE_HASH('r', 'f') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator->"));
+ case SIMPLE_HASH('a', 'p') :
+ /* apl */
+ if (*(d->p + 2) != 'l')
+ return (false);
+
+ d->p += 3;
+ return (VEC_PUSH_STR(&d->vec, "operator+="));
+ case SIMPLE_HASH('a', 'm') :
+ d->p += 2;
+ if (*d->p == 'i') {
+ ++d->p;
+ return (VEC_PUSH_STR(&d->vec, "operator-="));
+ } else if (*d->p == 'u') {
+ ++d->p;
+ return (VEC_PUSH_STR(&d->vec, "operator*="));
+ } else if (*d->p == 'd') {
+ ++d->p;
+ return (VEC_PUSH_STR(&d->vec, "operator%="));
+ }
+
+ return (false);
+ case SIMPLE_HASH('a', 'l') :
+ /* als */
+ if (*(d->p + 2) != 's')
+ return (false);
+
+ d->p += 3;
+ return (VEC_PUSH_STR(&d->vec, "operator<<="));
+ case SIMPLE_HASH('a', 'r') :
+ /* ars */
+ if (*(d->p + 2) != 's')
+ return (false);
+
+ d->p += 3;
+ return (VEC_PUSH_STR(&d->vec, "operator>>="));
+ case SIMPLE_HASH('a', 'o') :
+ /* aor */
+ if (*(d->p + 2) != 'r')
+ return (false);
+
+ d->p += 3;
+ return (VEC_PUSH_STR(&d->vec, "operator|="));
+ case SIMPLE_HASH('a', 'e') :
+ /* aer */
+ if (*(d->p + 2) != 'r')
+ return (false);
+
+ d->p += 3;
+ return (VEC_PUSH_STR(&d->vec, "operator^="));
+ case SIMPLE_HASH('c', 'm') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator,"));
+ case SIMPLE_HASH('r', 'm') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator->*"));
+ case SIMPLE_HASH('c', 'l') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "()"));
+ case SIMPLE_HASH('v', 'c') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "[]"));
+ case SIMPLE_HASH('n', 'w') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator new()"));
+ case SIMPLE_HASH('d', 'l') :
+ d->p += 2;
+ return (VEC_PUSH_STR(&d->vec, "operator delete()"));
+ case SIMPLE_HASH('o', 'p') :
+ /* __op<TO_TYPE>__<FROM_TYPE> */
+ d->p += 2;
+
+ d->type = ENCODE_OP_USER;
+
+ return (read_op_user(d));
+ case SIMPLE_HASH('t', 'f') :
+ d->p += 2;
+ d->type = ENCODE_OP_TF;
+
+ if (read_type(d) == false)
+ return (false);
+
+ return (VEC_PUSH_STR(&d->vec, " type_info function"));
+ case SIMPLE_HASH('t', 'i') :
+ d->p += 2;
+ d->type = ENCODE_OP_TI;
+
+ if (read_type(d) == false)
+ return (false);
+
+ return (VEC_PUSH_STR(&d->vec, " type_info node"));
+ default :
+ return (false);
+ };
+}
+
+static bool
+read_op_user(struct demangle_data *d)
+{
+ struct demangle_data from, to;
+ size_t from_len, to_len;
+ bool rtn;
+ char *from_str, *to_str;
+
+ if (d == NULL)
+ return (false);
+
+ if (init_demangle_data(&from) == false)
+ return (false);
+
+ rtn = false;
+ from_str = NULL;
+ to_str = NULL;
+ if (init_demangle_data(&to) == false)
+ goto clean;
+
+ to.p = d->p;
+ if (*to.p == 'Q') {
+ ++to.p;
+
+ if (read_qual_name(&to) == false)
+ goto clean;
+
+ /* pop last '::' */
+ if (vector_str_pop(&to.vec) == false)
+ goto clean;
+ } else {
+ if (read_class(&to) == false)
+ goto clean;
+
+ /* skip '__' */
+ to.p += 2;
+ }
+
+ if ((to_str = vector_str_get_flat(&to.vec, &to_len)) == NULL)
+ goto clean;
+
+ from.p = to.p;
+ if (*from.p == 'Q') {
+ ++from.p;
+
+ if (read_qual_name(&from) == false)
+ goto clean;
+
+ /* pop last '::' */
+ if (vector_str_pop(&from.vec) == false)
+ goto clean;
+ } else if (read_class(&from) == false)
+ goto clean;
+
+ if ((from_str = vector_str_get_flat(&from.vec, &from_len)) == NULL)
+ goto clean;
+
+ if (vector_str_push(&d->vec, from_str, from_len) == false)
+ goto clean;
+
+ if (VEC_PUSH_STR(&d->vec, "::operator ") == false)
+ goto clean;
+
+ if (vector_str_push(&d->vec, to_str, to_len) == false)
+ goto clean;
+
+ rtn = VEC_PUSH_STR(&d->vec, "()");
+clean:
+ free(to_str);
+ free(from_str);
+ dest_demangle_data(&to);
+ dest_demangle_data(&from);
+
+ return (rtn);
+}
+
+/* single digit + class names */
+static bool
+read_qual_name(struct demangle_data *d)
+{
+ int i;
+ char num;
+
+ if (d == NULL)
+ return (false);
+
+ assert(d->p != NULL && "d->p (org str) is NULL");
+ assert(*d->p > 48 && *d->p < 58 && "*d->p not in ASCII numeric range");
+
+ num = *d->p - 48;
+
+ assert(num > 0);
+
+ ++d->p;
+ for (i = 0; i < num ; ++i) {
+ if (read_class(d) == false)
+ return (false);
+
+ if (VEC_PUSH_STR(&d->vec, "::") == false)
+ return (false);
+ }
+
+ if (*d->p != '\0')
+ d->p = d->p + 2;
+
+ return (true);
+}
+
+/* Return -1 at fail, 0 at success, and 1 at end */
+static int
+read_subst(struct demangle_data *d)
+{
+ size_t idx;
+ char *str;
+
+ if (d == NULL)
+ return (-1);
+
+ idx = strtol(d->p + 1, &str, 10);
+ if (idx == 0 && (errno == EINVAL || errno == ERANGE))
+ return (-1);
+
+ assert(idx > 0);
+ assert(str != NULL);
+
+ d->p = str;
+
+ if (VEC_PUSH_STR(&d->vec, d->arg.container[idx - 1]) == false)
+ return (-1);
+
+ if (VEC_PUSH_STR(&d->arg, d->arg.container[idx - 1]) == false)
+ return (-1);
+
+ if (*d->p == '\0')
+ return (1);
+
+ return (0);
+}
+
+static int
+read_subst_iter(struct demangle_data *d)
+{
+ int i;
+ size_t idx;
+ char repeat;
+ char *str;
+
+ if (d == NULL)
+ return (-1);
+
+ ++d->p;
+ assert(*d->p > 48 && *d->p < 58 && "*d->p not in ASCII numeric range");
+
+ repeat = *d->p - 48;
+
+ assert(repeat > 1);
+
+ ++d->p;
+
+ idx = strtol(d->p, &str, 10);
+ if (idx == 0 && (errno == EINVAL || errno == ERANGE))
+ return (-1);
+
+ assert(idx > 0);
+ assert(str != NULL);
+
+ d->p = str;
+
+ for (i = 0; i < repeat ; ++i) {
+ if (VEC_PUSH_STR(&d->vec, d->arg.container[idx - 1]) == false)
+ return (-1);
+
+ if (VEC_PUSH_STR(&d->arg, d->arg.container[idx - 1]) == false)
+ return (-1);
+
+ if (i != repeat - 1 &&
+ VEC_PUSH_STR(&d->vec, ", ") == false)
+ return (-1);
+ }
+
+ if (*d->p == '\0')
+ return (1);
+
+ return (0);
+}
+
+static bool
+read_type(struct demangle_data *d)
+{
+
+ if (d == NULL)
+ return (false);
+
+ assert(d->p != NULL && "d->p (org str) is NULL");
+
+ while (*d->p == 'U' || *d->p == 'C' || *d->p == 'V' || *d->p == 'S' ||
+ *d->p == 'P' || *d->p == 'R' || *d->p == 'A' || *d->p == 'F' ||
+ *d->p == 'M') {
+ switch (*d->p) {
+ case 'U' :
+ ++d->p;
+
+ if (VEC_PUSH_STR(&d->vec, "unsigned ") == false)
+ return (false);
+
+ break;
+ case 'C' :
+ ++d->p;
+
+ if (*d->p == 'P')
+ d->cnst = true;
+ else {
+ if (VEC_PUSH_STR(&d->vec, "const ") ==
+ false)
+ return (false);
+ }
+
+ break;
+ case 'V' :
+ ++d->p;
+
+ if (VEC_PUSH_STR(&d->vec, "volatile ") == false)
+ return (false);
+
+ break;
+ case 'S' :
+ ++d->p;
+
+ if (VEC_PUSH_STR(&d->vec, "signed ") == false)
+ return (false);
+
+ break;
+ case 'P' :
+ ++d->p;
+
+ if (*d->p == 'F')
+ return (read_func_ptr(d));
+ else
+ d->ptr = true;
+
+ break;
+ case 'R' :
+ ++d->p;
+
+ d->ref = true;
+
+ break;
+ case 'F' :
+ break;
+ case 'A' :
+ ++d->p;
+
+ if (read_array(d) == false)
+ return (false);
+
+ break;
+ case 'M' :
+ ++d->p;
+
+ if (read_memptr(d) == false)
+ return (false);
+
+ break;
+ default :
+ break;
+ }
+ }
+
+ if (ELFTC_ISDIGIT(*d->p))
+ return (read_class(d));
+
+ switch (*d->p) {
+ case 'Q' :
+ ++d->p;
+
+ return (read_qual_name(d));
+ case 'v' :
+ ++d->p;
+
+ return (VEC_PUSH_STR(&d->vec, "void"));
+ case 'b':
+ ++d->p;
+
+ return(VEC_PUSH_STR(&d->vec, "bool"));
+ case 'c' :
+ ++d->p;
+
+ return (VEC_PUSH_STR(&d->vec, "char"));
+ case 's' :
+ ++d->p;
+
+ return (VEC_PUSH_STR(&d->vec, "short"));
+ case 'i' :
+ ++d->p;
+
+ return (VEC_PUSH_STR(&d->vec, "int"));
+ case 'l' :
+ ++d->p;
+
+ return (VEC_PUSH_STR(&d->vec, "long"));
+ case 'f' :
+ ++d->p;
+
+ return (VEC_PUSH_STR(&d->vec, "float"));
+ case 'd':
+ ++d->p;
+
+ return (VEC_PUSH_STR(&d->vec, "double"));
+ case 'r':
+ ++d->p;
+
+ return (VEC_PUSH_STR(&d->vec, "long double"));
+ case 'e':
+ ++d->p;
+
+ return (VEC_PUSH_STR(&d->vec, "..."));
+ case 'w':
+ ++d->p;
+
+ return (VEC_PUSH_STR(&d->vec, "wchar_t"));
+ case 'x':
+ ++d->p;
+
+ return (VEC_PUSH_STR(&d->vec, "long long"));
+ default:
+ return (false);
+ };
+
+ /* NOTREACHED */
+ return (false);
+}
diff --git a/rtemstoolkit/elftoolchain/libelftc/libelftc_dem_gnu3.c b/rtemstoolkit/elftoolchain/libelftc/libelftc_dem_gnu3.c
new file mode 100644
index 0000000..73ed371
--- /dev/null
+++ b/rtemstoolkit/elftoolchain/libelftc/libelftc_dem_gnu3.c
@@ -0,0 +1,3991 @@
+/*-
+ * Copyright (c) 2007 Hyogeol Lee <hyogeollee at gmail.com>
+ * Copyright (c) 2015-2017 Kai Wang <kaiwang27 at gmail.com>
+ * 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
+ * in this position and unchanged.
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``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 AUTHOR 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/types.h>
+#include <assert.h>
+#include <ctype.h>
+#include <errno.h>
+#include <libelftc.h>
+#include <limits.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "_libelftc.h"
+
+ELFTC_VCSID("$Id: libelftc_dem_gnu3.c 3583 2017-10-15 15:38:47Z emaste $");
+
+/**
+ * @file cpp_demangle.c
+ * @brief Decode IA-64 C++ ABI style implementation.
+ *
+ * IA-64 standard ABI(Itanium C++ ABI) references.
+ *
+ * http://www.codesourcery.com/cxx-abi/abi.html#mangling \n
+ * http://www.codesourcery.com/cxx-abi/abi-mangling.html
+ */
+
+enum type_qualifier {
+ TYPE_PTR, TYPE_REF, TYPE_CMX, TYPE_IMG, TYPE_EXT, TYPE_RST, TYPE_VAT,
+ TYPE_CST, TYPE_VEC, TYPE_RREF
+};
+
+struct vector_type_qualifier {
+ size_t size, capacity;
+ enum type_qualifier *q_container;
+ struct vector_str ext_name;
+};
+
+enum read_cmd {
+ READ_FAIL, READ_NEST, READ_TMPL, READ_EXPR, READ_EXPL, READ_LOCAL,
+ READ_TYPE, READ_FUNC, READ_PTRMEM
+};
+
+struct read_cmd_item {
+ enum read_cmd cmd;
+ void *data;
+};
+
+struct vector_read_cmd {
+ size_t size, capacity;
+ struct read_cmd_item *r_container;
+};
+
+enum push_qualifier {
+ PUSH_ALL_QUALIFIER,
+ PUSH_CV_QUALIFIER,
+ PUSH_NON_CV_QUALIFIER,
+};
+
+struct cpp_demangle_data {
+ struct vector_str output; /* output string vector */
+ struct vector_str subst; /* substitution string vector */
+ struct vector_str tmpl;
+ struct vector_str class_type;
+ struct vector_str *cur_output; /* ptr to current output vec */
+ struct vector_read_cmd cmd;
+ bool mem_rst; /* restrict member function */
+ bool mem_vat; /* volatile member function */
+ bool mem_cst; /* const member function */
+ bool mem_ref; /* lvalue-ref member func */
+ bool mem_rref; /* rvalue-ref member func */
+ bool is_tmpl; /* template args */
+ bool is_functype; /* function type */
+ bool ref_qualifier; /* ref qualifier */
+ enum type_qualifier ref_qualifier_type; /* ref qualifier type */
+ enum push_qualifier push_qualifier; /* which qualifiers to push */
+ int func_type;
+ const char *cur; /* current mangled name ptr */
+ const char *last_sname; /* last source name */
+};
+
+struct type_delimit {
+ bool paren;
+ bool firstp;
+};
+
+#define CPP_DEMANGLE_TRY_LIMIT 128
+#define FLOAT_SPRINTF_TRY_LIMIT 5
+#define FLOAT_QUADRUPLE_BYTES 16
+#define FLOAT_EXTENED_BYTES 10
+
+#define SIMPLE_HASH(x,y) (64 * x + y)
+#define DEM_PUSH_STR(d,s) cpp_demangle_push_str((d), (s), strlen((s)))
+#define VEC_PUSH_STR(d,s) vector_str_push((d), (s), strlen((s)))
+
+static void cpp_demangle_data_dest(struct cpp_demangle_data *);
+static int cpp_demangle_data_init(struct cpp_demangle_data *,
+ const char *);
+static int cpp_demangle_get_subst(struct cpp_demangle_data *, size_t);
+static int cpp_demangle_get_tmpl_param(struct cpp_demangle_data *, size_t);
+static int cpp_demangle_push_fp(struct cpp_demangle_data *,
+ char *(*)(const char *, size_t));
+static int cpp_demangle_push_str(struct cpp_demangle_data *, const char *,
+ size_t);
+static int cpp_demangle_pop_str(struct cpp_demangle_data *);
+static int cpp_demangle_push_subst(struct cpp_demangle_data *,
+ const char *, size_t);
+static int cpp_demangle_push_subst_v(struct cpp_demangle_data *,
+ struct vector_str *);
+static int cpp_demangle_push_type_qualifier(struct cpp_demangle_data *,
+ struct vector_type_qualifier *, const char *);
+static int cpp_demangle_read_array(struct cpp_demangle_data *);
+static int cpp_demangle_read_encoding(struct cpp_demangle_data *);
+static int cpp_demangle_read_expr_primary(struct cpp_demangle_data *);
+static int cpp_demangle_read_expression(struct cpp_demangle_data *);
+static int cpp_demangle_read_expression_flat(struct cpp_demangle_data *,
+ char **);
+static int cpp_demangle_read_expression_binary(struct cpp_demangle_data *,
+ const char *, size_t);
+static int cpp_demangle_read_expression_unary(struct cpp_demangle_data *,
+ const char *, size_t);
+static int cpp_demangle_read_expression_trinary(struct cpp_demangle_data *,
+ const char *, size_t, const char *, size_t);
+static int cpp_demangle_read_function(struct cpp_demangle_data *, int *,
+ struct vector_type_qualifier *);
+static int cpp_demangle_local_source_name(struct cpp_demangle_data *ddata);
+static int cpp_demangle_read_local_name(struct cpp_demangle_data *);
+static int cpp_demangle_read_name(struct cpp_demangle_data *);
+static int cpp_demangle_read_name_flat(struct cpp_demangle_data *,
+ char**);
+static int cpp_demangle_read_nested_name(struct cpp_demangle_data *);
+static int cpp_demangle_read_number(struct cpp_demangle_data *, long *);
+static int cpp_demangle_read_number_as_string(struct cpp_demangle_data *,
+ char **);
+static int cpp_demangle_read_nv_offset(struct cpp_demangle_data *);
+static int cpp_demangle_read_offset(struct cpp_demangle_data *);
+static int cpp_demangle_read_offset_number(struct cpp_demangle_data *);
+static int cpp_demangle_read_pointer_to_member(struct cpp_demangle_data *,
+ struct vector_type_qualifier *);
+static int cpp_demangle_read_sname(struct cpp_demangle_data *);
+static int cpp_demangle_read_subst(struct cpp_demangle_data *);
+static int cpp_demangle_read_subst_std(struct cpp_demangle_data *);
+static int cpp_demangle_read_subst_stdtmpl(struct cpp_demangle_data *,
+ const char *);
+static int cpp_demangle_read_tmpl_arg(struct cpp_demangle_data *);
+static int cpp_demangle_read_tmpl_args(struct cpp_demangle_data *);
+static int cpp_demangle_read_tmpl_param(struct cpp_demangle_data *);
+static int cpp_demangle_read_type(struct cpp_demangle_data *,
+ struct type_delimit *);
+static int cpp_demangle_read_type_flat(struct cpp_demangle_data *,
+ char **);
+static int cpp_demangle_read_uqname(struct cpp_demangle_data *);
+static int cpp_demangle_read_v_offset(struct cpp_demangle_data *);
+static char *decode_fp_to_double(const char *, size_t);
+static char *decode_fp_to_float(const char *, size_t);
+static char *decode_fp_to_float128(const char *, size_t);
+static char *decode_fp_to_float80(const char *, size_t);
+static char *decode_fp_to_long_double(const char *, size_t);
+static int hex_to_dec(char);
+static void vector_read_cmd_dest(struct vector_read_cmd *);
+static struct read_cmd_item *vector_read_cmd_find(struct vector_read_cmd *,
+ enum read_cmd);
+static int vector_read_cmd_init(struct vector_read_cmd *);
+static int vector_read_cmd_pop(struct vector_read_cmd *);
+static int vector_read_cmd_push(struct vector_read_cmd *, enum read_cmd,
+ void *);
+static void vector_type_qualifier_dest(struct vector_type_qualifier *);
+static int vector_type_qualifier_init(struct vector_type_qualifier *);
+static int vector_type_qualifier_push(struct vector_type_qualifier *,
+ enum type_qualifier);
+
+/**
+ * @brief Decode the input string by IA-64 C++ ABI style.
+ *
+ * GNU GCC v3 use IA-64 standard ABI.
+ * @return New allocated demangled string or NULL if failed.
+ * @todo 1. Testing and more test case. 2. Code cleaning.
+ */
+char *
+cpp_demangle_gnu3(const char *org)
+{
+ struct cpp_demangle_data ddata;
+ struct vector_str ret_type;
+ struct type_delimit td;
+ ssize_t org_len;
+ unsigned int limit;
+ char *rtn;
+ bool has_ret, more_type;
+
+ if (org == NULL || (org_len = strlen(org)) < 2)
+ return (NULL);
+
+ if (org_len > 11 && !strncmp(org, "_GLOBAL__I_", 11)) {
+ if ((rtn = malloc(org_len + 19)) == NULL)
+ return (NULL);
+ snprintf(rtn, org_len + 19,
+ "global constructors keyed to %s", org + 11);
+ return (rtn);
+ }
+
+ if (org[0] != '_' || org[1] != 'Z')
+ return (NULL);
+
+ if (!cpp_demangle_data_init(&ddata, org + 2))
+ return (NULL);
+
+ rtn = NULL;
+ has_ret = more_type = false;
+
+ if (!cpp_demangle_read_encoding(&ddata))
+ goto clean;
+
+ /*
+ * Pop function name from substitution candidate list.
+ */
+ if (*ddata.cur != 0 && ddata.subst.size >= 1) {
+ if (!vector_str_pop(&ddata.subst))
+ goto clean;
+ }
+
+ td.paren = false;
+ td.firstp = true;
+ limit = 0;
+
+ /*
+ * The first type is a return type if we just demangled template
+ * args. (the template args is right next to the function name,
+ * which means it's a template function)
+ */
+ if (ddata.is_tmpl) {
+ ddata.is_tmpl = false;
+ if (!vector_str_init(&ret_type))
+ goto clean;
+ ddata.cur_output = &ret_type;
+ has_ret = true;
+ }
+
+ while (*ddata.cur != '\0') {
+ /*
+ * Breaking at some gcc info at tail. e.g) @@GLIBCXX_3.4
+ */
+ if (*ddata.cur == '@' && *(ddata.cur + 1) == '@')
+ break;
+
+ if (has_ret) {
+ /* Read return type */
+ if (!cpp_demangle_read_type(&ddata, NULL))
+ goto clean;
+ } else {
+ /* Read function arg type */
+ if (!cpp_demangle_read_type(&ddata, &td))
+ goto clean;
+ }
+
+ if (has_ret) {
+ /* Push return type to the beginning */
+ if (!VEC_PUSH_STR(&ret_type, " "))
+ goto clean;
+ if (!vector_str_push_vector_head(&ddata.output,
+ &ret_type))
+ goto clean;
+ ddata.cur_output = &ddata.output;
+ vector_str_dest(&ret_type);
+ has_ret = false;
+ more_type = true;
+ } else if (more_type)
+ more_type = false;
+ if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
+ goto clean;
+ }
+ if (more_type)
+ goto clean;
+
+ if (ddata.output.size == 0)
+ goto clean;
+ if (td.paren && !VEC_PUSH_STR(&ddata.output, ")"))
+ goto clean;
+ if (ddata.mem_vat && !VEC_PUSH_STR(&ddata.output, " volatile"))
+ goto clean;
+ if (ddata.mem_cst && !VEC_PUSH_STR(&ddata.output, " const"))
+ goto clean;
+ if (ddata.mem_rst && !VEC_PUSH_STR(&ddata.output, " restrict"))
+ goto clean;
+ if (ddata.mem_ref && !VEC_PUSH_STR(&ddata.output, " &"))
+ goto clean;
+ if (ddata.mem_rref && !VEC_PUSH_STR(&ddata.output, " &&"))
+ goto clean;
+
+ rtn = vector_str_get_flat(&ddata.output, (size_t *) NULL);
+
+clean:
+ if (has_ret)
+ vector_str_dest(&ret_type);
+
+ cpp_demangle_data_dest(&ddata);
+
+ return (rtn);
+}
+
+static void
+cpp_demangle_data_dest(struct cpp_demangle_data *d)
+{
+
+ if (d == NULL)
+ return;
+
+ vector_read_cmd_dest(&d->cmd);
+ vector_str_dest(&d->class_type);
+ vector_str_dest(&d->tmpl);
+ vector_str_dest(&d->subst);
+ vector_str_dest(&d->output);
+}
+
+static int
+cpp_demangle_data_init(struct cpp_demangle_data *d, const char *cur)
+{
+
+ if (d == NULL || cur == NULL)
+ return (0);
+
+ if (!vector_str_init(&d->output))
+ return (0);
+ if (!vector_str_init(&d->subst))
+ goto clean1;
+ if (!vector_str_init(&d->tmpl))
+ goto clean2;
+ if (!vector_str_init(&d->class_type))
+ goto clean3;
+ if (!vector_read_cmd_init(&d->cmd))
+ goto clean4;
+
+ assert(d->output.container != NULL);
+ assert(d->subst.container != NULL);
+ assert(d->tmpl.container != NULL);
+ assert(d->class_type.container != NULL);
+
+ d->mem_rst = false;
+ d->mem_vat = false;
+ d->mem_cst = false;
+ d->mem_ref = false;
+ d->mem_rref = false;
+ d->is_tmpl = false;
+ d->is_functype = false;
+ d->ref_qualifier = false;
+ d->push_qualifier = PUSH_ALL_QUALIFIER;
+ d->func_type = 0;
+ d->cur = cur;
+ d->cur_output = &d->output;
+ d->last_sname = NULL;
+
+ return (1);
+
+clean4:
+ vector_str_dest(&d->class_type);
+clean3:
+ vector_str_dest(&d->tmpl);
+clean2:
+ vector_str_dest(&d->subst);
+clean1:
+ vector_str_dest(&d->output);
+
+ return (0);
+}
+
+static int
+cpp_demangle_push_fp(struct cpp_demangle_data *ddata,
+ char *(*decoder)(const char *, size_t))
+{
+ size_t len;
+ int rtn;
+ const char *fp;
+ char *f;
+
+ if (ddata == NULL || decoder == NULL)
+ return (0);
+
+ fp = ddata->cur;
+ while (*ddata->cur != 'E')
+ ++ddata->cur;
+
+ if ((f = decoder(fp, ddata->cur - fp)) == NULL)
+ return (0);
+
+ rtn = 0;
+ if ((len = strlen(f)) > 0)
+ rtn = cpp_demangle_push_str(ddata, f, len);
+
+ free(f);
+
+ ++ddata->cur;
+
+ return (rtn);
+}
+
+static int
+cpp_demangle_push_str(struct cpp_demangle_data *ddata, const char *str,
+ size_t len)
+{
+
+ if (ddata == NULL || str == NULL || len == 0)
+ return (0);
+
+ /*
+ * is_tmpl is used to check if the type (function arg) is right next
+ * to template args, and should always be cleared whenever new string
+ * pushed.
+ */
+ ddata->is_tmpl = false;
+
+ return (vector_str_push(ddata->cur_output, str, len));
+}
+
+static int
+cpp_demangle_pop_str(struct cpp_demangle_data *ddata)
+{
+
+ if (ddata == NULL)
+ return (0);
+
+ return (vector_str_pop(ddata->cur_output));
+}
+
+static int
+cpp_demangle_push_subst(struct cpp_demangle_data *ddata, const char *str,
+ size_t len)
+{
+
+ if (ddata == NULL || str == NULL || len == 0)
+ return (0);
+
+ if (!vector_str_find(&ddata->subst, str, len))
+ return (vector_str_push(&ddata->subst, str, len));
+
+ return (1);
+}
+
+static int
+cpp_demangle_push_subst_v(struct cpp_demangle_data *ddata, struct vector_str *v)
+{
+ size_t str_len;
+ int rtn;
+ char *str;
+
+ if (ddata == NULL || v == NULL)
+ return (0);
+
+ if ((str = vector_str_get_flat(v, &str_len)) == NULL)
+ return (0);
+
+ rtn = cpp_demangle_push_subst(ddata, str, str_len);
+
+ free(str);
+
+ return (rtn);
+}
+
+static int
+cpp_demangle_push_type_qualifier(struct cpp_demangle_data *ddata,
+ struct vector_type_qualifier *v, const char *type_str)
+{
+ struct vector_str subst_v;
+ enum type_qualifier t;
+ size_t idx, e_idx, e_len;
+ char *buf;
+ int rtn;
+ bool cv;
+
+ if (ddata == NULL || v == NULL)
+ return (0);
+
+ if ((idx = v->size) == 0)
+ return (1);
+
+ rtn = 0;
+ if (type_str != NULL) {
+ if (!vector_str_init(&subst_v))
+ return (0);
+ if (!VEC_PUSH_STR(&subst_v, type_str))
+ goto clean;
+ }
+
+ cv = true;
+ e_idx = 0;
+ while (idx > 0) {
+ switch (v->q_container[idx - 1]) {
+ case TYPE_PTR:
+ cv = false;
+ if (ddata->push_qualifier == PUSH_CV_QUALIFIER)
+ break;
+ if (!DEM_PUSH_STR(ddata, "*"))
+ goto clean;
+ if (type_str != NULL) {
+ if (!VEC_PUSH_STR(&subst_v, "*"))
+ goto clean;
+ if (!cpp_demangle_push_subst_v(ddata,
+ &subst_v))
+ goto clean;
+ }
+ break;
+
+ case TYPE_REF:
+ cv = false;
+ if (ddata->push_qualifier == PUSH_CV_QUALIFIER)
+ break;
+ if (!DEM_PUSH_STR(ddata, "&"))
+ goto clean;
+ if (type_str != NULL) {
+ if (!VEC_PUSH_STR(&subst_v, "&"))
+ goto clean;
+ if (!cpp_demangle_push_subst_v(ddata,
+ &subst_v))
+ goto clean;
+ }
+ break;
+
+ case TYPE_RREF:
+ cv = false;
+ if (ddata->push_qualifier == PUSH_CV_QUALIFIER)
+ break;
+ if (!DEM_PUSH_STR(ddata, "&&"))
+ goto clean;
+ if (type_str != NULL) {
+ if (!VEC_PUSH_STR(&subst_v, "&&"))
+ goto clean;
+ if (!cpp_demangle_push_subst_v(ddata,
+ &subst_v))
+ goto clean;
+ }
+ break;
+
+ case TYPE_CMX:
+ cv = false;
+ if (ddata->push_qualifier == PUSH_CV_QUALIFIER)
+ break;
+ if (!DEM_PUSH_STR(ddata, " complex"))
+ goto clean;
+ if (type_str != NULL) {
+ if (!VEC_PUSH_STR(&subst_v, " complex"))
+ goto clean;
+ if (!cpp_demangle_push_subst_v(ddata,
+ &subst_v))
+ goto clean;
+ }
+ break;
+
+ case TYPE_IMG:
+ cv = false;
+ if (ddata->push_qualifier == PUSH_CV_QUALIFIER)
+ break;
+ if (!DEM_PUSH_STR(ddata, " imaginary"))
+ goto clean;
+ if (type_str != NULL) {
+ if (!VEC_PUSH_STR(&subst_v, " imaginary"))
+ goto clean;
+ if (!cpp_demangle_push_subst_v(ddata,
+ &subst_v))
+ goto clean;
+ }
+ break;
+
+ case TYPE_EXT:
+ cv = false;
+ if (ddata->push_qualifier == PUSH_CV_QUALIFIER)
+ break;
+ if (v->ext_name.size == 0 ||
+ e_idx > v->ext_name.size - 1)
+ goto clean;
+ if ((e_len = strlen(v->ext_name.container[e_idx])) ==
+ 0)
+ goto clean;
+ if ((buf = malloc(e_len + 2)) == NULL)
+ goto clean;
+ snprintf(buf, e_len + 2, " %s",
+ v->ext_name.container[e_idx]);
+
+ if (!DEM_PUSH_STR(ddata, buf)) {
+ free(buf);
+ goto clean;
+ }
+
+ if (type_str != NULL) {
+ if (!VEC_PUSH_STR(&subst_v, buf)) {
+ free(buf);
+ goto clean;
+ }
+ if (!cpp_demangle_push_subst_v(ddata,
+ &subst_v)) {
+ free(buf);
+ goto clean;
+ }
+ }
+ free(buf);
+ ++e_idx;
+ break;
+
+ case TYPE_RST:
+ if (ddata->push_qualifier == PUSH_NON_CV_QUALIFIER &&
+ cv)
+ break;
+ if (ddata->push_qualifier == PUSH_CV_QUALIFIER && !cv)
+ break;
+ if (!DEM_PUSH_STR(ddata, " restrict"))
+ goto clean;
+ if (type_str != NULL) {
+ if (!VEC_PUSH_STR(&subst_v, " restrict"))
+ goto clean;
+ if (idx - 1 > 0) {
+ t = v->q_container[idx - 2];
+ if (t == TYPE_RST || t == TYPE_VAT ||
+ t == TYPE_CST)
+ break;
+ }
+ if (!cpp_demangle_push_subst_v(ddata,
+ &subst_v))
+ goto clean;
+ }
+ break;
+
+ case TYPE_VAT:
+ if (ddata->push_qualifier == PUSH_NON_CV_QUALIFIER &&
+ cv)
+ break;
+ if (ddata->push_qualifier == PUSH_CV_QUALIFIER && !cv)
+ break;
+ if (!DEM_PUSH_STR(ddata, " volatile"))
+ goto clean;
+ if (type_str != NULL) {
+ if (!VEC_PUSH_STR(&subst_v, " volatile"))
+ goto clean;
+ if (idx - 1 > 0) {
+ t = v->q_container[idx - 2];
+ if (t == TYPE_RST || t == TYPE_VAT ||
+ t == TYPE_CST)
+ break;
+ }
+ if (!cpp_demangle_push_subst_v(ddata,
+ &subst_v))
+ goto clean;
+ }
+ break;
+
+ case TYPE_CST:
+ if (ddata->push_qualifier == PUSH_NON_CV_QUALIFIER &&
+ cv)
+ break;
+ if (ddata->push_qualifier == PUSH_CV_QUALIFIER && !cv)
+ break;
+ if (!DEM_PUSH_STR(ddata, " const"))
+ goto clean;
+ if (type_str != NULL) {
+ if (!VEC_PUSH_STR(&subst_v, " const"))
+ goto clean;
+ if (idx - 1 > 0) {
+ t = v->q_container[idx - 2];
+ if (t == TYPE_RST || t == TYPE_VAT ||
+ t == TYPE_CST)
+ break;
+ }
+ if (!cpp_demangle_push_subst_v(ddata,
+ &subst_v))
+ goto clean;
+ }
+ break;
+
+ case TYPE_VEC:
+ cv = false;
+ if (ddata->push_qualifier == PUSH_CV_QUALIFIER)
+ break;
+ if (v->ext_name.size == 0 ||
+ e_idx > v->ext_name.size - 1)
+ goto clean;
+ if ((e_len = strlen(v->ext_name.container[e_idx])) ==
+ 0)
+ goto clean;
+ if ((buf = malloc(e_len + 12)) == NULL)
+ goto clean;
+ snprintf(buf, e_len + 12, " __vector(%s)",
+ v->ext_name.container[e_idx]);
+ if (!DEM_PUSH_STR(ddata, buf)) {
+ free(buf);
+ goto clean;
+ }
+ if (type_str != NULL) {
+ if (!VEC_PUSH_STR(&subst_v, buf)) {
+ free(buf);
+ goto clean;
+ }
+ if (!cpp_demangle_push_subst_v(ddata,
+ &subst_v)) {
+ free(buf);
+ goto clean;
+ }
+ }
+ free(buf);
+ ++e_idx;
+ break;
+ }
+ --idx;
+ }
+
+ rtn = 1;
+clean:
+ if (type_str != NULL)
+ vector_str_dest(&subst_v);
+
+ return (rtn);
+}
+
+static int
+cpp_demangle_get_subst(struct cpp_demangle_data *ddata, size_t idx)
+{
+ size_t len;
+
+ if (ddata == NULL || ddata->subst.size <= idx)
+ return (0);
+ if ((len = strlen(ddata->subst.container[idx])) == 0)
+ return (0);
+ if (!cpp_demangle_push_str(ddata, ddata->subst.container[idx], len))
+ return (0);
+
+ /* skip '_' */
+ ++ddata->cur;
+
+ return (1);
+}
+
+static int
+cpp_demangle_get_tmpl_param(struct cpp_demangle_data *ddata, size_t idx)
+{
+ size_t len;
+
+ if (ddata == NULL || ddata->tmpl.size <= idx)
+ return (0);
+ if ((len = strlen(ddata->tmpl.container[idx])) == 0)
+ return (0);
+ if (!cpp_demangle_push_str(ddata, ddata->tmpl.container[idx], len))
+ return (0);
+
+ ++ddata->cur;
+
+ return (1);
+}
+
+static int
+cpp_demangle_read_array(struct cpp_demangle_data *ddata)
+{
+ size_t i, num_len, exp_len, p_idx, idx;
+ const char *num;
+ char *exp;
+
+ if (ddata == NULL || *(++ddata->cur) == '\0')
+ return (0);
+
+ if (*ddata->cur == '_') {
+ if (*(++ddata->cur) == '\0')
+ return (0);
+
+ if (!cpp_demangle_read_type(ddata, NULL))
+ return (0);
+
+ if (!DEM_PUSH_STR(ddata, "[]"))
+ return (0);
+ } else {
+ if (ELFTC_ISDIGIT(*ddata->cur) != 0) {
+ num = ddata->cur;
+ while (ELFTC_ISDIGIT(*ddata->cur) != 0)
+ ++ddata->cur;
+ if (*ddata->cur != '_')
+ return (0);
+ num_len = ddata->cur - num;
+ assert(num_len > 0);
+ if (*(++ddata->cur) == '\0')
+ return (0);
+ if (!cpp_demangle_read_type(ddata, NULL))
+ return (0);
+ if (!DEM_PUSH_STR(ddata, "["))
+ return (0);
+ if (!cpp_demangle_push_str(ddata, num, num_len))
+ return (0);
+ if (!DEM_PUSH_STR(ddata, "]"))
+ return (0);
+ } else {
+ p_idx = ddata->output.size;
+ if (!cpp_demangle_read_expression(ddata))
+ return (0);
+ if ((exp = vector_str_substr(&ddata->output, p_idx,
+ ddata->output.size - 1, &exp_len)) == NULL)
+ return (0);
+ idx = ddata->output.size;
+ for (i = p_idx; i < idx; ++i)
+ if (!vector_str_pop(&ddata->output)) {
+ free(exp);
+ return (0);
+ }
+ if (*ddata->cur != '_') {
+ free(exp);
+ return (0);
+ }
+ ++ddata->cur;
+ if (*ddata->cur == '\0') {
+ free(exp);
+ return (0);
+ }
+ if (!cpp_demangle_read_type(ddata, NULL)) {
+ free(exp);
+ return (0);
+ }
+ if (!DEM_PUSH_STR(ddata, "[")) {
+ free(exp);
+ return (0);
+ }
+ if (!cpp_demangle_push_str(ddata, exp, exp_len)) {
+ free(exp);
+ return (0);
+ }
+ if (!DEM_PUSH_STR(ddata, "]")) {
+ free(exp);
+ return (0);
+ }
+ free(exp);
+ }
+ }
+
+ return (1);
+}
+
+static int
+cpp_demangle_read_expr_primary(struct cpp_demangle_data *ddata)
+{
+ const char *num;
+
+ if (ddata == NULL || *(++ddata->cur) == '\0')
+ return (0);
+
+ if (*ddata->cur == '_' && *(ddata->cur + 1) == 'Z') {
+ ddata->cur += 2;
+ if (*ddata->cur == '\0')
+ return (0);
+ if (!cpp_demangle_read_encoding(ddata))
+ return (0);
+ ++ddata->cur;
+ return (1);
+ }
+
+ switch (*ddata->cur) {
+ case 'b':
+ if (*(ddata->cur + 2) != 'E')
+ return (0);
+ switch (*(++ddata->cur)) {
+ case '0':
+ ddata->cur += 2;
+ return (DEM_PUSH_STR(ddata, "false"));
+ case '1':
+ ddata->cur += 2;
+ return (DEM_PUSH_STR(ddata, "true"));
+ default:
+ return (0);
+ }
+
+ case 'd':
+ ++ddata->cur;
+ return (cpp_demangle_push_fp(ddata, decode_fp_to_double));
+
+ case 'e':
+ ++ddata->cur;
+ if (sizeof(long double) == 10)
+ return (cpp_demangle_push_fp(ddata,
+ decode_fp_to_double));
+ return (cpp_demangle_push_fp(ddata, decode_fp_to_float80));
+
+ case 'f':
+ ++ddata->cur;
+ return (cpp_demangle_push_fp(ddata, decode_fp_to_float));
+
+ case 'g':
+ ++ddata->cur;
+ if (sizeof(long double) == 16)
+ return (cpp_demangle_push_fp(ddata,
+ decode_fp_to_double));
+ return (cpp_demangle_push_fp(ddata, decode_fp_to_float128));
+
+ case 'i':
+ case 'j':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 's':
+ case 't':
+ case 'x':
+ case 'y':
+ if (*(++ddata->cur) == 'n') {
+ if (!DEM_PUSH_STR(ddata, "-"))
+ return (0);
+ ++ddata->cur;
+ }
+ num = ddata->cur;
+ while (*ddata->cur != 'E') {
+ if (!ELFTC_ISDIGIT(*ddata->cur))
+ return (0);
+ ++ddata->cur;
+ }
+ ++ddata->cur;
+ return (cpp_demangle_push_str(ddata, num,
+ ddata->cur - num - 1));
+
+ default:
+ return (0);
+ }
+}
+
+static int
+cpp_demangle_read_expression(struct cpp_demangle_data *ddata)
+{
+
+ if (ddata == NULL || *ddata->cur == '\0')
+ return (0);
+
+ switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
+ case SIMPLE_HASH('s', 't'):
+ ddata->cur += 2;
+ return (cpp_demangle_read_type(ddata, NULL));
+
+ case SIMPLE_HASH('s', 'r'):
+ ddata->cur += 2;
+ if (!cpp_demangle_read_type(ddata, NULL))
+ return (0);
+ if (!cpp_demangle_read_uqname(ddata))
+ return (0);
+ if (*ddata->cur == 'I')
+ return (cpp_demangle_read_tmpl_args(ddata));
+ return (1);
+
+ case SIMPLE_HASH('a', 'a'):
+ /* operator && */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, "&&", 2));
+
+ case SIMPLE_HASH('a', 'd'):
+ /* operator & (unary) */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_unary(ddata, "&", 1));
+
+ case SIMPLE_HASH('a', 'n'):
+ /* operator & */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, "&", 1));
+
+ case SIMPLE_HASH('a', 'N'):
+ /* operator &= */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, "&=", 2));
+
+ case SIMPLE_HASH('a', 'S'):
+ /* operator = */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, "=", 1));
+
+ case SIMPLE_HASH('c', 'l'):
+ /* operator () */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, "()", 2));
+
+ case SIMPLE_HASH('c', 'm'):
+ /* operator , */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, ",", 1));
+
+ case SIMPLE_HASH('c', 'o'):
+ /* operator ~ */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, "~", 1));
+
+ case SIMPLE_HASH('c', 'v'):
+ /* operator (cast) */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, "(cast)", 6));
+
+ case SIMPLE_HASH('d', 'a'):
+ /* operator delete [] */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_unary(ddata, "delete []", 9));
+
+ case SIMPLE_HASH('d', 'e'):
+ /* operator * (unary) */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_unary(ddata, "*", 1));
+
+ case SIMPLE_HASH('d', 'l'):
+ /* operator delete */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_unary(ddata, "delete", 6));
+
+ case SIMPLE_HASH('d', 'v'):
+ /* operator / */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, "/", 1));
+
+ case SIMPLE_HASH('d', 'V'):
+ /* operator /= */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, "/=", 2));
+
+ case SIMPLE_HASH('e', 'o'):
+ /* operator ^ */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, "^", 1));
+
+ case SIMPLE_HASH('e', 'O'):
+ /* operator ^= */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, "^=", 2));
+
+ case SIMPLE_HASH('e', 'q'):
+ /* operator == */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, "==", 2));
+
+ case SIMPLE_HASH('g', 'e'):
+ /* operator >= */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, ">=", 2));
+
+ case SIMPLE_HASH('g', 't'):
+ /* operator > */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, ">", 1));
+
+ case SIMPLE_HASH('i', 'x'):
+ /* operator [] */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, "[]", 2));
+
+ case SIMPLE_HASH('l', 'e'):
+ /* operator <= */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, "<=", 2));
+
+ case SIMPLE_HASH('l', 's'):
+ /* operator << */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, "<<", 2));
+
+ case SIMPLE_HASH('l', 'S'):
+ /* operator <<= */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, "<<=", 3));
+
+ case SIMPLE_HASH('l', 't'):
+ /* operator < */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, "<", 1));
+
+ case SIMPLE_HASH('m', 'i'):
+ /* operator - */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, "-", 1));
+
+ case SIMPLE_HASH('m', 'I'):
+ /* operator -= */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, "-=", 2));
+
+ case SIMPLE_HASH('m', 'l'):
+ /* operator * */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, "*", 1));
+
+ case SIMPLE_HASH('m', 'L'):
+ /* operator *= */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, "*=", 2));
+
+ case SIMPLE_HASH('m', 'm'):
+ /* operator -- */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, "--", 2));
+
+ case SIMPLE_HASH('n', 'a'):
+ /* operator new[] */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_unary(ddata, "new []", 6));
+
+ case SIMPLE_HASH('n', 'e'):
+ /* operator != */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, "!=", 2));
+
+ case SIMPLE_HASH('n', 'g'):
+ /* operator - (unary) */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_unary(ddata, "-", 1));
+
+ case SIMPLE_HASH('n', 't'):
+ /* operator ! */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, "!", 1));
+
+ case SIMPLE_HASH('n', 'w'):
+ /* operator new */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_unary(ddata, "new", 3));
+
+ case SIMPLE_HASH('o', 'o'):
+ /* operator || */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, "||", 2));
+
+ case SIMPLE_HASH('o', 'r'):
+ /* operator | */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, "|", 1));
+
+ case SIMPLE_HASH('o', 'R'):
+ /* operator |= */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, "|=", 2));
+
+ case SIMPLE_HASH('p', 'l'):
+ /* operator + */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, "+", 1));
+
+ case SIMPLE_HASH('p', 'L'):
+ /* operator += */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, "+=", 2));
+
+ case SIMPLE_HASH('p', 'm'):
+ /* operator ->* */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, "->*", 3));
+
+ case SIMPLE_HASH('p', 'p'):
+ /* operator ++ */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, "++", 2));
+
+ case SIMPLE_HASH('p', 's'):
+ /* operator + (unary) */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_unary(ddata, "+", 1));
+
+ case SIMPLE_HASH('p', 't'):
+ /* operator -> */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, "->", 2));
+
+ case SIMPLE_HASH('q', 'u'):
+ /* operator ? */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_trinary(ddata, "?", 1,
+ ":", 1));
+
+ case SIMPLE_HASH('r', 'm'):
+ /* operator % */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, "%", 1));
+
+ case SIMPLE_HASH('r', 'M'):
+ /* operator %= */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, "%=", 2));
+
+ case SIMPLE_HASH('r', 's'):
+ /* operator >> */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, ">>", 2));
+
+ case SIMPLE_HASH('r', 'S'):
+ /* operator >>= */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_binary(ddata, ">>=", 3));
+
+ case SIMPLE_HASH('r', 'z'):
+ /* operator sizeof */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_unary(ddata, "sizeof", 6));
+
+ case SIMPLE_HASH('s', 'v'):
+ /* operator sizeof */
+ ddata->cur += 2;
+ return (cpp_demangle_read_expression_unary(ddata, "sizeof", 6));
+ }
+
+ switch (*ddata->cur) {
+ case 'L':
+ return (cpp_demangle_read_expr_primary(ddata));
+ case 'T':
+ return (cpp_demangle_read_tmpl_param(ddata));
+ }
+
+ return (0);
+}
+
+static int
+cpp_demangle_read_expression_flat(struct cpp_demangle_data *ddata, char **str)
+{
+ struct vector_str *output;
+ size_t i, p_idx, idx, exp_len;
+ char *exp;
+
+ output = &ddata->output;
+
+ p_idx = output->size;
+
+ if (!cpp_demangle_read_expression(ddata))
+ return (0);
+
+ if ((exp = vector_str_substr(output, p_idx, output->size - 1,
+ &exp_len)) == NULL)
+ return (0);
+
+ idx = output->size;
+ for (i = p_idx; i < idx; ++i) {
+ if (!vector_str_pop(output)) {
+ free(exp);
+ return (0);
+ }
+ }
+
+ *str = exp;
+
+ return (1);
+}
+
+static int
+cpp_demangle_read_expression_binary(struct cpp_demangle_data *ddata,
+ const char *name, size_t len)
+{
+
+ if (ddata == NULL || name == NULL || len == 0)
+ return (0);
+ if (!cpp_demangle_read_expression(ddata))
+ return (0);
+ if (!cpp_demangle_push_str(ddata, name, len))
+ return (0);
+
+ return (cpp_demangle_read_expression(ddata));
+}
+
+static int
+cpp_demangle_read_expression_unary(struct cpp_demangle_data *ddata,
+ const char *name, size_t len)
+{
+
+ if (ddata == NULL || name == NULL || len == 0)
+ return (0);
+ if (!cpp_demangle_read_expression(ddata))
+ return (0);
+
+ return (cpp_demangle_push_str(ddata, name, len));
+}
+
+static int
+cpp_demangle_read_expression_trinary(struct cpp_demangle_data *ddata,
+ const char *name1, size_t len1, const char *name2, size_t len2)
+{
+
+ if (ddata == NULL || name1 == NULL || len1 == 0 || name2 == NULL ||
+ len2 == 0)
+ return (0);
+
+ if (!cpp_demangle_read_expression(ddata))
+ return (0);
+ if (!cpp_demangle_push_str(ddata, name1, len1))
+ return (0);
+ if (!cpp_demangle_read_expression(ddata))
+ return (0);
+ if (!cpp_demangle_push_str(ddata, name2, len2))
+ return (0);
+
+ return (cpp_demangle_read_expression(ddata));
+}
+
+static int
+cpp_demangle_read_function(struct cpp_demangle_data *ddata, int *ext_c,
+ struct vector_type_qualifier *v)
+{
+ struct type_delimit td;
+ struct read_cmd_item *rc;
+ size_t class_type_size, class_type_len, limit;
+ const char *class_type;
+ int i;
+ bool paren, non_cv_qualifier;
+
+ if (ddata == NULL || *ddata->cur != 'F' || v == NULL)
+ return (0);
+
+ ++ddata->cur;
+ if (*ddata->cur == 'Y') {
+ if (ext_c != NULL)
+ *ext_c = 1;
+ ++ddata->cur;
+ }
+
+ /* Return type */
+ if (!cpp_demangle_read_type(ddata, NULL))
+ return (0);
+
+ if (*ddata->cur != 'E') {
+ if (!DEM_PUSH_STR(ddata, " "))
+ return (0);
+
+ non_cv_qualifier = false;
+ if (v->size > 0) {
+ for (i = 0; (size_t) i < v->size; i++) {
+ if (v->q_container[i] != TYPE_RST &&
+ v->q_container[i] != TYPE_VAT &&
+ v->q_container[i] != TYPE_CST) {
+ non_cv_qualifier = true;
+ break;
+ }
+ }
+ }
+
+ paren = false;
+ rc = vector_read_cmd_find(&ddata->cmd, READ_PTRMEM);
+ if (non_cv_qualifier || rc != NULL) {
+ if (!DEM_PUSH_STR(ddata, "("))
+ return (0);
+ paren = true;
+ }
+
+ /* Push non-cv qualifiers. */
+ ddata->push_qualifier = PUSH_NON_CV_QUALIFIER;
+ if (!cpp_demangle_push_type_qualifier(ddata, v, NULL))
+ return (0);
+
+ if (rc) {
+ if (non_cv_qualifier && !DEM_PUSH_STR(ddata, " "))
+ return (0);
+ if ((class_type_size = ddata->class_type.size) == 0)
+ return (0);
+ class_type =
+ ddata->class_type.container[class_type_size - 1];
+ if (class_type == NULL)
+ return (0);
+ if ((class_type_len = strlen(class_type)) == 0)
+ return (0);
+ if (!cpp_demangle_push_str(ddata, class_type,
+ class_type_len))
+ return (0);
+ if (!DEM_PUSH_STR(ddata, "::*"))
+ return (0);
+ /* Push pointer-to-member qualifiers. */
+ ddata->push_qualifier = PUSH_ALL_QUALIFIER;
+ if (!cpp_demangle_push_type_qualifier(ddata, rc->data,
+ NULL))
+ return (0);
+ ++ddata->func_type;
+ }
+
+ if (paren) {
+ if (!DEM_PUSH_STR(ddata, ")"))
+ return (0);
+ paren = false;
+ }
+
+ td.paren = false;
+ td.firstp = true;
+ limit = 0;
+ ddata->is_functype = true;
+ for (;;) {
+ if (!cpp_demangle_read_type(ddata, &td))
+ return (0);
+ if (*ddata->cur == 'E')
+ break;
+ if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
+ return (0);
+ }
+ ddata->is_functype = false;
+ if (td.paren) {
+ if (!DEM_PUSH_STR(ddata, ")"))
+ return (0);
+ td.paren = false;
+ }
+
+ /* Push CV qualifiers. */
+ ddata->push_qualifier = PUSH_CV_QUALIFIER;
+ if (!cpp_demangle_push_type_qualifier(ddata, v, NULL))
+ return (0);
+
+ ddata->push_qualifier = PUSH_ALL_QUALIFIER;
+
+ /* Release type qualifier vector. */
+ vector_type_qualifier_dest(v);
+ if (!vector_type_qualifier_init(v))
+ return (0);
+
+ /* Push ref-qualifiers. */
+ if (ddata->ref_qualifier) {
+ switch (ddata->ref_qualifier_type) {
+ case TYPE_REF:
+ if (!DEM_PUSH_STR(ddata, " &"))
+ return (0);
+ break;
+ case TYPE_RREF:
+ if (!DEM_PUSH_STR(ddata, " &&"))
+ return (0);
+ break;
+ default:
+ return (0);
+ }
+ ddata->ref_qualifier = false;
+ }
+ }
+
+ ++ddata->cur;
+
+ return (1);
+}
+
+/* read encoding, encoding are function name, data name, special-name */
+static int
+cpp_demangle_read_encoding(struct cpp_demangle_data *ddata)
+{
+ char *name, *type, *num_str;
+ long offset;
+ int rtn;
+
+ if (ddata == NULL || *ddata->cur == '\0')
+ return (0);
+
+ /* special name */
+ switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
+ case SIMPLE_HASH('G', 'A'):
+ if (!DEM_PUSH_STR(ddata, "hidden alias for "))
+ return (0);
+ ddata->cur += 2;
+ if (*ddata->cur == '\0')
+ return (0);
+ return (cpp_demangle_read_encoding(ddata));
+
+ case SIMPLE_HASH('G', 'R'):
+ if (!DEM_PUSH_STR(ddata, "reference temporary #"))
+ return (0);
+ ddata->cur += 2;
+ if (*ddata->cur == '\0')
+ return (0);
+ if (!cpp_demangle_read_name_flat(ddata, &name))
+ return (0);
+ rtn = 0;
+ if (!cpp_demangle_read_number_as_string(ddata, &num_str))
+ goto clean1;
+ if (!DEM_PUSH_STR(ddata, num_str))
+ goto clean2;
+ if (!DEM_PUSH_STR(ddata, " for "))
+ goto clean2;
+ if (!DEM_PUSH_STR(ddata, name))
+ goto clean2;
+ rtn = 1;
+ clean2:
+ free(num_str);
+ clean1:
+ free(name);
+ return (rtn);
+
+ case SIMPLE_HASH('G', 'T'):
+ ddata->cur += 2;
+ if (*ddata->cur == '\0')
+ return (0);
+ switch (*ddata->cur) {
+ case 'n':
+ if (!DEM_PUSH_STR(ddata, "non-transaction clone for "))
+ return (0);
+ break;
+ case 't':
+ default:
+ if (!DEM_PUSH_STR(ddata, "transaction clone for "))
+ return (0);
+ break;
+ }
+ ++ddata->cur;
+ return (cpp_demangle_read_encoding(ddata));
+
+ case SIMPLE_HASH('G', 'V'):
+ /* sentry object for 1 time init */
+ if (!DEM_PUSH_STR(ddata, "guard variable for "))
+ return (0);
+ ddata->cur += 2;
+ break;
+
+ case SIMPLE_HASH('T', 'c'):
+ /* virtual function covariant override thunk */
+ if (!DEM_PUSH_STR(ddata,
+ "virtual function covariant override "))
+ return (0);
+ ddata->cur += 2;
+ if (*ddata->cur == '\0')
+ return (0);
+ if (!cpp_demangle_read_offset(ddata))
+ return (0);
+ if (!cpp_demangle_read_offset(ddata))
+ return (0);
+ return (cpp_demangle_read_encoding(ddata));
+
+ case SIMPLE_HASH('T', 'C'):
+ /* construction vtable */
+ if (!DEM_PUSH_STR(ddata, "construction vtable for "))
+ return (0);
+ ddata->cur += 2;
+ if (*ddata->cur == '\0')
+ return (0);
+ if (!cpp_demangle_read_type_flat(ddata, &type))
+ return (0);
+ rtn = 0;
+ if (!cpp_demangle_read_number(ddata, &offset))
+ goto clean3;
+ if (*ddata->cur++ != '_')
+ goto clean3;
+ if (!cpp_demangle_read_type(ddata, NULL))
+ goto clean3;
+ if (!DEM_PUSH_STR(ddata, "-in-"))
+ goto clean3;
+ if (!DEM_PUSH_STR(ddata, type))
+ goto clean3;
+ rtn = 1;
+ clean3:
+ free(type);
+ return (rtn);
+
+ case SIMPLE_HASH('T', 'D'):
+ /* typeinfo common proxy */
+ break;
+
+ case SIMPLE_HASH('T', 'F'):
+ /* typeinfo fn */
+ if (!DEM_PUSH_STR(ddata, "typeinfo fn for "))
+ return (0);
+ ddata->cur += 2;
+ if (*ddata->cur == '\0')
+ return (0);
+ return (cpp_demangle_read_type(ddata, NULL));
+
+ case SIMPLE_HASH('T', 'h'):
+ /* virtual function non-virtual override thunk */
+ if (!DEM_PUSH_STR(ddata,
+ "virtual function non-virtual override "))
+ return (0);
+ ddata->cur += 2;
+ if (*ddata->cur == '\0')
+ return (0);
+ if (!cpp_demangle_read_nv_offset(ddata))
+ return (0);
+ return (cpp_demangle_read_encoding(ddata));
+
+ case SIMPLE_HASH('T', 'H'):
+ /* TLS init function */
+ if (!DEM_PUSH_STR(ddata, "TLS init function for "))
+ return (0);
+ ddata->cur += 2;
+ if (*ddata->cur == '\0')
+ return (0);
+ break;
+
+ case SIMPLE_HASH('T', 'I'):
+ /* typeinfo structure */
+ if (!DEM_PUSH_STR(ddata, "typeinfo for "))
+ return (0);
+ ddata->cur += 2;
+ if (*ddata->cur == '\0')
+ return (0);
+ return (cpp_demangle_read_type(ddata, NULL));
+
+ case SIMPLE_HASH('T', 'J'):
+ /* java class */
+ if (!DEM_PUSH_STR(ddata, "java Class for "))
+ return (0);
+ ddata->cur += 2;
+ if (*ddata->cur == '\0')
+ return (0);
+ return (cpp_demangle_read_type(ddata, NULL));
+
+ case SIMPLE_HASH('T', 'S'):
+ /* RTTI name (NTBS) */
+ if (!DEM_PUSH_STR(ddata, "typeinfo name for "))
+ return (0);
+ ddata->cur += 2;
+ if (*ddata->cur == '\0')
+ return (0);
+ return (cpp_demangle_read_type(ddata, NULL));
+
+ case SIMPLE_HASH('T', 'T'):
+ /* VTT table */
+ if (!DEM_PUSH_STR(ddata, "VTT for "))
+ return (0);
+ ddata->cur += 2;
+ if (*ddata->cur == '\0')
+ return (0);
+ return (cpp_demangle_read_type(ddata, NULL));
+
+ case SIMPLE_HASH('T', 'v'):
+ /* virtual function virtual override thunk */
+ if (!DEM_PUSH_STR(ddata, "virtual function virtual override "))
+ return (0);
+ ddata->cur += 2;
+ if (*ddata->cur == '\0')
+ return (0);
+ if (!cpp_demangle_read_v_offset(ddata))
+ return (0);
+ return (cpp_demangle_read_encoding(ddata));
+
+ case SIMPLE_HASH('T', 'V'):
+ /* virtual table */
+ if (!DEM_PUSH_STR(ddata, "vtable for "))
+ return (0);
+ ddata->cur += 2;
+ if (*ddata->cur == '\0')
+ return (0);
+ return (cpp_demangle_read_type(ddata, NULL));
+
+ case SIMPLE_HASH('T', 'W'):
+ /* TLS wrapper function */
+ if (!DEM_PUSH_STR(ddata, "TLS wrapper function for "))
+ return (0);
+ ddata->cur += 2;
+ if (*ddata->cur == '\0')
+ return (0);
+ break;
+ }
+
+ return (cpp_demangle_read_name(ddata));
+}
+
+static int
+cpp_demangle_read_local_name(struct cpp_demangle_data *ddata)
+{
+ struct vector_str local_name;
+ struct type_delimit td;
+ size_t limit;
+ bool more_type;
+
+ if (ddata == NULL)
+ return (0);
+ if (*(++ddata->cur) == '\0')
+ return (0);
+
+ vector_str_init(&local_name);
+ ddata->cur_output = &local_name;
+
+ if (!cpp_demangle_read_encoding(ddata)) {
+ vector_str_dest(&local_name);
+ return (0);
+ }
+
+ ddata->cur_output = &ddata->output;
+
+ td.paren = false;
+ td.firstp = true;
+ more_type = false;
+ limit = 0;
+
+ /*
+ * The first type is a return type if we just demangled template
+ * args. (the template args is right next to the function name,
+ * which means it's a template function)
+ */
+ if (ddata->is_tmpl) {
+ ddata->is_tmpl = false;
+
+ /* Read return type */
+ if (!cpp_demangle_read_type(ddata, NULL)) {
+ vector_str_dest(&local_name);
+ return (0);
+ }
+
+ more_type = true;
+ }
+
+ /* Now we can push the name after possible return type is handled. */
+ if (!vector_str_push_vector(&ddata->output, &local_name)) {
+ vector_str_dest(&local_name);
+ return (0);
+ }
+ vector_str_dest(&local_name);
+
+ while (*ddata->cur != '\0') {
+ if (!cpp_demangle_read_type(ddata, &td))
+ return (0);
+ if (more_type)
+ more_type = false;
+ if (*ddata->cur == 'E')
+ break;
+ if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
+ return (0);
+ }
+ if (more_type)
+ return (0);
+
+ if (*(++ddata->cur) == '\0')
+ return (0);
+ if (td.paren == true) {
+ if (!DEM_PUSH_STR(ddata, ")"))
+ return (0);
+ td.paren = false;
+ }
+ if (*ddata->cur == 's')
+ ++ddata->cur;
+ else {
+ if (!DEM_PUSH_STR(ddata, "::"))
+ return (0);
+ if (!cpp_demangle_read_name(ddata))
+ return (0);
+ }
+ if (*ddata->cur == '_') {
+ ++ddata->cur;
+ while (ELFTC_ISDIGIT(*ddata->cur) != 0)
+ ++ddata->cur;
+ }
+
+ return (1);
+}
+
+static int
+cpp_demangle_read_name(struct cpp_demangle_data *ddata)
+{
+ struct vector_str *output, v;
+ size_t p_idx, subst_str_len;
+ int rtn;
+ char *subst_str;
+
+ if (ddata == NULL || *ddata->cur == '\0')
+ return (0);
+
+ output = ddata->cur_output;
+
+ subst_str = NULL;
+
+ switch (*ddata->cur) {
+ case 'S':
+ return (cpp_demangle_read_subst(ddata));
+ case 'N':
+ return (cpp_demangle_read_nested_name(ddata));
+ case 'Z':
+ return (cpp_demangle_read_local_name(ddata));
+ }
+
+ if (!vector_str_init(&v))
+ return (0);
+
+ p_idx = output->size;
+ rtn = 0;
+ if (!cpp_demangle_read_uqname(ddata))
+ goto clean;
+ if ((subst_str = vector_str_substr(output, p_idx, output->size - 1,
+ &subst_str_len)) == NULL)
+ goto clean;
+ if (subst_str_len > 8 && strstr(subst_str, "operator") != NULL) {
+ rtn = 1;
+ goto clean;
+ }
+ if (!vector_str_push(&v, subst_str, subst_str_len))
+ goto clean;
+ if (!cpp_demangle_push_subst_v(ddata, &v))
+ goto clean;
+
+ if (*ddata->cur == 'I') {
+ p_idx = output->size;
+ if (!cpp_demangle_read_tmpl_args(ddata))
+ goto clean;
+ free(subst_str);
+ if ((subst_str = vector_str_substr(output, p_idx,
+ output->size - 1, &subst_str_len)) == NULL)
+ goto clean;
+ if (!vector_str_push(&v, subst_str, subst_str_len))
+ goto clean;
+ if (!cpp_demangle_push_subst_v(ddata, &v))
+ goto clean;
+ }
+
+ rtn = 1;
+
+clean:
+ free(subst_str);
+ vector_str_dest(&v);
+
+ return (rtn);
+}
+
+static int
+cpp_demangle_read_name_flat(struct cpp_demangle_data *ddata, char **str)
+{
+ struct vector_str *output;
+ size_t i, p_idx, idx, name_len;
+ char *name;
+
+ output = ddata->cur_output;
+
+ p_idx = output->size;
+
+ if (!cpp_demangle_read_name(ddata))
+ return (0);
+
+ if ((name = vector_str_substr(output, p_idx, output->size - 1,
+ &name_len)) == NULL)
+ return (0);
+
+ idx = output->size;
+ for (i = p_idx; i < idx; ++i) {
+ if (!vector_str_pop(output)) {
+ free(name);
+ return (0);
+ }
+ }
+
+ *str = name;
+
+ return (1);
+}
+
+static int
+cpp_demangle_read_nested_name(struct cpp_demangle_data *ddata)
+{
+ struct vector_str *output, v;
+ size_t limit, p_idx, subst_str_len;
+ int rtn;
+ char *subst_str;
+
+ if (ddata == NULL || *ddata->cur != 'N')
+ return (0);
+ if (*(++ddata->cur) == '\0')
+ return (0);
+
+ do {
+ switch (*ddata->cur) {
+ case 'r':
+ ddata->mem_rst = true;
+ break;
+ case 'V':
+ ddata->mem_vat = true;
+ break;
+ case 'K':
+ ddata->mem_cst = true;
+ break;
+ case 'R':
+ ddata->mem_ref = true;
+ break;
+ case 'O':
+ ddata->mem_rref = true;
+ break;
+ default:
+ goto next;
+ }
+ } while (*(++ddata->cur));
+
+next:
+ output = ddata->cur_output;
+ if (!vector_str_init(&v))
+ return (0);
+
+ rtn = 0;
+ limit = 0;
+ for (;;) {
+ p_idx = output->size;
+ switch (*ddata->cur) {
+ case 'I':
+ if (!cpp_demangle_read_tmpl_args(ddata))
+ goto clean;
+ break;
+ case 'S':
+ if (!cpp_demangle_read_subst(ddata))
+ goto clean;
+ break;
+ case 'T':
+ if (!cpp_demangle_read_tmpl_param(ddata))
+ goto clean;
+ break;
+ default:
+ if (!cpp_demangle_read_uqname(ddata))
+ goto clean;
+ }
+
+ if (p_idx == output->size)
+ goto next_comp;
+ if ((subst_str = vector_str_substr(output, p_idx,
+ output->size - 1, &subst_str_len)) == NULL)
+ goto clean;
+ if (!vector_str_push(&v, subst_str, subst_str_len)) {
+ free(subst_str);
+ goto clean;
+ }
+ free(subst_str);
+
+ if (!cpp_demangle_push_subst_v(ddata, &v))
+ goto clean;
+
+ next_comp:
+ if (*ddata->cur == 'E')
+ break;
+ else if (*ddata->cur != 'I' && *ddata->cur != 'C' &&
+ *ddata->cur != 'D' && p_idx != output->size) {
+ if (!DEM_PUSH_STR(ddata, "::"))
+ goto clean;
+ if (!VEC_PUSH_STR(&v, "::"))
+ goto clean;
+ }
+ if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
+ goto clean;
+ }
+
+ ++ddata->cur;
+ rtn = 1;
+
+clean:
+ vector_str_dest(&v);
+
+ return (rtn);
+}
+
+/*
+ * read number
+ * number ::= [n] <decimal>
+ */
+static int
+cpp_demangle_read_number(struct cpp_demangle_data *ddata, long *rtn)
+{
+ long len, negative_factor;
+
+ if (ddata == NULL || rtn == NULL)
+ return (0);
+
+ negative_factor = 1;
+ if (*ddata->cur == 'n') {
+ negative_factor = -1;
+
+ ++ddata->cur;
+ }
+ if (ELFTC_ISDIGIT(*ddata->cur) == 0)
+ return (0);
+
+ errno = 0;
+ if ((len = strtol(ddata->cur, (char **) NULL, 10)) == 0 &&
+ errno != 0)
+ return (0);
+
+ while (ELFTC_ISDIGIT(*ddata->cur) != 0)
+ ++ddata->cur;
+
+ assert(len >= 0);
+ assert(negative_factor == 1 || negative_factor == -1);
+
+ *rtn = len * negative_factor;
+
+ return (1);
+}
+
+static int
+cpp_demangle_read_number_as_string(struct cpp_demangle_data *ddata, char **str)
+{
+ long n;
+
+ if (!cpp_demangle_read_number(ddata, &n)) {
+ *str = NULL;
+ return (0);
+ }
+
+ if (asprintf(str, "%ld", n) < 0) {
+ *str = NULL;
+ return (0);
+ }
+
+ return (1);
+}
+
+static int
+cpp_demangle_read_nv_offset(struct cpp_demangle_data *ddata)
+{
+
+ if (ddata == NULL)
+ return (0);
+
+ if (!DEM_PUSH_STR(ddata, "offset : "))
+ return (0);
+
+ return (cpp_demangle_read_offset_number(ddata));
+}
+
+/* read offset, offset are nv-offset, v-offset */
+static int
+cpp_demangle_read_offset(struct cpp_demangle_data *ddata)
+{
+
+ if (ddata == NULL)
+ return (0);
+
+ if (*ddata->cur == 'h') {
+ ++ddata->cur;
+ return (cpp_demangle_read_nv_offset(ddata));
+ } else if (*ddata->cur == 'v') {
+ ++ddata->cur;
+ return (cpp_demangle_read_v_offset(ddata));
+ }
+
+ return (0);
+}
+
+static int
+cpp_demangle_read_offset_number(struct cpp_demangle_data *ddata)
+{
+ bool negative;
+ const char *start;
+
+ if (ddata == NULL || *ddata->cur == '\0')
+ return (0);
+
+ /* offset could be negative */
+ if (*ddata->cur == 'n') {
+ negative = true;
+ start = ddata->cur + 1;
+ } else {
+ negative = false;
+ start = ddata->cur;
+ }
+
+ while (*ddata->cur != '_')
+ ++ddata->cur;
+
+ if (negative && !DEM_PUSH_STR(ddata, "-"))
+ return (0);
+
+ assert(start != NULL);
+
+ if (!cpp_demangle_push_str(ddata, start, ddata->cur - start))
+ return (0);
+ if (!DEM_PUSH_STR(ddata, " "))
+ return (0);
+
+ ++ddata->cur;
+
+ return (1);
+}
+
+static int
+cpp_demangle_read_pointer_to_member(struct cpp_demangle_data *ddata,
+ struct vector_type_qualifier *v)
+{
+ size_t class_type_len, i, idx, p_idx;
+ int p_func_type, rtn;
+ char *class_type;
+
+ if (ddata == NULL || *ddata->cur != 'M' || *(++ddata->cur) == '\0')
+ return (0);
+
+ p_idx = ddata->output.size;
+ if (!cpp_demangle_read_type(ddata, NULL))
+ return (0);
+
+ if ((class_type = vector_str_substr(&ddata->output, p_idx,
+ ddata->output.size - 1, &class_type_len)) == NULL)
+ return (0);
+
+ rtn = 0;
+ idx = ddata->output.size;
+ for (i = p_idx; i < idx; ++i)
+ if (!vector_str_pop(&ddata->output))
+ goto clean1;
+
+ if (!vector_read_cmd_push(&ddata->cmd, READ_PTRMEM, v))
+ goto clean1;
+
+ if (!vector_str_push(&ddata->class_type, class_type, class_type_len))
+ goto clean2;
+
+ p_func_type = ddata->func_type;
+ if (!cpp_demangle_read_type(ddata, NULL))
+ goto clean3;
+
+ if (p_func_type == ddata->func_type) {
+ if (!DEM_PUSH_STR(ddata, " "))
+ goto clean3;
+ if (!cpp_demangle_push_str(ddata, class_type, class_type_len))
+ goto clean3;
+ if (!DEM_PUSH_STR(ddata, "::*"))
+ goto clean3;
+ }
+
+ rtn = 1;
+clean3:
+ if (!vector_str_pop(&ddata->class_type))
+ rtn = 0;
+clean2:
+ if (!vector_read_cmd_pop(&ddata->cmd))
+ rtn = 0;
+clean1:
+ free(class_type);
+
+ vector_type_qualifier_dest(v);
+ if (!vector_type_qualifier_init(v))
+ return (0);
+
+ return (rtn);
+}
+
+/* read source-name, source-name is <len> <ID> */
+static int
+cpp_demangle_read_sname(struct cpp_demangle_data *ddata)
+{
+ long len;
+ int err;
+
+ if (ddata == NULL || cpp_demangle_read_number(ddata, &len) == 0 ||
+ len <= 0)
+ return (0);
+
+ if (len == 12 && (memcmp("_GLOBAL__N_1", ddata->cur, 12) == 0))
+ err = DEM_PUSH_STR(ddata, "(anonymous namespace)");
+ else
+ err = cpp_demangle_push_str(ddata, ddata->cur, len);
+
+ if (err == 0)
+ return (0);
+
+ assert(ddata->output.size > 0);
+ if (vector_read_cmd_find(&ddata->cmd, READ_TMPL) == NULL)
+ ddata->last_sname =
+ ddata->output.container[ddata->output.size - 1];
+
+ ddata->cur += len;
+
+ return (1);
+}
+
+static int
+cpp_demangle_read_subst(struct cpp_demangle_data *ddata)
+{
+ long nth;
+
+ if (ddata == NULL || *ddata->cur == '\0')
+ return (0);
+
+ /* abbreviations of the form Sx */
+ switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
+ case SIMPLE_HASH('S', 'a'):
+ /* std::allocator */
+ if (!DEM_PUSH_STR(ddata, "std::allocator"))
+ return (0);
+ ddata->cur += 2;
+ if (*ddata->cur == 'I')
+ return (cpp_demangle_read_subst_stdtmpl(ddata,
+ "std::allocator"));
+ return (1);
+
+ case SIMPLE_HASH('S', 'b'):
+ /* std::basic_string */
+ if (!DEM_PUSH_STR(ddata, "std::basic_string"))
+ return (0);
+ ddata->cur += 2;
+ if (*ddata->cur == 'I')
+ return (cpp_demangle_read_subst_stdtmpl(ddata,
+ "std::basic_string"));
+ return (1);
+
+ case SIMPLE_HASH('S', 'd'):
+ /* std::basic_iostream<char, std::char_traits<char> > */
+ if (!DEM_PUSH_STR(ddata, "std::basic_iostream<char, "
+ "std::char_traits<char> >"))
+ return (0);
+ ddata->last_sname = "basic_iostream";
+ ddata->cur += 2;
+ if (*ddata->cur == 'I')
+ return (cpp_demangle_read_subst_stdtmpl(ddata,
+ "std::basic_iostream<char, std::char_traits"
+ "<char> >"));
+ return (1);
+
+ case SIMPLE_HASH('S', 'i'):
+ /* std::basic_istream<char, std::char_traits<char> > */
+ if (!DEM_PUSH_STR(ddata, "std::basic_istream<char, "
+ "std::char_traits<char> >"))
+ return (0);
+ ddata->last_sname = "basic_istream";
+ ddata->cur += 2;
+ if (*ddata->cur == 'I')
+ return (cpp_demangle_read_subst_stdtmpl(ddata,
+ "std::basic_istream<char, std::char_traits"
+ "<char> >"));
+ return (1);
+
+ case SIMPLE_HASH('S', 'o'):
+ /* std::basic_ostream<char, std::char_traits<char> > */
+ if (!DEM_PUSH_STR(ddata, "std::basic_ostream<char, "
+ "std::char_traits<char> >"))
+ return (0);
+ ddata->last_sname = "basic_ostream";
+ ddata->cur += 2;
+ if (*ddata->cur == 'I')
+ return (cpp_demangle_read_subst_stdtmpl(ddata,
+ "std::basic_ostream<char, std::char_traits"
+ "<char> >"));
+ return (1);
+
+ case SIMPLE_HASH('S', 's'):
+ /*
+ * std::basic_string<char, std::char_traits<char>,
+ * std::allocator<char> >
+ *
+ * a.k.a std::string
+ */
+ if (!DEM_PUSH_STR(ddata, "std::basic_string<char, "
+ "std::char_traits<char>, std::allocator<char> >"))
+ return (0);
+ ddata->last_sname = "string";
+ ddata->cur += 2;
+ if (*ddata->cur == 'I')
+ return (cpp_demangle_read_subst_stdtmpl(ddata,
+ "std::basic_string<char, std::char_traits<char>,"
+ " std::allocator<char> >"));
+ return (1);
+
+ case SIMPLE_HASH('S', 't'):
+ /* std:: */
+ return (cpp_demangle_read_subst_std(ddata));
+ }
+
+ if (*(++ddata->cur) == '\0')
+ return (0);
+
+ /* Skip unknown substitution abbreviations. */
+ if (!(*ddata->cur >= '0' && *ddata->cur <= '9') &&
+ !(*ddata->cur >= 'A' && *ddata->cur <= 'Z') &&
+ *ddata->cur != '_') {
+ ++ddata->cur;
+ return (1);
+ }
+
+ /* substitution */
+ if (*ddata->cur == '_')
+ return (cpp_demangle_get_subst(ddata, 0));
+ else {
+ errno = 0;
+ /* substitution number is base 36 */
+ if ((nth = strtol(ddata->cur, (char **) NULL, 36)) == 0 &&
+ errno != 0)
+ return (0);
+
+ /* first was '_', so increase one */
+ ++nth;
+
+ while (*ddata->cur != '_')
+ ++ddata->cur;
+
+ assert(nth > 0);
+
+ return (cpp_demangle_get_subst(ddata, nth));
+ }
+
+ /* NOTREACHED */
+ return (0);
+}
+
+static int
+cpp_demangle_read_subst_std(struct cpp_demangle_data *ddata)
+{
+ struct vector_str *output, v;
+ size_t p_idx, subst_str_len;
+ int rtn;
+ char *subst_str;
+
+ if (ddata == NULL)
+ return (0);
+
+ if (!vector_str_init(&v))
+ return (0);
+
+ subst_str = NULL;
+ rtn = 0;
+ if (!DEM_PUSH_STR(ddata, "std::"))
+ goto clean;
+
+ if (!VEC_PUSH_STR(&v, "std::"))
+ goto clean;
+
+ ddata->cur += 2;
+
+ output = ddata->cur_output;
+
+ p_idx = output->size;
+ if (!cpp_demangle_read_uqname(ddata))
+ goto clean;
+
+ if ((subst_str = vector_str_substr(output, p_idx, output->size - 1,
+ &subst_str_len)) == NULL)
+ goto clean;
+
+ if (!vector_str_push(&v, subst_str, subst_str_len))
+ goto clean;
+
+ if (!cpp_demangle_push_subst_v(ddata, &v))
+ goto clean;
+
+ if (*ddata->cur == 'I') {
+ p_idx = output->size;
+ if (!cpp_demangle_read_tmpl_args(ddata))
+ goto clean;
+ free(subst_str);
+ if ((subst_str = vector_str_substr(output, p_idx,
+ output->size - 1, &subst_str_len)) == NULL)
+ goto clean;
+ if (!vector_str_push(&v, subst_str, subst_str_len))
+ goto clean;
+ if (!cpp_demangle_push_subst_v(ddata, &v))
+ goto clean;
+ }
+
+ rtn = 1;
+clean:
+ free(subst_str);
+ vector_str_dest(&v);
+
+ return (rtn);
+}
+
+static int
+cpp_demangle_read_subst_stdtmpl(struct cpp_demangle_data *ddata,
+ const char *str)
+{
+ struct vector_str *output;
+ size_t p_idx, substr_len, len;
+ int rtn;
+ char *subst_str, *substr;
+
+ if (ddata == NULL || str == NULL)
+ return (0);
+
+ if ((len = strlen(str)) == 0)
+ return (0);
+
+ output = ddata->cur_output;
+
+ p_idx = output->size;
+ substr = NULL;
+ subst_str = NULL;
+
+ if (!cpp_demangle_read_tmpl_args(ddata))
+ return (0);
+ if ((substr = vector_str_substr(output, p_idx, output->size - 1,
+ &substr_len)) == NULL)
+ return (0);
+
+ rtn = 0;
+ if ((subst_str = malloc(sizeof(char) * (substr_len + len + 1))) ==
+ NULL)
+ goto clean;
+
+ memcpy(subst_str, str, len);
+ memcpy(subst_str + len, substr, substr_len);
+ subst_str[substr_len + len] = '\0';
+
+ if (!cpp_demangle_push_subst(ddata, subst_str, substr_len + len))
+ goto clean;
+
+ rtn = 1;
+clean:
+ free(subst_str);
+ free(substr);
+
+ return (rtn);
+}
+
+static int
+cpp_demangle_read_tmpl_arg(struct cpp_demangle_data *ddata)
+{
+
+ if (ddata == NULL || *ddata->cur == '\0')
+ return (0);
+
+ switch (*ddata->cur) {
+ case 'L':
+ return (cpp_demangle_read_expr_primary(ddata));
+ case 'X':
+ ++ddata->cur;
+ if (!cpp_demangle_read_expression(ddata))
+ return (0);
+ return (*ddata->cur++ == 'E');
+ }
+
+ return (cpp_demangle_read_type(ddata, NULL));
+}
+
+static int
+cpp_demangle_read_tmpl_args(struct cpp_demangle_data *ddata)
+{
+ struct vector_str *v;
+ size_t arg_len, idx, limit, size;
+ char *arg;
+
+ if (ddata == NULL || *ddata->cur == '\0')
+ return (0);
+
+ ++ddata->cur;
+
+ if (!vector_read_cmd_push(&ddata->cmd, READ_TMPL, NULL))
+ return (0);
+
+ if (!DEM_PUSH_STR(ddata, "<"))
+ return (0);
+
+ limit = 0;
+ v = &ddata->output;
+ for (;;) {
+ idx = v->size;
+ if (!cpp_demangle_read_tmpl_arg(ddata))
+ return (0);
+ if ((arg = vector_str_substr(v, idx, v->size - 1, &arg_len)) ==
+ NULL)
+ return (0);
+ if (!vector_str_find(&ddata->tmpl, arg, arg_len) &&
+ !vector_str_push(&ddata->tmpl, arg, arg_len)) {
+ free(arg);
+ return (0);
+ }
+
+ free(arg);
+
+ if (*ddata->cur == 'E') {
+ ++ddata->cur;
+ size = v->size;
+ assert(size > 0);
+ if (!strncmp(v->container[size - 1], ">", 1)) {
+ if (!DEM_PUSH_STR(ddata, " >"))
+ return (0);
+ } else if (!DEM_PUSH_STR(ddata, ">"))
+ return (0);
+ ddata->is_tmpl = true;
+ break;
+ } else if (*ddata->cur != 'I' &&
+ !DEM_PUSH_STR(ddata, ", "))
+ return (0);
+
+ if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
+ return (0);
+ }
+
+ return (vector_read_cmd_pop(&ddata->cmd));
+}
+
+/*
+ * Read template parameter that forms in 'T[number]_'.
+ * This function much like to read_subst but only for types.
+ */
+static int
+cpp_demangle_read_tmpl_param(struct cpp_demangle_data *ddata)
+{
+ long nth;
+
+ if (ddata == NULL || *ddata->cur != 'T')
+ return (0);
+
+ ++ddata->cur;
+
+ if (*ddata->cur == '_')
+ return (cpp_demangle_get_tmpl_param(ddata, 0));
+ else {
+
+ errno = 0;
+ if ((nth = strtol(ddata->cur, (char **) NULL, 36)) == 0 &&
+ errno != 0)
+ return (0);
+
+ /* T_ is first */
+ ++nth;
+
+ while (*ddata->cur != '_')
+ ++ddata->cur;
+
+ assert(nth > 0);
+
+ return (cpp_demangle_get_tmpl_param(ddata, nth));
+ }
+
+ /* NOTREACHED */
+ return (0);
+}
+
+static int
+cpp_demangle_read_type(struct cpp_demangle_data *ddata,
+ struct type_delimit *td)
+{
+ struct vector_type_qualifier v;
+ struct vector_str *output, sv;
+ size_t p_idx, type_str_len, subst_str_len;
+ int extern_c, is_builtin;
+ long len;
+ const char *p;
+ char *type_str, *exp_str, *num_str, *subst_str;
+ bool skip_ref_qualifier, omit_void;
+
+ if (ddata == NULL)
+ return (0);
+
+ output = ddata->cur_output;
+ if (td) {
+ if (td->paren == false) {
+ if (!DEM_PUSH_STR(ddata, "("))
+ return (0);
+ if (ddata->output.size < 2)
+ return (0);
+ td->paren = true;
+ }
+
+ if (!td->firstp) {
+ if (*ddata->cur != 'I') {
+ if (!DEM_PUSH_STR(ddata, ", "))
+ return (0);
+ }
+ }
+ }
+
+ assert(output != NULL);
+ /*
+ * [r, V, K] [P, R, O, C, G, U] builtin, function, class-enum, array
+ * pointer-to-member, template-param, template-template-param, subst
+ */
+
+ if (!vector_type_qualifier_init(&v))
+ return (0);
+
+ extern_c = 0;
+ is_builtin = 1;
+ p_idx = output->size;
+ type_str = exp_str = num_str = NULL;
+ skip_ref_qualifier = false;
+
+again:
+
+ /* Clear ref-qualifier flag */
+ if (*ddata->cur != 'R' && *ddata->cur != 'O' && *ddata->cur != 'E')
+ ddata->ref_qualifier = false;
+
+ /* builtin type */
+ switch (*ddata->cur) {
+ case 'a':
+ /* signed char */
+ if (!DEM_PUSH_STR(ddata, "signed char"))
+ goto clean;
+ ++ddata->cur;
+ goto rtn;
+
+ case 'A':
+ /* array type */
+ if (!cpp_demangle_read_array(ddata))
+ goto clean;
+ is_builtin = 0;
+ goto rtn;
+
+ case 'b':
+ /* bool */
+ if (!DEM_PUSH_STR(ddata, "bool"))
+ goto clean;
+ ++ddata->cur;
+ goto rtn;
+
+ case 'C':
+ /* complex pair */
+ if (!vector_type_qualifier_push(&v, TYPE_CMX))
+ goto clean;
+ ++ddata->cur;
+ if (td)
+ td->firstp = false;
+ goto again;
+
+ case 'c':
+ /* char */
+ if (!DEM_PUSH_STR(ddata, "char"))
+ goto clean;
+ ++ddata->cur;
+ goto rtn;
+
+ case 'd':
+ /* double */
+ if (!DEM_PUSH_STR(ddata, "double"))
+ goto clean;
+ ++ddata->cur;
+ goto rtn;
+
+ case 'D':
+ ++ddata->cur;
+ switch (*ddata->cur) {
+ case 'a':
+ /* auto */
+ if (!DEM_PUSH_STR(ddata, "auto"))
+ goto clean;
+ ++ddata->cur;
+ break;
+ case 'c':
+ /* decltype(auto) */
+ if (!DEM_PUSH_STR(ddata, "decltype(auto)"))
+ goto clean;
+ ++ddata->cur;
+ break;
+ case 'd':
+ /* IEEE 754r decimal floating point (64 bits) */
+ if (!DEM_PUSH_STR(ddata, "decimal64"))
+ goto clean;
+ ++ddata->cur;
+ break;
+ case 'e':
+ /* IEEE 754r decimal floating point (128 bits) */
+ if (!DEM_PUSH_STR(ddata, "decimal128"))
+ goto clean;
+ ++ddata->cur;
+ break;
+ case 'f':
+ /* IEEE 754r decimal floating point (32 bits) */
+ if (!DEM_PUSH_STR(ddata, "decimal32"))
+ goto clean;
+ ++ddata->cur;
+ break;
+ case 'h':
+ /* IEEE 754r half-precision floating point (16 bits) */
+ if (!DEM_PUSH_STR(ddata, "half"))
+ goto clean;
+ ++ddata->cur;
+ break;
+ case 'i':
+ /* char32_t */
+ if (!DEM_PUSH_STR(ddata, "char32_t"))
+ goto clean;
+ ++ddata->cur;
+ break;
+ case 'n':
+ /* std::nullptr_t (i.e., decltype(nullptr)) */
+ if (!DEM_PUSH_STR(ddata, "decltype(nullptr)"))
+ goto clean;
+ ++ddata->cur;
+ break;
+ case 's':
+ /* char16_t */
+ if (!DEM_PUSH_STR(ddata, "char16_t"))
+ goto clean;
+ ++ddata->cur;
+ break;
+ case 'v':
+ /* gcc vector_size extension. */
+ ++ddata->cur;
+ if (*ddata->cur == '_') {
+ ++ddata->cur;
+ if (!cpp_demangle_read_expression_flat(ddata,
+ &exp_str))
+ goto clean;
+ if (!VEC_PUSH_STR(&v.ext_name, exp_str))
+ goto clean;
+ } else {
+ if (!cpp_demangle_read_number_as_string(ddata,
+ &num_str))
+ goto clean;
+ if (!VEC_PUSH_STR(&v.ext_name, num_str))
+ goto clean;
+ }
+ if (*ddata->cur != '_')
+ goto clean;
+ ++ddata->cur;
+ if (!vector_type_qualifier_push(&v, TYPE_VEC))
+ goto clean;
+ if (td)
+ td->firstp = false;
+ goto again;
+ default:
+ goto clean;
+ }
+ goto rtn;
+
+ case 'e':
+ /* long double */
+ if (!DEM_PUSH_STR(ddata, "long double"))
+ goto clean;
+ ++ddata->cur;
+ goto rtn;
+
+ case 'E':
+ /* unexpected end except ref-qualifiers */
+ if (ddata->ref_qualifier && ddata->is_functype) {
+ skip_ref_qualifier = true;
+ /* Pop the delimiter. */
+ cpp_demangle_pop_str(ddata);
+ goto rtn;
+ }
+ goto clean;
+
+ case 'f':
+ /* float */
+ if (!DEM_PUSH_STR(ddata, "float"))
+ goto clean;
+ ++ddata->cur;
+ goto rtn;
+
+ case 'F':
+ /* function */
+ if (!cpp_demangle_read_function(ddata, &extern_c, &v))
+ goto clean;
+ is_builtin = 0;
+ goto rtn;
+
+ case 'g':
+ /* __float128 */
+ if (!DEM_PUSH_STR(ddata, "__float128"))
+ goto clean;
+ ++ddata->cur;
+ goto rtn;
+
+ case 'G':
+ /* imaginary */
+ if (!vector_type_qualifier_push(&v, TYPE_IMG))
+ goto clean;
+ ++ddata->cur;
+ if (td)
+ td->firstp = false;
+ goto again;
+
+ case 'h':
+ /* unsigned char */
+ if (!DEM_PUSH_STR(ddata, "unsigned char"))
+ goto clean;
+ ++ddata->cur;
+ goto rtn;
+
+ case 'i':
+ /* int */
+ if (!DEM_PUSH_STR(ddata, "int"))
+ goto clean;
+ ++ddata->cur;
+ goto rtn;
+
+ case 'I':
+ /* template args. */
+ /* handles <substitute><template-args> */
+ p_idx = output->size;
+ if (!cpp_demangle_read_tmpl_args(ddata))
+ goto clean;
+ if ((subst_str = vector_str_substr(output, p_idx,
+ output->size - 1, &subst_str_len)) == NULL)
+ goto clean;
+ if (!vector_str_init(&sv)) {
+ free(subst_str);
+ goto clean;
+ }
+ if (!vector_str_push(&sv, subst_str, subst_str_len)) {
+ free(subst_str);
+ vector_str_dest(&sv);
+ goto clean;
+ }
+ free(subst_str);
+ if (!cpp_demangle_push_subst_v(ddata, &sv)) {
+ vector_str_dest(&sv);
+ goto clean;
+ }
+ vector_str_dest(&sv);
+ goto rtn;
+
+ case 'j':
+ /* unsigned int */
+ if (!DEM_PUSH_STR(ddata, "unsigned int"))
+ goto clean;
+ ++ddata->cur;
+ goto rtn;
+
+ case 'K':
+ /* const */
+ if (!vector_type_qualifier_push(&v, TYPE_CST))
+ goto clean;
+ ++ddata->cur;
+ if (td)
+ td->firstp = false;
+ goto again;
+
+ case 'l':
+ /* long */
+ if (!DEM_PUSH_STR(ddata, "long"))
+ goto clean;
+ ++ddata->cur;
+ goto rtn;
+
+ case 'm':
+ /* unsigned long */
+ if (!DEM_PUSH_STR(ddata, "unsigned long"))
+ goto clean;
+
+ ++ddata->cur;
+
+ goto rtn;
+ case 'M':
+ /* pointer to member */
+ if (!cpp_demangle_read_pointer_to_member(ddata, &v))
+ goto clean;
+ is_builtin = 0;
+ goto rtn;
+
+ case 'n':
+ /* __int128 */
+ if (!DEM_PUSH_STR(ddata, "__int128"))
+ goto clean;
+ ++ddata->cur;
+ goto rtn;
+
+ case 'o':
+ /* unsigned __int128 */
+ if (!DEM_PUSH_STR(ddata, "unsigned __int128"))
+ goto clean;
+ ++ddata->cur;
+ goto rtn;
+
+ case 'O':
+ /* rvalue reference */
+ if (ddata->ref_qualifier)
+ goto clean;
+ if (!vector_type_qualifier_push(&v, TYPE_RREF))
+ goto clean;
+ ddata->ref_qualifier = true;
+ ddata->ref_qualifier_type = TYPE_RREF;
+ ++ddata->cur;
+ if (td)
+ td->firstp = false;
+ goto again;
+
+ case 'P':
+ /* pointer */
+ if (!vector_type_qualifier_push(&v, TYPE_PTR))
+ goto clean;
+ ++ddata->cur;
+ if (td)
+ td->firstp = false;
+ goto again;
+
+ case 'r':
+ /* restrict */
+ if (!vector_type_qualifier_push(&v, TYPE_RST))
+ goto clean;
+ ++ddata->cur;
+ if (td)
+ td->firstp = false;
+ goto again;
+
+ case 'R':
+ /* reference */
+ if (ddata->ref_qualifier)
+ goto clean;
+ if (!vector_type_qualifier_push(&v, TYPE_REF))
+ goto clean;
+ ddata->ref_qualifier = true;
+ ddata->ref_qualifier_type = TYPE_REF;
+ ++ddata->cur;
+ if (td)
+ td->firstp = false;
+ goto again;
+
+ case 's':
+ /* short, local string */
+ if (!DEM_PUSH_STR(ddata, "short"))
+ goto clean;
+ ++ddata->cur;
+ goto rtn;
+
+ case 'S':
+ /* substitution */
+ if (!cpp_demangle_read_subst(ddata))
+ goto clean;
+ is_builtin = 0;
+ goto rtn;
+
+ case 't':
+ /* unsigned short */
+ if (!DEM_PUSH_STR(ddata, "unsigned short"))
+ goto clean;
+ ++ddata->cur;
+ goto rtn;
+
+ case 'T':
+ /* template parameter */
+ if (!cpp_demangle_read_tmpl_param(ddata))
+ goto clean;
+ is_builtin = 0;
+ goto rtn;
+
+ case 'u':
+ /* vendor extended builtin */
+ ++ddata->cur;
+ if (!cpp_demangle_read_sname(ddata))
+ goto clean;
+ is_builtin = 0;
+ goto rtn;
+
+ case 'U':
+ /* vendor extended type qualifier */
+ ++ddata->cur;
+ if (!cpp_demangle_read_number(ddata, &len))
+ goto clean;
+ if (len <= 0)
+ goto clean;
+ if (!vector_str_push(&v.ext_name, ddata->cur, len))
+ return (0);
+ ddata->cur += len;
+ if (!vector_type_qualifier_push(&v, TYPE_EXT))
+ goto clean;
+ if (td)
+ td->firstp = false;
+ goto again;
+
+ case 'v':
+ /* void */
+ omit_void = false;
+ if (td && td->firstp) {
+ /*
+ * peek into next bytes and see if we should omit
+ * the "void".
+ */
+ omit_void = true;
+ for (p = ddata->cur + 1; *p != '\0'; p++) {
+ if (*p == 'E')
+ break;
+ if (*p != 'R' && *p != 'O') {
+ omit_void = false;
+ break;
+ }
+ }
+ }
+ if (!omit_void && !DEM_PUSH_STR(ddata, "void"))
+ goto clean;
+ ++ddata->cur;
+ goto rtn;
+
+ case 'V':
+ /* volatile */
+ if (!vector_type_qualifier_push(&v, TYPE_VAT))
+ goto clean;
+ ++ddata->cur;
+ if (td)
+ td->firstp = false;
+ goto again;
+
+ case 'w':
+ /* wchar_t */
+ if (!DEM_PUSH_STR(ddata, "wchar_t"))
+ goto clean;
+ ++ddata->cur;
+ goto rtn;
+
+ case 'x':
+ /* long long */
+ if (!DEM_PUSH_STR(ddata, "long long"))
+ goto clean;
+ ++ddata->cur;
+ goto rtn;
+
+ case 'y':
+ /* unsigned long long */
+ if (!DEM_PUSH_STR(ddata, "unsigned long long"))
+ goto clean;
+ ++ddata->cur;
+ goto rtn;
+
+ case 'z':
+ /* ellipsis */
+ if (!DEM_PUSH_STR(ddata, "..."))
+ goto clean;
+ ++ddata->cur;
+ goto rtn;
+ }
+
+ if (!cpp_demangle_read_name(ddata))
+ goto clean;
+
+ is_builtin = 0;
+rtn:
+
+ type_str = vector_str_substr(output, p_idx, output->size - 1,
+ &type_str_len);
+
+ if (is_builtin == 0) {
+ if (!vector_str_find(&ddata->subst, type_str, type_str_len) &&
+ !vector_str_push(&ddata->subst, type_str, type_str_len))
+ goto clean;
+ }
+
+ if (!skip_ref_qualifier &&
+ !cpp_demangle_push_type_qualifier(ddata, &v, type_str))
+ goto clean;
+
+ if (td)
+ td->firstp = false;
+
+ free(type_str);
+ free(exp_str);
+ free(num_str);
+ vector_type_qualifier_dest(&v);
+
+ return (1);
+clean:
+ free(type_str);
+ free(exp_str);
+ free(num_str);
+ vector_type_qualifier_dest(&v);
+
+ return (0);
+}
+
+static int
+cpp_demangle_read_type_flat(struct cpp_demangle_data *ddata, char **str)
+{
+ struct vector_str *output;
+ size_t i, p_idx, idx, type_len;
+ char *type;
+
+ output = ddata->cur_output;
+
+ p_idx = output->size;
+
+ if (!cpp_demangle_read_type(ddata, NULL))
+ return (0);
+
+ if ((type = vector_str_substr(output, p_idx, output->size - 1,
+ &type_len)) == NULL)
+ return (0);
+
+ idx = output->size;
+ for (i = p_idx; i < idx; ++i) {
+ if (!vector_str_pop(output)) {
+ free(type);
+ return (0);
+ }
+ }
+
+ *str = type;
+
+ return (1);
+}
+
+/*
+ * read unqualified-name, unqualified name are operator-name, ctor-dtor-name,
+ * source-name
+ */
+static int
+cpp_demangle_read_uqname(struct cpp_demangle_data *ddata)
+{
+ size_t len;
+
+ if (ddata == NULL || *ddata->cur == '\0')
+ return (0);
+
+ /* operator name */
+ switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
+ case SIMPLE_HASH('a', 'a'):
+ /* operator && */
+ if (!DEM_PUSH_STR(ddata, "operator&&"))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('a', 'd'):
+ /* operator & (unary) */
+ if (!DEM_PUSH_STR(ddata, "operator&"))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('a', 'n'):
+ /* operator & */
+ if (!DEM_PUSH_STR(ddata, "operator&"))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('a', 'N'):
+ /* operator &= */
+ if (!DEM_PUSH_STR(ddata, "operator&="))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('a', 'S'):
+ /* operator = */
+ if (!DEM_PUSH_STR(ddata, "operator="))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('c', 'l'):
+ /* operator () */
+ if (!DEM_PUSH_STR(ddata, "operator()"))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('c', 'm'):
+ /* operator , */
+ if (!DEM_PUSH_STR(ddata, "operator,"))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('c', 'o'):
+ /* operator ~ */
+ if (!DEM_PUSH_STR(ddata, "operator~"))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('c', 'v'):
+ /* operator (cast) */
+ if (!DEM_PUSH_STR(ddata, "operator(cast)"))
+ return (0);
+ ddata->cur += 2;
+ return (cpp_demangle_read_type(ddata, NULL));
+
+ case SIMPLE_HASH('d', 'a'):
+ /* operator delete [] */
+ if (!DEM_PUSH_STR(ddata, "operator delete []"))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('d', 'e'):
+ /* operator * (unary) */
+ if (!DEM_PUSH_STR(ddata, "operator*"))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('d', 'l'):
+ /* operator delete */
+ if (!DEM_PUSH_STR(ddata, "operator delete"))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('d', 'v'):
+ /* operator / */
+ if (!DEM_PUSH_STR(ddata, "operator/"))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('d', 'V'):
+ /* operator /= */
+ if (!DEM_PUSH_STR(ddata, "operator/="))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('e', 'o'):
+ /* operator ^ */
+ if (!DEM_PUSH_STR(ddata, "operator^"))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('e', 'O'):
+ /* operator ^= */
+ if (!DEM_PUSH_STR(ddata, "operator^="))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('e', 'q'):
+ /* operator == */
+ if (!DEM_PUSH_STR(ddata, "operator=="))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('g', 'e'):
+ /* operator >= */
+ if (!DEM_PUSH_STR(ddata, "operator>="))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('g', 't'):
+ /* operator > */
+ if (!DEM_PUSH_STR(ddata, "operator>"))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('i', 'x'):
+ /* operator [] */
+ if (!DEM_PUSH_STR(ddata, "operator[]"))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('l', 'e'):
+ /* operator <= */
+ if (!DEM_PUSH_STR(ddata, "operator<="))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('l', 's'):
+ /* operator << */
+ if (!DEM_PUSH_STR(ddata, "operator<<"))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('l', 'S'):
+ /* operator <<= */
+ if (!DEM_PUSH_STR(ddata, "operator<<="))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('l', 't'):
+ /* operator < */
+ if (!DEM_PUSH_STR(ddata, "operator<"))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('m', 'i'):
+ /* operator - */
+ if (!DEM_PUSH_STR(ddata, "operator-"))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('m', 'I'):
+ /* operator -= */
+ if (!DEM_PUSH_STR(ddata, "operator-="))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('m', 'l'):
+ /* operator * */
+ if (!DEM_PUSH_STR(ddata, "operator*"))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('m', 'L'):
+ /* operator *= */
+ if (!DEM_PUSH_STR(ddata, "operator*="))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('m', 'm'):
+ /* operator -- */
+ if (!DEM_PUSH_STR(ddata, "operator--"))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('n', 'a'):
+ /* operator new[] */
+ if (!DEM_PUSH_STR(ddata, "operator new []"))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('n', 'e'):
+ /* operator != */
+ if (!DEM_PUSH_STR(ddata, "operator!="))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('n', 'g'):
+ /* operator - (unary) */
+ if (!DEM_PUSH_STR(ddata, "operator-"))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('n', 't'):
+ /* operator ! */
+ if (!DEM_PUSH_STR(ddata, "operator!"))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('n', 'w'):
+ /* operator new */
+ if (!DEM_PUSH_STR(ddata, "operator new"))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('o', 'o'):
+ /* operator || */
+ if (!DEM_PUSH_STR(ddata, "operator||"))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('o', 'r'):
+ /* operator | */
+ if (!DEM_PUSH_STR(ddata, "operator|"))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('o', 'R'):
+ /* operator |= */
+ if (!DEM_PUSH_STR(ddata, "operator|="))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('p', 'l'):
+ /* operator + */
+ if (!DEM_PUSH_STR(ddata, "operator+"))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('p', 'L'):
+ /* operator += */
+ if (!DEM_PUSH_STR(ddata, "operator+="))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('p', 'm'):
+ /* operator ->* */
+ if (!DEM_PUSH_STR(ddata, "operator->*"))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('p', 'p'):
+ /* operator ++ */
+ if (!DEM_PUSH_STR(ddata, "operator++"))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('p', 's'):
+ /* operator + (unary) */
+ if (!DEM_PUSH_STR(ddata, "operator+"))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('p', 't'):
+ /* operator -> */
+ if (!DEM_PUSH_STR(ddata, "operator->"))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('q', 'u'):
+ /* operator ? */
+ if (!DEM_PUSH_STR(ddata, "operator?"))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('r', 'm'):
+ /* operator % */
+ if (!DEM_PUSH_STR(ddata, "operator%"))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('r', 'M'):
+ /* operator %= */
+ if (!DEM_PUSH_STR(ddata, "operator%="))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('r', 's'):
+ /* operator >> */
+ if (!DEM_PUSH_STR(ddata, "operator>>"))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('r', 'S'):
+ /* operator >>= */
+ if (!DEM_PUSH_STR(ddata, "operator>>="))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('r', 'z'):
+ /* operator sizeof */
+ if (!DEM_PUSH_STR(ddata, "operator sizeof "))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('s', 'r'):
+ /* scope resolution operator */
+ if (!DEM_PUSH_STR(ddata, "scope resolution operator "))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+
+ case SIMPLE_HASH('s', 'v'):
+ /* operator sizeof */
+ if (!DEM_PUSH_STR(ddata, "operator sizeof "))
+ return (0);
+ ddata->cur += 2;
+ return (1);
+ }
+
+ /* vendor extened operator */
+ if (*ddata->cur == 'v' && ELFTC_ISDIGIT(*(ddata->cur + 1))) {
+ if (!DEM_PUSH_STR(ddata, "vendor extened operator "))
+ return (0);
+ if (!cpp_demangle_push_str(ddata, ddata->cur + 1, 1))
+ return (0);
+ ddata->cur += 2;
+ return (cpp_demangle_read_sname(ddata));
+ }
+
+ /* ctor-dtor-name */
+ switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
+ case SIMPLE_HASH('C', '1'):
+ case SIMPLE_HASH('C', '2'):
+ case SIMPLE_HASH('C', '3'):
+ if (ddata->last_sname == NULL)
+ return (0);
+ if ((len = strlen(ddata->last_sname)) == 0)
+ return (0);
+ if (!DEM_PUSH_STR(ddata, "::"))
+ return (0);
+ if (!cpp_demangle_push_str(ddata, ddata->last_sname, len))
+ return (0);
+ ddata->cur +=2;
+ return (1);
+
+ case SIMPLE_HASH('D', '0'):
+ case SIMPLE_HASH('D', '1'):
+ case SIMPLE_HASH('D', '2'):
+ if (ddata->last_sname == NULL)
+ return (0);
+ if ((len = strlen(ddata->last_sname)) == 0)
+ return (0);
+ if (!DEM_PUSH_STR(ddata, "::~"))
+ return (0);
+ if (!cpp_demangle_push_str(ddata, ddata->last_sname, len))
+ return (0);
+ ddata->cur +=2;
+ return (1);
+ }
+
+ /* source name */
+ if (ELFTC_ISDIGIT(*ddata->cur) != 0)
+ return (cpp_demangle_read_sname(ddata));
+
+ /* local source name */
+ if (*ddata->cur == 'L')
+ return (cpp_demangle_local_source_name(ddata));
+
+ return (1);
+}
+
+/*
+ * Read local source name.
+ *
+ * References:
+ * http://gcc.gnu.org/bugzilla/show_bug.cgi?id=31775
+ * http://gcc.gnu.org/viewcvs?view=rev&revision=124467
+ */
+static int
+cpp_demangle_local_source_name(struct cpp_demangle_data *ddata)
+{
+ /* L */
+ if (ddata == NULL || *ddata->cur != 'L')
+ return (0);
+ ++ddata->cur;
+
+ /* source name */
+ if (!cpp_demangle_read_sname(ddata))
+ return (0);
+
+ /* discriminator */
+ if (*ddata->cur == '_') {
+ ++ddata->cur;
+ while (ELFTC_ISDIGIT(*ddata->cur) != 0)
+ ++ddata->cur;
+ }
+
+ return (1);
+}
+
+static int
+cpp_demangle_read_v_offset(struct cpp_demangle_data *ddata)
+{
+
+ if (ddata == NULL)
+ return (0);
+
+ if (!DEM_PUSH_STR(ddata, "offset : "))
+ return (0);
+
+ if (!cpp_demangle_read_offset_number(ddata))
+ return (0);
+
+ if (!DEM_PUSH_STR(ddata, "virtual offset : "))
+ return (0);
+
+ return (!cpp_demangle_read_offset_number(ddata));
+}
+
+/*
+ * Decode floating point representation to string
+ * Return new allocated string or NULL
+ *
+ * Todo
+ * Replace these functions to macro.
+ */
+static char *
+decode_fp_to_double(const char *p, size_t len)
+{
+ double f;
+ size_t rtn_len, limit, i;
+ int byte;
+ char *rtn;
+
+ if (p == NULL || len == 0 || len % 2 != 0 || len / 2 > sizeof(double))
+ return (NULL);
+
+ memset(&f, 0, sizeof(double));
+
+ for (i = 0; i < len / 2; ++i) {
+ byte = hex_to_dec(p[len - i * 2 - 1]) +
+ hex_to_dec(p[len - i * 2 - 2]) * 16;
+
+ if (byte < 0 || byte > 255)
+ return (NULL);
+
+#if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
+ ((unsigned char *)&f)[i] = (unsigned char)(byte);
+#else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
+ ((unsigned char *)&f)[sizeof(double) - i - 1] =
+ (unsigned char)(byte);
+#endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
+ }
+
+ rtn_len = 64;
+ limit = 0;
+again:
+ if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
+ return (NULL);
+
+ if (snprintf(rtn, rtn_len, "%fld", f) >= (int)rtn_len) {
+ free(rtn);
+ if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
+ return (NULL);
+ rtn_len *= BUFFER_GROWFACTOR;
+ goto again;
+ }
+
+ return rtn;
+}
+
+static char *
+decode_fp_to_float(const char *p, size_t len)
+{
+ size_t i, rtn_len, limit;
+ float f;
+ int byte;
+ char *rtn;
+
+ if (p == NULL || len == 0 || len % 2 != 0 || len / 2 > sizeof(float))
+ return (NULL);
+
+ memset(&f, 0, sizeof(float));
+
+ for (i = 0; i < len / 2; ++i) {
+ byte = hex_to_dec(p[len - i * 2 - 1]) +
+ hex_to_dec(p[len - i * 2 - 2]) * 16;
+ if (byte < 0 || byte > 255)
+ return (NULL);
+#if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
+ ((unsigned char *)&f)[i] = (unsigned char)(byte);
+#else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
+ ((unsigned char *)&f)[sizeof(float) - i - 1] =
+ (unsigned char)(byte);
+#endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
+ }
+
+ rtn_len = 64;
+ limit = 0;
+again:
+ if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
+ return (NULL);
+
+ if (snprintf(rtn, rtn_len, "%ff", f) >= (int)rtn_len) {
+ free(rtn);
+ if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
+ return (NULL);
+ rtn_len *= BUFFER_GROWFACTOR;
+ goto again;
+ }
+
+ return rtn;
+}
+
+static char *
+decode_fp_to_float128(const char *p, size_t len)
+{
+ long double f;
+ size_t rtn_len, limit, i;
+ int byte;
+ unsigned char buf[FLOAT_QUADRUPLE_BYTES];
+ char *rtn;
+
+ switch(sizeof(long double)) {
+ case FLOAT_QUADRUPLE_BYTES:
+ return (decode_fp_to_long_double(p, len));
+ case FLOAT_EXTENED_BYTES:
+ if (p == NULL || len == 0 || len % 2 != 0 ||
+ len / 2 > FLOAT_QUADRUPLE_BYTES)
+ return (NULL);
+
+ memset(buf, 0, FLOAT_QUADRUPLE_BYTES);
+
+ for (i = 0; i < len / 2; ++i) {
+ byte = hex_to_dec(p[len - i * 2 - 1]) +
+ hex_to_dec(p[len - i * 2 - 2]) * 16;
+ if (byte < 0 || byte > 255)
+ return (NULL);
+#if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
+ buf[i] = (unsigned char)(byte);
+#else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
+ buf[FLOAT_QUADRUPLE_BYTES - i -1] =
+ (unsigned char)(byte);
+#endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
+ }
+ memset(&f, 0, FLOAT_EXTENED_BYTES);
+
+#if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
+ memcpy(&f, buf, FLOAT_EXTENED_BYTES);
+#else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
+ memcpy(&f, buf + 6, FLOAT_EXTENED_BYTES);
+#endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
+
+ rtn_len = 256;
+ limit = 0;
+again:
+ if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
+ return (NULL);
+
+ if (snprintf(rtn, rtn_len, "%Lfd", f) >= (int)rtn_len) {
+ free(rtn);
+ if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
+ return (NULL);
+ rtn_len *= BUFFER_GROWFACTOR;
+ goto again;
+ }
+
+ return (rtn);
+ default:
+ return (NULL);
+ }
+}
+
+static char *
+decode_fp_to_float80(const char *p, size_t len)
+{
+ long double f;
+ size_t rtn_len, limit, i;
+ int byte;
+ unsigned char buf[FLOAT_EXTENED_BYTES];
+ char *rtn;
+
+ switch(sizeof(long double)) {
+ case FLOAT_QUADRUPLE_BYTES:
+ if (p == NULL || len == 0 || len % 2 != 0 ||
+ len / 2 > FLOAT_EXTENED_BYTES)
+ return (NULL);
+
+ memset(buf, 0, FLOAT_EXTENED_BYTES);
+
+ for (i = 0; i < len / 2; ++i) {
+ byte = hex_to_dec(p[len - i * 2 - 1]) +
+ hex_to_dec(p[len - i * 2 - 2]) * 16;
+
+ if (byte < 0 || byte > 255)
+ return (NULL);
+
+#if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
+ buf[i] = (unsigned char)(byte);
+#else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
+ buf[FLOAT_EXTENED_BYTES - i -1] =
+ (unsigned char)(byte);
+#endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
+ }
+
+ memset(&f, 0, FLOAT_QUADRUPLE_BYTES);
+
+#if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
+ memcpy(&f, buf, FLOAT_EXTENED_BYTES);
+#else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
+ memcpy((unsigned char *)(&f) + 6, buf, FLOAT_EXTENED_BYTES);
+#endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
+
+ rtn_len = 256;
+ limit = 0;
+again:
+ if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
+ return (NULL);
+
+ if (snprintf(rtn, rtn_len, "%Lfd", f) >= (int)rtn_len) {
+ free(rtn);
+ if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
+ return (NULL);
+ rtn_len *= BUFFER_GROWFACTOR;
+ goto again;
+ }
+
+ return (rtn);
+ case FLOAT_EXTENED_BYTES:
+ return (decode_fp_to_long_double(p, len));
+ default:
+ return (NULL);
+ }
+}
+
+static char *
+decode_fp_to_long_double(const char *p, size_t len)
+{
+ long double f;
+ size_t rtn_len, limit, i;
+ int byte;
+ char *rtn;
+
+ if (p == NULL || len == 0 || len % 2 != 0 ||
+ len / 2 > sizeof(long double))
+ return (NULL);
+
+ memset(&f, 0, sizeof(long double));
+
+ for (i = 0; i < len / 2; ++i) {
+ byte = hex_to_dec(p[len - i * 2 - 1]) +
+ hex_to_dec(p[len - i * 2 - 2]) * 16;
+
+ if (byte < 0 || byte > 255)
+ return (NULL);
+
+#if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
+ ((unsigned char *)&f)[i] = (unsigned char)(byte);
+#else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
+ ((unsigned char *)&f)[sizeof(long double) - i - 1] =
+ (unsigned char)(byte);
+#endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
+ }
+
+ rtn_len = 256;
+ limit = 0;
+again:
+ if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
+ return (NULL);
+
+ if (snprintf(rtn, rtn_len, "%Lfd", f) >= (int)rtn_len) {
+ free(rtn);
+ if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
+ return (NULL);
+ rtn_len *= BUFFER_GROWFACTOR;
+ goto again;
+ }
+
+ return (rtn);
+}
+
+/* Simple hex to integer function used by decode_to_* function. */
+static int
+hex_to_dec(char c)
+{
+
+ switch (c) {
+ case '0':
+ return (0);
+ case '1':
+ return (1);
+ case '2':
+ return (2);
+ case '3':
+ return (3);
+ case '4':
+ return (4);
+ case '5':
+ return (5);
+ case '6':
+ return (6);
+ case '7':
+ return (7);
+ case '8':
+ return (8);
+ case '9':
+ return (9);
+ case 'a':
+ return (10);
+ case 'b':
+ return (11);
+ case 'c':
+ return (12);
+ case 'd':
+ return (13);
+ case 'e':
+ return (14);
+ case 'f':
+ return (15);
+ default:
+ return (-1);
+ }
+}
+
+/**
+ * @brief Test input string is mangled by IA-64 C++ ABI style.
+ *
+ * Test string heads with "_Z" or "_GLOBAL__I_".
+ * @return Return 0 at false.
+ */
+bool
+is_cpp_mangled_gnu3(const char *org)
+{
+ size_t len;
+
+ len = strlen(org);
+ return ((len > 2 && *org == '_' && *(org + 1) == 'Z') ||
+ (len > 11 && !strncmp(org, "_GLOBAL__I_", 11)));
+}
+
+static void
+vector_read_cmd_dest(struct vector_read_cmd *v)
+{
+
+ if (v == NULL)
+ return;
+
+ free(v->r_container);
+}
+
+static struct read_cmd_item *
+vector_read_cmd_find(struct vector_read_cmd *v, enum read_cmd dst)
+{
+ int i;
+
+ if (v == NULL || dst == READ_FAIL)
+ return (NULL);
+
+ for (i = (int) v->size - 1; i >= 0; i--)
+ if (v->r_container[i].cmd == dst)
+ return (&v->r_container[i]);
+
+ return (NULL);
+}
+
+static int
+vector_read_cmd_init(struct vector_read_cmd *v)
+{
+
+ if (v == NULL)
+ return (0);
+
+ v->size = 0;
+ v->capacity = VECTOR_DEF_CAPACITY;
+
+ if ((v->r_container = malloc(sizeof(*v->r_container) * v->capacity))
+ == NULL)
+ return (0);
+
+ return (1);
+}
+
+static int
+vector_read_cmd_pop(struct vector_read_cmd *v)
+{
+
+ if (v == NULL || v->size == 0)
+ return (0);
+
+ --v->size;
+ v->r_container[v->size].cmd = READ_FAIL;
+ v->r_container[v->size].data = NULL;
+
+ return (1);
+}
+
+static int
+vector_read_cmd_push(struct vector_read_cmd *v, enum read_cmd cmd, void *data)
+{
+ struct read_cmd_item *tmp_r_ctn;
+ size_t tmp_cap;
+ size_t i;
+
+ if (v == NULL)
+ return (0);
+
+ if (v->size == v->capacity) {
+ tmp_cap = v->capacity * BUFFER_GROWFACTOR;
+ if ((tmp_r_ctn = malloc(sizeof(*tmp_r_ctn) * tmp_cap)) == NULL)
+ return (0);
+ for (i = 0; i < v->size; ++i)
+ tmp_r_ctn[i] = v->r_container[i];
+ free(v->r_container);
+ v->r_container = tmp_r_ctn;
+ v->capacity = tmp_cap;
+ }
+
+ v->r_container[v->size].cmd = cmd;
+ v->r_container[v->size].data = data;
+ ++v->size;
+
+ return (1);
+}
+
+static void
+vector_type_qualifier_dest(struct vector_type_qualifier *v)
+{
+
+ if (v == NULL)
+ return;
+
+ free(v->q_container);
+ vector_str_dest(&v->ext_name);
+}
+
+/* size, capacity, ext_name */
+static int
+vector_type_qualifier_init(struct vector_type_qualifier *v)
+{
+
+ if (v == NULL)
+ return (0);
+
+ v->size = 0;
+ v->capacity = VECTOR_DEF_CAPACITY;
+
+ if ((v->q_container = malloc(sizeof(enum type_qualifier) * v->capacity))
+ == NULL)
+ return (0);
+
+ assert(v->q_container != NULL);
+
+ if (vector_str_init(&v->ext_name) == false) {
+ free(v->q_container);
+ return (0);
+ }
+
+ return (1);
+}
+
+static int
+vector_type_qualifier_push(struct vector_type_qualifier *v,
+ enum type_qualifier t)
+{
+ enum type_qualifier *tmp_ctn;
+ size_t tmp_cap;
+ size_t i;
+
+ if (v == NULL)
+ return (0);
+
+ if (v->size == v->capacity) {
+ tmp_cap = v->capacity * BUFFER_GROWFACTOR;
+ if ((tmp_ctn = malloc(sizeof(enum type_qualifier) * tmp_cap))
+ == NULL)
+ return (0);
+ for (i = 0; i < v->size; ++i)
+ tmp_ctn[i] = v->q_container[i];
+ free(v->q_container);
+ v->q_container = tmp_ctn;
+ v->capacity = tmp_cap;
+ }
+
+ v->q_container[v->size] = t;
+ ++v->size;
+
+ return (1);
+}
diff --git a/rtemstoolkit/elftoolchain/libelftc/libelftc_hash.c b/rtemstoolkit/elftoolchain/libelftc/libelftc_hash.c
new file mode 100644
index 0000000..6cc54b9
--- /dev/null
+++ b/rtemstoolkit/elftoolchain/libelftc/libelftc_hash.c
@@ -0,0 +1,70 @@
+/*-
+ * Copyright (c) 2013, Joseph Koshy
+ * 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
+ * in this position and unchanged.
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``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 AUTHOR(S) 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.
+ */
+
+/*
+ * An implementation of the Fowler-Noll-Vo hash function.
+ *
+ * References:
+ * - http://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function
+ * - http://www.isthe.com/chongo/tech/comp/fnv/
+ */
+
+#include <sys/types.h>
+
+#include <limits.h>
+
+#include "_libelftc.h"
+
+ELFTC_VCSID("$Id: libelftc_hash.c 2870 2013-01-07 10:38:43Z jkoshy $");
+
+/*
+ * Use the size of an 'int' to determine the magic numbers used by the
+ * hash function.
+ */
+
+#if INT_MAX == 2147483647UL
+#define FNV_PRIME 16777619UL
+#define FNV_OFFSET 2166136261UL
+#elif INT_MAX == 18446744073709551615ULL
+#define FNV_PRIME 1099511628211ULL
+#define FNV_OFFSET 14695981039346656037ULL
+#else
+#error sizeof(int) is unknown.
+#endif
+
+unsigned int
+libelftc_hash_string(const char *s)
+{
+ char c;
+ unsigned int hash;
+
+ for (hash = FNV_OFFSET; (c = *s) != '\0'; s++) {
+ hash ^= c;
+ hash *= FNV_PRIME;
+ }
+
+ return (hash);
+}
diff --git a/rtemstoolkit/elftoolchain/libelftc/libelftc_vstr.c b/rtemstoolkit/elftoolchain/libelftc/libelftc_vstr.c
new file mode 100644
index 0000000..934b5db
--- /dev/null
+++ b/rtemstoolkit/elftoolchain/libelftc/libelftc_vstr.c
@@ -0,0 +1,359 @@
+/*-
+ * Copyright (c) 2008 Hyogeol Lee <hyogeollee at gmail.com>
+ * 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
+ * in this position and unchanged.
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``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 AUTHOR 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/types.h>
+#include <assert.h>
+#include <libelftc.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "_libelftc.h"
+
+ELFTC_VCSID("$Id: libelftc_vstr.c 3531 2017-06-05 05:08:43Z kaiwang27 $");
+
+/**
+ * @file vector_str.c
+ * @brief Dynamic vector data for string implementation.
+ *
+ * Resemble to std::vector<std::string> in C++.
+ */
+
+static size_t get_strlen_sum(const struct vector_str *v);
+static bool vector_str_grow(struct vector_str *v);
+
+static size_t
+get_strlen_sum(const struct vector_str *v)
+{
+ size_t i, len = 0;
+
+ if (v == NULL)
+ return (0);
+
+ assert(v->size > 0);
+
+ for (i = 0; i < v->size; ++i)
+ len += strlen(v->container[i]);
+
+ return (len);
+}
+
+/**
+ * @brief Deallocate resource in vector_str.
+ */
+void
+vector_str_dest(struct vector_str *v)
+{
+ size_t i;
+
+ if (v == NULL)
+ return;
+
+ for (i = 0; i < v->size; ++i)
+ free(v->container[i]);
+
+ free(v->container);
+}
+
+/**
+ * @brief Find string in vector_str.
+ * @param v Destination vector.
+ * @param o String to find.
+ * @param l Length of the string.
+ * @return -1 at failed, 0 at not found, 1 at found.
+ */
+int
+vector_str_find(const struct vector_str *v, const char *o, size_t l)
+{
+ size_t i;
+
+ if (v == NULL || o == NULL)
+ return (-1);
+
+ for (i = 0; i < v->size; ++i)
+ if (strncmp(v->container[i], o, l) == 0)
+ return (1);
+
+ return (0);
+}
+
+/**
+ * @brief Get new allocated flat string from vector.
+ *
+ * If l is not NULL, return length of the string.
+ * @param v Destination vector.
+ * @param l Length of the string.
+ * @return NULL at failed or NUL terminated new allocated string.
+ */
+char *
+vector_str_get_flat(const struct vector_str *v, size_t *l)
+{
+ ssize_t elem_pos, elem_size, rtn_size;
+ size_t i;
+ char *rtn;
+
+ if (v == NULL || v->size == 0)
+ return (NULL);
+
+ if ((rtn_size = get_strlen_sum(v)) == 0)
+ return (NULL);
+
+ if ((rtn = malloc(sizeof(char) * (rtn_size + 1))) == NULL)
+ return (NULL);
+
+ elem_pos = 0;
+ for (i = 0; i < v->size; ++i) {
+ elem_size = strlen(v->container[i]);
+
+ memcpy(rtn + elem_pos, v->container[i], elem_size);
+
+ elem_pos += elem_size;
+ }
+
+ rtn[rtn_size] = '\0';
+
+ if (l != NULL)
+ *l = rtn_size;
+
+ return (rtn);
+}
+
+static bool
+vector_str_grow(struct vector_str *v)
+{
+ size_t i, tmp_cap;
+ char **tmp_ctn;
+
+ if (v == NULL)
+ return (false);
+
+ assert(v->capacity > 0);
+
+ tmp_cap = v->capacity * BUFFER_GROWFACTOR;
+
+ assert(tmp_cap > v->capacity);
+
+ if ((tmp_ctn = malloc(sizeof(char *) * tmp_cap)) == NULL)
+ return (false);
+
+ for (i = 0; i < v->size; ++i)
+ tmp_ctn[i] = v->container[i];
+
+ free(v->container);
+
+ v->container = tmp_ctn;
+ v->capacity = tmp_cap;
+
+ return (true);
+}
+
+/**
+ * @brief Initialize vector_str.
+ * @return false at failed, true at success.
+ */
+bool
+vector_str_init(struct vector_str *v)
+{
+
+ if (v == NULL)
+ return (false);
+
+ v->size = 0;
+ v->capacity = VECTOR_DEF_CAPACITY;
+
+ assert(v->capacity > 0);
+
+ if ((v->container = malloc(sizeof(char *) * v->capacity)) == NULL)
+ return (false);
+
+ assert(v->container != NULL);
+
+ return (true);
+}
+
+/**
+ * @brief Remove last element in vector_str.
+ * @return false at failed, true at success.
+ */
+bool
+vector_str_pop(struct vector_str *v)
+{
+
+ if (v == NULL)
+ return (false);
+
+ if (v->size == 0)
+ return (true);
+
+ --v->size;
+
+ free(v->container[v->size]);
+ v->container[v->size] = NULL;
+
+ return (true);
+}
+
+/**
+ * @brief Push back string to vector.
+ * @return false at failed, true at success.
+ */
+bool
+vector_str_push(struct vector_str *v, const char *str, size_t len)
+{
+
+ if (v == NULL || str == NULL)
+ return (false);
+
+ if (v->size == v->capacity && vector_str_grow(v) == false)
+ return (false);
+
+ if ((v->container[v->size] = malloc(sizeof(char) * (len + 1))) == NULL)
+ return (false);
+
+ snprintf(v->container[v->size], len + 1, "%s", str);
+
+ ++v->size;
+
+ return (true);
+}
+
+/**
+ * @brief Push front org vector to det vector.
+ * @return false at failed, true at success.
+ */
+bool
+vector_str_push_vector_head(struct vector_str *dst, struct vector_str *org)
+{
+ size_t i, j, tmp_cap;
+ char **tmp_ctn;
+
+ if (dst == NULL || org == NULL)
+ return (false);
+
+ tmp_cap = (dst->size + org->size) * BUFFER_GROWFACTOR;
+
+ if ((tmp_ctn = malloc(sizeof(char *) * tmp_cap)) == NULL)
+ return (false);
+
+ for (i = 0; i < org->size; ++i)
+ if ((tmp_ctn[i] = strdup(org->container[i])) == NULL) {
+ for (j = 0; j < i; ++j)
+ free(tmp_ctn[j]);
+
+ free(tmp_ctn);
+
+ return (false);
+ }
+
+ for (i = 0; i < dst->size; ++i)
+ tmp_ctn[i + org->size] = dst->container[i];
+
+ free(dst->container);
+
+ dst->container = tmp_ctn;
+ dst->capacity = tmp_cap;
+ dst->size += org->size;
+
+ return (true);
+}
+
+/**
+ * @brief Push org vector to the tail of det vector.
+ * @return false at failed, true at success.
+ */
+bool
+vector_str_push_vector(struct vector_str *dst, struct vector_str *org)
+{
+ size_t i, j, tmp_cap;
+ char **tmp_ctn;
+
+ if (dst == NULL || org == NULL)
+ return (false);
+
+ tmp_cap = (dst->size + org->size) * BUFFER_GROWFACTOR;
+
+ if ((tmp_ctn = malloc(sizeof(char *) * tmp_cap)) == NULL)
+ return (false);
+
+ for (i = 0; i < dst->size; ++i)
+ tmp_ctn[i] = dst->container[i];
+
+ for (i = 0; i < org->size; ++i)
+ if ((tmp_ctn[i + dst->size] = strdup(org->container[i])) ==
+ NULL) {
+ for (j = 0; j < i + dst->size; ++j)
+ free(tmp_ctn[j]);
+
+ free(tmp_ctn);
+
+ return (false);
+ }
+
+ free(dst->container);
+
+ dst->container = tmp_ctn;
+ dst->capacity = tmp_cap;
+ dst->size += org->size;
+
+ return (true);
+}
+
+/**
+ * @brief Get new allocated flat string from vector between begin and end.
+ *
+ * If r_len is not NULL, string length will be returned.
+ * @return NULL at failed or NUL terminated new allocated string.
+ */
+char *
+vector_str_substr(const struct vector_str *v, size_t begin, size_t end,
+ size_t *r_len)
+{
+ size_t cur, i, len;
+ char *rtn;
+
+ if (v == NULL || begin > end)
+ return (NULL);
+
+ len = 0;
+ for (i = begin; i < end + 1; ++i)
+ len += strlen(v->container[i]);
+
+ if ((rtn = malloc(sizeof(char) * (len + 1))) == NULL)
+ return (NULL);
+
+ if (r_len != NULL)
+ *r_len = len;
+
+ cur = 0;
+ for (i = begin; i < end + 1; ++i) {
+ len = strlen(v->container[i]);
+ memcpy(rtn + cur, v->container[i], len);
+ cur += len;
+ }
+ rtn[cur] = '\0';
+
+ return (rtn);
+}
diff --git a/rtemstoolkit/elftoolchain/libelftc/make-toolchain-version b/rtemstoolkit/elftoolchain/libelftc/make-toolchain-version
new file mode 100755
index 0000000..0cdf370
--- /dev/null
+++ b/rtemstoolkit/elftoolchain/libelftc/make-toolchain-version
@@ -0,0 +1,110 @@
+#!/bin/sh
+#
+# This script generates a project-wide version identifier for use by
+# the `elftc_version()' API.
+#
+# $Id: make-toolchain-version 3414 2016-02-16 22:55:28Z jkoshy $
+
+#
+# Defaults.
+#
+buildhost=`uname -s`
+elftcname="elftoolchain"
+options="e:h:o:r:t:"
+top=""
+version="HEAD"
+versionfile="elftc_version.c"
+progname=`basename ${0}`
+
+usage()
+{
+ exec >&2
+
+ # Print a message, if supplied.
+ if [ -n "${*}" ]; then echo "##${@}"; fi
+
+ echo "Usage: ${progname} [options]"
+ echo " Generate a toolchain-wide version number"
+ echo " -e PROJECTNAME Set the project name [default: ${elftcname}]."
+ echo " -h HOSTOS Set the build OS [default: ${buildhost}]."
+ echo " -o OUTPUT Set the output file [default: ${versionfile}]."
+ echo " -r VERSION Set the version string [default: ${version}]."
+ echo " -t TOPDIR Set the top-of-tree directory [required]."
+ exit 1
+}
+
+#
+# Parse options.
+#
+
+while getopts ${options} option
+do
+ case ${option} in
+ 'e') elftcname="${OPTARG}" ;;
+ 'h') buildhost="${OPTARG}" ;;
+ 'o') versionfile="${OPTARG}" ;;
+ 'r') version="${OPTARG}" ;;
+ 't') top="${OPTARG}" ;;
+ '?') usage ;;
+ esac
+done
+
+[ -n "${top}" ] || usage
+
+# Try to determine the in-tree revision number.
+#
+# This script attempts to handle the case where our sources have been
+# incorporated into an operating system's base sources.
+#
+# - If SVN is detected, we use the `svninfo' tool to determine the
+# in-tree revision number.
+# - If CVS is detected, we use the string `unknown'.
+# - Otherwise, we use `git --describe'.
+
+curdir=`pwd`
+cd ${top} || usage "ERROR: Cannot change directory to \"${top}\"."
+
+if [ -d CVS ]; then # Look for CVS (NetBSD).
+ versionstring=" cvs:unknown"
+else # Try git (DragonFlyBSD).
+ gitversion="$(git describe --all --dirty --long 2> /dev/null)"
+ if [ -n "${gitversion}" ]; then
+ versionstring=" git:${gitversion}"
+ else # Assume an SVN checkout (SourceForge or FreeBSD).
+ svnversion="$(svnversion)"
+ if [ -n "${svnversion}" ]; then
+ versionstring=" svn:$(svnversion)"
+ fi
+ fi
+fi
+
+if [ -z "${versionstring}" ]; then
+ echo "ERROR: cannot determine a revision number." 1>&2
+ exit 1
+fi
+
+cd ${curdir} || usage "Cannot change back to ${curdir}."
+
+#
+# Only replace the source file if its content has changed.
+#
+tmpfile=`mktemp ${TMPDIR:-/tmp}/MV.XXXXXXX`
+trap "rm -f ${tmpfile};" 0 1 2 3 15
+
+cat > ${tmpfile} <<EOF
+/* WARNING: Generated by "${progname}". */
+
+#include <sys/types.h>
+#include <libelftc.h>
+
+const char *
+elftc_version(void)
+{
+ return "${elftcname} ${version} ${buildhost}${versionstring}";
+}
+EOF
+
+if ! cmp -s ${tmpfile} ${versionfile}; then
+ echo "@ ${progname}: building \"${versionfile}\"."
+ cp ${tmpfile} ${versionfile} || exit ${?}
+fi
diff --git a/rtemstoolkit/elftoolchain/libelftc/os.FreeBSD.mk b/rtemstoolkit/elftoolchain/libelftc/os.FreeBSD.mk
new file mode 100644
index 0000000..8079a5b
--- /dev/null
+++ b/rtemstoolkit/elftoolchain/libelftc/os.FreeBSD.mk
@@ -0,0 +1,7 @@
+#
+# Building for a FreeBSD target.
+#
+# $Id: os.freebsd.mk 189 2008-07-20 10:38:08Z jkoshy $
+
+# Symbol versioning support [FreeBSD 7.X and later]
+VERSION_MAP= ${.CURDIR}/Version.map
diff --git a/rtemstoolkit/elftoolchain/libelftc/os.Linux.mk b/rtemstoolkit/elftoolchain/libelftc/os.Linux.mk
new file mode 100644
index 0000000..d99117d
--- /dev/null
+++ b/rtemstoolkit/elftoolchain/libelftc/os.Linux.mk
@@ -0,0 +1,3 @@
+# $Id: os.Linux.mk 3210 2015-05-17 13:40:49Z kaiwang27 $
+
+CFLAGS+= -Wall -D_GNU_SOURCE
diff --git a/rtemstoolkit/elftoolchain/libelftc/os.NetBSD.mk b/rtemstoolkit/elftoolchain/libelftc/os.NetBSD.mk
new file mode 100644
index 0000000..ae214e3
--- /dev/null
+++ b/rtemstoolkit/elftoolchain/libelftc/os.NetBSD.mk
@@ -0,0 +1,2 @@
+# TODO(#511): Revert after the source tree is -Wconversion clean.
+WARNS=5
diff --git a/rtemstoolkit/wscript b/rtemstoolkit/wscript
index 4c30935..4b5fa34 100644
--- a/rtemstoolkit/wscript
+++ b/rtemstoolkit/wscript
@@ -170,6 +170,7 @@ def conf_elftoolchain(conf):
def bld_elftoolchain(bld, conf):
libelf = 'elftoolchain/libelf/'
+ libelftc = 'elftoolchain/libelftc/'
libdwarf = 'elftoolchain/libdwarf/'
libelf_m4_rule = '${M4} -D SRCDIR=../rtemstoolkit/' + libelf[:-1] + ' ${SRC} > ${TGT}'
libdwarf_m4_rule = '${M4} -D SRCDIR=../rtemstoolkit/' + libdwarf[:-1] + ' ${SRC} > ${TGT}'
@@ -334,6 +335,29 @@ def bld_elftoolchain(bld, conf):
libdwarf + 'libdwarf_sections.c',
libdwarf + 'libdwarf_str.c'] + libdwarf_m4_source)
+ bld.stlib(target = 'elftc',
+ features = 'c',
+ install_path = None,
+ includes = [bld.bldnode.abspath(),
+ 'elftoolchain/libelf',
+ 'elftoolchain/libelftc',
+ 'elftoolchain/common'] + includes,
+ cflags = conf['cflags'],
+ source =[libelftc + 'elftc_bfdtarget.c',
+ libelftc + 'elftc_copyfile.c',
+ libelftc + 'elftc_demangle.c',
+ libelftc + 'elftc_reloc_type_str.c',
+ libelftc + 'elftc_set_timestamps.c',
+ libelftc + 'elftc_string_table.c',
+ libelftc + 'elftc_timestamp.c',
+ libelftc + 'elftc_version.c',
+ libelftc + 'libelftc_bfdtarget.c',
+ libelftc + 'libelftc_dem_arm.c',
+ libelftc + 'libelftc_dem_gnu2.c',
+ libelftc + 'libelftc_dem_gnu3.c',
+ libelftc + 'libelftc_hash.c',
+ libelftc + 'libelftc_vstr.c'])
+
#
# Libiberty module.
#
More information about the vc
mailing list