svn commit: r284550 - vendor/libcxxrt/2015-06-18-e64e93fe5bba67a6d52cbe5a97f8770c054bfa65
Ed Maste
emaste at FreeBSD.org
Thu Jun 18 14:02:20 UTC 2015
Author: emaste
Date: Thu Jun 18 14:02:19 2015
New Revision: 284550
URL: https://svnweb.freebsd.org/changeset/base/284550
Log:
Tag libcxxrt master e64e93fe5bba67a6d52cbe5a97f8770c054bfa65.
Added:
vendor/libcxxrt/2015-06-18-e64e93fe5bba67a6d52cbe5a97f8770c054bfa65/
- copied from r284545, vendor/libcxxrt/dist/
Replaced:
vendor/libcxxrt/2015-06-18-e64e93fe5bba67a6d52cbe5a97f8770c054bfa65/dwarf_eh.h
- copied unchanged from r284549, vendor/libcxxrt/dist/dwarf_eh.h
vendor/libcxxrt/2015-06-18-e64e93fe5bba67a6d52cbe5a97f8770c054bfa65/libelftc_dem_gnu3.c
- copied unchanged from r284549, vendor/libcxxrt/dist/libelftc_dem_gnu3.c
Copied: vendor/libcxxrt/2015-06-18-e64e93fe5bba67a6d52cbe5a97f8770c054bfa65/dwarf_eh.h (from r284549, vendor/libcxxrt/dist/dwarf_eh.h)
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ vendor/libcxxrt/2015-06-18-e64e93fe5bba67a6d52cbe5a97f8770c054bfa65/dwarf_eh.h Thu Jun 18 14:02:19 2015 (r284550, copy of r284549, vendor/libcxxrt/dist/dwarf_eh.h)
@@ -0,0 +1,477 @@
+/*
+ * Copyright 2010-2011 PathScale, Inc. 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 COPYRIGHT HOLDERS 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 COPYRIGHT HOLDER 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.
+ */
+/**
+ * dwarf_eh.h - Defines some helper functions for parsing DWARF exception
+ * handling tables.
+ *
+ * This file contains various helper functions that are independent of the
+ * language-specific code. It can be used in any personality function for the
+ * Itanium ABI.
+ */
+#include <assert.h>
+
+// TODO: Factor out Itanium / ARM differences. We probably want an itanium.h
+// and arm.h that can be included by this file depending on the target ABI.
+
+// _GNU_SOURCE must be defined for unwind.h to expose some of the functions
+// that we want. If it isn't, then we define it and undefine it to make sure
+// that it doesn't impact the rest of the program.
+#ifndef _GNU_SOURCE
+# define _GNU_SOURCE 1
+# include "unwind.h"
+# undef _GNU_SOURCE
+#else
+# include "unwind.h"
+#endif
+
+#include <stdint.h>
+
+/// Type used for pointers into DWARF data
+typedef unsigned char *dw_eh_ptr_t;
+
+// Flag indicating a signed quantity
+#define DW_EH_PE_signed 0x08
+/// DWARF data encoding types.
+enum dwarf_data_encoding
+{
+ /// Absolute pointer value
+ DW_EH_PE_absptr = 0x00,
+ /// Unsigned, little-endian, base 128-encoded (variable length).
+ DW_EH_PE_uleb128 = 0x01,
+ /// Unsigned 16-bit integer.
+ DW_EH_PE_udata2 = 0x02,
+ /// Unsigned 32-bit integer.
+ DW_EH_PE_udata4 = 0x03,
+ /// Unsigned 64-bit integer.
+ DW_EH_PE_udata8 = 0x04,
+ /// Signed, little-endian, base 128-encoded (variable length)
+ DW_EH_PE_sleb128 = DW_EH_PE_uleb128 | DW_EH_PE_signed,
+ /// Signed 16-bit integer.
+ DW_EH_PE_sdata2 = DW_EH_PE_udata2 | DW_EH_PE_signed,
+ /// Signed 32-bit integer.
+ DW_EH_PE_sdata4 = DW_EH_PE_udata4 | DW_EH_PE_signed,
+ /// Signed 32-bit integer.
+ DW_EH_PE_sdata8 = DW_EH_PE_udata8 | DW_EH_PE_signed
+};
+
+/**
+ * Returns the encoding for a DWARF EH table entry. The encoding is stored in
+ * the low four of an octet. The high four bits store the addressing mode.
+ */
+static inline enum dwarf_data_encoding get_encoding(unsigned char x)
+{
+ return static_cast<enum dwarf_data_encoding>(x & 0xf);
+}
+
+/**
+ * DWARF addressing mode constants. When reading a pointer value from a DWARF
+ * exception table, you must know how it is stored and what the addressing mode
+ * is. The low four bits tell you the encoding, allowing you to decode a
+ * number. The high four bits tell you the addressing mode, allowing you to
+ * turn that number into an address in memory.
+ */
+enum dwarf_data_relative
+{
+ /// Value is omitted
+ DW_EH_PE_omit = 0xff,
+ /// Value relative to program counter
+ DW_EH_PE_pcrel = 0x10,
+ /// Value relative to the text segment
+ DW_EH_PE_textrel = 0x20,
+ /// Value relative to the data segment
+ DW_EH_PE_datarel = 0x30,
+ /// Value relative to the start of the function
+ DW_EH_PE_funcrel = 0x40,
+ /// Aligned pointer (Not supported yet - are they actually used?)
+ DW_EH_PE_aligned = 0x50,
+ /// Pointer points to address of real value
+ DW_EH_PE_indirect = 0x80
+};
+/**
+ * Returns the addressing mode component of this encoding.
+ */
+static inline enum dwarf_data_relative get_base(unsigned char x)
+{
+ return static_cast<enum dwarf_data_relative>(x & 0x70);
+}
+/**
+ * Returns whether an encoding represents an indirect address.
+ */
+static int is_indirect(unsigned char x)
+{
+ return ((x & DW_EH_PE_indirect) == DW_EH_PE_indirect);
+}
+
+/**
+ * Returns the size of a fixed-size encoding. This function will abort if
+ * called with a value that is not a fixed-size encoding.
+ */
+static inline int dwarf_size_of_fixed_size_field(unsigned char type)
+{
+ switch (get_encoding(type))
+ {
+ default: abort();
+ case DW_EH_PE_sdata2:
+ case DW_EH_PE_udata2: return 2;
+ case DW_EH_PE_sdata4:
+ case DW_EH_PE_udata4: return 4;
+ case DW_EH_PE_sdata8:
+ case DW_EH_PE_udata8: return 8;
+ case DW_EH_PE_absptr: return sizeof(void*);
+ }
+}
+
+/**
+ * Read an unsigned, little-endian, base-128, DWARF value. Updates *data to
+ * point to the end of the value. Stores the number of bits read in the value
+ * pointed to by b, allowing you to determine the value of the highest bit, and
+ * therefore the sign of a signed value.
+ *
+ * This function is not intended to be called directly. Use read_sleb128() or
+ * read_uleb128() for reading signed and unsigned versions, respectively.
+ */
+static uint64_t read_leb128(dw_eh_ptr_t *data, int *b)
+{
+ uint64_t uleb = 0;
+ unsigned int bit = 0;
+ unsigned char digit = 0;
+ // We have to read at least one octet, and keep reading until we get to one
+ // with the high bit unset
+ do
+ {
+ // This check is a bit too strict - we should also check the highest
+ // bit of the digit.
+ assert(bit < sizeof(uint64_t) * 8);
+ // Get the base 128 digit
+ digit = (**data) & 0x7f;
+ // Add it to the current value
+ uleb += digit << bit;
+ // Increase the shift value
+ bit += 7;
+ // Proceed to the next octet
+ (*data)++;
+ // Terminate when we reach a value that does not have the high bit set
+ // (i.e. which was not modified when we mask it with 0x7f)
+ } while ((*(*data - 1)) != digit);
+ *b = bit;
+
+ return uleb;
+}
+
+/**
+ * Reads an unsigned little-endian base-128 value starting at the address
+ * pointed to by *data. Updates *data to point to the next byte after the end
+ * of the variable-length value.
+ */
+static int64_t read_uleb128(dw_eh_ptr_t *data)
+{
+ int b;
+ return read_leb128(data, &b);
+}
+
+/**
+ * Reads a signed little-endian base-128 value starting at the address pointed
+ * to by *data. Updates *data to point to the next byte after the end of the
+ * variable-length value.
+ */
+static int64_t read_sleb128(dw_eh_ptr_t *data)
+{
+ int bits;
+ // Read as if it's signed
+ uint64_t uleb = read_leb128(data, &bits);
+ // If the most significant bit read is 1, then we need to sign extend it
+ if ((uleb >> (bits-1)) == 1)
+ {
+ // Sign extend by setting all bits in front of it to 1
+ uleb |= static_cast<int64_t>(-1) << bits;
+ }
+ return static_cast<int64_t>(uleb);
+}
+/**
+ * Reads a value using the specified encoding from the address pointed to by
+ * *data. Updates the value of *data to point to the next byte after the end
+ * of the data.
+ */
+static uint64_t read_value(char encoding, dw_eh_ptr_t *data)
+{
+ enum dwarf_data_encoding type = get_encoding(encoding);
+ switch (type)
+ {
+ // Read fixed-length types
+#define READ(dwarf, type) \
+ case dwarf:\
+ {\
+ type t;\
+ memcpy(&t, *data, sizeof t);\
+ *data += sizeof t;\
+ return static_cast<uint64_t>(t);\
+ }
+ READ(DW_EH_PE_udata2, uint16_t)
+ READ(DW_EH_PE_udata4, uint32_t)
+ READ(DW_EH_PE_udata8, uint64_t)
+ READ(DW_EH_PE_sdata2, int16_t)
+ READ(DW_EH_PE_sdata4, int32_t)
+ READ(DW_EH_PE_sdata8, int64_t)
+ READ(DW_EH_PE_absptr, intptr_t)
+#undef READ
+ // Read variable-length types
+ case DW_EH_PE_sleb128:
+ return read_sleb128(data);
+ case DW_EH_PE_uleb128:
+ return read_uleb128(data);
+ default: abort();
+ }
+}
+
+/**
+ * Resolves an indirect value. This expects an unwind context, an encoding, a
+ * decoded value, and the start of the region as arguments. The returned value
+ * is a pointer to the address identified by the encoded value.
+ *
+ * If the encoding does not specify an indirect value, then this returns v.
+ */
+static uint64_t resolve_indirect_value(_Unwind_Context *c,
+ unsigned char encoding,
+ int64_t v,
+ dw_eh_ptr_t start)
+{
+ switch (get_base(encoding))
+ {
+ case DW_EH_PE_pcrel:
+ v += reinterpret_cast<uint64_t>(start);
+ break;
+ case DW_EH_PE_textrel:
+ v += static_cast<uint64_t>(static_cast<uintptr_t>(_Unwind_GetTextRelBase(c)));
+ break;
+ case DW_EH_PE_datarel:
+ v += static_cast<uint64_t>(static_cast<uintptr_t>(_Unwind_GetDataRelBase(c)));
+ break;
+ case DW_EH_PE_funcrel:
+ v += static_cast<uint64_t>(static_cast<uintptr_t>(_Unwind_GetRegionStart(c)));
+ default:
+ break;
+ }
+ // If this is an indirect value, then it is really the address of the real
+ // value
+ // TODO: Check whether this should really always be a pointer - it seems to
+ // be a GCC extensions, so not properly documented...
+ if (is_indirect(encoding))
+ {
+ v = static_cast<uint64_t>(reinterpret_cast<uintptr_t>(*reinterpret_cast<void**>(v)));
+ }
+ return v;
+}
+
+
+/**
+ * Reads an encoding and a value, updating *data to point to the next byte.
+ */
+static inline void read_value_with_encoding(_Unwind_Context *context,
+ dw_eh_ptr_t *data,
+ uint64_t *out)
+{
+ dw_eh_ptr_t start = *data;
+ unsigned char encoding = *((*data)++);
+ // If this value is omitted, skip it and don't touch the output value
+ if (encoding == DW_EH_PE_omit) { return; }
+
+ *out = read_value(encoding, data);
+ *out = resolve_indirect_value(context, encoding, *out, start);
+}
+
+/**
+ * Structure storing a decoded language-specific data area. Use parse_lsda()
+ * to generate an instance of this structure from the address returned by the
+ * generic unwind library.
+ *
+ * You should not need to inspect the fields of this structure directly if you
+ * are just using this header. The structure stores the locations of the
+ * various tables used for unwinding exceptions and is used by the functions
+ * for reading values from these tables.
+ */
+struct dwarf_eh_lsda
+{
+ /// The start of the region. This is a cache of the value returned by
+ /// _Unwind_GetRegionStart().
+ dw_eh_ptr_t region_start;
+ /// The start of the landing pads table.
+ dw_eh_ptr_t landing_pads;
+ /// The start of the type table.
+ dw_eh_ptr_t type_table;
+ /// The encoding used for entries in the type tables.
+ unsigned char type_table_encoding;
+ /// The location of the call-site table.
+ dw_eh_ptr_t call_site_table;
+ /// The location of the action table.
+ dw_eh_ptr_t action_table;
+ /// The encoding used for entries in the call-site table.
+ unsigned char callsite_encoding;
+};
+
+/**
+ * Parse the header on the language-specific data area and return a structure
+ * containing the addresses and encodings of the various tables.
+ */
+static inline struct dwarf_eh_lsda parse_lsda(_Unwind_Context *context,
+ unsigned char *data)
+{
+ struct dwarf_eh_lsda lsda;
+
+ lsda.region_start = reinterpret_cast<dw_eh_ptr_t>(_Unwind_GetRegionStart(context));
+
+ // If the landing pads are relative to anything other than the start of
+ // this region, find out where. This is @LPStart in the spec, although the
+ // encoding that GCC uses does not quite match the spec.
+ uint64_t v = static_cast<uint64_t>(reinterpret_cast<uintptr_t>(lsda.region_start));
+ read_value_with_encoding(context, &data, &v);
+ lsda.landing_pads = reinterpret_cast<dw_eh_ptr_t>(static_cast<uintptr_t>(v));
+
+ // If there is a type table, find out where it is. This is @TTBase in the
+ // spec. Note: we find whether there is a type table pointer by checking
+ // whether the leading byte is DW_EH_PE_omit (0xff), which is not what the
+ // spec says, but does seem to be how G++ indicates this.
+ lsda.type_table = 0;
+ lsda.type_table_encoding = *data++;
+ if (lsda.type_table_encoding != DW_EH_PE_omit)
+ {
+ v = read_uleb128(&data);
+ dw_eh_ptr_t type_table = data;
+ type_table += v;
+ lsda.type_table = type_table;
+ //lsda.type_table = (uintptr_t*)(data + v);
+ }
+#if defined(__arm__) && !defined(__ARM_DWARF_EH__)
+ lsda.type_table_encoding = (DW_EH_PE_pcrel | DW_EH_PE_indirect);
+#endif
+
+ lsda.callsite_encoding = static_cast<enum dwarf_data_encoding>(*(data++));
+
+ // Action table is immediately after the call site table
+ lsda.action_table = data;
+ uintptr_t callsite_size = static_cast<uintptr_t>(read_uleb128(&data));
+ lsda.action_table = data + callsite_size;
+ // Call site table is immediately after the header
+ lsda.call_site_table = static_cast<dw_eh_ptr_t>(data);
+
+
+ return lsda;
+}
+
+/**
+ * Structure representing an action to be performed while unwinding. This
+ * contains the address that should be unwound to and the action record that
+ * provoked this action.
+ */
+struct dwarf_eh_action
+{
+ /**
+ * The address that this action directs should be the new program counter
+ * value after unwinding.
+ */
+ dw_eh_ptr_t landing_pad;
+ /// The address of the action record.
+ dw_eh_ptr_t action_record;
+};
+
+/**
+ * Look up the landing pad that corresponds to the current invoke.
+ * Returns true if record exists. The context is provided by the generic
+ * unwind library and the lsda should be the result of a call to parse_lsda().
+ *
+ * The action record is returned via the result parameter.
+ */
+static bool dwarf_eh_find_callsite(struct _Unwind_Context *context,
+ struct dwarf_eh_lsda *lsda,
+ struct dwarf_eh_action *result)
+{
+ result->action_record = 0;
+ result->landing_pad = 0;
+ // The current instruction pointer offset within the region
+ uint64_t ip = _Unwind_GetIP(context) - _Unwind_GetRegionStart(context);
+ unsigned char *callsite_table = static_cast<unsigned char*>(lsda->call_site_table);
+
+ while (callsite_table <= lsda->action_table)
+ {
+ // Once again, the layout deviates from the spec.
+ uint64_t call_site_start, call_site_size, landing_pad, action;
+ call_site_start = read_value(lsda->callsite_encoding, &callsite_table);
+ call_site_size = read_value(lsda->callsite_encoding, &callsite_table);
+
+ // Call site entries are sorted, so if we find a call site that's after
+ // the current instruction pointer then there is no action associated
+ // with this call and we should unwind straight through this frame
+ // without doing anything.
+ if (call_site_start > ip) { break; }
+
+ // Read the address of the landing pad and the action from the call
+ // site table.
+ landing_pad = read_value(lsda->callsite_encoding, &callsite_table);
+ action = read_uleb128(&callsite_table);
+
+ // We should not include the call_site_start (beginning of the region)
+ // address in the ip range. For each call site:
+ //
+ // address1: call proc
+ // address2: next instruction
+ //
+ // The call stack contains address2 and not address1, address1 can be
+ // at the end of another EH region.
+ if (call_site_start < ip && ip <= call_site_start + call_site_size)
+ {
+ if (action)
+ {
+ // Action records are 1-biased so both no-record and zeroth
+ // record can be stored.
+ result->action_record = lsda->action_table + action - 1;
+ }
+ // No landing pad means keep unwinding.
+ if (landing_pad)
+ {
+ // Landing pad is the offset from the value in the header
+ result->landing_pad = lsda->landing_pads + landing_pad;
+ }
+ return true;
+ }
+ }
+ return false;
+}
+
+/// Defines an exception class from 8 bytes (endian independent)
+#define EXCEPTION_CLASS(a,b,c,d,e,f,g,h) \
+ ((static_cast<uint64_t>(a) << 56) +\
+ (static_cast<uint64_t>(b) << 48) +\
+ (static_cast<uint64_t>(c) << 40) +\
+ (static_cast<uint64_t>(d) << 32) +\
+ (static_cast<uint64_t>(e) << 24) +\
+ (static_cast<uint64_t>(f) << 16) +\
+ (static_cast<uint64_t>(g) << 8) +\
+ (static_cast<uint64_t>(h)))
+
+#define GENERIC_EXCEPTION_CLASS(e,f,g,h) \
+ (static_cast<uint32_t>(e) << 24) +\
+ (static_cast<uint32_t>(f) << 16) +\
+ (static_cast<uint32_t>(g) << 8) +\
+ (static_cast<uint32_t>(h))
Copied: vendor/libcxxrt/2015-06-18-e64e93fe5bba67a6d52cbe5a97f8770c054bfa65/libelftc_dem_gnu3.c (from r284549, vendor/libcxxrt/dist/libelftc_dem_gnu3.c)
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ vendor/libcxxrt/2015-06-18-e64e93fe5bba67a6d52cbe5a97f8770c054bfa65/libelftc_dem_gnu3.c Thu Jun 18 14:02:19 2015 (r284550, copy of r284549, vendor/libcxxrt/dist/libelftc_dem_gnu3.c)
@@ -0,0 +1,3893 @@
+/*-
+ * 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.
+ */
+#include <sys/types.h>
+#include <assert.h>
+#include <ctype.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/**
+ * @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
+ */
+
+/** @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 VECTOR_DEF_CAPACITY 8
+#define ELFTC_ISDIGIT(C) (isdigit((C) & 0xFF))
+
+enum type_qualifier {
+ TYPE_PTR, TYPE_REF, TYPE_CMX, TYPE_IMG, TYPE_EXT, TYPE_RST, TYPE_VAT,
+ TYPE_CST, TYPE_VEC
+};
+
+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 vector_read_cmd {
+ size_t size, capacity;
+ enum read_cmd *r_container;
+};
+
+struct cpp_demangle_data {
+ struct vector_str output; /* output string vector */
+ struct vector_str output_tmp;
+ struct vector_str subst; /* substitution string vector */
+ struct vector_str tmpl;
+ struct vector_str class_type;
+ struct vector_read_cmd cmd;
+ bool paren; /* parenthesis opened */
+ bool pfirst; /* first element of parameter */
+ bool mem_rst; /* restrict member function */
+ bool mem_vat; /* volatile member function */
+ bool mem_cst; /* const member function */
+ int func_type;
+ const char *cur; /* current mangled name ptr */
+ const char *last_sname; /* last source name */
+ int push_head;
+};
+
+#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)
+
+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.
+ */
+static 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.
+ */
+static 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.
+ */
+static 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.
+ */
+static 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.
+ */
+static 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.
+ */
+static 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.
+ */
+static 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 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.
+ */
+static 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);
+}
+
+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_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 *);
+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 *, size_t);
+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 *, int);
+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 int 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);
+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 *
+__cxa_demangle_gnu3(const char *org)
+{
+ struct cpp_demangle_data ddata;
+ ssize_t org_len;
+ unsigned int limit;
+ char *rtn = NULL;
+
+ if (org == NULL)
+ return (NULL);
+
+ org_len = strlen(org);
+ 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);
+ }
+
+ // Try demangling as a type for short encodings
+ if ((org_len < 2) || (org[0] != '_' || org[1] != 'Z' )) {
+ if (!cpp_demangle_data_init(&ddata, org))
+ return (NULL);
+ if (!cpp_demangle_read_type(&ddata, 0))
+ goto clean;
+ rtn = vector_str_get_flat(&ddata.output, (size_t *) NULL);
+ goto clean;
+ }
+
+
+ if (!cpp_demangle_data_init(&ddata, org + 2))
+ return (NULL);
+
+ rtn = NULL;
+
+ if (!cpp_demangle_read_encoding(&ddata))
+ goto clean;
+
+ limit = 0;
+ while (*ddata.cur != '\0') {
+ /*
+ * Breaking at some gcc info at tail. e.g) @@GLIBCXX_3.4
+ */
+ if (*ddata.cur == '@' && *(ddata.cur + 1) == '@')
+ break;
+ if (!cpp_demangle_read_type(&ddata, 1))
+ goto clean;
+ if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
+ goto clean;
+ }
+
+ if (ddata.output.size == 0)
+ goto clean;
+ if (ddata.paren && !vector_str_push(&ddata.output, ")", 1))
+ goto clean;
+ if (ddata.mem_vat && !vector_str_push(&ddata.output, " volatile", 9))
+ goto clean;
+ if (ddata.mem_cst && !vector_str_push(&ddata.output, " const", 6))
*** DIFF OUTPUT TRUNCATED AT 1000 LINES ***
More information about the svn-src-all
mailing list