binutils-gdb/libiberty/cp-demangle.c

6827 lines
178 KiB
C
Raw Normal View History

2003-11-21 18:42:45 +01:00
/* Demangler for g++ V3 ABI.
Copyright (C) 2003-2019 Free Software Foundation, Inc.
2003-11-21 18:42:45 +01:00
Written by Ian Lance Taylor <ian@wasabisystems.com>.
2003-08-12 14:23:42 +02:00
This file is part of the libiberty library, which is part of GCC.
2000-10-12 04:16:48 +02:00
2003-08-12 14:23:42 +02:00
This file is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
2002-03-12 22:11:11 +01:00
In addition to the permissions in the GNU General Public License, the
Free Software Foundation gives you unlimited permission to link the
compiled version of this file into combinations with other programs,
and to distribute those combinations without any restriction coming
from the use of this file. (The General Public License restrictions
do apply in other respects; for example, they cover modification of
the file, and distribution when not linked into a combined
executable.)
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
*/
2003-12-04 21:03:39 +01:00
/* This code implements a demangler for the g++ V3 ABI. The ABI is
described on this web page:
https://itanium-cxx-abi.github.io/cxx-abi/abi.html#mangling
2003-12-04 21:03:39 +01:00
This code was written while looking at the demangler written by
Alex Samuel <samuel@codesourcery.com>.
This code first pulls the mangled name apart into a list of
components, and then walks the list generating the demangled
name.
This file will normally define the following functions, q.v.:
char *cplus_demangle_v3(const char *mangled, int options)
char *java_demangle_v3(const char *mangled)
2007-01-31 00:16:58 +01:00
int cplus_demangle_v3_callback(const char *mangled, int options,
demangle_callbackref callback)
int java_demangle_v3_callback(const char *mangled,
demangle_callbackref callback)
2003-12-04 21:03:39 +01:00
enum gnu_v3_ctor_kinds is_gnu_v3_mangled_ctor (const char *name)
enum gnu_v3_dtor_kinds is_gnu_v3_mangled_dtor (const char *name)
2004-01-12 22:24:38 +01:00
Also, the interface to the component list is public, and defined in
demangle.h. The interface consists of these types, which are
defined in demangle.h:
enum demangle_component_type
struct demangle_component
2007-01-31 00:16:58 +01:00
demangle_callbackref
2004-01-12 22:24:38 +01:00
and these functions defined in this file:
cplus_demangle_fill_name
cplus_demangle_fill_extended_operator
cplus_demangle_fill_ctor
cplus_demangle_fill_dtor
cplus_demangle_print
2007-01-31 00:16:58 +01:00
cplus_demangle_print_callback
2004-01-12 22:24:38 +01:00
and other functions defined in the file cp-demint.c.
This file also defines some other functions and variables which are
only to be used by the file cp-demint.c.
2003-12-04 21:03:39 +01:00
Preprocessor macros you can define while compiling this file:
IN_LIBGCC2
2007-01-31 00:16:58 +01:00
If defined, this file defines the following functions, q.v.:
2003-12-04 21:03:39 +01:00
char *__cxa_demangle (const char *mangled, char *buf, size_t *len,
int *status)
2007-01-31 00:16:58 +01:00
int __gcclibcxx_demangle_callback (const char *,
void (*)
(const char *, size_t, void *),
void *)
instead of cplus_demangle_v3[_callback]() and
java_demangle_v3[_callback]().
2003-12-04 21:03:39 +01:00
IN_GLIBCPP_V3
2007-01-31 00:16:58 +01:00
If defined, this file defines only __cxa_demangle() and
__gcclibcxx_demangle_callback(), and no other publically visible
functions or variables.
2003-12-04 21:03:39 +01:00
STANDALONE_DEMANGLER
If defined, this file defines a main() function which demangles
any arguments, or, if none, demangles stdin.
CP_DEMANGLE_DEBUG
If defined, turns on debugging mode, which prints information on
stdout about the mangled string. This is not generally useful.
CHECK_DEMANGLER
If defined, additional sanity checks will be performed. It will
cause some slowdown, but will allow to catch out-of-bound access
errors earlier. This macro is intended for testing and debugging. */
2003-12-04 21:03:39 +01:00
2007-01-31 00:16:58 +01:00
#if defined (_AIX) && !defined (__GNUC__)
#pragma alloca
#endif
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
2003-11-21 18:42:45 +01:00
#include <stdio.h>
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef HAVE_STRING_H
#include <string.h>
#endif
2007-01-31 00:16:58 +01:00
#ifdef HAVE_ALLOCA_H
# include <alloca.h>
#else
# ifndef alloca
# ifdef __GNUC__
# define alloca __builtin_alloca
# else
extern char *alloca ();
# endif /* __GNUC__ */
# endif /* alloca */
#endif /* HAVE_ALLOCA_H */
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
#ifdef HAVE_LIMITS_H
#include <limits.h>
#endif
#ifndef INT_MAX
# define INT_MAX (int)(((unsigned int) ~0) >> 1) /* 0x7FFFFFFF */
#endif
#include "ansidecl.h"
#include "libiberty.h"
#include "demangle.h"
2004-01-12 22:24:38 +01:00
#include "cp-demangle.h"
/* If IN_GLIBCPP_V3 is defined, some functions are made static. We
also rename them via #define to avoid compiler errors when the
static definition conflicts with the extern declaration in a header
file. */
#ifdef IN_GLIBCPP_V3
#define CP_STATIC_IF_GLIBCPP_V3 static
#define cplus_demangle_fill_name d_fill_name
2005-03-27 07:28:42 +02:00
static int d_fill_name (struct demangle_component *, const char *, int);
2004-01-12 22:24:38 +01:00
#define cplus_demangle_fill_extended_operator d_fill_extended_operator
static int
2005-03-27 07:28:42 +02:00
d_fill_extended_operator (struct demangle_component *, int,
struct demangle_component *);
2004-01-12 22:24:38 +01:00
#define cplus_demangle_fill_ctor d_fill_ctor
static int
2005-03-27 07:28:42 +02:00
d_fill_ctor (struct demangle_component *, enum gnu_v3_ctor_kinds,
struct demangle_component *);
2004-01-12 22:24:38 +01:00
#define cplus_demangle_fill_dtor d_fill_dtor
static int
2005-03-27 07:28:42 +02:00
d_fill_dtor (struct demangle_component *, enum gnu_v3_dtor_kinds,
struct demangle_component *);
2004-01-12 22:24:38 +01:00
#define cplus_demangle_mangled_name d_mangled_name
2005-03-27 07:28:42 +02:00
static struct demangle_component *d_mangled_name (struct d_info *, int);
2004-01-12 22:24:38 +01:00
#define cplus_demangle_type d_type
2005-03-27 07:28:42 +02:00
static struct demangle_component *d_type (struct d_info *);
2004-01-12 22:24:38 +01:00
#define cplus_demangle_print d_print
static char *d_print (int, struct demangle_component *, int, size_t *);
2004-01-12 22:24:38 +01:00
2007-01-31 00:16:58 +01:00
#define cplus_demangle_print_callback d_print_callback
static int d_print_callback (int, struct demangle_component *,
2007-01-31 00:16:58 +01:00
demangle_callbackref, void *);
2004-01-12 22:24:38 +01:00
#define cplus_demangle_init_info d_init_info
2005-03-27 07:28:42 +02:00
static void d_init_info (const char *, int, size_t, struct d_info *);
2004-01-12 22:24:38 +01:00
#else /* ! defined(IN_GLIBCPP_V3) */
#define CP_STATIC_IF_GLIBCPP_V3
#endif /* ! defined(IN_GLIBCPP_V3) */
2003-12-22 17:03:32 +01:00
/* See if the compiler supports dynamic arrays. */
#ifdef __GNUC__
#define CP_DYNAMIC_ARRAYS
#else
#ifdef __STDC__
#ifdef __STDC_VERSION__
#if __STDC_VERSION__ >= 199901L
#define CP_DYNAMIC_ARRAYS
#endif /* __STDC__VERSION >= 199901L */
#endif /* defined (__STDC_VERSION__) */
#endif /* defined (__STDC__) */
#endif /* ! defined (__GNUC__) */
2003-12-04 21:03:39 +01:00
/* We avoid pulling in the ctype tables, to prevent pulling in
additional unresolved symbols when this code is used in a library.
FIXME: Is this really a valid reason? This comes from the original
V3 demangler code.
2003-11-21 18:42:45 +01:00
2003-12-04 21:03:39 +01:00
As of this writing this file has the following undefined references
2007-01-31 00:16:58 +01:00
when compiled with -DIN_GLIBCPP_V3: realloc, free, memcpy, strcpy,
strcat, strlen. */
2003-11-21 18:42:45 +01:00
#define IS_DIGIT(c) ((c) >= '0' && (c) <= '9')
2003-12-04 21:03:39 +01:00
#define IS_UPPER(c) ((c) >= 'A' && (c) <= 'Z')
#define IS_LOWER(c) ((c) >= 'a' && (c) <= 'z')
2000-07-20 20:56:16 +02:00
2000-10-12 04:16:48 +02:00
/* The prefix prepended by GCC to an identifier represnting the
anonymous namespace. */
#define ANONYMOUS_NAMESPACE_PREFIX "_GLOBAL_"
2003-11-21 18:42:45 +01:00
#define ANONYMOUS_NAMESPACE_PREFIX_LEN \
(sizeof (ANONYMOUS_NAMESPACE_PREFIX) - 1)
2000-10-12 04:16:48 +02:00
2003-12-15 18:45:42 +01:00
/* Information we keep for the standard substitutions. */
struct d_standard_sub_info
{
/* The code for this substitution. */
char code;
/* The simple string it expands to. */
const char *simple_expansion;
2003-12-22 17:03:32 +01:00
/* The length of the simple expansion. */
int simple_len;
2003-12-15 18:45:42 +01:00
/* The results of a full, verbose, expansion. This is used when
qualifying a constructor/destructor, or when in verbose mode. */
const char *full_expansion;
2003-12-22 17:03:32 +01:00
/* The length of the full expansion. */
int full_len;
2003-12-15 18:45:42 +01:00
/* What to set the last_name field of d_info to; NULL if we should
not set it. This is only relevant when qualifying a
constructor/destructor. */
const char *set_last_name;
2003-12-22 17:03:32 +01:00
/* The length of set_last_name. */
int set_last_name_len;
2003-12-15 18:45:42 +01:00
};
2004-01-12 22:24:38 +01:00
/* Accessors for subtrees of struct demangle_component. */
2003-11-21 18:42:45 +01:00
#define d_left(dc) ((dc)->u.s_binary.left)
#define d_right(dc) ((dc)->u.s_binary.right)
/* A list of templates. This is used while printing. */
2003-11-21 18:42:45 +01:00
struct d_print_template
{
/* Next template on the list. */
struct d_print_template *next;
/* This template. */
2005-05-24 23:01:33 +02:00
const struct demangle_component *template_decl;
2003-11-21 18:42:45 +01:00
};
2003-11-21 18:42:45 +01:00
/* A list of type modifiers. This is used while printing. */
2003-11-21 18:42:45 +01:00
struct d_print_mod
{
/* Next modifier on the list. These are in the reverse of the order
in which they appeared in the mangled string. */
struct d_print_mod *next;
/* The modifier. */
struct demangle_component *mod;
2003-11-21 18:42:45 +01:00
/* Whether this modifier was printed. */
int printed;
2003-11-27 02:17:34 +01:00
/* The list of templates which applies to this modifier. */
struct d_print_template *templates;
2003-11-21 18:42:45 +01:00
};
2007-01-31 00:16:58 +01:00
/* We use these structures to hold information during printing. */
2003-11-21 18:42:45 +01:00
2007-01-31 00:16:58 +01:00
struct d_growable_string
2003-11-21 18:42:45 +01:00
{
/* Buffer holding the result. */
char *buf;
/* Current length of data in buffer. */
size_t len;
/* Allocated size of buffer. */
size_t alc;
2007-01-31 00:16:58 +01:00
/* Set to 1 if we had a memory allocation failure. */
int allocation_failure;
};
/* Stack of components, innermost first, used to avoid loops. */
struct d_component_stack
{
/* This component. */
const struct demangle_component *dc;
/* This component's parent. */
const struct d_component_stack *parent;
};
/* A demangle component and some scope captured when it was first
traversed. */
struct d_saved_scope
{
/* The component whose scope this is. */
const struct demangle_component *container;
/* The list of templates, if any, that was current when this
scope was captured. */
struct d_print_template *templates;
};
/* Checkpoint structure to allow backtracking. This holds copies
of the fields of struct d_info that need to be restored
if a trial parse needs to be backtracked over. */
struct d_info_checkpoint
{
const char *n;
int next_comp;
int next_sub;
int expansion;
};
/* Maximum number of times d_print_comp may be called recursively. */
#define MAX_RECURSION_COUNT 1024
2007-01-31 00:16:58 +01:00
enum { D_PRINT_BUFFER_LENGTH = 256 };
struct d_print_info
{
/* Fixed-length allocated buffer for demangled data, flushed to the
callback with a NUL termination once full. */
char buf[D_PRINT_BUFFER_LENGTH];
/* Current length of data in buffer. */
size_t len;
/* The last character printed, saved individually so that it survives
any buffer flush. */
char last_char;
/* Callback function to handle demangled buffer flush. */
demangle_callbackref callback;
/* Opaque callback argument. */
void *opaque;
2003-11-21 18:42:45 +01:00
/* The current list of templates, if any. */
struct d_print_template *templates;
/* The current list of modifiers (e.g., pointer, reference, etc.),
if any. */
struct d_print_mod *modifiers;
2007-01-31 00:16:58 +01:00
/* Set to 1 if we saw a demangling error. */
int demangle_failure;
/* Number of times d_print_comp was recursively called. Should not
be bigger than MAX_RECURSION_COUNT. */
int recursion;
/* Non-zero if we're printing a lambda argument. A template
parameter reference actually means 'auto'. */
int is_lambda_arg;
2008-10-07 03:28:01 +02:00
/* The current index into any template argument packs we are using
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
for printing, or -1 to print the whole pack. */
2008-10-07 03:28:01 +02:00
int pack_index;
/* Number of d_print_flush calls so far. */
unsigned long int flush_count;
/* Stack of components, innermost first, used to avoid loops. */
const struct d_component_stack *component_stack;
/* Array of saved scopes for evaluating substitutions. */
struct d_saved_scope *saved_scopes;
/* Index of the next unused saved scope in the above array. */
int next_saved_scope;
/* Number of saved scopes in the above array. */
int num_saved_scopes;
/* Array of templates for saving into scopes. */
struct d_print_template *copy_templates;
/* Index of the next unused copy template in the above array. */
int next_copy_template;
/* Number of copy templates in the above array. */
int num_copy_templates;
/* The nearest enclosing template, if any. */
const struct demangle_component *current_template;
2003-11-21 18:42:45 +01:00
};
#ifdef CP_DEMANGLE_DEBUG
2005-03-27 07:28:42 +02:00
static void d_dump (struct demangle_component *, int);
#endif
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_make_empty (struct d_info *);
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_make_comp (struct d_info *, enum demangle_component_type,
struct demangle_component *,
struct demangle_component *);
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_make_name (struct d_info *, const char *, int);
2004-01-12 22:24:38 +01:00
static struct demangle_component *
d_make_demangle_mangled_name (struct d_info *, const char *);
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_make_builtin_type (struct d_info *,
const struct demangle_builtin_type_info *);
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_make_operator (struct d_info *,
const struct demangle_operator_info *);
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_make_extended_operator (struct d_info *, int,
struct demangle_component *);
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_make_ctor (struct d_info *, enum gnu_v3_ctor_kinds,
struct demangle_component *);
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_make_dtor (struct d_info *, enum gnu_v3_dtor_kinds,
struct demangle_component *);
2004-01-12 22:24:38 +01:00
static struct demangle_component *
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
d_make_template_param (struct d_info *, int);
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_make_sub (struct d_info *, const char *, int);
2004-01-12 22:24:38 +01:00
static int
2005-03-27 07:28:42 +02:00
has_return_type (struct demangle_component *);
2004-01-12 22:24:38 +01:00
static int
2005-03-27 07:28:42 +02:00
is_ctor_dtor_or_conversion (struct demangle_component *);
2004-01-12 22:24:38 +01:00
2005-03-27 07:28:42 +02:00
static struct demangle_component *d_encoding (struct d_info *, int);
2004-01-12 22:24:38 +01:00
Update the libiberty sources with the latest patches found in the master sources. 2017-01-02 Richard Biener <rguenther@suse.de> PR lto/83452 * simple-object-elf.c (simple_object_elf_copy_lto_debug_section): Do not use UNDEF locals for removed symbols but instead just define them in the first prevailing section and with no name. Use the same gnu_lto_v1 name for all removed globals we promote to WEAK UNDEFs so hpux can use a stub to provide this symbol. Clear sh_info and sh_link in removed sections. 2017-10-30 Richard Biener <rguenther@suse.de> PR lto/82757 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Strip two leading _s from the __gnu_lto_* symbols. 2017-10-24 Alan Modra <amodra@gmail.com> PR lto/82687 PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Only make __gnu_lto symbols hidden. 2017-10-20 Alan Modra <amodra@gmail.com> PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Make discarded non-local symbols weak and hidden. 2017-10-18 Jakub Jelinek <jakub@redhat.com> PR lto/82598 * simple-object.c (handle_lto_debug_sections): Copy over also .note.GNU-stack section with unchanged name. * simple-object-elf.c (SHF_EXECINSTR): Define. (simple_object_elf_copy_lto_debug_section): Drop SHF_EXECINSTR bit on .note.GNU-stack section. 2017-09-25 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_encoding): Strip return type when name is a LOCAL_NAME. (d_local_name): Strip return type of enclosing TYPED_NAME. * testsuite/demangle-expected: Add and adjust tests. 2017-09-21 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Revert addition of 'toplevel' parm. (has_return_type): Recurse for DEMANGLE_COMPONENT_LOCAL_NAME. (d_encoding): Revert d_name change. Use is_fnqual_component_type to strip modifiers that do not belong. (d_special_name, d_class_enum_type): Revert d_name call change. (d_expresion_1): Commonize DEMANGLE_COMPONENT_UNARY building. (d_local_name): Revert parsing of a function type. (d_print_comp_inner): An inner LOCAL_NAME might contain a TEMPLATE. * testsuite/demangle-expected: Add & adjust tests
2018-01-10 14:57:48 +01:00
static struct demangle_component *d_name (struct d_info *);
2004-01-12 22:24:38 +01:00
2005-03-27 07:28:42 +02:00
static struct demangle_component *d_nested_name (struct d_info *);
2004-01-12 22:24:38 +01:00
2005-03-27 07:28:42 +02:00
static struct demangle_component *d_prefix (struct d_info *);
2004-01-12 22:24:38 +01:00
2005-03-27 07:28:42 +02:00
static struct demangle_component *d_unqualified_name (struct d_info *);
2004-01-12 22:24:38 +01:00
2005-03-27 07:28:42 +02:00
static struct demangle_component *d_source_name (struct d_info *);
2004-01-12 22:24:38 +01:00
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
static int d_number (struct d_info *);
2004-01-12 22:24:38 +01:00
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
static struct demangle_component *d_identifier (struct d_info *, int);
2004-01-12 22:24:38 +01:00
2005-03-27 07:28:42 +02:00
static struct demangle_component *d_operator_name (struct d_info *);
2004-01-12 22:24:38 +01:00
2005-03-27 07:28:42 +02:00
static struct demangle_component *d_special_name (struct d_info *);
2004-01-12 22:24:38 +01:00
static struct demangle_component *d_parmlist (struct d_info *);
2005-03-27 07:28:42 +02:00
static int d_call_offset (struct d_info *, int);
2004-01-12 22:24:38 +01:00
2005-03-27 07:28:42 +02:00
static struct demangle_component *d_ctor_dtor_name (struct d_info *);
2004-01-12 22:24:38 +01:00
static struct demangle_component **
2005-03-27 07:28:42 +02:00
d_cv_qualifiers (struct d_info *, struct demangle_component **, int);
2004-01-12 22:24:38 +01:00
2013-04-03 20:21:49 +02:00
static struct demangle_component *
d_ref_qualifier (struct d_info *, struct demangle_component *);
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_function_type (struct d_info *);
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_bare_function_type (struct d_info *, int);
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_class_enum_type (struct d_info *);
2004-01-12 22:24:38 +01:00
2005-03-27 07:28:42 +02:00
static struct demangle_component *d_array_type (struct d_info *);
2004-01-12 22:24:38 +01:00
2010-02-04 00:28:01 +01:00
static struct demangle_component *d_vector_type (struct d_info *);
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_pointer_to_member_type (struct d_info *);
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_template_param (struct d_info *);
2004-01-12 22:24:38 +01:00
2005-03-27 07:28:42 +02:00
static struct demangle_component *d_template_args (struct d_info *);
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
static struct demangle_component *d_template_args_1 (struct d_info *);
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_template_arg (struct d_info *);
2004-01-12 22:24:38 +01:00
2005-03-27 07:28:42 +02:00
static struct demangle_component *d_expression (struct d_info *);
2004-01-12 22:24:38 +01:00
2005-03-27 07:28:42 +02:00
static struct demangle_component *d_expr_primary (struct d_info *);
2004-01-12 22:24:38 +01:00
Update the libiberty sources with the latest patches found in the master sources. 2017-01-02 Richard Biener <rguenther@suse.de> PR lto/83452 * simple-object-elf.c (simple_object_elf_copy_lto_debug_section): Do not use UNDEF locals for removed symbols but instead just define them in the first prevailing section and with no name. Use the same gnu_lto_v1 name for all removed globals we promote to WEAK UNDEFs so hpux can use a stub to provide this symbol. Clear sh_info and sh_link in removed sections. 2017-10-30 Richard Biener <rguenther@suse.de> PR lto/82757 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Strip two leading _s from the __gnu_lto_* symbols. 2017-10-24 Alan Modra <amodra@gmail.com> PR lto/82687 PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Only make __gnu_lto symbols hidden. 2017-10-20 Alan Modra <amodra@gmail.com> PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Make discarded non-local symbols weak and hidden. 2017-10-18 Jakub Jelinek <jakub@redhat.com> PR lto/82598 * simple-object.c (handle_lto_debug_sections): Copy over also .note.GNU-stack section with unchanged name. * simple-object-elf.c (SHF_EXECINSTR): Define. (simple_object_elf_copy_lto_debug_section): Drop SHF_EXECINSTR bit on .note.GNU-stack section. 2017-09-25 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_encoding): Strip return type when name is a LOCAL_NAME. (d_local_name): Strip return type of enclosing TYPED_NAME. * testsuite/demangle-expected: Add and adjust tests. 2017-09-21 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Revert addition of 'toplevel' parm. (has_return_type): Recurse for DEMANGLE_COMPONENT_LOCAL_NAME. (d_encoding): Revert d_name change. Use is_fnqual_component_type to strip modifiers that do not belong. (d_special_name, d_class_enum_type): Revert d_name call change. (d_expresion_1): Commonize DEMANGLE_COMPONENT_UNARY building. (d_local_name): Revert parsing of a function type. (d_print_comp_inner): An inner LOCAL_NAME might contain a TEMPLATE. * testsuite/demangle-expected: Add & adjust tests
2018-01-10 14:57:48 +01:00
static struct demangle_component *d_local_name (struct d_info *);
2004-01-12 22:24:38 +01:00
2005-03-27 07:28:42 +02:00
static int d_discriminator (struct d_info *);
2004-01-12 22:24:38 +01:00
2009-10-02 20:23:01 +02:00
static struct demangle_component *d_lambda (struct d_info *);
static struct demangle_component *d_unnamed_type (struct d_info *);
2011-09-24 00:21:36 +02:00
static struct demangle_component *
d_clone_suffix (struct d_info *, struct demangle_component *);
2004-01-12 22:24:38 +01:00
static int
2005-03-27 07:28:42 +02:00
d_add_substitution (struct d_info *, struct demangle_component *);
2004-01-12 22:24:38 +01:00
2005-03-27 07:28:42 +02:00
static struct demangle_component *d_substitution (struct d_info *, int);
2004-01-12 22:24:38 +01:00
static void d_checkpoint (struct d_info *, struct d_info_checkpoint *);
static void d_backtrack (struct d_info *, struct d_info_checkpoint *);
2007-01-31 00:16:58 +01:00
static void d_growable_string_init (struct d_growable_string *, size_t);
2004-01-12 22:24:38 +01:00
2007-01-31 00:16:58 +01:00
static inline void
d_growable_string_resize (struct d_growable_string *, size_t);
2004-01-12 22:24:38 +01:00
2007-01-31 00:16:58 +01:00
static inline void
d_growable_string_append_buffer (struct d_growable_string *,
const char *, size_t);
2004-01-12 22:24:38 +01:00
static void
2007-01-31 00:16:58 +01:00
d_growable_string_callback_adapter (const char *, size_t, void *);
static void
d_print_init (struct d_print_info *, demangle_callbackref, void *,
const struct demangle_component *);
2007-01-31 00:16:58 +01:00
static inline void d_print_error (struct d_print_info *);
static inline int d_print_saw_error (struct d_print_info *);
static inline void d_print_flush (struct d_print_info *);
static inline void d_append_char (struct d_print_info *, char);
2004-01-12 22:24:38 +01:00
2007-01-31 00:16:58 +01:00
static inline void d_append_buffer (struct d_print_info *,
const char *, size_t);
static inline void d_append_string (struct d_print_info *, const char *);
static inline char d_last_char (struct d_print_info *);
2004-01-12 22:24:38 +01:00
static void
d_print_comp (struct d_print_info *, int, struct demangle_component *);
2004-01-12 22:24:38 +01:00
static void
2005-03-27 07:28:42 +02:00
d_print_java_identifier (struct d_print_info *, const char *, int);
2004-01-12 22:24:38 +01:00
static void
2011-06-14 01:01:48 +02:00
d_print_mod_list (struct d_print_info *, int, struct d_print_mod *, int);
2004-01-12 22:24:38 +01:00
static void
d_print_mod (struct d_print_info *, int, struct demangle_component *);
2004-01-12 22:24:38 +01:00
static void
2011-06-14 01:01:48 +02:00
d_print_function_type (struct d_print_info *, int,
struct demangle_component *,
2005-03-27 07:28:42 +02:00
struct d_print_mod *);
2004-01-12 22:24:38 +01:00
static void
2011-06-14 01:01:48 +02:00
d_print_array_type (struct d_print_info *, int,
struct demangle_component *,
2005-03-27 07:28:42 +02:00
struct d_print_mod *);
2004-01-12 22:24:38 +01:00
static void
d_print_expr_op (struct d_print_info *, int, struct demangle_component *);
2004-01-12 22:24:38 +01:00
PR other/61321 - demangler crash on casts in template parameters The fix for bug 59195: [C++ demangler handles conversion operator incorrectly] https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59195 unfortunately makes the demangler crash due to infinite recursion, in case of casts in template parameters. For example, with: template<int> struct A {}; template <typename Y> void function_temp(A<sizeof ((Y)(999))>) {} template void function_temp<int>(A<sizeof (int)>); The 'function_temp<int>' instantiation above mangles to: _Z13function_tempIiEv1AIXszcvT_Li999EEE The demangler parses this as: typed name template name 'function_temp' template argument list builtin type int function type builtin type void argument list template (*) name 'A' template argument list unary operator operator sizeof unary operator cast template parameter 0 (**) literal builtin type int name '999' And after the fix for 59195, due to: static void d_print_cast (struct d_print_info *dpi, int options, const struct demangle_component *dc) { ... /* For a cast operator, we need the template parameters from the enclosing template in scope for processing the type. */ if (dpi->current_template != NULL) { dpt.next = dpi->templates; dpi->templates = &dpt; dpt.template_decl = dpi->current_template; } when printing the template argument list of A (what should be "<sizeof (int)>"), the template parameter 0 (that is, "T_", the '**' above) now refers to the first parameter of the the template argument list of the 'A' template (the '*' above), exactly what we were already trying to print. This leads to infinite recursion, and stack exaustion. The template parameter 0 should actually refer to the first parameter of the 'function_temp' template. Where it reads "for the cast operator" in the comment in d_print_cast (above), it's really talking about a conversion operator, like: struct A { template <typename U> explicit operator U(); }; We don't want to inject the template parameters from the enclosing template in scope when processing a cast _expression_, only when handling a conversion operator. The problem is that DEMANGLE_COMPONENT_CAST is currently ambiguous, and means _both_ 'conversion operator' and 'cast expression'. Fix this by adding a new DEMANGLE_COMPONENT_CONVERSION component type, which does what DEMANGLE_COMPONENT_CAST does today, and making DEMANGLE_COMPONENT_CAST just simply print its component subtree. I think we could instead reuse DEMANGLE_COMPONENT_CAST and in d_print_comp_inner still do: @@ -5001,9 +5013,9 @@ d_print_comp_inner (struct d_print_info *dpi, int options, d_print_comp (dpi, options, dc->u.s_extended_operator.name); return; case DEMANGLE_COMPONENT_CAST: d_append_string (dpi, "operator "); - d_print_cast (dpi, options, dc); + d_print_conversion (dpi, options, dc); return; leaving the unary cast case below calling d_print_cast, but seems to me that spliting the component types makes it easier to reason about the code. g++'s testsuite actually generates three symbols that crash the demangler in the same way. I've added those as tests in the demangler testsuite as well. And then this fixes PR other/61233 too, which happens to be a demangler crash originally reported to GDB, at: https://sourceware.org/bugzilla/show_bug.cgi?id=16957 Bootstrapped and regtested on x86_64 Fedora 20. Also ran this through GDB's testsuite. GDB will require a small update to use DEMANGLE_COMPONENT_CONVERSION in one place it's using DEMANGLE_COMPONENT_CAST in its sources. libiberty/ 2015-11-27 Pedro Alves <palves@redhat.com> PR other/61321 PR other/61233 * demangle.h (enum demangle_component_type) <DEMANGLE_COMPONENT_CONVERSION>: New value. * cp-demangle.c (d_demangle_callback, d_make_comp): Handle DEMANGLE_COMPONENT_CONVERSION. (is_ctor_dtor_or_conversion): Handle DEMANGLE_COMPONENT_CONVERSION instead of DEMANGLE_COMPONENT_CAST. (d_operator_name): Return a DEMANGLE_COMPONENT_CONVERSION component if handling a conversion. (d_count_templates_scopes, d_print_comp_inner): Handle DEMANGLE_COMPONENT_CONVERSION. (d_print_comp_inner): Handle DEMANGLE_COMPONENT_CONVERSION instead of DEMANGLE_COMPONENT_CAST. (d_print_cast): Rename as ... (d_print_conversion): ... this. Adjust comments. (d_print_cast): Rewrite - simply print the left subcomponent. * cp-demint.c (cplus_demangle_fill_component): Handle DEMANGLE_COMPONENT_CONVERSION. * testsuite/demangle-expected: Add tests. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@231020 138bc75d-0d04-0410-961f-82ee72b054a4
2015-11-28 17:39:31 +01:00
static void d_print_cast (struct d_print_info *, int,
struct demangle_component *);
PR other/61321 - demangler crash on casts in template parameters The fix for bug 59195: [C++ demangler handles conversion operator incorrectly] https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59195 unfortunately makes the demangler crash due to infinite recursion, in case of casts in template parameters. For example, with: template<int> struct A {}; template <typename Y> void function_temp(A<sizeof ((Y)(999))>) {} template void function_temp<int>(A<sizeof (int)>); The 'function_temp<int>' instantiation above mangles to: _Z13function_tempIiEv1AIXszcvT_Li999EEE The demangler parses this as: typed name template name 'function_temp' template argument list builtin type int function type builtin type void argument list template (*) name 'A' template argument list unary operator operator sizeof unary operator cast template parameter 0 (**) literal builtin type int name '999' And after the fix for 59195, due to: static void d_print_cast (struct d_print_info *dpi, int options, const struct demangle_component *dc) { ... /* For a cast operator, we need the template parameters from the enclosing template in scope for processing the type. */ if (dpi->current_template != NULL) { dpt.next = dpi->templates; dpi->templates = &dpt; dpt.template_decl = dpi->current_template; } when printing the template argument list of A (what should be "<sizeof (int)>"), the template parameter 0 (that is, "T_", the '**' above) now refers to the first parameter of the the template argument list of the 'A' template (the '*' above), exactly what we were already trying to print. This leads to infinite recursion, and stack exaustion. The template parameter 0 should actually refer to the first parameter of the 'function_temp' template. Where it reads "for the cast operator" in the comment in d_print_cast (above), it's really talking about a conversion operator, like: struct A { template <typename U> explicit operator U(); }; We don't want to inject the template parameters from the enclosing template in scope when processing a cast _expression_, only when handling a conversion operator. The problem is that DEMANGLE_COMPONENT_CAST is currently ambiguous, and means _both_ 'conversion operator' and 'cast expression'. Fix this by adding a new DEMANGLE_COMPONENT_CONVERSION component type, which does what DEMANGLE_COMPONENT_CAST does today, and making DEMANGLE_COMPONENT_CAST just simply print its component subtree. I think we could instead reuse DEMANGLE_COMPONENT_CAST and in d_print_comp_inner still do: @@ -5001,9 +5013,9 @@ d_print_comp_inner (struct d_print_info *dpi, int options, d_print_comp (dpi, options, dc->u.s_extended_operator.name); return; case DEMANGLE_COMPONENT_CAST: d_append_string (dpi, "operator "); - d_print_cast (dpi, options, dc); + d_print_conversion (dpi, options, dc); return; leaving the unary cast case below calling d_print_cast, but seems to me that spliting the component types makes it easier to reason about the code. g++'s testsuite actually generates three symbols that crash the demangler in the same way. I've added those as tests in the demangler testsuite as well. And then this fixes PR other/61233 too, which happens to be a demangler crash originally reported to GDB, at: https://sourceware.org/bugzilla/show_bug.cgi?id=16957 Bootstrapped and regtested on x86_64 Fedora 20. Also ran this through GDB's testsuite. GDB will require a small update to use DEMANGLE_COMPONENT_CONVERSION in one place it's using DEMANGLE_COMPONENT_CAST in its sources. libiberty/ 2015-11-27 Pedro Alves <palves@redhat.com> PR other/61321 PR other/61233 * demangle.h (enum demangle_component_type) <DEMANGLE_COMPONENT_CONVERSION>: New value. * cp-demangle.c (d_demangle_callback, d_make_comp): Handle DEMANGLE_COMPONENT_CONVERSION. (is_ctor_dtor_or_conversion): Handle DEMANGLE_COMPONENT_CONVERSION instead of DEMANGLE_COMPONENT_CAST. (d_operator_name): Return a DEMANGLE_COMPONENT_CONVERSION component if handling a conversion. (d_count_templates_scopes, d_print_comp_inner): Handle DEMANGLE_COMPONENT_CONVERSION. (d_print_comp_inner): Handle DEMANGLE_COMPONENT_CONVERSION instead of DEMANGLE_COMPONENT_CAST. (d_print_cast): Rename as ... (d_print_conversion): ... this. Adjust comments. (d_print_cast): Rewrite - simply print the left subcomponent. * cp-demint.c (cplus_demangle_fill_component): Handle DEMANGLE_COMPONENT_CONVERSION. * testsuite/demangle-expected: Add tests. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@231020 138bc75d-0d04-0410-961f-82ee72b054a4
2015-11-28 17:39:31 +01:00
static void d_print_conversion (struct d_print_info *, int,
struct demangle_component *);
2004-01-12 22:24:38 +01:00
2007-01-31 00:16:58 +01:00
static int d_demangle_callback (const char *, int,
demangle_callbackref, void *);
2005-03-27 07:28:42 +02:00
static char *d_demangle (const char *, int, size_t *);
2003-11-21 18:42:45 +01:00
#define FNQUAL_COMPONENT_CASE \
case DEMANGLE_COMPONENT_RESTRICT_THIS: \
case DEMANGLE_COMPONENT_VOLATILE_THIS: \
case DEMANGLE_COMPONENT_CONST_THIS: \
case DEMANGLE_COMPONENT_REFERENCE_THIS: \
case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS: \
case DEMANGLE_COMPONENT_TRANSACTION_SAFE: \
case DEMANGLE_COMPONENT_NOEXCEPT: \
case DEMANGLE_COMPONENT_THROW_SPEC
Sync libiberty/ & include/ with GCC Note this brings in the interface files for libcc1/G++ as well, which we will be needing in GDB soon anyway. That commit renamed a method in the C interface and that required a small update to GDB's compile/ code, which I've included that in this patch to keep the tree building. include/ChangeLog: 2017-09-15 Pedro Alves <palves@redhat.com> * ansidecl.h (DISABLE_COPY_AND_ASSIGN): New macro. 2017-09-12 Jiong Wang <jiong.wang@arm.com> * dwarf2.def (DW_CFA_AARCH64_negate_ra_state): New DW_CFA_DUP. * dwarf2.h (DW_CFA_DUP): New define. 2017-08-21 Richard Biener <rguenther@suse.de> * simple-object.h (simple_object_copy_lto_debug_sections): New function. 2017-05-18 Martin Liska <mliska@suse.cz> * ansidecl.h: Define CONSTEXPR macro. 2017-05-24 Nathan Sidwell <nathan@acm.org> * libiberty.h (ASTRDUP): Adjust cast to avoid warning. 2017-01-30 Alexandre Oliva <aoliva@redhat.com> Introduce C++ support in libcc1. * gcc-c-fe.def (int_type_v0): Rename from... (int_type): ... this. Introduce new version. (float_type_v0): Rename from... (float_type): ... this. Introduce new version. (char_type): New. * gcc-c-interface.h (gcc_c_api_version): Add GCC_C_FE_VERSION_1. (gcc_type_array): Move... * gcc-interface.h: ... here. * gcc-cp-fe.def: New. * gcc-cp-interface.h: New. 2016-04-29 Oleg Endo <olegendo@gcc.gnu.org> * longlong.h (umul_ppmm): Remove SHMEDIA checks. (__umulsidi3, count_leading_zeros): Remove SHMEDIA implementations. 2017-09-15 Yao Qi <yao.qi@linaro.org> Pedro Alves <palves@redhat.com> * ansidecl.h (DISABLE_COPY_AND_ASSIGN): New macro. 2017-09-12 Jiong Wang <jiong.wang@arm.com> * dwarf2.def (DW_CFA_AARCH64_negate_ra_state): New DW_CFA_DUP. * dwarf2.h (DW_CFA_DUP): New define. 2017-08-21 Richard Biener <rguenther@suse.de> * simple-object.h (simple_object_copy_lto_debug_sections): New function. 2017-05-18 Martin Liska <mliska@suse.cz> * ansidecl.h: Define CONSTEXPR macro. 2017-05-24 Nathan Sidwell <nathan@acm.org> * libiberty.h (ASTRDUP): Adjust cast to avoid warning. 2017-01-30 Alexandre Oliva <aoliva@redhat.com> Introduce C++ support in libcc1. * gcc-c-fe.def (int_type_v0): Rename from... (int_type): ... this. Introduce new version. (float_type_v0): Rename from... (float_type): ... this. Introduce new version. (char_type): New. * gcc-c-interface.h (gcc_c_api_version): Add GCC_C_FE_VERSION_1. (gcc_type_array): Move... * gcc-interface.h: ... here. * gcc-cp-fe.def: New. * gcc-cp-interface.h: New. 2016-04-29 Oleg Endo <olegendo@gcc.gnu.org> * longlong.h (umul_ppmm): Remove SHMEDIA checks. (__umulsidi3, count_leading_zeros): Remove SHMEDIA implementations. libiberty/ChangeLog: 2017-09-15 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Add 'toplevel' parm. Pass to ... (d_local_name): ... here. Parse trailing function args on nested local_name. (d_encoding, d_special_name, d_class_enum_type): Adjust d_name calls. * testsuite/demangle-expected: Add tests. 2017-09-15 Richard Biener <rguenther@suse.de> PR lto/81968 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Iterate marking dependent sections necessary. 2017-09-15 Nathan Sidwell <nathan@acm.org> * cp-demangle.c (is_fnqual_component_type): Reimplement using FNQUAL_COMPONENT_CASE. (d_encoding): Hold bare_function_type in local var. (d_local_name): Build name in both cases and build result once. Collapse switch-if to single conditional. (d_local_name): * testsuite/demangle-expected: Realign blank lines with tests. 2017-09-12 Jiong Wang <jiong.wang@arm.com> * dwarfnames.c (DW_CFA_DUP): New define. gdb/ChangeLog: 2017-09-15 Pedro Alves <palves@redhat.com> * compile/compile-c-types.c (convert_enum, convert_int) (convert_float): Adjust to refer to int_type_v0 and float_type_v0.
2017-09-15 18:40:33 +02:00
/* True iff TYPE is a demangling component representing a
function-type-qualifier. */
static int
is_fnqual_component_type (enum demangle_component_type type)
{
switch (type)
{
FNQUAL_COMPONENT_CASE:
return 1;
default:
break;
}
return 0;
}
#ifdef CP_DEMANGLE_DEBUG
2003-11-21 18:42:45 +01:00
static void
2005-03-27 07:28:42 +02:00
d_dump (struct demangle_component *dc, int indent)
{
int i;
2003-11-21 18:42:45 +01:00
if (dc == NULL)
2007-01-31 00:16:58 +01:00
{
if (indent == 0)
printf ("failed demangling\n");
return;
}
2003-11-21 18:42:45 +01:00
for (i = 0; i < indent; ++i)
putchar (' ');
switch (dc->type)
{
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_NAME:
2003-11-21 18:42:45 +01:00
printf ("name '%.*s'\n", dc->u.s_name.len, dc->u.s_name.s);
return;
2012-11-11 23:37:30 +01:00
case DEMANGLE_COMPONENT_TAGGED_NAME:
printf ("tagged name\n");
d_dump (dc->u.s_binary.left, indent + 2);
d_dump (dc->u.s_binary.right, indent + 2);
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
2003-11-21 18:42:45 +01:00
printf ("template parameter %ld\n", dc->u.s_number.number);
return;
Synchronize libiberty with gcc and add --no-recruse-limit option to tools that support name demangling. This patch addresses the multitude of bug reports about resource exhaustion in libiberty's name demangling code. It adds a limit to the amount of recursion that is allowed, before an error is triggered. It also adds a new demangling option to disable this limit. (The limit is enabled by default). PR 87681 PR 87675 PR 87636 PR 87335 libiberty * cp-demangle.h (struct d_info): Add recursion_limit field. * cp-demangle.c (d_function_type): If the recursion limit is enabled and reached, return with a failure result. (d_demangle_callback): If the recursion limit is enabled, check for a mangled string that is so long that there is not enough stack space for the local arrays. * cplus-dem.c (struct work): Add recursion_level field. (demangle_nested_args): If the recursion limit is enabled and reached, return with a failure result. include * demangle.h (DMGL_RECURSE_LIMIT): Define. (DEMANGLE_RECURSION_LIMIT): Prototype. binutuils * addr2line.c (demangle_flags): New static variable. (long_options): Add --recurse-limit and --no-recurse-limit. (translate_address): Pass demangle_flags to bfd_demangle. (main): Handle --recurse-limit and --no-recurse-limit options. * cxxfilt.c (flags): Add DMGL_RECURSE_LIMIT. (long_options): Add --recurse-limit and --no-recurse-limit. (main): Handle new options. * dlltool.c (gen_def_file): Include DMGL_RECURSE_LIMIT in flags passed to cplus_demangle. * nm.c (demangle_flags): New static variable. (long_options): Add --recurse-limit and --no-recurse-limit. (main): Handle new options. * objdump.c (demangle_flags): New static variable. (usage): Add --recurse-limit and --no-recurse-limit. (long_options): Likewise. (objdump_print_symname): Pass demangle_flags to bfd_demangle. (disassemble_section): Likewise. (dump_dymbols): Likewise. (main): Handle new options. * prdbg.c (demangle_flags): New static variable. (tg_variable): Pass demangle_flags to demangler. (tg_start_function): Likewise. * stabs.c (demangle_flags): New static variable. (stab_demangle_template): Pass demangle_flags to demangler. (stab_demangle_v3_argtypes): Likewise. (stab_demangle_v3_arg): Likewise. * doc/binutuls.texi: Document new command line options. * NEWS: Mention the new feature. * testsuite/config/default.exp (CXXFILT): Define if not already defined. (CXXFILTFLAGS): Likewise. * testsuite/binutils-all/cxxfilt.exp: New file. Runs a few simple tests of the cxxfilt program.
2018-12-07 12:32:55 +01:00
case DEMANGLE_COMPONENT_TPARM_OBJ:
printf ("template parameter object\n");
break;
case DEMANGLE_COMPONENT_FUNCTION_PARAM:
printf ("function parameter %ld\n", dc->u.s_number.number);
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_CTOR:
2003-11-21 18:42:45 +01:00
printf ("constructor %d\n", (int) dc->u.s_ctor.kind);
d_dump (dc->u.s_ctor.name, indent + 2);
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_DTOR:
2003-11-21 18:42:45 +01:00
printf ("destructor %d\n", (int) dc->u.s_dtor.kind);
d_dump (dc->u.s_dtor.name, indent + 2);
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_SUB_STD:
2003-11-21 18:42:45 +01:00
printf ("standard substitution %s\n", dc->u.s_string.string);
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_BUILTIN_TYPE:
2003-11-21 18:42:45 +01:00
printf ("builtin type %s\n", dc->u.s_builtin.type->name);
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_OPERATOR:
2003-11-21 18:42:45 +01:00
printf ("operator %s\n", dc->u.s_operator.op->name);
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
2003-11-21 18:42:45 +01:00
printf ("extended operator with %d args\n",
dc->u.s_extended_operator.args);
d_dump (dc->u.s_extended_operator.name, indent + 2);
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_QUAL_NAME:
2003-11-21 18:42:45 +01:00
printf ("qualified name\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_LOCAL_NAME:
2003-12-19 23:03:41 +01:00
printf ("local name\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_TYPED_NAME:
2003-11-21 18:42:45 +01:00
printf ("typed name\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_TEMPLATE:
2003-11-21 18:42:45 +01:00
printf ("template\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_VTABLE:
2003-11-21 18:42:45 +01:00
printf ("vtable\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_VTT:
2003-11-21 18:42:45 +01:00
printf ("VTT\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
2003-11-21 18:42:45 +01:00
printf ("construction vtable\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_TYPEINFO:
2003-11-21 18:42:45 +01:00
printf ("typeinfo\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_TYPEINFO_NAME:
2003-11-21 18:42:45 +01:00
printf ("typeinfo name\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_TYPEINFO_FN:
2003-11-21 18:42:45 +01:00
printf ("typeinfo function\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_THUNK:
2003-11-21 18:42:45 +01:00
printf ("thunk\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
2003-11-21 18:42:45 +01:00
printf ("virtual thunk\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_COVARIANT_THUNK:
2003-11-21 18:42:45 +01:00
printf ("covariant thunk\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_JAVA_CLASS:
2003-11-21 18:42:45 +01:00
printf ("java class\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_GUARD:
2003-11-21 18:42:45 +01:00
printf ("guard\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_REFTEMP:
2003-11-21 18:42:45 +01:00
printf ("reference temporary\n");
break;
case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
printf ("hidden alias\n");
break;
2011-11-08 17:01:58 +01:00
case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
printf ("transaction clone\n");
break;
case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
printf ("non-transaction clone\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_RESTRICT:
2003-11-21 18:42:45 +01:00
printf ("restrict\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_VOLATILE:
2003-11-21 18:42:45 +01:00
printf ("volatile\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_CONST:
2003-11-21 18:42:45 +01:00
printf ("const\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_RESTRICT_THIS:
2003-12-04 21:03:39 +01:00
printf ("restrict this\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_VOLATILE_THIS:
2003-12-04 21:03:39 +01:00
printf ("volatile this\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_CONST_THIS:
2003-12-04 21:03:39 +01:00
printf ("const this\n");
break;
2013-04-03 20:21:49 +02:00
case DEMANGLE_COMPONENT_REFERENCE_THIS:
printf ("reference this\n");
break;
case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
printf ("rvalue reference this\n");
break;
Implement N4514, C++ Extensions for Transactional Memory. gcc/ * builtins.def (BUILT_IN_ABORT): Add transaction_pure attribute. gcc/c-family/ * c-common.c (c_common_reswords): Add C++ TM TS keywords. (c_common_attribute_table): Add transaction_safe_dynamic. transaction_safe now affects type identity. (handle_tm_attribute): Handle transaction_safe_dynamic. * c-common.h (enum rid): Add RID_ATOMIC_NOEXCEPT, RID_ATOMIC_CANCEL, RID_SYNCHRONIZED. (OBJC_IS_CXX_KEYWORD): Add RID_SYNCHRONIZED. (D_TRANSMEM): New. * c-cppbuiltin.c (c_cpp_builtins): Define __cpp_transactional_memory. * c-pretty-print.c (pp_c_attributes_display): Don't print transaction_safe in C++. gcc/c/ * c-parser.c (c_lex_one_token): Handle @synchronized. * c-decl.c (match_builtin_function_types): A declaration of a built-in can change whether the function is transaction_safe. gcc/cp/ * cp-tree.h (struct cp_declarator): Add tx_qualifier field. (BCS_NORMAL, BCS_TRANSACTION): New enumerators. * lex.c (init_reswords): Limit TM kewords to -fgnu-tm. * parser.c (cp_lexer_get_preprocessor_token): Fix @synchronized. (make_call_declarator): Take tx_qualifier. (cp_parser_tx_qualifier_opt): New. (cp_parser_lambda_declarator_opt): Use it. (cp_parser_direct_declarator): Likewise. (cp_parser_statement): Handle atomic_noexcept, atomic_cancel. (cp_parser_compound_statement): Change in_try parameter to bcs_flags. (cp_parser_std_attribute): Map optimize_for_synchronized to transaction_callable. (cp_parser_transaction): Take the token. Handle atomic_noexcept. * lambda.c (maybe_add_lambda_conv_op): Handle transaction-safety. * call.c (enum conversion_kind): Add ck_tsafe. (standard_conversion): Handle transaction-safety conversion. (convert_like_real, resolve_address_of_overloaded_function): Likewise. (check_methods): Diagnose transaction_safe_dynamic on non-virtual function. (look_for_tm_attr_overrides): Don't inherit transaction_safe_dynamic. * cvt.c (tx_safe_fn_type_p, tx_unsafe_fn_variant) (can_convert_tx_safety): New. * typeck.c (composite_pointer_type): Handle transaction-safety. * name-lookup.h (enum scope_kind): Add sk_transaction. * name-lookup.c (begin_scope): Handle it. * semantics.c (begin_compound_stmt): Pass it. * decl.c (check_previous_goto_1): Check it. (struct named_label_entry): Add in_transaction_scope. (poplevel_named_label_1): Set it. (check_goto): Check it. (duplicate_decls): A specialization can be transaction_safe independently of its template. (grokdeclarator): Handle tx-qualifier. * rtti.c (ptr_initializer): Handle transaction-safe. * search.c (check_final_overrider): Check transaction_safe_dynamic. Don't check transaction_safe. * mangle.c (write_function_type): Mangle transaction_safe here. (write_CV_qualifiers_for_type): Not here. (write_type): Preserve transaction_safe when stripping attributes. * error.c (dump_type_suffix): Print transaction_safe. libiberty/ * cp-demangle.c (d_cv_qualifiers): Dx means transaction_safe. (cplus_demangle_type): Let d_cv_qualifiers handle it. (d_dump, d_make_comp, has_return_type, d_encoding) (d_count_templates_scopes, d_print_comp_inner) (d_print_mod_list, d_print_mod, d_print_function_type) (is_ctor_or_dtor): Handle DEMANGLE_COMPONENT_TRANSACTION_SAFE. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@228462 138bc75d-0d04-0410-961f-82ee72b054a4
2015-11-28 17:39:30 +01:00
case DEMANGLE_COMPONENT_TRANSACTION_SAFE:
printf ("transaction_safe this\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
2003-11-21 18:42:45 +01:00
printf ("vendor type qualifier\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_POINTER:
2003-11-21 18:42:45 +01:00
printf ("pointer\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_REFERENCE:
2003-11-21 18:42:45 +01:00
printf ("reference\n");
break;
2007-08-31 22:20:49 +02:00
case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
printf ("rvalue reference\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_COMPLEX:
2003-11-21 18:42:45 +01:00
printf ("complex\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_IMAGINARY:
2003-11-21 18:42:45 +01:00
printf ("imaginary\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_VENDOR_TYPE:
2003-11-21 18:42:45 +01:00
printf ("vendor type\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_FUNCTION_TYPE:
2003-11-21 18:42:45 +01:00
printf ("function type\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_ARRAY_TYPE:
2003-11-21 18:42:45 +01:00
printf ("array type\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_PTRMEM_TYPE:
2003-11-21 18:42:45 +01:00
printf ("pointer to member type\n");
break;
2008-12-11 00:28:19 +01:00
case DEMANGLE_COMPONENT_FIXED_TYPE:
Sync libiberty with upstream GCC. include/ChangeLog * libiberty.h (PEX_STDOUT_APPEND): New flag. (PEX_STDERR_APPEND): Likewise. * demangle.h (DMGL_DLANG): New macro. (DMGL_STYLE_MASK): Add DMGL_DLANG. (demangling_styles): Add dlang_demangling. (DLANG_DEMANGLING_STYLE_STRING): New macro. (DLANG_DEMANGLING): New macro. (dlang_demangle): New prototype. * longlong.h: Add __udiv_w_sdiv prototype. libiberty/ChangeLog * cp-demangle.c (d_substitution): Handle abi tags on abbreviation. * pex-common.h (struct pex_funcs): Add new parameter for open_write field. * pex-unix.c (pex_unix_open_write): Add support for new parameter. * pex-djgpp.c (pex_djgpp_open_write): Likewise. * pex-win32.c (pex_win32_open_write): Likewise. * pex-common.c (pex_run_in_environment): Likewise. * Makefile.in (CFILES): Add d-demangle.c. (REQUIRED_OFILES): Add d-demangle.o. * cplus-dem.c (libiberty_demanglers): Add dlang_demangling case. (cplus_demangle): Likewise. * d-demangle.c: New file. * testsuite/Makefile.in (really-check): Add check-d-demangle. * testsuite/d-demangle-expected: New file. * simple-object-elf.c (simple_object_elf_write_ehdr): Correctly handle objects with more than SHN_LORESERVE sections. (simple_object_elf_write_shdr): Add sh_link parameter. (simple_object_elf_write_to_file): Correctly handle objects with more than SHN_LORESERVE sections. * cp-demangle.c (d_dump): Only access field from s_fixed part of the union for DEMANGLE_COMPONENT_FIXED_TYPE. (d_count_templates_scopes): Likewise. * testsuite/demangler-fuzzer.c: New file. * testsuite/Makefile.in (fuzz-demangler): New rule. (demangler-fuzzer): Likewise. (mostlyclean): Clean up demangler fuzzer.
2014-10-11 11:29:10 +02:00
printf ("fixed-point type, accum? %d, sat? %d\n",
dc->u.s_fixed.accum, dc->u.s_fixed.sat);
d_dump (dc->u.s_fixed.length, indent + 2);
2008-12-11 00:28:19 +01:00
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_ARGLIST:
2003-11-21 18:42:45 +01:00
printf ("argument list\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
2003-11-21 18:42:45 +01:00
printf ("template argument list\n");
break;
2012-01-06 23:04:43 +01:00
case DEMANGLE_COMPONENT_INITIALIZER_LIST:
printf ("initializer list\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_CAST:
2003-11-21 18:42:45 +01:00
printf ("cast\n");
break;
PR other/61321 - demangler crash on casts in template parameters The fix for bug 59195: [C++ demangler handles conversion operator incorrectly] https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59195 unfortunately makes the demangler crash due to infinite recursion, in case of casts in template parameters. For example, with: template<int> struct A {}; template <typename Y> void function_temp(A<sizeof ((Y)(999))>) {} template void function_temp<int>(A<sizeof (int)>); The 'function_temp<int>' instantiation above mangles to: _Z13function_tempIiEv1AIXszcvT_Li999EEE The demangler parses this as: typed name template name 'function_temp' template argument list builtin type int function type builtin type void argument list template (*) name 'A' template argument list unary operator operator sizeof unary operator cast template parameter 0 (**) literal builtin type int name '999' And after the fix for 59195, due to: static void d_print_cast (struct d_print_info *dpi, int options, const struct demangle_component *dc) { ... /* For a cast operator, we need the template parameters from the enclosing template in scope for processing the type. */ if (dpi->current_template != NULL) { dpt.next = dpi->templates; dpi->templates = &dpt; dpt.template_decl = dpi->current_template; } when printing the template argument list of A (what should be "<sizeof (int)>"), the template parameter 0 (that is, "T_", the '**' above) now refers to the first parameter of the the template argument list of the 'A' template (the '*' above), exactly what we were already trying to print. This leads to infinite recursion, and stack exaustion. The template parameter 0 should actually refer to the first parameter of the 'function_temp' template. Where it reads "for the cast operator" in the comment in d_print_cast (above), it's really talking about a conversion operator, like: struct A { template <typename U> explicit operator U(); }; We don't want to inject the template parameters from the enclosing template in scope when processing a cast _expression_, only when handling a conversion operator. The problem is that DEMANGLE_COMPONENT_CAST is currently ambiguous, and means _both_ 'conversion operator' and 'cast expression'. Fix this by adding a new DEMANGLE_COMPONENT_CONVERSION component type, which does what DEMANGLE_COMPONENT_CAST does today, and making DEMANGLE_COMPONENT_CAST just simply print its component subtree. I think we could instead reuse DEMANGLE_COMPONENT_CAST and in d_print_comp_inner still do: @@ -5001,9 +5013,9 @@ d_print_comp_inner (struct d_print_info *dpi, int options, d_print_comp (dpi, options, dc->u.s_extended_operator.name); return; case DEMANGLE_COMPONENT_CAST: d_append_string (dpi, "operator "); - d_print_cast (dpi, options, dc); + d_print_conversion (dpi, options, dc); return; leaving the unary cast case below calling d_print_cast, but seems to me that spliting the component types makes it easier to reason about the code. g++'s testsuite actually generates three symbols that crash the demangler in the same way. I've added those as tests in the demangler testsuite as well. And then this fixes PR other/61233 too, which happens to be a demangler crash originally reported to GDB, at: https://sourceware.org/bugzilla/show_bug.cgi?id=16957 Bootstrapped and regtested on x86_64 Fedora 20. Also ran this through GDB's testsuite. GDB will require a small update to use DEMANGLE_COMPONENT_CONVERSION in one place it's using DEMANGLE_COMPONENT_CAST in its sources. libiberty/ 2015-11-27 Pedro Alves <palves@redhat.com> PR other/61321 PR other/61233 * demangle.h (enum demangle_component_type) <DEMANGLE_COMPONENT_CONVERSION>: New value. * cp-demangle.c (d_demangle_callback, d_make_comp): Handle DEMANGLE_COMPONENT_CONVERSION. (is_ctor_dtor_or_conversion): Handle DEMANGLE_COMPONENT_CONVERSION instead of DEMANGLE_COMPONENT_CAST. (d_operator_name): Return a DEMANGLE_COMPONENT_CONVERSION component if handling a conversion. (d_count_templates_scopes, d_print_comp_inner): Handle DEMANGLE_COMPONENT_CONVERSION. (d_print_comp_inner): Handle DEMANGLE_COMPONENT_CONVERSION instead of DEMANGLE_COMPONENT_CAST. (d_print_cast): Rename as ... (d_print_conversion): ... this. Adjust comments. (d_print_cast): Rewrite - simply print the left subcomponent. * cp-demint.c (cplus_demangle_fill_component): Handle DEMANGLE_COMPONENT_CONVERSION. * testsuite/demangle-expected: Add tests. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@231020 138bc75d-0d04-0410-961f-82ee72b054a4
2015-11-28 17:39:31 +01:00
case DEMANGLE_COMPONENT_CONVERSION:
printf ("conversion operator\n");
break;
2012-01-06 23:04:43 +01:00
case DEMANGLE_COMPONENT_NULLARY:
printf ("nullary operator\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_UNARY:
2003-11-21 18:42:45 +01:00
printf ("unary operator\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_BINARY:
2003-11-21 18:42:45 +01:00
printf ("binary operator\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_BINARY_ARGS:
2003-11-21 18:42:45 +01:00
printf ("binary operator arguments\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_TRINARY:
2003-11-21 18:42:45 +01:00
printf ("trinary operator\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_TRINARY_ARG1:
2003-11-21 18:42:45 +01:00
printf ("trinary operator arguments 1\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_TRINARY_ARG2:
2003-11-21 18:42:45 +01:00
printf ("trinary operator arguments 1\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_LITERAL:
2003-11-21 18:42:45 +01:00
printf ("literal\n");
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_LITERAL_NEG:
2003-12-15 18:45:42 +01:00
printf ("negative literal\n");
break;
case DEMANGLE_COMPONENT_JAVA_RESOURCE:
printf ("java resource\n");
break;
case DEMANGLE_COMPONENT_COMPOUND_NAME:
printf ("compound name\n");
break;
case DEMANGLE_COMPONENT_CHARACTER:
printf ("character '%c'\n", dc->u.s_character.character);
return;
case DEMANGLE_COMPONENT_NUMBER:
printf ("number %ld\n", dc->u.s_number.number);
return;
2008-09-09 20:21:49 +02:00
case DEMANGLE_COMPONENT_DECLTYPE:
printf ("decltype\n");
break;
2008-10-07 03:28:01 +02:00
case DEMANGLE_COMPONENT_PACK_EXPANSION:
printf ("pack expansion\n");
break;
2012-10-10 05:11:33 +02:00
case DEMANGLE_COMPONENT_TLS_INIT:
printf ("tls init function\n");
break;
case DEMANGLE_COMPONENT_TLS_WRAPPER:
printf ("tls wrapper function\n");
break;
2013-02-15 03:48:33 +01:00
case DEMANGLE_COMPONENT_DEFAULT_ARG:
printf ("default argument %d\n", dc->u.s_unary_num.num);
d_dump (dc->u.s_unary_num.sub, indent+2);
return;
case DEMANGLE_COMPONENT_LAMBDA:
printf ("lambda %d\n", dc->u.s_unary_num.num);
d_dump (dc->u.s_unary_num.sub, indent+2);
return;
}
2003-11-21 18:42:45 +01:00
d_dump (d_left (dc), indent + 2);
d_dump (d_right (dc), indent + 2);
}
#endif /* CP_DEMANGLE_DEBUG */
2004-01-12 22:24:38 +01:00
/* Fill in a DEMANGLE_COMPONENT_NAME. */
CP_STATIC_IF_GLIBCPP_V3
int
2005-03-27 07:28:42 +02:00
cplus_demangle_fill_name (struct demangle_component *p, const char *s, int len)
2004-01-12 22:24:38 +01:00
{
if (p == NULL || s == NULL || len <= 0)
2004-01-12 22:24:38 +01:00
return 0;
p->d_printing = 0;
2004-01-12 22:24:38 +01:00
p->type = DEMANGLE_COMPONENT_NAME;
p->u.s_name.s = s;
p->u.s_name.len = len;
return 1;
}
/* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR. */
CP_STATIC_IF_GLIBCPP_V3
int
2005-03-27 07:28:42 +02:00
cplus_demangle_fill_extended_operator (struct demangle_component *p, int args,
struct demangle_component *name)
2004-01-12 22:24:38 +01:00
{
if (p == NULL || args < 0 || name == NULL)
return 0;
p->d_printing = 0;
2004-01-12 22:24:38 +01:00
p->type = DEMANGLE_COMPONENT_EXTENDED_OPERATOR;
p->u.s_extended_operator.args = args;
p->u.s_extended_operator.name = name;
return 1;
}
/* Fill in a DEMANGLE_COMPONENT_CTOR. */
CP_STATIC_IF_GLIBCPP_V3
int
2005-03-27 07:28:42 +02:00
cplus_demangle_fill_ctor (struct demangle_component *p,
enum gnu_v3_ctor_kinds kind,
struct demangle_component *name)
2004-01-12 22:24:38 +01:00
{
if (p == NULL
|| name == NULL
2009-05-19 05:02:30 +02:00
|| (int) kind < gnu_v3_complete_object_ctor
2011-11-08 17:01:58 +01:00
|| (int) kind > gnu_v3_object_ctor_group)
2004-01-12 22:24:38 +01:00
return 0;
p->d_printing = 0;
2004-01-12 22:24:38 +01:00
p->type = DEMANGLE_COMPONENT_CTOR;
p->u.s_ctor.kind = kind;
p->u.s_ctor.name = name;
return 1;
}
/* Fill in a DEMANGLE_COMPONENT_DTOR. */
CP_STATIC_IF_GLIBCPP_V3
int
2005-03-27 07:28:42 +02:00
cplus_demangle_fill_dtor (struct demangle_component *p,
enum gnu_v3_dtor_kinds kind,
struct demangle_component *name)
2004-01-12 22:24:38 +01:00
{
if (p == NULL
|| name == NULL
2009-05-19 05:02:30 +02:00
|| (int) kind < gnu_v3_deleting_dtor
2011-11-08 17:01:58 +01:00
|| (int) kind > gnu_v3_object_dtor_group)
2004-01-12 22:24:38 +01:00
return 0;
p->d_printing = 0;
2004-01-12 22:24:38 +01:00
p->type = DEMANGLE_COMPONENT_DTOR;
p->u.s_dtor.kind = kind;
p->u.s_dtor.name = name;
return 1;
}
2003-11-21 18:42:45 +01:00
/* Add a new component. */
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_make_empty (struct d_info *di)
2003-11-21 18:42:45 +01:00
{
2004-01-12 22:24:38 +01:00
struct demangle_component *p;
2003-11-21 18:42:45 +01:00
if (di->next_comp >= di->num_comps)
return NULL;
p = &di->comps[di->next_comp];
p->d_printing = 0;
2003-11-21 18:42:45 +01:00
++di->next_comp;
return p;
}
/* Add a new generic component. */
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_make_comp (struct d_info *di, enum demangle_component_type type,
struct demangle_component *left,
struct demangle_component *right)
2003-11-21 18:42:45 +01:00
{
2004-01-12 22:24:38 +01:00
struct demangle_component *p;
2003-11-21 18:42:45 +01:00
/* We check for errors here. A typical error would be a NULL return
2003-11-27 02:17:34 +01:00
from a subroutine. We catch those here, and return NULL
upward. */
2003-11-21 18:42:45 +01:00
switch (type)
{
/* These types require two parameters. */
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_QUAL_NAME:
case DEMANGLE_COMPONENT_LOCAL_NAME:
case DEMANGLE_COMPONENT_TYPED_NAME:
2012-11-11 23:37:30 +01:00
case DEMANGLE_COMPONENT_TAGGED_NAME:
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_TEMPLATE:
case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
case DEMANGLE_COMPONENT_PTRMEM_TYPE:
case DEMANGLE_COMPONENT_UNARY:
case DEMANGLE_COMPONENT_BINARY:
case DEMANGLE_COMPONENT_BINARY_ARGS:
case DEMANGLE_COMPONENT_TRINARY:
case DEMANGLE_COMPONENT_TRINARY_ARG1:
case DEMANGLE_COMPONENT_LITERAL:
case DEMANGLE_COMPONENT_LITERAL_NEG:
case DEMANGLE_COMPONENT_COMPOUND_NAME:
2010-02-04 00:28:01 +01:00
case DEMANGLE_COMPONENT_VECTOR_TYPE:
2011-09-24 00:21:36 +02:00
case DEMANGLE_COMPONENT_CLONE:
2003-11-21 18:42:45 +01:00
if (left == NULL || right == NULL)
return NULL;
break;
/* These types only require one parameter. */
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_VTABLE:
case DEMANGLE_COMPONENT_VTT:
case DEMANGLE_COMPONENT_TYPEINFO:
case DEMANGLE_COMPONENT_TYPEINFO_NAME:
case DEMANGLE_COMPONENT_TYPEINFO_FN:
case DEMANGLE_COMPONENT_THUNK:
case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
case DEMANGLE_COMPONENT_COVARIANT_THUNK:
case DEMANGLE_COMPONENT_JAVA_CLASS:
case DEMANGLE_COMPONENT_GUARD:
2012-10-10 05:11:33 +02:00
case DEMANGLE_COMPONENT_TLS_INIT:
case DEMANGLE_COMPONENT_TLS_WRAPPER:
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_REFTEMP:
case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
2011-11-08 17:01:58 +01:00
case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_POINTER:
case DEMANGLE_COMPONENT_REFERENCE:
2007-08-31 22:20:49 +02:00
case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_COMPLEX:
case DEMANGLE_COMPONENT_IMAGINARY:
case DEMANGLE_COMPONENT_VENDOR_TYPE:
case DEMANGLE_COMPONENT_CAST:
PR other/61321 - demangler crash on casts in template parameters The fix for bug 59195: [C++ demangler handles conversion operator incorrectly] https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59195 unfortunately makes the demangler crash due to infinite recursion, in case of casts in template parameters. For example, with: template<int> struct A {}; template <typename Y> void function_temp(A<sizeof ((Y)(999))>) {} template void function_temp<int>(A<sizeof (int)>); The 'function_temp<int>' instantiation above mangles to: _Z13function_tempIiEv1AIXszcvT_Li999EEE The demangler parses this as: typed name template name 'function_temp' template argument list builtin type int function type builtin type void argument list template (*) name 'A' template argument list unary operator operator sizeof unary operator cast template parameter 0 (**) literal builtin type int name '999' And after the fix for 59195, due to: static void d_print_cast (struct d_print_info *dpi, int options, const struct demangle_component *dc) { ... /* For a cast operator, we need the template parameters from the enclosing template in scope for processing the type. */ if (dpi->current_template != NULL) { dpt.next = dpi->templates; dpi->templates = &dpt; dpt.template_decl = dpi->current_template; } when printing the template argument list of A (what should be "<sizeof (int)>"), the template parameter 0 (that is, "T_", the '**' above) now refers to the first parameter of the the template argument list of the 'A' template (the '*' above), exactly what we were already trying to print. This leads to infinite recursion, and stack exaustion. The template parameter 0 should actually refer to the first parameter of the 'function_temp' template. Where it reads "for the cast operator" in the comment in d_print_cast (above), it's really talking about a conversion operator, like: struct A { template <typename U> explicit operator U(); }; We don't want to inject the template parameters from the enclosing template in scope when processing a cast _expression_, only when handling a conversion operator. The problem is that DEMANGLE_COMPONENT_CAST is currently ambiguous, and means _both_ 'conversion operator' and 'cast expression'. Fix this by adding a new DEMANGLE_COMPONENT_CONVERSION component type, which does what DEMANGLE_COMPONENT_CAST does today, and making DEMANGLE_COMPONENT_CAST just simply print its component subtree. I think we could instead reuse DEMANGLE_COMPONENT_CAST and in d_print_comp_inner still do: @@ -5001,9 +5013,9 @@ d_print_comp_inner (struct d_print_info *dpi, int options, d_print_comp (dpi, options, dc->u.s_extended_operator.name); return; case DEMANGLE_COMPONENT_CAST: d_append_string (dpi, "operator "); - d_print_cast (dpi, options, dc); + d_print_conversion (dpi, options, dc); return; leaving the unary cast case below calling d_print_cast, but seems to me that spliting the component types makes it easier to reason about the code. g++'s testsuite actually generates three symbols that crash the demangler in the same way. I've added those as tests in the demangler testsuite as well. And then this fixes PR other/61233 too, which happens to be a demangler crash originally reported to GDB, at: https://sourceware.org/bugzilla/show_bug.cgi?id=16957 Bootstrapped and regtested on x86_64 Fedora 20. Also ran this through GDB's testsuite. GDB will require a small update to use DEMANGLE_COMPONENT_CONVERSION in one place it's using DEMANGLE_COMPONENT_CAST in its sources. libiberty/ 2015-11-27 Pedro Alves <palves@redhat.com> PR other/61321 PR other/61233 * demangle.h (enum demangle_component_type) <DEMANGLE_COMPONENT_CONVERSION>: New value. * cp-demangle.c (d_demangle_callback, d_make_comp): Handle DEMANGLE_COMPONENT_CONVERSION. (is_ctor_dtor_or_conversion): Handle DEMANGLE_COMPONENT_CONVERSION instead of DEMANGLE_COMPONENT_CAST. (d_operator_name): Return a DEMANGLE_COMPONENT_CONVERSION component if handling a conversion. (d_count_templates_scopes, d_print_comp_inner): Handle DEMANGLE_COMPONENT_CONVERSION. (d_print_comp_inner): Handle DEMANGLE_COMPONENT_CONVERSION instead of DEMANGLE_COMPONENT_CAST. (d_print_cast): Rename as ... (d_print_conversion): ... this. Adjust comments. (d_print_cast): Rewrite - simply print the left subcomponent. * cp-demint.c (cplus_demangle_fill_component): Handle DEMANGLE_COMPONENT_CONVERSION. * testsuite/demangle-expected: Add tests. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@231020 138bc75d-0d04-0410-961f-82ee72b054a4
2015-11-28 17:39:31 +01:00
case DEMANGLE_COMPONENT_CONVERSION:
case DEMANGLE_COMPONENT_JAVA_RESOURCE:
2008-09-09 20:21:49 +02:00
case DEMANGLE_COMPONENT_DECLTYPE:
2008-10-07 03:28:01 +02:00
case DEMANGLE_COMPONENT_PACK_EXPANSION:
2009-07-17 22:20:45 +02:00
case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
2012-01-06 23:04:43 +01:00
case DEMANGLE_COMPONENT_NULLARY:
case DEMANGLE_COMPONENT_TRINARY_ARG2:
Synchronize libiberty with gcc and add --no-recruse-limit option to tools that support name demangling. This patch addresses the multitude of bug reports about resource exhaustion in libiberty's name demangling code. It adds a limit to the amount of recursion that is allowed, before an error is triggered. It also adds a new demangling option to disable this limit. (The limit is enabled by default). PR 87681 PR 87675 PR 87636 PR 87335 libiberty * cp-demangle.h (struct d_info): Add recursion_limit field. * cp-demangle.c (d_function_type): If the recursion limit is enabled and reached, return with a failure result. (d_demangle_callback): If the recursion limit is enabled, check for a mangled string that is so long that there is not enough stack space for the local arrays. * cplus-dem.c (struct work): Add recursion_level field. (demangle_nested_args): If the recursion limit is enabled and reached, return with a failure result. include * demangle.h (DMGL_RECURSE_LIMIT): Define. (DEMANGLE_RECURSION_LIMIT): Prototype. binutuils * addr2line.c (demangle_flags): New static variable. (long_options): Add --recurse-limit and --no-recurse-limit. (translate_address): Pass demangle_flags to bfd_demangle. (main): Handle --recurse-limit and --no-recurse-limit options. * cxxfilt.c (flags): Add DMGL_RECURSE_LIMIT. (long_options): Add --recurse-limit and --no-recurse-limit. (main): Handle new options. * dlltool.c (gen_def_file): Include DMGL_RECURSE_LIMIT in flags passed to cplus_demangle. * nm.c (demangle_flags): New static variable. (long_options): Add --recurse-limit and --no-recurse-limit. (main): Handle new options. * objdump.c (demangle_flags): New static variable. (usage): Add --recurse-limit and --no-recurse-limit. (long_options): Likewise. (objdump_print_symname): Pass demangle_flags to bfd_demangle. (disassemble_section): Likewise. (dump_dymbols): Likewise. (main): Handle new options. * prdbg.c (demangle_flags): New static variable. (tg_variable): Pass demangle_flags to demangler. (tg_start_function): Likewise. * stabs.c (demangle_flags): New static variable. (stab_demangle_template): Pass demangle_flags to demangler. (stab_demangle_v3_argtypes): Likewise. (stab_demangle_v3_arg): Likewise. * doc/binutuls.texi: Document new command line options. * NEWS: Mention the new feature. * testsuite/config/default.exp (CXXFILT): Define if not already defined. (CXXFILTFLAGS): Likewise. * testsuite/binutils-all/cxxfilt.exp: New file. Runs a few simple tests of the cxxfilt program.
2018-12-07 12:32:55 +01:00
case DEMANGLE_COMPONENT_TPARM_OBJ:
2003-11-21 18:42:45 +01:00
if (left == NULL)
return NULL;
break;
/* This needs a right parameter, but the left parameter can be
empty. */
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_ARRAY_TYPE:
2012-01-06 23:04:43 +01:00
case DEMANGLE_COMPONENT_INITIALIZER_LIST:
2003-11-21 18:42:45 +01:00
if (right == NULL)
return NULL;
break;
/* These are allowed to have no parameters--in some cases they
will be filled in later. */
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_FUNCTION_TYPE:
case DEMANGLE_COMPONENT_RESTRICT:
case DEMANGLE_COMPONENT_VOLATILE:
case DEMANGLE_COMPONENT_CONST:
2008-10-07 03:28:01 +02:00
case DEMANGLE_COMPONENT_ARGLIST:
case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
FNQUAL_COMPONENT_CASE:
2003-11-21 18:42:45 +01:00
break;
/* Other types should not be seen here. */
default:
return NULL;
}
2003-11-21 18:42:45 +01:00
2004-01-12 22:24:38 +01:00
p = d_make_empty (di);
2003-11-21 18:42:45 +01:00
if (p != NULL)
{
2004-01-12 22:24:38 +01:00
p->type = type;
2003-11-21 18:42:45 +01:00
p->u.s_binary.left = left;
p->u.s_binary.right = right;
}
2003-11-21 18:42:45 +01:00
return p;
}
/* Add a new demangle mangled name component. */
static struct demangle_component *
d_make_demangle_mangled_name (struct d_info *di, const char *s)
{
if (d_peek_char (di) != '_' || d_peek_next_char (di) != 'Z')
return d_make_name (di, s, strlen (s));
d_advance (di, 2);
return d_encoding (di, 0);
}
2003-11-21 18:42:45 +01:00
/* Add a new name component. */
2000-07-20 20:56:16 +02:00
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_make_name (struct d_info *di, const char *s, int len)
2003-11-21 18:42:45 +01:00
{
2004-01-12 22:24:38 +01:00
struct demangle_component *p;
2000-07-20 20:56:16 +02:00
2004-01-12 22:24:38 +01:00
p = d_make_empty (di);
if (! cplus_demangle_fill_name (p, s, len))
2003-12-04 21:03:39 +01:00
return NULL;
2003-11-21 18:42:45 +01:00
return p;
}
2003-11-21 18:42:45 +01:00
/* Add a new builtin type component. */
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_make_builtin_type (struct d_info *di,
const struct demangle_builtin_type_info *type)
{
2004-01-12 22:24:38 +01:00
struct demangle_component *p;
2003-11-21 18:42:45 +01:00
2003-11-27 02:17:34 +01:00
if (type == NULL)
return NULL;
2004-01-12 22:24:38 +01:00
p = d_make_empty (di);
2003-11-21 18:42:45 +01:00
if (p != NULL)
2004-01-12 22:24:38 +01:00
{
p->type = DEMANGLE_COMPONENT_BUILTIN_TYPE;
p->u.s_builtin.type = type;
}
2003-11-21 18:42:45 +01:00
return p;
}
2003-11-21 18:42:45 +01:00
/* Add a new operator component. */
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_make_operator (struct d_info *di, const struct demangle_operator_info *op)
{
2004-01-12 22:24:38 +01:00
struct demangle_component *p;
2003-11-21 18:42:45 +01:00
2004-01-12 22:24:38 +01:00
p = d_make_empty (di);
2003-11-21 18:42:45 +01:00
if (p != NULL)
2004-01-12 22:24:38 +01:00
{
p->type = DEMANGLE_COMPONENT_OPERATOR;
p->u.s_operator.op = op;
}
2003-11-21 18:42:45 +01:00
return p;
}
2003-11-21 18:42:45 +01:00
/* Add a new extended operator component. */
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_make_extended_operator (struct d_info *di, int args,
struct demangle_component *name)
{
2004-01-12 22:24:38 +01:00
struct demangle_component *p;
2000-07-20 20:56:16 +02:00
2004-01-12 22:24:38 +01:00
p = d_make_empty (di);
if (! cplus_demangle_fill_extended_operator (p, args, name))
2003-11-27 02:17:34 +01:00
return NULL;
2003-11-21 18:42:45 +01:00
return p;
}
2009-10-02 20:23:01 +02:00
static struct demangle_component *
d_make_default_arg (struct d_info *di, int num,
struct demangle_component *sub)
{
struct demangle_component *p = d_make_empty (di);
if (p)
{
p->type = DEMANGLE_COMPONENT_DEFAULT_ARG;
p->u.s_unary_num.num = num;
p->u.s_unary_num.sub = sub;
}
return p;
}
2003-11-21 18:42:45 +01:00
/* Add a new constructor component. */
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_make_ctor (struct d_info *di, enum gnu_v3_ctor_kinds kind,
struct demangle_component *name)
{
2004-01-12 22:24:38 +01:00
struct demangle_component *p;
2003-11-21 18:42:45 +01:00
2004-01-12 22:24:38 +01:00
p = d_make_empty (di);
if (! cplus_demangle_fill_ctor (p, kind, name))
2003-11-27 02:17:34 +01:00
return NULL;
2003-11-21 18:42:45 +01:00
return p;
}
2003-11-21 18:42:45 +01:00
/* Add a new destructor component. */
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_make_dtor (struct d_info *di, enum gnu_v3_dtor_kinds kind,
struct demangle_component *name)
{
2004-01-12 22:24:38 +01:00
struct demangle_component *p;
2003-11-21 18:42:45 +01:00
2004-01-12 22:24:38 +01:00
p = d_make_empty (di);
if (! cplus_demangle_fill_dtor (p, kind, name))
2003-11-27 02:17:34 +01:00
return NULL;
2003-11-21 18:42:45 +01:00
return p;
}
2003-11-21 18:42:45 +01:00
/* Add a new template parameter. */
2004-01-12 22:24:38 +01:00
static struct demangle_component *
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
d_make_template_param (struct d_info *di, int i)
{
2004-01-12 22:24:38 +01:00
struct demangle_component *p;
2003-11-21 18:42:45 +01:00
2004-01-12 22:24:38 +01:00
p = d_make_empty (di);
2003-11-21 18:42:45 +01:00
if (p != NULL)
2004-01-12 22:24:38 +01:00
{
p->type = DEMANGLE_COMPONENT_TEMPLATE_PARAM;
p->u.s_number.number = i;
}
2003-11-21 18:42:45 +01:00
return p;
}
2009-03-18 01:07:49 +01:00
/* Add a new function parameter. */
static struct demangle_component *
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
d_make_function_param (struct d_info *di, int i)
2009-03-18 01:07:49 +01:00
{
struct demangle_component *p;
p = d_make_empty (di);
if (p != NULL)
{
p->type = DEMANGLE_COMPONENT_FUNCTION_PARAM;
p->u.s_number.number = i;
}
return p;
}
2003-11-21 18:42:45 +01:00
/* Add a new standard substitution component. */
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_make_sub (struct d_info *di, const char *name, int len)
{
2004-01-12 22:24:38 +01:00
struct demangle_component *p;
2003-11-21 18:42:45 +01:00
2004-01-12 22:24:38 +01:00
p = d_make_empty (di);
2003-11-21 18:42:45 +01:00
if (p != NULL)
2003-12-22 17:03:32 +01:00
{
2004-01-12 22:24:38 +01:00
p->type = DEMANGLE_COMPONENT_SUB_STD;
2003-12-22 17:03:32 +01:00
p->u.s_string.string = name;
p->u.s_string.len = len;
}
2003-11-21 18:42:45 +01:00
return p;
}
2011-09-24 00:21:36 +02:00
/* <mangled-name> ::= _Z <encoding> [<clone-suffix>]*
2003-11-27 02:17:34 +01:00
TOP_LEVEL is non-zero when called at the top level. */
2004-01-12 22:24:38 +01:00
CP_STATIC_IF_GLIBCPP_V3
struct demangle_component *
2005-03-27 07:28:42 +02:00
cplus_demangle_mangled_name (struct d_info *di, int top_level)
{
2011-09-24 00:21:36 +02:00
struct demangle_component *p;
2009-03-18 01:07:49 +01:00
if (! d_check_char (di, '_')
/* Allow missing _ if not at toplevel to work around a
bug in G++ abi-version=2 mangling; see the comment in
write_template_arg. */
&& top_level)
2003-11-21 18:42:45 +01:00
return NULL;
if (! d_check_char (di, 'Z'))
2003-11-21 18:42:45 +01:00
return NULL;
2011-09-24 00:21:36 +02:00
p = d_encoding (di, top_level);
/* If at top level and parsing parameters, check for a clone
suffix. */
if (top_level && (di->options & DMGL_PARAMS) != 0)
while (d_peek_char (di) == '.'
&& (IS_LOWER (d_peek_next_char (di))
|| d_peek_next_char (di) == '_'
|| IS_DIGIT (d_peek_next_char (di))))
p = d_clone_suffix (di, p);
return p;
}
2003-11-21 18:42:45 +01:00
/* Return whether a function should have a return type. The argument
is the function name, which may be qualified in various ways. The
rules are that template functions have return types with some
exceptions, function types which are not part of a function name
mangling have return types with some exceptions, and non-template
function names do not have return types. The exceptions are that
constructors, destructors, and conversion operators do not have
return types. */
static int
2005-03-27 07:28:42 +02:00
has_return_type (struct demangle_component *dc)
{
2003-11-21 18:42:45 +01:00
if (dc == NULL)
return 0;
switch (dc->type)
{
default:
return 0;
Update the libiberty sources with the latest patches found in the master sources. 2017-01-02 Richard Biener <rguenther@suse.de> PR lto/83452 * simple-object-elf.c (simple_object_elf_copy_lto_debug_section): Do not use UNDEF locals for removed symbols but instead just define them in the first prevailing section and with no name. Use the same gnu_lto_v1 name for all removed globals we promote to WEAK UNDEFs so hpux can use a stub to provide this symbol. Clear sh_info and sh_link in removed sections. 2017-10-30 Richard Biener <rguenther@suse.de> PR lto/82757 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Strip two leading _s from the __gnu_lto_* symbols. 2017-10-24 Alan Modra <amodra@gmail.com> PR lto/82687 PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Only make __gnu_lto symbols hidden. 2017-10-20 Alan Modra <amodra@gmail.com> PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Make discarded non-local symbols weak and hidden. 2017-10-18 Jakub Jelinek <jakub@redhat.com> PR lto/82598 * simple-object.c (handle_lto_debug_sections): Copy over also .note.GNU-stack section with unchanged name. * simple-object-elf.c (SHF_EXECINSTR): Define. (simple_object_elf_copy_lto_debug_section): Drop SHF_EXECINSTR bit on .note.GNU-stack section. 2017-09-25 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_encoding): Strip return type when name is a LOCAL_NAME. (d_local_name): Strip return type of enclosing TYPED_NAME. * testsuite/demangle-expected: Add and adjust tests. 2017-09-21 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Revert addition of 'toplevel' parm. (has_return_type): Recurse for DEMANGLE_COMPONENT_LOCAL_NAME. (d_encoding): Revert d_name change. Use is_fnqual_component_type to strip modifiers that do not belong. (d_special_name, d_class_enum_type): Revert d_name call change. (d_expresion_1): Commonize DEMANGLE_COMPONENT_UNARY building. (d_local_name): Revert parsing of a function type. (d_print_comp_inner): An inner LOCAL_NAME might contain a TEMPLATE. * testsuite/demangle-expected: Add & adjust tests
2018-01-10 14:57:48 +01:00
case DEMANGLE_COMPONENT_LOCAL_NAME:
return has_return_type (d_right (dc));
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_TEMPLATE:
2003-11-21 18:42:45 +01:00
return ! is_ctor_dtor_or_conversion (d_left (dc));
FNQUAL_COMPONENT_CASE:
2003-11-21 23:01:27 +01:00
return has_return_type (d_left (dc));
2003-11-21 18:42:45 +01:00
}
}
2003-11-21 18:42:45 +01:00
/* Return whether a name is a constructor, a destructor, or a
conversion operator. */
static int
2005-03-27 07:28:42 +02:00
is_ctor_dtor_or_conversion (struct demangle_component *dc)
{
2003-11-21 18:42:45 +01:00
if (dc == NULL)
return 0;
switch (dc->type)
{
default:
return 0;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_QUAL_NAME:
case DEMANGLE_COMPONENT_LOCAL_NAME:
2003-11-21 18:42:45 +01:00
return is_ctor_dtor_or_conversion (d_right (dc));
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_CTOR:
case DEMANGLE_COMPONENT_DTOR:
PR other/61321 - demangler crash on casts in template parameters The fix for bug 59195: [C++ demangler handles conversion operator incorrectly] https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59195 unfortunately makes the demangler crash due to infinite recursion, in case of casts in template parameters. For example, with: template<int> struct A {}; template <typename Y> void function_temp(A<sizeof ((Y)(999))>) {} template void function_temp<int>(A<sizeof (int)>); The 'function_temp<int>' instantiation above mangles to: _Z13function_tempIiEv1AIXszcvT_Li999EEE The demangler parses this as: typed name template name 'function_temp' template argument list builtin type int function type builtin type void argument list template (*) name 'A' template argument list unary operator operator sizeof unary operator cast template parameter 0 (**) literal builtin type int name '999' And after the fix for 59195, due to: static void d_print_cast (struct d_print_info *dpi, int options, const struct demangle_component *dc) { ... /* For a cast operator, we need the template parameters from the enclosing template in scope for processing the type. */ if (dpi->current_template != NULL) { dpt.next = dpi->templates; dpi->templates = &dpt; dpt.template_decl = dpi->current_template; } when printing the template argument list of A (what should be "<sizeof (int)>"), the template parameter 0 (that is, "T_", the '**' above) now refers to the first parameter of the the template argument list of the 'A' template (the '*' above), exactly what we were already trying to print. This leads to infinite recursion, and stack exaustion. The template parameter 0 should actually refer to the first parameter of the 'function_temp' template. Where it reads "for the cast operator" in the comment in d_print_cast (above), it's really talking about a conversion operator, like: struct A { template <typename U> explicit operator U(); }; We don't want to inject the template parameters from the enclosing template in scope when processing a cast _expression_, only when handling a conversion operator. The problem is that DEMANGLE_COMPONENT_CAST is currently ambiguous, and means _both_ 'conversion operator' and 'cast expression'. Fix this by adding a new DEMANGLE_COMPONENT_CONVERSION component type, which does what DEMANGLE_COMPONENT_CAST does today, and making DEMANGLE_COMPONENT_CAST just simply print its component subtree. I think we could instead reuse DEMANGLE_COMPONENT_CAST and in d_print_comp_inner still do: @@ -5001,9 +5013,9 @@ d_print_comp_inner (struct d_print_info *dpi, int options, d_print_comp (dpi, options, dc->u.s_extended_operator.name); return; case DEMANGLE_COMPONENT_CAST: d_append_string (dpi, "operator "); - d_print_cast (dpi, options, dc); + d_print_conversion (dpi, options, dc); return; leaving the unary cast case below calling d_print_cast, but seems to me that spliting the component types makes it easier to reason about the code. g++'s testsuite actually generates three symbols that crash the demangler in the same way. I've added those as tests in the demangler testsuite as well. And then this fixes PR other/61233 too, which happens to be a demangler crash originally reported to GDB, at: https://sourceware.org/bugzilla/show_bug.cgi?id=16957 Bootstrapped and regtested on x86_64 Fedora 20. Also ran this through GDB's testsuite. GDB will require a small update to use DEMANGLE_COMPONENT_CONVERSION in one place it's using DEMANGLE_COMPONENT_CAST in its sources. libiberty/ 2015-11-27 Pedro Alves <palves@redhat.com> PR other/61321 PR other/61233 * demangle.h (enum demangle_component_type) <DEMANGLE_COMPONENT_CONVERSION>: New value. * cp-demangle.c (d_demangle_callback, d_make_comp): Handle DEMANGLE_COMPONENT_CONVERSION. (is_ctor_dtor_or_conversion): Handle DEMANGLE_COMPONENT_CONVERSION instead of DEMANGLE_COMPONENT_CAST. (d_operator_name): Return a DEMANGLE_COMPONENT_CONVERSION component if handling a conversion. (d_count_templates_scopes, d_print_comp_inner): Handle DEMANGLE_COMPONENT_CONVERSION. (d_print_comp_inner): Handle DEMANGLE_COMPONENT_CONVERSION instead of DEMANGLE_COMPONENT_CAST. (d_print_cast): Rename as ... (d_print_conversion): ... this. Adjust comments. (d_print_cast): Rewrite - simply print the left subcomponent. * cp-demint.c (cplus_demangle_fill_component): Handle DEMANGLE_COMPONENT_CONVERSION. * testsuite/demangle-expected: Add tests. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@231020 138bc75d-0d04-0410-961f-82ee72b054a4
2015-11-28 17:39:31 +01:00
case DEMANGLE_COMPONENT_CONVERSION:
2003-11-21 18:42:45 +01:00
return 1;
}
}
2003-11-21 18:42:45 +01:00
/* <encoding> ::= <(function) name> <bare-function-type>
::= <(data) name>
2003-11-24 20:33:33 +01:00
::= <special-name>
TOP_LEVEL is non-zero when called at the top level, in which case
if DMGL_PARAMS is not set we do not demangle the function
parameters. We only set this at the top level, because otherwise
we would not correctly demangle names in local scopes. */
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_encoding (struct d_info *di, int top_level)
{
2003-11-21 18:42:45 +01:00
char peek = d_peek_char (di);
Update the libiberty sources with the latest patches found in the master sources. 2017-01-02 Richard Biener <rguenther@suse.de> PR lto/83452 * simple-object-elf.c (simple_object_elf_copy_lto_debug_section): Do not use UNDEF locals for removed symbols but instead just define them in the first prevailing section and with no name. Use the same gnu_lto_v1 name for all removed globals we promote to WEAK UNDEFs so hpux can use a stub to provide this symbol. Clear sh_info and sh_link in removed sections. 2017-10-30 Richard Biener <rguenther@suse.de> PR lto/82757 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Strip two leading _s from the __gnu_lto_* symbols. 2017-10-24 Alan Modra <amodra@gmail.com> PR lto/82687 PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Only make __gnu_lto symbols hidden. 2017-10-20 Alan Modra <amodra@gmail.com> PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Make discarded non-local symbols weak and hidden. 2017-10-18 Jakub Jelinek <jakub@redhat.com> PR lto/82598 * simple-object.c (handle_lto_debug_sections): Copy over also .note.GNU-stack section with unchanged name. * simple-object-elf.c (SHF_EXECINSTR): Define. (simple_object_elf_copy_lto_debug_section): Drop SHF_EXECINSTR bit on .note.GNU-stack section. 2017-09-25 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_encoding): Strip return type when name is a LOCAL_NAME. (d_local_name): Strip return type of enclosing TYPED_NAME. * testsuite/demangle-expected: Add and adjust tests. 2017-09-21 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Revert addition of 'toplevel' parm. (has_return_type): Recurse for DEMANGLE_COMPONENT_LOCAL_NAME. (d_encoding): Revert d_name change. Use is_fnqual_component_type to strip modifiers that do not belong. (d_special_name, d_class_enum_type): Revert d_name call change. (d_expresion_1): Commonize DEMANGLE_COMPONENT_UNARY building. (d_local_name): Revert parsing of a function type. (d_print_comp_inner): An inner LOCAL_NAME might contain a TEMPLATE. * testsuite/demangle-expected: Add & adjust tests
2018-01-10 14:57:48 +01:00
struct demangle_component *dc;
2000-07-20 20:56:16 +02:00
2003-11-21 18:42:45 +01:00
if (peek == 'G' || peek == 'T')
Update the libiberty sources with the latest patches found in the master sources. 2017-01-02 Richard Biener <rguenther@suse.de> PR lto/83452 * simple-object-elf.c (simple_object_elf_copy_lto_debug_section): Do not use UNDEF locals for removed symbols but instead just define them in the first prevailing section and with no name. Use the same gnu_lto_v1 name for all removed globals we promote to WEAK UNDEFs so hpux can use a stub to provide this symbol. Clear sh_info and sh_link in removed sections. 2017-10-30 Richard Biener <rguenther@suse.de> PR lto/82757 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Strip two leading _s from the __gnu_lto_* symbols. 2017-10-24 Alan Modra <amodra@gmail.com> PR lto/82687 PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Only make __gnu_lto symbols hidden. 2017-10-20 Alan Modra <amodra@gmail.com> PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Make discarded non-local symbols weak and hidden. 2017-10-18 Jakub Jelinek <jakub@redhat.com> PR lto/82598 * simple-object.c (handle_lto_debug_sections): Copy over also .note.GNU-stack section with unchanged name. * simple-object-elf.c (SHF_EXECINSTR): Define. (simple_object_elf_copy_lto_debug_section): Drop SHF_EXECINSTR bit on .note.GNU-stack section. 2017-09-25 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_encoding): Strip return type when name is a LOCAL_NAME. (d_local_name): Strip return type of enclosing TYPED_NAME. * testsuite/demangle-expected: Add and adjust tests. 2017-09-21 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Revert addition of 'toplevel' parm. (has_return_type): Recurse for DEMANGLE_COMPONENT_LOCAL_NAME. (d_encoding): Revert d_name change. Use is_fnqual_component_type to strip modifiers that do not belong. (d_special_name, d_class_enum_type): Revert d_name call change. (d_expresion_1): Commonize DEMANGLE_COMPONENT_UNARY building. (d_local_name): Revert parsing of a function type. (d_print_comp_inner): An inner LOCAL_NAME might contain a TEMPLATE. * testsuite/demangle-expected: Add & adjust tests
2018-01-10 14:57:48 +01:00
dc = d_special_name (di);
2003-11-21 18:42:45 +01:00
else
2000-07-20 20:56:16 +02:00
{
Update the libiberty sources with the latest patches found in the master sources. 2017-01-02 Richard Biener <rguenther@suse.de> PR lto/83452 * simple-object-elf.c (simple_object_elf_copy_lto_debug_section): Do not use UNDEF locals for removed symbols but instead just define them in the first prevailing section and with no name. Use the same gnu_lto_v1 name for all removed globals we promote to WEAK UNDEFs so hpux can use a stub to provide this symbol. Clear sh_info and sh_link in removed sections. 2017-10-30 Richard Biener <rguenther@suse.de> PR lto/82757 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Strip two leading _s from the __gnu_lto_* symbols. 2017-10-24 Alan Modra <amodra@gmail.com> PR lto/82687 PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Only make __gnu_lto symbols hidden. 2017-10-20 Alan Modra <amodra@gmail.com> PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Make discarded non-local symbols weak and hidden. 2017-10-18 Jakub Jelinek <jakub@redhat.com> PR lto/82598 * simple-object.c (handle_lto_debug_sections): Copy over also .note.GNU-stack section with unchanged name. * simple-object-elf.c (SHF_EXECINSTR): Define. (simple_object_elf_copy_lto_debug_section): Drop SHF_EXECINSTR bit on .note.GNU-stack section. 2017-09-25 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_encoding): Strip return type when name is a LOCAL_NAME. (d_local_name): Strip return type of enclosing TYPED_NAME. * testsuite/demangle-expected: Add and adjust tests. 2017-09-21 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Revert addition of 'toplevel' parm. (has_return_type): Recurse for DEMANGLE_COMPONENT_LOCAL_NAME. (d_encoding): Revert d_name change. Use is_fnqual_component_type to strip modifiers that do not belong. (d_special_name, d_class_enum_type): Revert d_name call change. (d_expresion_1): Commonize DEMANGLE_COMPONENT_UNARY building. (d_local_name): Revert parsing of a function type. (d_print_comp_inner): An inner LOCAL_NAME might contain a TEMPLATE. * testsuite/demangle-expected: Add & adjust tests
2018-01-10 14:57:48 +01:00
dc = d_name (di);
2003-11-27 02:17:34 +01:00
Update the libiberty sources with the latest patches found in the master sources. 2017-01-02 Richard Biener <rguenther@suse.de> PR lto/83452 * simple-object-elf.c (simple_object_elf_copy_lto_debug_section): Do not use UNDEF locals for removed symbols but instead just define them in the first prevailing section and with no name. Use the same gnu_lto_v1 name for all removed globals we promote to WEAK UNDEFs so hpux can use a stub to provide this symbol. Clear sh_info and sh_link in removed sections. 2017-10-30 Richard Biener <rguenther@suse.de> PR lto/82757 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Strip two leading _s from the __gnu_lto_* symbols. 2017-10-24 Alan Modra <amodra@gmail.com> PR lto/82687 PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Only make __gnu_lto symbols hidden. 2017-10-20 Alan Modra <amodra@gmail.com> PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Make discarded non-local symbols weak and hidden. 2017-10-18 Jakub Jelinek <jakub@redhat.com> PR lto/82598 * simple-object.c (handle_lto_debug_sections): Copy over also .note.GNU-stack section with unchanged name. * simple-object-elf.c (SHF_EXECINSTR): Define. (simple_object_elf_copy_lto_debug_section): Drop SHF_EXECINSTR bit on .note.GNU-stack section. 2017-09-25 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_encoding): Strip return type when name is a LOCAL_NAME. (d_local_name): Strip return type of enclosing TYPED_NAME. * testsuite/demangle-expected: Add and adjust tests. 2017-09-21 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Revert addition of 'toplevel' parm. (has_return_type): Recurse for DEMANGLE_COMPONENT_LOCAL_NAME. (d_encoding): Revert d_name change. Use is_fnqual_component_type to strip modifiers that do not belong. (d_special_name, d_class_enum_type): Revert d_name call change. (d_expresion_1): Commonize DEMANGLE_COMPONENT_UNARY building. (d_local_name): Revert parsing of a function type. (d_print_comp_inner): An inner LOCAL_NAME might contain a TEMPLATE. * testsuite/demangle-expected: Add & adjust tests
2018-01-10 14:57:48 +01:00
if (!dc)
/* Failed already. */;
else if (top_level && (di->options & DMGL_PARAMS) == 0)
2003-11-27 02:17:34 +01:00
{
/* Strip off any initial CV-qualifiers, as they really apply
to the `this' parameter, and they were not output by the
v2 demangler without DMGL_PARAMS. */
Update the libiberty sources with the latest patches found in the master sources. 2017-01-02 Richard Biener <rguenther@suse.de> PR lto/83452 * simple-object-elf.c (simple_object_elf_copy_lto_debug_section): Do not use UNDEF locals for removed symbols but instead just define them in the first prevailing section and with no name. Use the same gnu_lto_v1 name for all removed globals we promote to WEAK UNDEFs so hpux can use a stub to provide this symbol. Clear sh_info and sh_link in removed sections. 2017-10-30 Richard Biener <rguenther@suse.de> PR lto/82757 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Strip two leading _s from the __gnu_lto_* symbols. 2017-10-24 Alan Modra <amodra@gmail.com> PR lto/82687 PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Only make __gnu_lto symbols hidden. 2017-10-20 Alan Modra <amodra@gmail.com> PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Make discarded non-local symbols weak and hidden. 2017-10-18 Jakub Jelinek <jakub@redhat.com> PR lto/82598 * simple-object.c (handle_lto_debug_sections): Copy over also .note.GNU-stack section with unchanged name. * simple-object-elf.c (SHF_EXECINSTR): Define. (simple_object_elf_copy_lto_debug_section): Drop SHF_EXECINSTR bit on .note.GNU-stack section. 2017-09-25 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_encoding): Strip return type when name is a LOCAL_NAME. (d_local_name): Strip return type of enclosing TYPED_NAME. * testsuite/demangle-expected: Add and adjust tests. 2017-09-21 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Revert addition of 'toplevel' parm. (has_return_type): Recurse for DEMANGLE_COMPONENT_LOCAL_NAME. (d_encoding): Revert d_name change. Use is_fnqual_component_type to strip modifiers that do not belong. (d_special_name, d_class_enum_type): Revert d_name call change. (d_expresion_1): Commonize DEMANGLE_COMPONENT_UNARY building. (d_local_name): Revert parsing of a function type. (d_print_comp_inner): An inner LOCAL_NAME might contain a TEMPLATE. * testsuite/demangle-expected: Add & adjust tests
2018-01-10 14:57:48 +01:00
while (is_fnqual_component_type (dc->type))
2003-11-27 02:17:34 +01:00
dc = d_left (dc);
2004-01-02 22:11:34 +01:00
2004-01-12 22:24:38 +01:00
/* If the top level is a DEMANGLE_COMPONENT_LOCAL_NAME, then
there may be function-qualifiers on its right argument which
2004-01-12 22:24:38 +01:00
really apply here; this happens when parsing a class
which is local to a function. */
if (dc->type == DEMANGLE_COMPONENT_LOCAL_NAME)
Update the libiberty sources with the latest patches found in the master sources. 2017-01-02 Richard Biener <rguenther@suse.de> PR lto/83452 * simple-object-elf.c (simple_object_elf_copy_lto_debug_section): Do not use UNDEF locals for removed symbols but instead just define them in the first prevailing section and with no name. Use the same gnu_lto_v1 name for all removed globals we promote to WEAK UNDEFs so hpux can use a stub to provide this symbol. Clear sh_info and sh_link in removed sections. 2017-10-30 Richard Biener <rguenther@suse.de> PR lto/82757 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Strip two leading _s from the __gnu_lto_* symbols. 2017-10-24 Alan Modra <amodra@gmail.com> PR lto/82687 PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Only make __gnu_lto symbols hidden. 2017-10-20 Alan Modra <amodra@gmail.com> PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Make discarded non-local symbols weak and hidden. 2017-10-18 Jakub Jelinek <jakub@redhat.com> PR lto/82598 * simple-object.c (handle_lto_debug_sections): Copy over also .note.GNU-stack section with unchanged name. * simple-object-elf.c (SHF_EXECINSTR): Define. (simple_object_elf_copy_lto_debug_section): Drop SHF_EXECINSTR bit on .note.GNU-stack section. 2017-09-25 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_encoding): Strip return type when name is a LOCAL_NAME. (d_local_name): Strip return type of enclosing TYPED_NAME. * testsuite/demangle-expected: Add and adjust tests. 2017-09-21 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Revert addition of 'toplevel' parm. (has_return_type): Recurse for DEMANGLE_COMPONENT_LOCAL_NAME. (d_encoding): Revert d_name change. Use is_fnqual_component_type to strip modifiers that do not belong. (d_special_name, d_class_enum_type): Revert d_name call change. (d_expresion_1): Commonize DEMANGLE_COMPONENT_UNARY building. (d_local_name): Revert parsing of a function type. (d_print_comp_inner): An inner LOCAL_NAME might contain a TEMPLATE. * testsuite/demangle-expected: Add & adjust tests
2018-01-10 14:57:48 +01:00
while (is_fnqual_component_type (d_right (dc)->type))
d_right (dc) = d_left (d_right (dc));
}
else
{
peek = d_peek_char (di);
if (peek != '\0' && peek != 'E')
2004-01-02 22:11:34 +01:00
{
Update the libiberty sources with the latest patches found in the master sources. 2017-01-02 Richard Biener <rguenther@suse.de> PR lto/83452 * simple-object-elf.c (simple_object_elf_copy_lto_debug_section): Do not use UNDEF locals for removed symbols but instead just define them in the first prevailing section and with no name. Use the same gnu_lto_v1 name for all removed globals we promote to WEAK UNDEFs so hpux can use a stub to provide this symbol. Clear sh_info and sh_link in removed sections. 2017-10-30 Richard Biener <rguenther@suse.de> PR lto/82757 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Strip two leading _s from the __gnu_lto_* symbols. 2017-10-24 Alan Modra <amodra@gmail.com> PR lto/82687 PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Only make __gnu_lto symbols hidden. 2017-10-20 Alan Modra <amodra@gmail.com> PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Make discarded non-local symbols weak and hidden. 2017-10-18 Jakub Jelinek <jakub@redhat.com> PR lto/82598 * simple-object.c (handle_lto_debug_sections): Copy over also .note.GNU-stack section with unchanged name. * simple-object-elf.c (SHF_EXECINSTR): Define. (simple_object_elf_copy_lto_debug_section): Drop SHF_EXECINSTR bit on .note.GNU-stack section. 2017-09-25 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_encoding): Strip return type when name is a LOCAL_NAME. (d_local_name): Strip return type of enclosing TYPED_NAME. * testsuite/demangle-expected: Add and adjust tests. 2017-09-21 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Revert addition of 'toplevel' parm. (has_return_type): Recurse for DEMANGLE_COMPONENT_LOCAL_NAME. (d_encoding): Revert d_name change. Use is_fnqual_component_type to strip modifiers that do not belong. (d_special_name, d_class_enum_type): Revert d_name call change. (d_expresion_1): Commonize DEMANGLE_COMPONENT_UNARY building. (d_local_name): Revert parsing of a function type. (d_print_comp_inner): An inner LOCAL_NAME might contain a TEMPLATE. * testsuite/demangle-expected: Add & adjust tests
2018-01-10 14:57:48 +01:00
struct demangle_component *ftype;
2004-01-02 22:11:34 +01:00
Update the libiberty sources with the latest patches found in the master sources. 2017-01-02 Richard Biener <rguenther@suse.de> PR lto/83452 * simple-object-elf.c (simple_object_elf_copy_lto_debug_section): Do not use UNDEF locals for removed symbols but instead just define them in the first prevailing section and with no name. Use the same gnu_lto_v1 name for all removed globals we promote to WEAK UNDEFs so hpux can use a stub to provide this symbol. Clear sh_info and sh_link in removed sections. 2017-10-30 Richard Biener <rguenther@suse.de> PR lto/82757 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Strip two leading _s from the __gnu_lto_* symbols. 2017-10-24 Alan Modra <amodra@gmail.com> PR lto/82687 PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Only make __gnu_lto symbols hidden. 2017-10-20 Alan Modra <amodra@gmail.com> PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Make discarded non-local symbols weak and hidden. 2017-10-18 Jakub Jelinek <jakub@redhat.com> PR lto/82598 * simple-object.c (handle_lto_debug_sections): Copy over also .note.GNU-stack section with unchanged name. * simple-object-elf.c (SHF_EXECINSTR): Define. (simple_object_elf_copy_lto_debug_section): Drop SHF_EXECINSTR bit on .note.GNU-stack section. 2017-09-25 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_encoding): Strip return type when name is a LOCAL_NAME. (d_local_name): Strip return type of enclosing TYPED_NAME. * testsuite/demangle-expected: Add and adjust tests. 2017-09-21 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Revert addition of 'toplevel' parm. (has_return_type): Recurse for DEMANGLE_COMPONENT_LOCAL_NAME. (d_encoding): Revert d_name change. Use is_fnqual_component_type to strip modifiers that do not belong. (d_special_name, d_class_enum_type): Revert d_name call change. (d_expresion_1): Commonize DEMANGLE_COMPONENT_UNARY building. (d_local_name): Revert parsing of a function type. (d_print_comp_inner): An inner LOCAL_NAME might contain a TEMPLATE. * testsuite/demangle-expected: Add & adjust tests
2018-01-10 14:57:48 +01:00
ftype = d_bare_function_type (di, has_return_type (dc));
if (ftype)
{
/* If this is a non-top-level local-name, clear the
return type, so it doesn't confuse the user by
being confused with the return type of whaever
this is nested within. */
if (!top_level && dc->type == DEMANGLE_COMPONENT_LOCAL_NAME
&& ftype->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
d_left (ftype) = NULL;
dc = d_make_comp (di, DEMANGLE_COMPONENT_TYPED_NAME,
dc, ftype);
}
else
dc = NULL;
}
2003-11-27 02:17:34 +01:00
}
2000-07-20 20:56:16 +02:00
}
Update the libiberty sources with the latest patches found in the master sources. 2017-01-02 Richard Biener <rguenther@suse.de> PR lto/83452 * simple-object-elf.c (simple_object_elf_copy_lto_debug_section): Do not use UNDEF locals for removed symbols but instead just define them in the first prevailing section and with no name. Use the same gnu_lto_v1 name for all removed globals we promote to WEAK UNDEFs so hpux can use a stub to provide this symbol. Clear sh_info and sh_link in removed sections. 2017-10-30 Richard Biener <rguenther@suse.de> PR lto/82757 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Strip two leading _s from the __gnu_lto_* symbols. 2017-10-24 Alan Modra <amodra@gmail.com> PR lto/82687 PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Only make __gnu_lto symbols hidden. 2017-10-20 Alan Modra <amodra@gmail.com> PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Make discarded non-local symbols weak and hidden. 2017-10-18 Jakub Jelinek <jakub@redhat.com> PR lto/82598 * simple-object.c (handle_lto_debug_sections): Copy over also .note.GNU-stack section with unchanged name. * simple-object-elf.c (SHF_EXECINSTR): Define. (simple_object_elf_copy_lto_debug_section): Drop SHF_EXECINSTR bit on .note.GNU-stack section. 2017-09-25 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_encoding): Strip return type when name is a LOCAL_NAME. (d_local_name): Strip return type of enclosing TYPED_NAME. * testsuite/demangle-expected: Add and adjust tests. 2017-09-21 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Revert addition of 'toplevel' parm. (has_return_type): Recurse for DEMANGLE_COMPONENT_LOCAL_NAME. (d_encoding): Revert d_name change. Use is_fnqual_component_type to strip modifiers that do not belong. (d_special_name, d_class_enum_type): Revert d_name call change. (d_expresion_1): Commonize DEMANGLE_COMPONENT_UNARY building. (d_local_name): Revert parsing of a function type. (d_print_comp_inner): An inner LOCAL_NAME might contain a TEMPLATE. * testsuite/demangle-expected: Add & adjust tests
2018-01-10 14:57:48 +01:00
return dc;
2003-11-21 18:42:45 +01:00
}
2012-11-11 23:37:30 +01:00
/* <tagged-name> ::= <name> B <source-name> */
static struct demangle_component *
d_abi_tags (struct d_info *di, struct demangle_component *dc)
{
struct demangle_component *hold_last_name;
2012-11-11 23:37:30 +01:00
char peek;
/* Preserve the last name, so the ABI tag doesn't clobber it. */
hold_last_name = di->last_name;
2012-11-11 23:37:30 +01:00
while (peek = d_peek_char (di),
peek == 'B')
{
struct demangle_component *tag;
d_advance (di, 1);
tag = d_source_name (di);
dc = d_make_comp (di, DEMANGLE_COMPONENT_TAGGED_NAME, dc, tag);
}
di->last_name = hold_last_name;
2012-11-11 23:37:30 +01:00
return dc;
}
2003-11-21 18:42:45 +01:00
/* <name> ::= <nested-name>
::= <unscoped-name>
::= <unscoped-template-name> <template-args>
::= <local-name>
<unscoped-name> ::= <unqualified-name>
::= St <unqualified-name>
2003-11-21 18:42:45 +01:00
<unscoped-template-name> ::= <unscoped-name>
::= <substitution>
*/
2004-01-12 22:24:38 +01:00
static struct demangle_component *
Update the libiberty sources with the latest patches found in the master sources. 2017-01-02 Richard Biener <rguenther@suse.de> PR lto/83452 * simple-object-elf.c (simple_object_elf_copy_lto_debug_section): Do not use UNDEF locals for removed symbols but instead just define them in the first prevailing section and with no name. Use the same gnu_lto_v1 name for all removed globals we promote to WEAK UNDEFs so hpux can use a stub to provide this symbol. Clear sh_info and sh_link in removed sections. 2017-10-30 Richard Biener <rguenther@suse.de> PR lto/82757 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Strip two leading _s from the __gnu_lto_* symbols. 2017-10-24 Alan Modra <amodra@gmail.com> PR lto/82687 PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Only make __gnu_lto symbols hidden. 2017-10-20 Alan Modra <amodra@gmail.com> PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Make discarded non-local symbols weak and hidden. 2017-10-18 Jakub Jelinek <jakub@redhat.com> PR lto/82598 * simple-object.c (handle_lto_debug_sections): Copy over also .note.GNU-stack section with unchanged name. * simple-object-elf.c (SHF_EXECINSTR): Define. (simple_object_elf_copy_lto_debug_section): Drop SHF_EXECINSTR bit on .note.GNU-stack section. 2017-09-25 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_encoding): Strip return type when name is a LOCAL_NAME. (d_local_name): Strip return type of enclosing TYPED_NAME. * testsuite/demangle-expected: Add and adjust tests. 2017-09-21 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Revert addition of 'toplevel' parm. (has_return_type): Recurse for DEMANGLE_COMPONENT_LOCAL_NAME. (d_encoding): Revert d_name change. Use is_fnqual_component_type to strip modifiers that do not belong. (d_special_name, d_class_enum_type): Revert d_name call change. (d_expresion_1): Commonize DEMANGLE_COMPONENT_UNARY building. (d_local_name): Revert parsing of a function type. (d_print_comp_inner): An inner LOCAL_NAME might contain a TEMPLATE. * testsuite/demangle-expected: Add & adjust tests
2018-01-10 14:57:48 +01:00
d_name (struct d_info *di)
2003-11-21 18:42:45 +01:00
{
char peek = d_peek_char (di);
2004-01-12 22:24:38 +01:00
struct demangle_component *dc;
2003-11-21 18:42:45 +01:00
switch (peek)
{
2003-11-21 18:42:45 +01:00
case 'N':
return d_nested_name (di);
case 'Z':
Update the libiberty sources with the latest patches found in the master sources. 2017-01-02 Richard Biener <rguenther@suse.de> PR lto/83452 * simple-object-elf.c (simple_object_elf_copy_lto_debug_section): Do not use UNDEF locals for removed symbols but instead just define them in the first prevailing section and with no name. Use the same gnu_lto_v1 name for all removed globals we promote to WEAK UNDEFs so hpux can use a stub to provide this symbol. Clear sh_info and sh_link in removed sections. 2017-10-30 Richard Biener <rguenther@suse.de> PR lto/82757 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Strip two leading _s from the __gnu_lto_* symbols. 2017-10-24 Alan Modra <amodra@gmail.com> PR lto/82687 PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Only make __gnu_lto symbols hidden. 2017-10-20 Alan Modra <amodra@gmail.com> PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Make discarded non-local symbols weak and hidden. 2017-10-18 Jakub Jelinek <jakub@redhat.com> PR lto/82598 * simple-object.c (handle_lto_debug_sections): Copy over also .note.GNU-stack section with unchanged name. * simple-object-elf.c (SHF_EXECINSTR): Define. (simple_object_elf_copy_lto_debug_section): Drop SHF_EXECINSTR bit on .note.GNU-stack section. 2017-09-25 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_encoding): Strip return type when name is a LOCAL_NAME. (d_local_name): Strip return type of enclosing TYPED_NAME. * testsuite/demangle-expected: Add and adjust tests. 2017-09-21 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Revert addition of 'toplevel' parm. (has_return_type): Recurse for DEMANGLE_COMPONENT_LOCAL_NAME. (d_encoding): Revert d_name change. Use is_fnqual_component_type to strip modifiers that do not belong. (d_special_name, d_class_enum_type): Revert d_name call change. (d_expresion_1): Commonize DEMANGLE_COMPONENT_UNARY building. (d_local_name): Revert parsing of a function type. (d_print_comp_inner): An inner LOCAL_NAME might contain a TEMPLATE. * testsuite/demangle-expected: Add & adjust tests
2018-01-10 14:57:48 +01:00
return d_local_name (di);
2003-11-21 18:42:45 +01:00
2009-10-02 20:23:01 +02:00
case 'U':
return d_unqualified_name (di);
2009-10-02 20:23:01 +02:00
2003-11-21 18:42:45 +01:00
case 'S':
{
int subst;
if (d_peek_next_char (di) != 't')
{
2003-12-15 18:45:42 +01:00
dc = d_substitution (di, 0);
2003-11-21 18:42:45 +01:00
subst = 1;
}
else
{
d_advance (di, 2);
2004-01-12 22:24:38 +01:00
dc = d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME,
d_make_name (di, "std", 3),
2003-11-21 18:42:45 +01:00
d_unqualified_name (di));
2003-12-22 17:03:32 +01:00
di->expansion += 3;
2003-11-21 18:42:45 +01:00
subst = 0;
}
if (d_peek_char (di) != 'I')
{
/* The grammar does not permit this case to occur if we
called d_substitution() above (i.e., subst == 1). We
don't bother to check. */
}
else
{
/* This is <template-args>, which means that we just saw
<unscoped-template-name>, which is a substitution
candidate if we didn't just get it from a
substitution. */
if (! subst)
{
if (! d_add_substitution (di, dc))
return NULL;
}
2004-01-12 22:24:38 +01:00
dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
d_template_args (di));
2003-11-21 18:42:45 +01:00
}
return dc;
}
2013-10-16 02:29:48 +02:00
case 'L':
2003-11-21 18:42:45 +01:00
default:
dc = d_unqualified_name (di);
if (d_peek_char (di) == 'I')
2000-07-20 20:56:16 +02:00
{
2003-11-21 18:42:45 +01:00
/* This is <template-args>, which means that we just saw
<unscoped-template-name>, which is a substitution
candidate. */
if (! d_add_substitution (di, dc))
return NULL;
2004-01-12 22:24:38 +01:00
dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
d_template_args (di));
2000-07-20 20:56:16 +02:00
}
2003-11-21 18:42:45 +01:00
return dc;
}
2003-11-21 18:42:45 +01:00
}
2013-04-03 20:21:49 +02:00
/* <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E
2003-11-21 18:42:45 +01:00
*/
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_nested_name (struct d_info *di)
2003-11-21 18:42:45 +01:00
{
2004-01-12 22:24:38 +01:00
struct demangle_component *ret;
struct demangle_component **pret;
2013-04-03 20:21:49 +02:00
struct demangle_component *rqual;
2000-07-20 20:56:16 +02:00
if (! d_check_char (di, 'N'))
2003-11-21 18:42:45 +01:00
return NULL;
2003-12-04 21:03:39 +01:00
pret = d_cv_qualifiers (di, &ret, 1);
2003-11-21 18:42:45 +01:00
if (pret == NULL)
return NULL;
2013-04-03 20:21:49 +02:00
/* Parse the ref-qualifier now and then attach it
once we have something to attach it to. */
rqual = d_ref_qualifier (di, NULL);
2003-11-21 18:42:45 +01:00
*pret = d_prefix (di);
if (*pret == NULL)
return NULL;
2013-04-03 20:21:49 +02:00
if (rqual)
{
d_left (rqual) = ret;
ret = rqual;
}
if (! d_check_char (di, 'E'))
return NULL;
2003-11-21 18:42:45 +01:00
return ret;
}
2003-11-21 18:42:45 +01:00
/* <prefix> ::= <prefix> <unqualified-name>
::= <template-prefix> <template-args>
::= <template-param>
2011-08-06 20:40:27 +02:00
::= <decltype>
2003-11-21 18:42:45 +01:00
::=
::= <substitution>
2003-11-21 18:42:45 +01:00
<template-prefix> ::= <prefix> <(template) unqualified-name>
::= <template-param>
::= <substitution>
*/
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_prefix (struct d_info *di)
{
2004-01-12 22:24:38 +01:00
struct demangle_component *ret = NULL;
2003-11-21 18:42:45 +01:00
while (1)
{
2003-11-21 18:42:45 +01:00
char peek;
2004-01-12 22:24:38 +01:00
enum demangle_component_type comb_type;
struct demangle_component *dc;
2003-11-21 18:42:45 +01:00
peek = d_peek_char (di);
if (peek == '\0')
return NULL;
/* The older code accepts a <local-name> here, but I don't see
that in the grammar. The older code does not accept a
<template-param> here. */
2004-01-12 22:24:38 +01:00
comb_type = DEMANGLE_COMPONENT_QUAL_NAME;
2011-08-06 20:40:27 +02:00
if (peek == 'D')
{
char peek2 = d_peek_next_char (di);
if (peek2 == 'T' || peek2 == 't')
/* Decltype. */
dc = cplus_demangle_type (di);
else
/* Destructor name. */
dc = d_unqualified_name (di);
}
else if (IS_DIGIT (peek)
2003-12-04 21:03:39 +01:00
|| IS_LOWER (peek)
2003-11-21 18:42:45 +01:00
|| peek == 'C'
2009-10-02 20:23:01 +02:00
|| peek == 'U'
|| peek == 'L')
2003-11-21 18:42:45 +01:00
dc = d_unqualified_name (di);
else if (peek == 'S')
2003-12-15 18:45:42 +01:00
dc = d_substitution (di, 1);
2003-11-21 18:42:45 +01:00
else if (peek == 'I')
{
if (ret == NULL)
return NULL;
2004-01-12 22:24:38 +01:00
comb_type = DEMANGLE_COMPONENT_TEMPLATE;
2003-11-21 18:42:45 +01:00
dc = d_template_args (di);
}
else if (peek == 'T')
dc = d_template_param (di);
else if (peek == 'E')
return ret;
2009-10-02 20:23:01 +02:00
else if (peek == 'M')
{
/* Initializer scope for a lambda. We don't need to represent
this; the normal code will just treat the variable as a type
scope, which gives appropriate output. */
if (ret == NULL)
return NULL;
d_advance (di, 1);
continue;
}
2003-11-21 18:42:45 +01:00
else
return NULL;
if (ret == NULL)
ret = dc;
else
2003-11-21 18:42:45 +01:00
ret = d_make_comp (di, comb_type, ret, dc);
if (peek != 'S' && d_peek_char (di) != 'E')
{
if (! d_add_substitution (di, ret))
return NULL;
}
}
}
2003-11-21 18:42:45 +01:00
/* <unqualified-name> ::= <operator-name>
::= <ctor-dtor-name>
::= <source-name>
::= <local-source-name>
<local-source-name> ::= L <source-name> <discriminator>
2003-11-21 18:42:45 +01:00
*/
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_unqualified_name (struct d_info *di)
{
2012-11-11 23:37:30 +01:00
struct demangle_component *ret;
2003-11-21 18:42:45 +01:00
char peek;
peek = d_peek_char (di);
if (IS_DIGIT (peek))
2012-11-11 23:37:30 +01:00
ret = d_source_name (di);
2003-12-04 21:03:39 +01:00
else if (IS_LOWER (peek))
2003-12-22 17:03:32 +01:00
{
if (peek == 'o' && d_peek_next_char (di) == 'n')
d_advance (di, 2);
2003-12-22 17:03:32 +01:00
ret = d_operator_name (di);
2004-01-12 22:24:38 +01:00
if (ret != NULL && ret->type == DEMANGLE_COMPONENT_OPERATOR)
2012-03-08 01:01:31 +01:00
{
di->expansion += sizeof "operator" + ret->u.s_operator.op->len - 2;
if (!strcmp (ret->u.s_operator.op->code, "li"))
ret = d_make_comp (di, DEMANGLE_COMPONENT_UNARY, ret,
d_source_name (di));
}
2003-12-22 17:03:32 +01:00
}
2003-11-21 18:42:45 +01:00
else if (peek == 'C' || peek == 'D')
2012-11-11 23:37:30 +01:00
ret = d_ctor_dtor_name (di);
else if (peek == 'L')
{
d_advance (di, 1);
ret = d_source_name (di);
if (ret == NULL)
return NULL;
if (! d_discriminator (di))
return NULL;
}
2009-10-02 20:23:01 +02:00
else if (peek == 'U')
{
switch (d_peek_next_char (di))
{
case 'l':
2012-11-11 23:37:30 +01:00
ret = d_lambda (di);
break;
2009-10-02 20:23:01 +02:00
case 't':
2012-11-11 23:37:30 +01:00
ret = d_unnamed_type (di);
break;
2009-10-02 20:23:01 +02:00
default:
return NULL;
}
}
2003-11-21 18:42:45 +01:00
else
2000-07-20 20:56:16 +02:00
return NULL;
2012-11-11 23:37:30 +01:00
if (d_peek_char (di) == 'B')
ret = d_abi_tags (di, ret);
return ret;
}
2003-11-21 18:42:45 +01:00
/* <source-name> ::= <(positive length) number> <identifier> */
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_source_name (struct d_info *di)
{
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
int len;
2004-01-12 22:24:38 +01:00
struct demangle_component *ret;
2003-11-21 18:42:45 +01:00
len = d_number (di);
if (len <= 0)
return NULL;
ret = d_identifier (di, len);
di->last_name = ret;
return ret;
}
2003-11-21 18:42:45 +01:00
/* number ::= [n] <(non-negative decimal integer)> */
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
static int
2005-03-27 07:28:42 +02:00
d_number (struct d_info *di)
{
2003-12-22 17:03:32 +01:00
int negative;
2003-11-21 18:42:45 +01:00
char peek;
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
int ret;
2003-12-22 17:03:32 +01:00
negative = 0;
2003-11-21 18:42:45 +01:00
peek = d_peek_char (di);
if (peek == 'n')
{
2003-12-22 17:03:32 +01:00
negative = 1;
2003-11-21 18:42:45 +01:00
d_advance (di, 1);
peek = d_peek_char (di);
}
2003-11-21 18:42:45 +01:00
ret = 0;
while (1)
{
2003-11-21 18:42:45 +01:00
if (! IS_DIGIT (peek))
2003-12-22 17:03:32 +01:00
{
if (negative)
ret = - ret;
return ret;
}
if (ret > ((INT_MAX - (peek - '0')) / 10))
return -1;
2003-11-21 18:42:45 +01:00
ret = ret * 10 + peek - '0';
d_advance (di, 1);
peek = d_peek_char (di);
}
}
2010-02-04 00:28:01 +01:00
/* Like d_number, but returns a demangle_component. */
static struct demangle_component *
d_number_component (struct d_info *di)
{
struct demangle_component *ret = d_make_empty (di);
if (ret)
{
ret->type = DEMANGLE_COMPONENT_NUMBER;
ret->u.s_number.number = d_number (di);
}
return ret;
}
2003-11-21 18:42:45 +01:00
/* identifier ::= <(unqualified source code identifier)> */
2004-01-12 22:24:38 +01:00
static struct demangle_component *
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
d_identifier (struct d_info *di, int len)
{
2003-11-21 18:42:45 +01:00
const char *name;
2003-11-21 18:42:45 +01:00
name = d_str (di);
2003-12-22 17:03:32 +01:00
if (di->send - name < len)
return NULL;
2003-11-21 18:42:45 +01:00
d_advance (di, len);
2003-12-20 17:06:10 +01:00
/* A Java mangled name may have a trailing '$' if it is a C++
keyword. This '$' is not included in the length count. We just
ignore the '$'. */
if ((di->options & DMGL_JAVA) != 0
&& d_peek_char (di) == '$')
d_advance (di, 1);
2003-11-21 18:42:45 +01:00
/* Look for something which looks like a gcc encoding of an
anonymous namespace, and replace it with a more user friendly
name. */
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
if (len >= (int) ANONYMOUS_NAMESPACE_PREFIX_LEN + 2
2003-11-21 18:42:45 +01:00
&& memcmp (name, ANONYMOUS_NAMESPACE_PREFIX,
ANONYMOUS_NAMESPACE_PREFIX_LEN) == 0)
{
2003-11-21 18:42:45 +01:00
const char *s;
s = name + ANONYMOUS_NAMESPACE_PREFIX_LEN;
if ((*s == '.' || *s == '_' || *s == '$')
&& s[1] == 'N')
2003-12-22 17:03:32 +01:00
{
di->expansion -= len - sizeof "(anonymous namespace)";
return d_make_name (di, "(anonymous namespace)",
sizeof "(anonymous namespace)" - 1);
}
}
2003-11-21 18:42:45 +01:00
return d_make_name (di, name, len);
}
2003-11-21 18:42:45 +01:00
/* operator_name ::= many different two character encodings.
::= cv <type>
::= v <digit> <source-name>
2012-01-06 23:04:43 +01:00
This list is sorted for binary search. */
2003-12-22 17:03:32 +01:00
#define NL(s) s, (sizeof s) - 1
2004-01-12 22:24:38 +01:00
CP_STATIC_IF_GLIBCPP_V3
const struct demangle_operator_info cplus_demangle_operators[] =
2003-11-21 18:42:45 +01:00
{
2003-12-22 17:03:32 +01:00
{ "aN", NL ("&="), 2 },
{ "aS", NL ("="), 2 },
{ "aa", NL ("&&"), 2 },
{ "ad", NL ("&"), 1 },
{ "an", NL ("&"), 2 },
2012-01-06 23:04:43 +01:00
{ "at", NL ("alignof "), 1 },
{ "az", NL ("alignof "), 1 },
2012-07-18 22:09:08 +02:00
{ "cc", NL ("const_cast"), 2 },
2008-09-09 20:21:49 +02:00
{ "cl", NL ("()"), 2 },
2003-12-22 17:03:32 +01:00
{ "cm", NL (","), 2 },
{ "co", NL ("~"), 1 },
{ "dV", NL ("/="), 2 },
2012-01-06 23:04:43 +01:00
{ "da", NL ("delete[] "), 1 },
2012-07-18 22:09:08 +02:00
{ "dc", NL ("dynamic_cast"), 2 },
2003-12-22 17:03:32 +01:00
{ "de", NL ("*"), 1 },
2012-01-06 23:04:43 +01:00
{ "dl", NL ("delete "), 1 },
{ "ds", NL (".*"), 2 },
2008-10-07 03:28:01 +02:00
{ "dt", NL ("."), 2 },
2003-12-22 17:03:32 +01:00
{ "dv", NL ("/"), 2 },
{ "eO", NL ("^="), 2 },
{ "eo", NL ("^"), 2 },
{ "eq", NL ("=="), 2 },
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
{ "fL", NL ("..."), 3 },
{ "fR", NL ("..."), 3 },
{ "fl", NL ("..."), 2 },
{ "fr", NL ("..."), 2 },
2003-12-22 17:03:32 +01:00
{ "ge", NL (">="), 2 },
2012-01-06 23:04:43 +01:00
{ "gs", NL ("::"), 1 },
2003-12-22 17:03:32 +01:00
{ "gt", NL (">"), 2 },
{ "ix", NL ("[]"), 2 },
{ "lS", NL ("<<="), 2 },
{ "le", NL ("<="), 2 },
2012-03-08 01:01:31 +01:00
{ "li", NL ("operator\"\" "), 1 },
2003-12-22 17:03:32 +01:00
{ "ls", NL ("<<"), 2 },
{ "lt", NL ("<"), 2 },
{ "mI", NL ("-="), 2 },
{ "mL", NL ("*="), 2 },
{ "mi", NL ("-"), 2 },
{ "ml", NL ("*"), 2 },
{ "mm", NL ("--"), 1 },
2012-01-06 23:04:43 +01:00
{ "na", NL ("new[]"), 3 },
2003-12-22 17:03:32 +01:00
{ "ne", NL ("!="), 2 },
{ "ng", NL ("-"), 1 },
{ "nt", NL ("!"), 1 },
2012-01-06 23:04:43 +01:00
{ "nw", NL ("new"), 3 },
2003-12-22 17:03:32 +01:00
{ "oR", NL ("|="), 2 },
{ "oo", NL ("||"), 2 },
{ "or", NL ("|"), 2 },
{ "pL", NL ("+="), 2 },
{ "pl", NL ("+"), 2 },
{ "pm", NL ("->*"), 2 },
{ "pp", NL ("++"), 1 },
{ "ps", NL ("+"), 1 },
{ "pt", NL ("->"), 2 },
{ "qu", NL ("?"), 3 },
{ "rM", NL ("%="), 2 },
{ "rS", NL (">>="), 2 },
2012-07-18 22:09:08 +02:00
{ "rc", NL ("reinterpret_cast"), 2 },
2003-12-22 17:03:32 +01:00
{ "rm", NL ("%"), 2 },
{ "rs", NL (">>"), 2 },
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
{ "sP", NL ("sizeof..."), 1 },
{ "sZ", NL ("sizeof..."), 1 },
2012-07-18 22:09:08 +02:00
{ "sc", NL ("static_cast"), 2 },
2003-12-22 17:03:32 +01:00
{ "st", NL ("sizeof "), 1 },
2004-01-12 22:24:38 +01:00
{ "sz", NL ("sizeof "), 1 },
2012-01-06 23:04:43 +01:00
{ "tr", NL ("throw"), 0 },
{ "tw", NL ("throw "), 1 },
2004-01-12 22:24:38 +01:00
{ NULL, NULL, 0, 0 }
2003-11-21 18:42:45 +01:00
};
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_operator_name (struct d_info *di)
{
2003-11-21 18:42:45 +01:00
char c1;
char c2;
2003-11-21 18:42:45 +01:00
c1 = d_next_char (di);
c2 = d_next_char (di);
if (c1 == 'v' && IS_DIGIT (c2))
return d_make_extended_operator (di, c2 - '0', d_source_name (di));
else if (c1 == 'c' && c2 == 'v')
{
struct demangle_component *type;
int was_conversion = di->is_conversion;
PR other/61321 - demangler crash on casts in template parameters The fix for bug 59195: [C++ demangler handles conversion operator incorrectly] https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59195 unfortunately makes the demangler crash due to infinite recursion, in case of casts in template parameters. For example, with: template<int> struct A {}; template <typename Y> void function_temp(A<sizeof ((Y)(999))>) {} template void function_temp<int>(A<sizeof (int)>); The 'function_temp<int>' instantiation above mangles to: _Z13function_tempIiEv1AIXszcvT_Li999EEE The demangler parses this as: typed name template name 'function_temp' template argument list builtin type int function type builtin type void argument list template (*) name 'A' template argument list unary operator operator sizeof unary operator cast template parameter 0 (**) literal builtin type int name '999' And after the fix for 59195, due to: static void d_print_cast (struct d_print_info *dpi, int options, const struct demangle_component *dc) { ... /* For a cast operator, we need the template parameters from the enclosing template in scope for processing the type. */ if (dpi->current_template != NULL) { dpt.next = dpi->templates; dpi->templates = &dpt; dpt.template_decl = dpi->current_template; } when printing the template argument list of A (what should be "<sizeof (int)>"), the template parameter 0 (that is, "T_", the '**' above) now refers to the first parameter of the the template argument list of the 'A' template (the '*' above), exactly what we were already trying to print. This leads to infinite recursion, and stack exaustion. The template parameter 0 should actually refer to the first parameter of the 'function_temp' template. Where it reads "for the cast operator" in the comment in d_print_cast (above), it's really talking about a conversion operator, like: struct A { template <typename U> explicit operator U(); }; We don't want to inject the template parameters from the enclosing template in scope when processing a cast _expression_, only when handling a conversion operator. The problem is that DEMANGLE_COMPONENT_CAST is currently ambiguous, and means _both_ 'conversion operator' and 'cast expression'. Fix this by adding a new DEMANGLE_COMPONENT_CONVERSION component type, which does what DEMANGLE_COMPONENT_CAST does today, and making DEMANGLE_COMPONENT_CAST just simply print its component subtree. I think we could instead reuse DEMANGLE_COMPONENT_CAST and in d_print_comp_inner still do: @@ -5001,9 +5013,9 @@ d_print_comp_inner (struct d_print_info *dpi, int options, d_print_comp (dpi, options, dc->u.s_extended_operator.name); return; case DEMANGLE_COMPONENT_CAST: d_append_string (dpi, "operator "); - d_print_cast (dpi, options, dc); + d_print_conversion (dpi, options, dc); return; leaving the unary cast case below calling d_print_cast, but seems to me that spliting the component types makes it easier to reason about the code. g++'s testsuite actually generates three symbols that crash the demangler in the same way. I've added those as tests in the demangler testsuite as well. And then this fixes PR other/61233 too, which happens to be a demangler crash originally reported to GDB, at: https://sourceware.org/bugzilla/show_bug.cgi?id=16957 Bootstrapped and regtested on x86_64 Fedora 20. Also ran this through GDB's testsuite. GDB will require a small update to use DEMANGLE_COMPONENT_CONVERSION in one place it's using DEMANGLE_COMPONENT_CAST in its sources. libiberty/ 2015-11-27 Pedro Alves <palves@redhat.com> PR other/61321 PR other/61233 * demangle.h (enum demangle_component_type) <DEMANGLE_COMPONENT_CONVERSION>: New value. * cp-demangle.c (d_demangle_callback, d_make_comp): Handle DEMANGLE_COMPONENT_CONVERSION. (is_ctor_dtor_or_conversion): Handle DEMANGLE_COMPONENT_CONVERSION instead of DEMANGLE_COMPONENT_CAST. (d_operator_name): Return a DEMANGLE_COMPONENT_CONVERSION component if handling a conversion. (d_count_templates_scopes, d_print_comp_inner): Handle DEMANGLE_COMPONENT_CONVERSION. (d_print_comp_inner): Handle DEMANGLE_COMPONENT_CONVERSION instead of DEMANGLE_COMPONENT_CAST. (d_print_cast): Rename as ... (d_print_conversion): ... this. Adjust comments. (d_print_cast): Rewrite - simply print the left subcomponent. * cp-demint.c (cplus_demangle_fill_component): Handle DEMANGLE_COMPONENT_CONVERSION. * testsuite/demangle-expected: Add tests. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@231020 138bc75d-0d04-0410-961f-82ee72b054a4
2015-11-28 17:39:31 +01:00
struct demangle_component *res;
di->is_conversion = ! di->is_expression;
type = cplus_demangle_type (di);
PR other/61321 - demangler crash on casts in template parameters The fix for bug 59195: [C++ demangler handles conversion operator incorrectly] https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59195 unfortunately makes the demangler crash due to infinite recursion, in case of casts in template parameters. For example, with: template<int> struct A {}; template <typename Y> void function_temp(A<sizeof ((Y)(999))>) {} template void function_temp<int>(A<sizeof (int)>); The 'function_temp<int>' instantiation above mangles to: _Z13function_tempIiEv1AIXszcvT_Li999EEE The demangler parses this as: typed name template name 'function_temp' template argument list builtin type int function type builtin type void argument list template (*) name 'A' template argument list unary operator operator sizeof unary operator cast template parameter 0 (**) literal builtin type int name '999' And after the fix for 59195, due to: static void d_print_cast (struct d_print_info *dpi, int options, const struct demangle_component *dc) { ... /* For a cast operator, we need the template parameters from the enclosing template in scope for processing the type. */ if (dpi->current_template != NULL) { dpt.next = dpi->templates; dpi->templates = &dpt; dpt.template_decl = dpi->current_template; } when printing the template argument list of A (what should be "<sizeof (int)>"), the template parameter 0 (that is, "T_", the '**' above) now refers to the first parameter of the the template argument list of the 'A' template (the '*' above), exactly what we were already trying to print. This leads to infinite recursion, and stack exaustion. The template parameter 0 should actually refer to the first parameter of the 'function_temp' template. Where it reads "for the cast operator" in the comment in d_print_cast (above), it's really talking about a conversion operator, like: struct A { template <typename U> explicit operator U(); }; We don't want to inject the template parameters from the enclosing template in scope when processing a cast _expression_, only when handling a conversion operator. The problem is that DEMANGLE_COMPONENT_CAST is currently ambiguous, and means _both_ 'conversion operator' and 'cast expression'. Fix this by adding a new DEMANGLE_COMPONENT_CONVERSION component type, which does what DEMANGLE_COMPONENT_CAST does today, and making DEMANGLE_COMPONENT_CAST just simply print its component subtree. I think we could instead reuse DEMANGLE_COMPONENT_CAST and in d_print_comp_inner still do: @@ -5001,9 +5013,9 @@ d_print_comp_inner (struct d_print_info *dpi, int options, d_print_comp (dpi, options, dc->u.s_extended_operator.name); return; case DEMANGLE_COMPONENT_CAST: d_append_string (dpi, "operator "); - d_print_cast (dpi, options, dc); + d_print_conversion (dpi, options, dc); return; leaving the unary cast case below calling d_print_cast, but seems to me that spliting the component types makes it easier to reason about the code. g++'s testsuite actually generates three symbols that crash the demangler in the same way. I've added those as tests in the demangler testsuite as well. And then this fixes PR other/61233 too, which happens to be a demangler crash originally reported to GDB, at: https://sourceware.org/bugzilla/show_bug.cgi?id=16957 Bootstrapped and regtested on x86_64 Fedora 20. Also ran this through GDB's testsuite. GDB will require a small update to use DEMANGLE_COMPONENT_CONVERSION in one place it's using DEMANGLE_COMPONENT_CAST in its sources. libiberty/ 2015-11-27 Pedro Alves <palves@redhat.com> PR other/61321 PR other/61233 * demangle.h (enum demangle_component_type) <DEMANGLE_COMPONENT_CONVERSION>: New value. * cp-demangle.c (d_demangle_callback, d_make_comp): Handle DEMANGLE_COMPONENT_CONVERSION. (is_ctor_dtor_or_conversion): Handle DEMANGLE_COMPONENT_CONVERSION instead of DEMANGLE_COMPONENT_CAST. (d_operator_name): Return a DEMANGLE_COMPONENT_CONVERSION component if handling a conversion. (d_count_templates_scopes, d_print_comp_inner): Handle DEMANGLE_COMPONENT_CONVERSION. (d_print_comp_inner): Handle DEMANGLE_COMPONENT_CONVERSION instead of DEMANGLE_COMPONENT_CAST. (d_print_cast): Rename as ... (d_print_conversion): ... this. Adjust comments. (d_print_cast): Rewrite - simply print the left subcomponent. * cp-demint.c (cplus_demangle_fill_component): Handle DEMANGLE_COMPONENT_CONVERSION. * testsuite/demangle-expected: Add tests. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@231020 138bc75d-0d04-0410-961f-82ee72b054a4
2015-11-28 17:39:31 +01:00
if (di->is_conversion)
res = d_make_comp (di, DEMANGLE_COMPONENT_CONVERSION, type, NULL);
else
res = d_make_comp (di, DEMANGLE_COMPONENT_CAST, type, NULL);
di->is_conversion = was_conversion;
PR other/61321 - demangler crash on casts in template parameters The fix for bug 59195: [C++ demangler handles conversion operator incorrectly] https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59195 unfortunately makes the demangler crash due to infinite recursion, in case of casts in template parameters. For example, with: template<int> struct A {}; template <typename Y> void function_temp(A<sizeof ((Y)(999))>) {} template void function_temp<int>(A<sizeof (int)>); The 'function_temp<int>' instantiation above mangles to: _Z13function_tempIiEv1AIXszcvT_Li999EEE The demangler parses this as: typed name template name 'function_temp' template argument list builtin type int function type builtin type void argument list template (*) name 'A' template argument list unary operator operator sizeof unary operator cast template parameter 0 (**) literal builtin type int name '999' And after the fix for 59195, due to: static void d_print_cast (struct d_print_info *dpi, int options, const struct demangle_component *dc) { ... /* For a cast operator, we need the template parameters from the enclosing template in scope for processing the type. */ if (dpi->current_template != NULL) { dpt.next = dpi->templates; dpi->templates = &dpt; dpt.template_decl = dpi->current_template; } when printing the template argument list of A (what should be "<sizeof (int)>"), the template parameter 0 (that is, "T_", the '**' above) now refers to the first parameter of the the template argument list of the 'A' template (the '*' above), exactly what we were already trying to print. This leads to infinite recursion, and stack exaustion. The template parameter 0 should actually refer to the first parameter of the 'function_temp' template. Where it reads "for the cast operator" in the comment in d_print_cast (above), it's really talking about a conversion operator, like: struct A { template <typename U> explicit operator U(); }; We don't want to inject the template parameters from the enclosing template in scope when processing a cast _expression_, only when handling a conversion operator. The problem is that DEMANGLE_COMPONENT_CAST is currently ambiguous, and means _both_ 'conversion operator' and 'cast expression'. Fix this by adding a new DEMANGLE_COMPONENT_CONVERSION component type, which does what DEMANGLE_COMPONENT_CAST does today, and making DEMANGLE_COMPONENT_CAST just simply print its component subtree. I think we could instead reuse DEMANGLE_COMPONENT_CAST and in d_print_comp_inner still do: @@ -5001,9 +5013,9 @@ d_print_comp_inner (struct d_print_info *dpi, int options, d_print_comp (dpi, options, dc->u.s_extended_operator.name); return; case DEMANGLE_COMPONENT_CAST: d_append_string (dpi, "operator "); - d_print_cast (dpi, options, dc); + d_print_conversion (dpi, options, dc); return; leaving the unary cast case below calling d_print_cast, but seems to me that spliting the component types makes it easier to reason about the code. g++'s testsuite actually generates three symbols that crash the demangler in the same way. I've added those as tests in the demangler testsuite as well. And then this fixes PR other/61233 too, which happens to be a demangler crash originally reported to GDB, at: https://sourceware.org/bugzilla/show_bug.cgi?id=16957 Bootstrapped and regtested on x86_64 Fedora 20. Also ran this through GDB's testsuite. GDB will require a small update to use DEMANGLE_COMPONENT_CONVERSION in one place it's using DEMANGLE_COMPONENT_CAST in its sources. libiberty/ 2015-11-27 Pedro Alves <palves@redhat.com> PR other/61321 PR other/61233 * demangle.h (enum demangle_component_type) <DEMANGLE_COMPONENT_CONVERSION>: New value. * cp-demangle.c (d_demangle_callback, d_make_comp): Handle DEMANGLE_COMPONENT_CONVERSION. (is_ctor_dtor_or_conversion): Handle DEMANGLE_COMPONENT_CONVERSION instead of DEMANGLE_COMPONENT_CAST. (d_operator_name): Return a DEMANGLE_COMPONENT_CONVERSION component if handling a conversion. (d_count_templates_scopes, d_print_comp_inner): Handle DEMANGLE_COMPONENT_CONVERSION. (d_print_comp_inner): Handle DEMANGLE_COMPONENT_CONVERSION instead of DEMANGLE_COMPONENT_CAST. (d_print_cast): Rename as ... (d_print_conversion): ... this. Adjust comments. (d_print_cast): Rewrite - simply print the left subcomponent. * cp-demint.c (cplus_demangle_fill_component): Handle DEMANGLE_COMPONENT_CONVERSION. * testsuite/demangle-expected: Add tests. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@231020 138bc75d-0d04-0410-961f-82ee72b054a4
2015-11-28 17:39:31 +01:00
return res;
}
2003-11-21 18:42:45 +01:00
else
{
2004-01-12 22:24:38 +01:00
/* LOW is the inclusive lower bound. */
2003-11-21 18:42:45 +01:00
int low = 0;
2004-01-12 22:24:38 +01:00
/* HIGH is the exclusive upper bound. We subtract one to ignore
the sentinel at the end of the array. */
int high = ((sizeof (cplus_demangle_operators)
/ sizeof (cplus_demangle_operators[0]))
- 1);
2003-11-21 18:42:45 +01:00
while (1)
{
int i;
2004-01-12 22:24:38 +01:00
const struct demangle_operator_info *p;
2003-11-21 18:42:45 +01:00
i = low + (high - low) / 2;
2004-01-12 22:24:38 +01:00
p = cplus_demangle_operators + i;
2003-11-21 18:42:45 +01:00
if (c1 == p->code[0] && c2 == p->code[1])
return d_make_operator (di, p);
if (c1 < p->code[0] || (c1 == p->code[0] && c2 < p->code[1]))
high = i;
else
low = i + 1;
if (low == high)
return NULL;
}
}
}
static struct demangle_component *
d_make_character (struct d_info *di, int c)
{
struct demangle_component *p;
p = d_make_empty (di);
if (p != NULL)
{
p->type = DEMANGLE_COMPONENT_CHARACTER;
p->u.s_character.character = c;
}
return p;
}
static struct demangle_component *
d_java_resource (struct d_info *di)
{
struct demangle_component *p = NULL;
struct demangle_component *next = NULL;
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
int len, i;
char c;
const char *str;
len = d_number (di);
if (len <= 1)
return NULL;
/* Eat the leading '_'. */
if (d_next_char (di) != '_')
return NULL;
len--;
str = d_str (di);
i = 0;
while (len > 0)
{
c = str[i];
if (!c)
return NULL;
/* Each chunk is either a '$' escape... */
if (c == '$')
{
i++;
switch (str[i++])
{
case 'S':
c = '/';
break;
case '_':
c = '.';
break;
case '$':
c = '$';
break;
default:
return NULL;
}
next = d_make_character (di, c);
d_advance (di, i);
str = d_str (di);
len -= i;
i = 0;
if (next == NULL)
return NULL;
}
/* ... or a sequence of characters. */
else
{
while (i < len && str[i] && str[i] != '$')
i++;
next = d_make_name (di, str, i);
d_advance (di, i);
str = d_str (di);
len -= i;
i = 0;
if (next == NULL)
return NULL;
}
if (p == NULL)
p = next;
else
{
p = d_make_comp (di, DEMANGLE_COMPONENT_COMPOUND_NAME, p, next);
if (p == NULL)
return NULL;
}
}
p = d_make_comp (di, DEMANGLE_COMPONENT_JAVA_RESOURCE, p, NULL);
return p;
}
2003-11-21 18:42:45 +01:00
/* <special-name> ::= TV <type>
::= TT <type>
::= TI <type>
::= TS <type>
Synchronize libiberty with gcc and add --no-recruse-limit option to tools that support name demangling. This patch addresses the multitude of bug reports about resource exhaustion in libiberty's name demangling code. It adds a limit to the amount of recursion that is allowed, before an error is triggered. It also adds a new demangling option to disable this limit. (The limit is enabled by default). PR 87681 PR 87675 PR 87636 PR 87335 libiberty * cp-demangle.h (struct d_info): Add recursion_limit field. * cp-demangle.c (d_function_type): If the recursion limit is enabled and reached, return with a failure result. (d_demangle_callback): If the recursion limit is enabled, check for a mangled string that is so long that there is not enough stack space for the local arrays. * cplus-dem.c (struct work): Add recursion_level field. (demangle_nested_args): If the recursion limit is enabled and reached, return with a failure result. include * demangle.h (DMGL_RECURSE_LIMIT): Define. (DEMANGLE_RECURSION_LIMIT): Prototype. binutuils * addr2line.c (demangle_flags): New static variable. (long_options): Add --recurse-limit and --no-recurse-limit. (translate_address): Pass demangle_flags to bfd_demangle. (main): Handle --recurse-limit and --no-recurse-limit options. * cxxfilt.c (flags): Add DMGL_RECURSE_LIMIT. (long_options): Add --recurse-limit and --no-recurse-limit. (main): Handle new options. * dlltool.c (gen_def_file): Include DMGL_RECURSE_LIMIT in flags passed to cplus_demangle. * nm.c (demangle_flags): New static variable. (long_options): Add --recurse-limit and --no-recurse-limit. (main): Handle new options. * objdump.c (demangle_flags): New static variable. (usage): Add --recurse-limit and --no-recurse-limit. (long_options): Likewise. (objdump_print_symname): Pass demangle_flags to bfd_demangle. (disassemble_section): Likewise. (dump_dymbols): Likewise. (main): Handle new options. * prdbg.c (demangle_flags): New static variable. (tg_variable): Pass demangle_flags to demangler. (tg_start_function): Likewise. * stabs.c (demangle_flags): New static variable. (stab_demangle_template): Pass demangle_flags to demangler. (stab_demangle_v3_argtypes): Likewise. (stab_demangle_v3_arg): Likewise. * doc/binutuls.texi: Document new command line options. * NEWS: Mention the new feature. * testsuite/config/default.exp (CXXFILT): Define if not already defined. (CXXFILTFLAGS): Likewise. * testsuite/binutils-all/cxxfilt.exp: New file. Runs a few simple tests of the cxxfilt program.
2018-12-07 12:32:55 +01:00
::= TA <template-arg>
2003-11-21 18:42:45 +01:00
::= GV <(object) name>
::= T <call-offset> <(base) encoding>
::= Tc <call-offset> <call-offset> <(base) encoding>
Also g++ extensions:
::= TC <type> <(offset) number> _ <(base) type>
::= TF <type>
::= TJ <type>
::= GR <name>
::= GA <encoding>
::= Gr <resource name>
2011-11-08 17:01:58 +01:00
::= GTt <encoding>
::= GTn <encoding>
2003-11-21 18:42:45 +01:00
*/
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_special_name (struct d_info *di)
{
2003-12-22 17:03:32 +01:00
di->expansion += 20;
if (d_check_char (di, 'T'))
2000-07-20 20:56:16 +02:00
{
2003-11-21 18:42:45 +01:00
switch (d_next_char (di))
{
case 'V':
2003-12-22 17:03:32 +01:00
di->expansion -= 5;
2004-01-12 22:24:38 +01:00
return d_make_comp (di, DEMANGLE_COMPONENT_VTABLE,
cplus_demangle_type (di), NULL);
2003-11-21 18:42:45 +01:00
case 'T':
2003-12-22 17:03:32 +01:00
di->expansion -= 10;
2004-01-12 22:24:38 +01:00
return d_make_comp (di, DEMANGLE_COMPONENT_VTT,
cplus_demangle_type (di), NULL);
2003-11-21 18:42:45 +01:00
case 'I':
2004-01-12 22:24:38 +01:00
return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO,
cplus_demangle_type (di), NULL);
2003-11-21 18:42:45 +01:00
case 'S':
2004-01-12 22:24:38 +01:00
return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_NAME,
cplus_demangle_type (di), NULL);
2003-11-21 18:42:45 +01:00
case 'h':
if (! d_call_offset (di, 'h'))
return NULL;
2004-01-12 22:24:38 +01:00
return d_make_comp (di, DEMANGLE_COMPONENT_THUNK,
d_encoding (di, 0), NULL);
2003-11-21 18:42:45 +01:00
case 'v':
if (! d_call_offset (di, 'v'))
return NULL;
2004-01-12 22:24:38 +01:00
return d_make_comp (di, DEMANGLE_COMPONENT_VIRTUAL_THUNK,
d_encoding (di, 0), NULL);
2003-11-21 18:42:45 +01:00
case 'c':
if (! d_call_offset (di, '\0'))
return NULL;
if (! d_call_offset (di, '\0'))
return NULL;
2004-01-12 22:24:38 +01:00
return d_make_comp (di, DEMANGLE_COMPONENT_COVARIANT_THUNK,
d_encoding (di, 0), NULL);
2003-11-21 18:42:45 +01:00
case 'C':
{
2004-01-12 22:24:38 +01:00
struct demangle_component *derived_type;
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
int offset;
2004-01-12 22:24:38 +01:00
struct demangle_component *base_type;
2003-11-21 18:42:45 +01:00
2004-01-12 22:24:38 +01:00
derived_type = cplus_demangle_type (di);
2003-11-21 18:42:45 +01:00
offset = d_number (di);
if (offset < 0)
return NULL;
if (! d_check_char (di, '_'))
2003-11-21 18:42:45 +01:00
return NULL;
2004-01-12 22:24:38 +01:00
base_type = cplus_demangle_type (di);
2003-11-21 18:42:45 +01:00
/* We don't display the offset. FIXME: We should display
it in verbose mode. */
2003-12-22 17:03:32 +01:00
di->expansion += 5;
2004-01-12 22:24:38 +01:00
return d_make_comp (di, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE,
base_type, derived_type);
2003-11-21 18:42:45 +01:00
}
2003-11-21 18:42:45 +01:00
case 'F':
2004-01-12 22:24:38 +01:00
return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_FN,
cplus_demangle_type (di), NULL);
2003-11-21 18:42:45 +01:00
case 'J':
2004-01-12 22:24:38 +01:00
return d_make_comp (di, DEMANGLE_COMPONENT_JAVA_CLASS,
cplus_demangle_type (di), NULL);
2012-10-10 05:11:33 +02:00
case 'H':
return d_make_comp (di, DEMANGLE_COMPONENT_TLS_INIT,
Update the libiberty sources with the latest patches found in the master sources. 2017-01-02 Richard Biener <rguenther@suse.de> PR lto/83452 * simple-object-elf.c (simple_object_elf_copy_lto_debug_section): Do not use UNDEF locals for removed symbols but instead just define them in the first prevailing section and with no name. Use the same gnu_lto_v1 name for all removed globals we promote to WEAK UNDEFs so hpux can use a stub to provide this symbol. Clear sh_info and sh_link in removed sections. 2017-10-30 Richard Biener <rguenther@suse.de> PR lto/82757 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Strip two leading _s from the __gnu_lto_* symbols. 2017-10-24 Alan Modra <amodra@gmail.com> PR lto/82687 PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Only make __gnu_lto symbols hidden. 2017-10-20 Alan Modra <amodra@gmail.com> PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Make discarded non-local symbols weak and hidden. 2017-10-18 Jakub Jelinek <jakub@redhat.com> PR lto/82598 * simple-object.c (handle_lto_debug_sections): Copy over also .note.GNU-stack section with unchanged name. * simple-object-elf.c (SHF_EXECINSTR): Define. (simple_object_elf_copy_lto_debug_section): Drop SHF_EXECINSTR bit on .note.GNU-stack section. 2017-09-25 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_encoding): Strip return type when name is a LOCAL_NAME. (d_local_name): Strip return type of enclosing TYPED_NAME. * testsuite/demangle-expected: Add and adjust tests. 2017-09-21 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Revert addition of 'toplevel' parm. (has_return_type): Recurse for DEMANGLE_COMPONENT_LOCAL_NAME. (d_encoding): Revert d_name change. Use is_fnqual_component_type to strip modifiers that do not belong. (d_special_name, d_class_enum_type): Revert d_name call change. (d_expresion_1): Commonize DEMANGLE_COMPONENT_UNARY building. (d_local_name): Revert parsing of a function type. (d_print_comp_inner): An inner LOCAL_NAME might contain a TEMPLATE. * testsuite/demangle-expected: Add & adjust tests
2018-01-10 14:57:48 +01:00
d_name (di), NULL);
2012-10-10 05:11:33 +02:00
case 'W':
return d_make_comp (di, DEMANGLE_COMPONENT_TLS_WRAPPER,
Update the libiberty sources with the latest patches found in the master sources. 2017-01-02 Richard Biener <rguenther@suse.de> PR lto/83452 * simple-object-elf.c (simple_object_elf_copy_lto_debug_section): Do not use UNDEF locals for removed symbols but instead just define them in the first prevailing section and with no name. Use the same gnu_lto_v1 name for all removed globals we promote to WEAK UNDEFs so hpux can use a stub to provide this symbol. Clear sh_info and sh_link in removed sections. 2017-10-30 Richard Biener <rguenther@suse.de> PR lto/82757 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Strip two leading _s from the __gnu_lto_* symbols. 2017-10-24 Alan Modra <amodra@gmail.com> PR lto/82687 PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Only make __gnu_lto symbols hidden. 2017-10-20 Alan Modra <amodra@gmail.com> PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Make discarded non-local symbols weak and hidden. 2017-10-18 Jakub Jelinek <jakub@redhat.com> PR lto/82598 * simple-object.c (handle_lto_debug_sections): Copy over also .note.GNU-stack section with unchanged name. * simple-object-elf.c (SHF_EXECINSTR): Define. (simple_object_elf_copy_lto_debug_section): Drop SHF_EXECINSTR bit on .note.GNU-stack section. 2017-09-25 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_encoding): Strip return type when name is a LOCAL_NAME. (d_local_name): Strip return type of enclosing TYPED_NAME. * testsuite/demangle-expected: Add and adjust tests. 2017-09-21 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Revert addition of 'toplevel' parm. (has_return_type): Recurse for DEMANGLE_COMPONENT_LOCAL_NAME. (d_encoding): Revert d_name change. Use is_fnqual_component_type to strip modifiers that do not belong. (d_special_name, d_class_enum_type): Revert d_name call change. (d_expresion_1): Commonize DEMANGLE_COMPONENT_UNARY building. (d_local_name): Revert parsing of a function type. (d_print_comp_inner): An inner LOCAL_NAME might contain a TEMPLATE. * testsuite/demangle-expected: Add & adjust tests
2018-01-10 14:57:48 +01:00
d_name (di), NULL);
2012-10-10 05:11:33 +02:00
Synchronize libiberty with gcc and add --no-recruse-limit option to tools that support name demangling. This patch addresses the multitude of bug reports about resource exhaustion in libiberty's name demangling code. It adds a limit to the amount of recursion that is allowed, before an error is triggered. It also adds a new demangling option to disable this limit. (The limit is enabled by default). PR 87681 PR 87675 PR 87636 PR 87335 libiberty * cp-demangle.h (struct d_info): Add recursion_limit field. * cp-demangle.c (d_function_type): If the recursion limit is enabled and reached, return with a failure result. (d_demangle_callback): If the recursion limit is enabled, check for a mangled string that is so long that there is not enough stack space for the local arrays. * cplus-dem.c (struct work): Add recursion_level field. (demangle_nested_args): If the recursion limit is enabled and reached, return with a failure result. include * demangle.h (DMGL_RECURSE_LIMIT): Define. (DEMANGLE_RECURSION_LIMIT): Prototype. binutuils * addr2line.c (demangle_flags): New static variable. (long_options): Add --recurse-limit and --no-recurse-limit. (translate_address): Pass demangle_flags to bfd_demangle. (main): Handle --recurse-limit and --no-recurse-limit options. * cxxfilt.c (flags): Add DMGL_RECURSE_LIMIT. (long_options): Add --recurse-limit and --no-recurse-limit. (main): Handle new options. * dlltool.c (gen_def_file): Include DMGL_RECURSE_LIMIT in flags passed to cplus_demangle. * nm.c (demangle_flags): New static variable. (long_options): Add --recurse-limit and --no-recurse-limit. (main): Handle new options. * objdump.c (demangle_flags): New static variable. (usage): Add --recurse-limit and --no-recurse-limit. (long_options): Likewise. (objdump_print_symname): Pass demangle_flags to bfd_demangle. (disassemble_section): Likewise. (dump_dymbols): Likewise. (main): Handle new options. * prdbg.c (demangle_flags): New static variable. (tg_variable): Pass demangle_flags to demangler. (tg_start_function): Likewise. * stabs.c (demangle_flags): New static variable. (stab_demangle_template): Pass demangle_flags to demangler. (stab_demangle_v3_argtypes): Likewise. (stab_demangle_v3_arg): Likewise. * doc/binutuls.texi: Document new command line options. * NEWS: Mention the new feature. * testsuite/config/default.exp (CXXFILT): Define if not already defined. (CXXFILTFLAGS): Likewise. * testsuite/binutils-all/cxxfilt.exp: New file. Runs a few simple tests of the cxxfilt program.
2018-12-07 12:32:55 +01:00
case 'A':
return d_make_comp (di, DEMANGLE_COMPONENT_TPARM_OBJ,
d_template_arg (di), NULL);
2003-11-21 18:42:45 +01:00
default:
return NULL;
}
}
else if (d_check_char (di, 'G'))
{
2003-11-21 18:42:45 +01:00
switch (d_next_char (di))
{
case 'V':
Sync libiberty/ & include/ with GCC Note this brings in the interface files for libcc1/G++ as well, which we will be needing in GDB soon anyway. That commit renamed a method in the C interface and that required a small update to GDB's compile/ code, which I've included that in this patch to keep the tree building. include/ChangeLog: 2017-09-15 Pedro Alves <palves@redhat.com> * ansidecl.h (DISABLE_COPY_AND_ASSIGN): New macro. 2017-09-12 Jiong Wang <jiong.wang@arm.com> * dwarf2.def (DW_CFA_AARCH64_negate_ra_state): New DW_CFA_DUP. * dwarf2.h (DW_CFA_DUP): New define. 2017-08-21 Richard Biener <rguenther@suse.de> * simple-object.h (simple_object_copy_lto_debug_sections): New function. 2017-05-18 Martin Liska <mliska@suse.cz> * ansidecl.h: Define CONSTEXPR macro. 2017-05-24 Nathan Sidwell <nathan@acm.org> * libiberty.h (ASTRDUP): Adjust cast to avoid warning. 2017-01-30 Alexandre Oliva <aoliva@redhat.com> Introduce C++ support in libcc1. * gcc-c-fe.def (int_type_v0): Rename from... (int_type): ... this. Introduce new version. (float_type_v0): Rename from... (float_type): ... this. Introduce new version. (char_type): New. * gcc-c-interface.h (gcc_c_api_version): Add GCC_C_FE_VERSION_1. (gcc_type_array): Move... * gcc-interface.h: ... here. * gcc-cp-fe.def: New. * gcc-cp-interface.h: New. 2016-04-29 Oleg Endo <olegendo@gcc.gnu.org> * longlong.h (umul_ppmm): Remove SHMEDIA checks. (__umulsidi3, count_leading_zeros): Remove SHMEDIA implementations. 2017-09-15 Yao Qi <yao.qi@linaro.org> Pedro Alves <palves@redhat.com> * ansidecl.h (DISABLE_COPY_AND_ASSIGN): New macro. 2017-09-12 Jiong Wang <jiong.wang@arm.com> * dwarf2.def (DW_CFA_AARCH64_negate_ra_state): New DW_CFA_DUP. * dwarf2.h (DW_CFA_DUP): New define. 2017-08-21 Richard Biener <rguenther@suse.de> * simple-object.h (simple_object_copy_lto_debug_sections): New function. 2017-05-18 Martin Liska <mliska@suse.cz> * ansidecl.h: Define CONSTEXPR macro. 2017-05-24 Nathan Sidwell <nathan@acm.org> * libiberty.h (ASTRDUP): Adjust cast to avoid warning. 2017-01-30 Alexandre Oliva <aoliva@redhat.com> Introduce C++ support in libcc1. * gcc-c-fe.def (int_type_v0): Rename from... (int_type): ... this. Introduce new version. (float_type_v0): Rename from... (float_type): ... this. Introduce new version. (char_type): New. * gcc-c-interface.h (gcc_c_api_version): Add GCC_C_FE_VERSION_1. (gcc_type_array): Move... * gcc-interface.h: ... here. * gcc-cp-fe.def: New. * gcc-cp-interface.h: New. 2016-04-29 Oleg Endo <olegendo@gcc.gnu.org> * longlong.h (umul_ppmm): Remove SHMEDIA checks. (__umulsidi3, count_leading_zeros): Remove SHMEDIA implementations. libiberty/ChangeLog: 2017-09-15 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Add 'toplevel' parm. Pass to ... (d_local_name): ... here. Parse trailing function args on nested local_name. (d_encoding, d_special_name, d_class_enum_type): Adjust d_name calls. * testsuite/demangle-expected: Add tests. 2017-09-15 Richard Biener <rguenther@suse.de> PR lto/81968 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Iterate marking dependent sections necessary. 2017-09-15 Nathan Sidwell <nathan@acm.org> * cp-demangle.c (is_fnqual_component_type): Reimplement using FNQUAL_COMPONENT_CASE. (d_encoding): Hold bare_function_type in local var. (d_local_name): Build name in both cases and build result once. Collapse switch-if to single conditional. (d_local_name): * testsuite/demangle-expected: Realign blank lines with tests. 2017-09-12 Jiong Wang <jiong.wang@arm.com> * dwarfnames.c (DW_CFA_DUP): New define. gdb/ChangeLog: 2017-09-15 Pedro Alves <palves@redhat.com> * compile/compile-c-types.c (convert_enum, convert_int) (convert_float): Adjust to refer to int_type_v0 and float_type_v0.
2017-09-15 18:40:33 +02:00
return d_make_comp (di, DEMANGLE_COMPONENT_GUARD,
Update the libiberty sources with the latest patches found in the master sources. 2017-01-02 Richard Biener <rguenther@suse.de> PR lto/83452 * simple-object-elf.c (simple_object_elf_copy_lto_debug_section): Do not use UNDEF locals for removed symbols but instead just define them in the first prevailing section and with no name. Use the same gnu_lto_v1 name for all removed globals we promote to WEAK UNDEFs so hpux can use a stub to provide this symbol. Clear sh_info and sh_link in removed sections. 2017-10-30 Richard Biener <rguenther@suse.de> PR lto/82757 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Strip two leading _s from the __gnu_lto_* symbols. 2017-10-24 Alan Modra <amodra@gmail.com> PR lto/82687 PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Only make __gnu_lto symbols hidden. 2017-10-20 Alan Modra <amodra@gmail.com> PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Make discarded non-local symbols weak and hidden. 2017-10-18 Jakub Jelinek <jakub@redhat.com> PR lto/82598 * simple-object.c (handle_lto_debug_sections): Copy over also .note.GNU-stack section with unchanged name. * simple-object-elf.c (SHF_EXECINSTR): Define. (simple_object_elf_copy_lto_debug_section): Drop SHF_EXECINSTR bit on .note.GNU-stack section. 2017-09-25 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_encoding): Strip return type when name is a LOCAL_NAME. (d_local_name): Strip return type of enclosing TYPED_NAME. * testsuite/demangle-expected: Add and adjust tests. 2017-09-21 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Revert addition of 'toplevel' parm. (has_return_type): Recurse for DEMANGLE_COMPONENT_LOCAL_NAME. (d_encoding): Revert d_name change. Use is_fnqual_component_type to strip modifiers that do not belong. (d_special_name, d_class_enum_type): Revert d_name call change. (d_expresion_1): Commonize DEMANGLE_COMPONENT_UNARY building. (d_local_name): Revert parsing of a function type. (d_print_comp_inner): An inner LOCAL_NAME might contain a TEMPLATE. * testsuite/demangle-expected: Add & adjust tests
2018-01-10 14:57:48 +01:00
d_name (di), NULL);
2003-11-21 18:42:45 +01:00
case 'R':
2011-11-04 15:32:13 +01:00
{
Update the libiberty sources with the latest patches found in the master sources. 2017-01-02 Richard Biener <rguenther@suse.de> PR lto/83452 * simple-object-elf.c (simple_object_elf_copy_lto_debug_section): Do not use UNDEF locals for removed symbols but instead just define them in the first prevailing section and with no name. Use the same gnu_lto_v1 name for all removed globals we promote to WEAK UNDEFs so hpux can use a stub to provide this symbol. Clear sh_info and sh_link in removed sections. 2017-10-30 Richard Biener <rguenther@suse.de> PR lto/82757 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Strip two leading _s from the __gnu_lto_* symbols. 2017-10-24 Alan Modra <amodra@gmail.com> PR lto/82687 PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Only make __gnu_lto symbols hidden. 2017-10-20 Alan Modra <amodra@gmail.com> PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Make discarded non-local symbols weak and hidden. 2017-10-18 Jakub Jelinek <jakub@redhat.com> PR lto/82598 * simple-object.c (handle_lto_debug_sections): Copy over also .note.GNU-stack section with unchanged name. * simple-object-elf.c (SHF_EXECINSTR): Define. (simple_object_elf_copy_lto_debug_section): Drop SHF_EXECINSTR bit on .note.GNU-stack section. 2017-09-25 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_encoding): Strip return type when name is a LOCAL_NAME. (d_local_name): Strip return type of enclosing TYPED_NAME. * testsuite/demangle-expected: Add and adjust tests. 2017-09-21 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Revert addition of 'toplevel' parm. (has_return_type): Recurse for DEMANGLE_COMPONENT_LOCAL_NAME. (d_encoding): Revert d_name change. Use is_fnqual_component_type to strip modifiers that do not belong. (d_special_name, d_class_enum_type): Revert d_name call change. (d_expresion_1): Commonize DEMANGLE_COMPONENT_UNARY building. (d_local_name): Revert parsing of a function type. (d_print_comp_inner): An inner LOCAL_NAME might contain a TEMPLATE. * testsuite/demangle-expected: Add & adjust tests
2018-01-10 14:57:48 +01:00
struct demangle_component *name = d_name (di);
2011-11-04 15:32:13 +01:00
return d_make_comp (di, DEMANGLE_COMPONENT_REFTEMP, name,
d_number_component (di));
}
2003-11-21 18:42:45 +01:00
case 'A':
return d_make_comp (di, DEMANGLE_COMPONENT_HIDDEN_ALIAS,
d_encoding (di, 0), NULL);
2011-11-08 17:01:58 +01:00
case 'T':
switch (d_next_char (di))
{
case 'n':
return d_make_comp (di, DEMANGLE_COMPONENT_NONTRANSACTION_CLONE,
d_encoding (di, 0), NULL);
default:
/* ??? The proposal is that other letters (such as 'h') stand
for different variants of transaction cloning, such as
compiling directly for hardware transaction support. But
they still should all be transactional clones of some sort
so go ahead and call them that. */
case 't':
return d_make_comp (di, DEMANGLE_COMPONENT_TRANSACTION_CLONE,
d_encoding (di, 0), NULL);
}
case 'r':
return d_java_resource (di);
2003-11-21 18:42:45 +01:00
default:
return NULL;
}
}
2003-11-21 18:42:45 +01:00
else
return NULL;
}
2003-11-21 18:42:45 +01:00
/* <call-offset> ::= h <nv-offset> _
::= v <v-offset> _
2003-11-21 18:42:45 +01:00
<nv-offset> ::= <(offset) number>
2003-11-21 18:42:45 +01:00
<v-offset> ::= <(offset) number> _ <(virtual offset) number>
2003-11-21 18:42:45 +01:00
The C parameter, if not '\0', is a character we just read which is
the start of the <call-offset>.
2003-11-21 18:42:45 +01:00
We don't display the offset information anywhere. FIXME: We should
display it in verbose mode. */
2003-11-21 18:42:45 +01:00
static int
2005-03-27 07:28:42 +02:00
d_call_offset (struct d_info *di, int c)
{
2003-11-21 18:42:45 +01:00
if (c == '\0')
c = d_next_char (di);
2003-11-21 18:42:45 +01:00
if (c == 'h')
2004-11-24 04:00:34 +01:00
d_number (di);
2003-11-21 18:42:45 +01:00
else if (c == 'v')
{
2004-11-24 04:00:34 +01:00
d_number (di);
if (! d_check_char (di, '_'))
2003-11-21 18:42:45 +01:00
return 0;
2004-11-24 04:00:34 +01:00
d_number (di);
}
2003-11-21 18:42:45 +01:00
else
return 0;
if (! d_check_char (di, '_'))
2003-11-21 18:42:45 +01:00
return 0;
2003-11-21 18:42:45 +01:00
return 1;
}
2003-11-21 18:42:45 +01:00
/* <ctor-dtor-name> ::= C1
::= C2
::= C3
::= D0
::= D1
::= D2
*/
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_ctor_dtor_name (struct d_info *di)
2003-11-21 18:42:45 +01:00
{
2003-12-22 17:03:32 +01:00
if (di->last_name != NULL)
{
2004-01-12 22:24:38 +01:00
if (di->last_name->type == DEMANGLE_COMPONENT_NAME)
2003-12-22 17:03:32 +01:00
di->expansion += di->last_name->u.s_name.len;
2004-01-12 22:24:38 +01:00
else if (di->last_name->type == DEMANGLE_COMPONENT_SUB_STD)
2003-12-22 17:03:32 +01:00
di->expansion += di->last_name->u.s_string.len;
}
switch (d_peek_char (di))
2003-11-21 18:42:45 +01:00
{
case 'C':
{
enum gnu_v3_ctor_kinds kind;
int inheriting = 0;
if (d_peek_next_char (di) == 'I')
{
inheriting = 1;
d_advance (di, 1);
}
2003-11-21 18:42:45 +01:00
switch (d_peek_next_char (di))
2003-11-21 18:42:45 +01:00
{
case '1':
kind = gnu_v3_complete_object_ctor;
break;
case '2':
kind = gnu_v3_base_object_ctor;
break;
case '3':
kind = gnu_v3_complete_object_allocating_ctor;
break;
case '4':
kind = gnu_v3_unified_ctor;
break;
2011-11-08 17:01:58 +01:00
case '5':
kind = gnu_v3_object_ctor_group;
break;
2003-11-21 18:42:45 +01:00
default:
return NULL;
}
d_advance (di, 2);
if (inheriting)
cplus_demangle_type (di);
2003-11-21 18:42:45 +01:00
return d_make_ctor (di, kind, di->last_name);
}
case 'D':
{
enum gnu_v3_dtor_kinds kind;
switch (d_peek_next_char (di))
2003-11-21 18:42:45 +01:00
{
case '0':
kind = gnu_v3_deleting_dtor;
break;
case '1':
kind = gnu_v3_complete_object_dtor;
break;
case '2':
kind = gnu_v3_base_object_dtor;
break;
/* digit '3' is not used */
case '4':
kind = gnu_v3_unified_dtor;
break;
2011-11-08 17:01:58 +01:00
case '5':
kind = gnu_v3_object_dtor_group;
break;
2003-11-21 18:42:45 +01:00
default:
return NULL;
}
d_advance (di, 2);
2003-11-21 18:42:45 +01:00
return d_make_dtor (di, kind, di->last_name);
}
2003-11-21 18:42:45 +01:00
default:
return NULL;
}
}
/* True iff we're looking at an order-insensitive type-qualifier, including
function-type-qualifiers. */
static int
next_is_type_qual (struct d_info *di)
{
char peek = d_peek_char (di);
if (peek == 'r' || peek == 'V' || peek == 'K')
return 1;
if (peek == 'D')
{
peek = d_peek_next_char (di);
if (peek == 'x' || peek == 'o' || peek == 'O' || peek == 'w')
return 1;
}
return 0;
}
2003-11-21 18:42:45 +01:00
/* <type> ::= <builtin-type>
::= <function-type>
::= <class-enum-type>
::= <array-type>
::= <pointer-to-member-type>
::= <template-param>
::= <template-template-param> <template-args>
::= <substitution>
::= <CV-qualifiers> <type>
::= P <type>
::= R <type>
2007-08-31 22:20:49 +02:00
::= O <type> (C++0x)
2003-11-21 18:42:45 +01:00
::= C <type>
::= G <type>
::= U <source-name> <type>
<builtin-type> ::= various one letter codes
::= u <source-name>
*/
2004-01-12 22:24:38 +01:00
CP_STATIC_IF_GLIBCPP_V3
const struct demangle_builtin_type_info
cplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT] =
2003-11-21 18:42:45 +01:00
{
2004-02-25 06:40:03 +01:00
/* a */ { NL ("signed char"), NL ("signed char"), D_PRINT_DEFAULT },
2003-12-22 17:03:32 +01:00
/* b */ { NL ("bool"), NL ("boolean"), D_PRINT_BOOL },
2004-02-25 06:40:03 +01:00
/* c */ { NL ("char"), NL ("byte"), D_PRINT_DEFAULT },
/* d */ { NL ("double"), NL ("double"), D_PRINT_FLOAT },
/* e */ { NL ("long double"), NL ("long double"), D_PRINT_FLOAT },
/* f */ { NL ("float"), NL ("float"), D_PRINT_FLOAT },
/* g */ { NL ("__float128"), NL ("__float128"), D_PRINT_FLOAT },
/* h */ { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_DEFAULT },
2003-12-22 17:03:32 +01:00
/* i */ { NL ("int"), NL ("int"), D_PRINT_INT },
2004-02-25 06:40:03 +01:00
/* j */ { NL ("unsigned int"), NL ("unsigned"), D_PRINT_UNSIGNED },
2003-12-22 17:03:32 +01:00
/* k */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
/* l */ { NL ("long"), NL ("long"), D_PRINT_LONG },
2004-02-25 06:40:03 +01:00
/* m */ { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_UNSIGNED_LONG },
2003-12-22 17:03:32 +01:00
/* n */ { NL ("__int128"), NL ("__int128"), D_PRINT_DEFAULT },
2004-02-25 06:40:03 +01:00
/* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"),
D_PRINT_DEFAULT },
2008-10-07 03:28:01 +02:00
/* p */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
/* q */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
/* r */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
2004-02-25 06:40:03 +01:00
/* s */ { NL ("short"), NL ("short"), D_PRINT_DEFAULT },
/* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_DEFAULT },
2008-10-07 03:28:01 +02:00
/* u */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
2003-12-22 17:03:32 +01:00
/* v */ { NL ("void"), NL ("void"), D_PRINT_VOID },
2004-02-25 06:40:03 +01:00
/* w */ { NL ("wchar_t"), NL ("char"), D_PRINT_DEFAULT },
/* x */ { NL ("long long"), NL ("long"), D_PRINT_LONG_LONG },
/* y */ { NL ("unsigned long long"), NL ("unsigned long long"),
D_PRINT_UNSIGNED_LONG_LONG },
2003-12-22 17:03:32 +01:00
/* z */ { NL ("..."), NL ("..."), D_PRINT_DEFAULT },
2008-10-07 03:28:01 +02:00
/* 26 */ { NL ("decimal32"), NL ("decimal32"), D_PRINT_DEFAULT },
/* 27 */ { NL ("decimal64"), NL ("decimal64"), D_PRINT_DEFAULT },
/* 28 */ { NL ("decimal128"), NL ("decimal128"), D_PRINT_DEFAULT },
/* 29 */ { NL ("half"), NL ("half"), D_PRINT_FLOAT },
2019-04-07 13:11:49 +02:00
/* 30 */ { NL ("char8_t"), NL ("char8_t"), D_PRINT_DEFAULT },
/* 31 */ { NL ("char16_t"), NL ("char16_t"), D_PRINT_DEFAULT },
/* 32 */ { NL ("char32_t"), NL ("char32_t"), D_PRINT_DEFAULT },
/* 33 */ { NL ("decltype(nullptr)"), NL ("decltype(nullptr)"),
2010-05-06 23:40:04 +02:00
D_PRINT_DEFAULT },
2003-11-21 18:42:45 +01:00
};
2004-01-12 22:24:38 +01:00
CP_STATIC_IF_GLIBCPP_V3
struct demangle_component *
2005-03-27 07:28:42 +02:00
cplus_demangle_type (struct d_info *di)
{
2003-11-21 18:42:45 +01:00
char peek;
2004-01-12 22:24:38 +01:00
struct demangle_component *ret;
2003-11-21 18:42:45 +01:00
int can_subst;
/* The ABI specifies that when CV-qualifiers are used, the base type
is substitutable, and the fully qualified type is substitutable,
but the base type with a strict subset of the CV-qualifiers is
not substitutable. The natural recursive implementation of the
CV-qualifiers would cause subsets to be substitutable, so instead
we pull them all off now.
2003-11-27 02:17:34 +01:00
FIXME: The ABI says that order-insensitive vendor qualifiers
should be handled in the same way, but we have no way to tell
which vendor qualifiers are order-insensitive and which are
order-sensitive. So we just assume that they are all
order-sensitive. g++ 3.4 supports only one vendor qualifier,
__vector, and it treats it as order-sensitive when mangling
names. */
2003-11-21 18:42:45 +01:00
if (next_is_type_qual (di))
2003-11-21 18:42:45 +01:00
{
2004-01-12 22:24:38 +01:00
struct demangle_component **pret;
2000-10-12 04:16:48 +02:00
2003-12-04 21:03:39 +01:00
pret = d_cv_qualifiers (di, &ret, 0);
2003-11-27 02:17:34 +01:00
if (pret == NULL)
return NULL;
2013-04-04 03:03:01 +02:00
if (d_peek_char (di) == 'F')
{
/* cv-qualifiers before a function type apply to 'this',
so avoid adding the unqualified function type to
the substitution list. */
*pret = d_function_type (di);
}
else
*pret = cplus_demangle_type (di);
if (!*pret)
2013-04-03 20:21:49 +02:00
return NULL;
if ((*pret)->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
|| (*pret)->type == DEMANGLE_COMPONENT_REFERENCE_THIS)
{
/* Move the ref-qualifier outside the cv-qualifiers so that
they are printed in the right order. */
struct demangle_component *fn = d_left (*pret);
d_left (*pret) = ret;
ret = *pret;
*pret = fn;
}
if (! d_add_substitution (di, ret))
2003-11-21 18:42:45 +01:00
return NULL;
return ret;
}
2003-11-21 18:42:45 +01:00
can_subst = 1;
peek = d_peek_char (di);
2000-10-12 04:16:48 +02:00
switch (peek)
{
2003-11-21 18:42:45 +01:00
case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
case 'h': case 'i': case 'j': case 'l': case 'm': case 'n':
case 'o': case 's': case 't':
case 'v': case 'w': case 'x': case 'y': case 'z':
2004-01-12 22:24:38 +01:00
ret = d_make_builtin_type (di,
&cplus_demangle_builtin_types[peek - 'a']);
2003-12-22 17:03:32 +01:00
di->expansion += ret->u.s_builtin.type->len;
2003-11-21 18:42:45 +01:00
can_subst = 0;
d_advance (di, 1);
break;
case 'u':
d_advance (di, 1);
2004-01-12 22:24:38 +01:00
ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE,
d_source_name (di), NULL);
2003-11-21 18:42:45 +01:00
break;
case 'F':
ret = d_function_type (di);
break;
2003-11-21 18:42:45 +01:00
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
case 'N':
case 'Z':
2003-11-21 18:42:45 +01:00
ret = d_class_enum_type (di);
break;
2003-11-21 18:42:45 +01:00
case 'A':
ret = d_array_type (di);
break;
case 'M':
ret = d_pointer_to_member_type (di);
break;
case 'T':
ret = d_template_param (di);
if (d_peek_char (di) == 'I')
2000-07-20 20:56:16 +02:00
{
/* This may be <template-template-param> <template-args>.
If this is the type for a conversion operator, we can
have a <template-template-param> here only by following
a derivation like this:
<nested-name>
-> <template-prefix> <template-args>
-> <prefix> <template-unqualified-name> <template-args>
-> <unqualified-name> <template-unqualified-name> <template-args>
-> <source-name> <template-unqualified-name> <template-args>
-> <source-name> <operator-name> <template-args>
-> <source-name> cv <type> <template-args>
-> <source-name> cv <template-template-param> <template-args> <template-args>
where the <template-args> is followed by another.
Otherwise, we must have a derivation like this:
<nested-name>
-> <template-prefix> <template-args>
-> <prefix> <template-unqualified-name> <template-args>
-> <unqualified-name> <template-unqualified-name> <template-args>
-> <source-name> <template-unqualified-name> <template-args>
-> <source-name> <operator-name> <template-args>
-> <source-name> cv <type> <template-args>
-> <source-name> cv <template-param> <template-args>
where we need to leave the <template-args> to be processed
by d_prefix (following the <template-prefix>).
The <template-template-param> part is a substitution
2003-11-21 18:42:45 +01:00
candidate. */
if (! di->is_conversion)
{
if (! d_add_substitution (di, ret))
return NULL;
ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
d_template_args (di));
}
else
{
struct demangle_component *args;
struct d_info_checkpoint checkpoint;
d_checkpoint (di, &checkpoint);
args = d_template_args (di);
if (d_peek_char (di) == 'I')
{
if (! d_add_substitution (di, ret))
return NULL;
ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
args);
}
else
d_backtrack (di, &checkpoint);
}
2000-07-20 20:56:16 +02:00
}
2003-11-21 18:42:45 +01:00
break;
case 'S':
/* If this is a special substitution, then it is the start of
<class-enum-type>. */
{
char peek_next;
2000-10-12 04:16:48 +02:00
2003-11-21 18:42:45 +01:00
peek_next = d_peek_next_char (di);
if (IS_DIGIT (peek_next)
|| peek_next == '_'
2003-12-04 21:03:39 +01:00
|| IS_UPPER (peek_next))
2003-11-21 18:42:45 +01:00
{
2003-12-15 18:45:42 +01:00
ret = d_substitution (di, 0);
2003-11-21 18:42:45 +01:00
/* The substituted name may have been a template name and
may be followed by tepmlate args. */
if (d_peek_char (di) == 'I')
2004-01-12 22:24:38 +01:00
ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
2003-11-21 18:42:45 +01:00
d_template_args (di));
else
can_subst = 0;
}
else
{
ret = d_class_enum_type (di);
/* If the substitution was a complete type, then it is not
a new substitution candidate. However, if the
substitution was followed by template arguments, then
the whole thing is a substitution candidate. */
2004-01-12 22:24:38 +01:00
if (ret != NULL && ret->type == DEMANGLE_COMPONENT_SUB_STD)
2003-11-21 18:42:45 +01:00
can_subst = 0;
}
}
break;
2007-08-31 22:20:49 +02:00
case 'O':
d_advance (di, 1);
ret = d_make_comp (di, DEMANGLE_COMPONENT_RVALUE_REFERENCE,
cplus_demangle_type (di), NULL);
break;
2003-11-21 18:42:45 +01:00
case 'P':
d_advance (di, 1);
2004-01-12 22:24:38 +01:00
ret = d_make_comp (di, DEMANGLE_COMPONENT_POINTER,
cplus_demangle_type (di), NULL);
2003-11-21 18:42:45 +01:00
break;
2003-11-21 18:42:45 +01:00
case 'R':
d_advance (di, 1);
2004-01-12 22:24:38 +01:00
ret = d_make_comp (di, DEMANGLE_COMPONENT_REFERENCE,
2007-08-31 22:20:49 +02:00
cplus_demangle_type (di), NULL);
2003-11-21 18:42:45 +01:00
break;
2003-11-21 18:42:45 +01:00
case 'C':
d_advance (di, 1);
2004-01-12 22:24:38 +01:00
ret = d_make_comp (di, DEMANGLE_COMPONENT_COMPLEX,
cplus_demangle_type (di), NULL);
2003-11-21 18:42:45 +01:00
break;
case 'G':
d_advance (di, 1);
2004-01-12 22:24:38 +01:00
ret = d_make_comp (di, DEMANGLE_COMPONENT_IMAGINARY,
cplus_demangle_type (di), NULL);
2003-11-21 18:42:45 +01:00
break;
2003-11-21 18:42:45 +01:00
case 'U':
d_advance (di, 1);
ret = d_source_name (di);
if (d_peek_char (di) == 'I')
ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
d_template_args (di));
2004-01-12 22:24:38 +01:00
ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL,
cplus_demangle_type (di), ret);
break;
2003-11-21 18:42:45 +01:00
2008-09-09 20:21:49 +02:00
case 'D':
can_subst = 0;
d_advance (di, 1);
peek = d_next_char (di);
switch (peek)
{
case 'T':
case 't':
/* decltype (expression) */
ret = d_make_comp (di, DEMANGLE_COMPONENT_DECLTYPE,
d_expression (di), NULL);
if (ret && d_next_char (di) != 'E')
ret = NULL;
2012-01-06 23:04:43 +01:00
can_subst = 1;
2008-09-09 20:21:49 +02:00
break;
case 'p':
/* Pack expansion. */
2008-10-07 03:28:01 +02:00
ret = d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
cplus_demangle_type (di), NULL);
2012-01-06 23:04:43 +01:00
can_subst = 1;
2008-10-07 03:28:01 +02:00
break;
2012-04-02 20:50:29 +02:00
case 'a':
/* auto */
ret = d_make_name (di, "auto", 4);
break;
case 'c':
/* decltype(auto) */
ret = d_make_name (di, "decltype(auto)", 14);
break;
2008-09-09 20:21:49 +02:00
case 'f':
2008-10-07 03:28:01 +02:00
/* 32-bit decimal floating point */
ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[26]);
2008-09-09 20:21:49 +02:00
di->expansion += ret->u.s_builtin.type->len;
break;
case 'd':
2008-10-07 03:28:01 +02:00
/* 64-bit DFP */
ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[27]);
2008-09-09 20:21:49 +02:00
di->expansion += ret->u.s_builtin.type->len;
break;
case 'e':
/* 128-bit DFP */
2008-10-07 03:28:01 +02:00
ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[28]);
2008-09-09 20:21:49 +02:00
di->expansion += ret->u.s_builtin.type->len;
break;
case 'h':
/* 16-bit half-precision FP */
2008-10-07 03:28:01 +02:00
ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[29]);
di->expansion += ret->u.s_builtin.type->len;
break;
2019-04-07 13:11:49 +02:00
case 'u':
/* char8_t */
ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[30]);
di->expansion += ret->u.s_builtin.type->len;
break;
2008-10-07 03:28:01 +02:00
case 's':
/* char16_t */
2019-04-07 13:11:49 +02:00
ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[31]);
2008-10-07 03:28:01 +02:00
di->expansion += ret->u.s_builtin.type->len;
break;
case 'i':
/* char32_t */
2019-04-07 13:11:49 +02:00
ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[32]);
2008-09-09 20:21:49 +02:00
di->expansion += ret->u.s_builtin.type->len;
break;
2008-12-11 00:28:19 +01:00
case 'F':
/* Fixed point types. DF<int bits><length><fract bits><sat> */
ret = d_make_empty (di);
ret->type = DEMANGLE_COMPONENT_FIXED_TYPE;
if ((ret->u.s_fixed.accum = IS_DIGIT (d_peek_char (di))))
/* For demangling we don't care about the bits. */
d_number (di);
ret->u.s_fixed.length = cplus_demangle_type (di);
2010-02-04 00:28:01 +01:00
if (ret->u.s_fixed.length == NULL)
return NULL;
2008-12-11 00:28:19 +01:00
d_number (di);
peek = d_next_char (di);
ret->u.s_fixed.sat = (peek == 's');
break;
2009-01-07 19:52:57 +01:00
2010-02-04 00:28:01 +01:00
case 'v':
ret = d_vector_type (di);
2012-01-06 23:04:43 +01:00
can_subst = 1;
2010-02-04 00:28:01 +01:00
break;
2010-05-06 23:40:04 +02:00
case 'n':
/* decltype(nullptr) */
2019-04-07 13:11:49 +02:00
ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[33]);
2010-05-06 23:40:04 +02:00
di->expansion += ret->u.s_builtin.type->len;
break;
2009-01-07 19:52:57 +01:00
default:
return NULL;
2008-09-09 20:21:49 +02:00
}
break;
2003-11-21 18:42:45 +01:00
default:
return NULL;
}
2003-11-21 18:42:45 +01:00
if (can_subst)
{
if (! d_add_substitution (di, ret))
return NULL;
}
2003-11-21 18:42:45 +01:00
return ret;
}
Implement N4514, C++ Extensions for Transactional Memory. gcc/ * builtins.def (BUILT_IN_ABORT): Add transaction_pure attribute. gcc/c-family/ * c-common.c (c_common_reswords): Add C++ TM TS keywords. (c_common_attribute_table): Add transaction_safe_dynamic. transaction_safe now affects type identity. (handle_tm_attribute): Handle transaction_safe_dynamic. * c-common.h (enum rid): Add RID_ATOMIC_NOEXCEPT, RID_ATOMIC_CANCEL, RID_SYNCHRONIZED. (OBJC_IS_CXX_KEYWORD): Add RID_SYNCHRONIZED. (D_TRANSMEM): New. * c-cppbuiltin.c (c_cpp_builtins): Define __cpp_transactional_memory. * c-pretty-print.c (pp_c_attributes_display): Don't print transaction_safe in C++. gcc/c/ * c-parser.c (c_lex_one_token): Handle @synchronized. * c-decl.c (match_builtin_function_types): A declaration of a built-in can change whether the function is transaction_safe. gcc/cp/ * cp-tree.h (struct cp_declarator): Add tx_qualifier field. (BCS_NORMAL, BCS_TRANSACTION): New enumerators. * lex.c (init_reswords): Limit TM kewords to -fgnu-tm. * parser.c (cp_lexer_get_preprocessor_token): Fix @synchronized. (make_call_declarator): Take tx_qualifier. (cp_parser_tx_qualifier_opt): New. (cp_parser_lambda_declarator_opt): Use it. (cp_parser_direct_declarator): Likewise. (cp_parser_statement): Handle atomic_noexcept, atomic_cancel. (cp_parser_compound_statement): Change in_try parameter to bcs_flags. (cp_parser_std_attribute): Map optimize_for_synchronized to transaction_callable. (cp_parser_transaction): Take the token. Handle atomic_noexcept. * lambda.c (maybe_add_lambda_conv_op): Handle transaction-safety. * call.c (enum conversion_kind): Add ck_tsafe. (standard_conversion): Handle transaction-safety conversion. (convert_like_real, resolve_address_of_overloaded_function): Likewise. (check_methods): Diagnose transaction_safe_dynamic on non-virtual function. (look_for_tm_attr_overrides): Don't inherit transaction_safe_dynamic. * cvt.c (tx_safe_fn_type_p, tx_unsafe_fn_variant) (can_convert_tx_safety): New. * typeck.c (composite_pointer_type): Handle transaction-safety. * name-lookup.h (enum scope_kind): Add sk_transaction. * name-lookup.c (begin_scope): Handle it. * semantics.c (begin_compound_stmt): Pass it. * decl.c (check_previous_goto_1): Check it. (struct named_label_entry): Add in_transaction_scope. (poplevel_named_label_1): Set it. (check_goto): Check it. (duplicate_decls): A specialization can be transaction_safe independently of its template. (grokdeclarator): Handle tx-qualifier. * rtti.c (ptr_initializer): Handle transaction-safe. * search.c (check_final_overrider): Check transaction_safe_dynamic. Don't check transaction_safe. * mangle.c (write_function_type): Mangle transaction_safe here. (write_CV_qualifiers_for_type): Not here. (write_type): Preserve transaction_safe when stripping attributes. * error.c (dump_type_suffix): Print transaction_safe. libiberty/ * cp-demangle.c (d_cv_qualifiers): Dx means transaction_safe. (cplus_demangle_type): Let d_cv_qualifiers handle it. (d_dump, d_make_comp, has_return_type, d_encoding) (d_count_templates_scopes, d_print_comp_inner) (d_print_mod_list, d_print_mod, d_print_function_type) (is_ctor_or_dtor): Handle DEMANGLE_COMPONENT_TRANSACTION_SAFE. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@228462 138bc75d-0d04-0410-961f-82ee72b054a4
2015-11-28 17:39:30 +01:00
/* <CV-qualifiers> ::= [r] [V] [K] [Dx] */
2004-01-12 22:24:38 +01:00
static struct demangle_component **
2005-03-27 07:28:42 +02:00
d_cv_qualifiers (struct d_info *di,
struct demangle_component **pret, int member_fn)
{
2011-10-10 23:02:57 +02:00
struct demangle_component **pstart;
char peek;
2011-10-10 23:02:57 +02:00
pstart = pret;
2003-11-21 18:42:45 +01:00
peek = d_peek_char (di);
while (next_is_type_qual (di))
{
2004-01-12 22:24:38 +01:00
enum demangle_component_type t;
struct demangle_component *right = NULL;
2003-11-21 18:42:45 +01:00
d_advance (di, 1);
if (peek == 'r')
2003-12-22 17:03:32 +01:00
{
2004-01-12 22:24:38 +01:00
t = (member_fn
? DEMANGLE_COMPONENT_RESTRICT_THIS
: DEMANGLE_COMPONENT_RESTRICT);
2003-12-22 17:03:32 +01:00
di->expansion += sizeof "restrict";
}
2003-11-21 18:42:45 +01:00
else if (peek == 'V')
2003-12-22 17:03:32 +01:00
{
2004-01-12 22:24:38 +01:00
t = (member_fn
? DEMANGLE_COMPONENT_VOLATILE_THIS
: DEMANGLE_COMPONENT_VOLATILE);
2003-12-22 17:03:32 +01:00
di->expansion += sizeof "volatile";
}
Implement N4514, C++ Extensions for Transactional Memory. gcc/ * builtins.def (BUILT_IN_ABORT): Add transaction_pure attribute. gcc/c-family/ * c-common.c (c_common_reswords): Add C++ TM TS keywords. (c_common_attribute_table): Add transaction_safe_dynamic. transaction_safe now affects type identity. (handle_tm_attribute): Handle transaction_safe_dynamic. * c-common.h (enum rid): Add RID_ATOMIC_NOEXCEPT, RID_ATOMIC_CANCEL, RID_SYNCHRONIZED. (OBJC_IS_CXX_KEYWORD): Add RID_SYNCHRONIZED. (D_TRANSMEM): New. * c-cppbuiltin.c (c_cpp_builtins): Define __cpp_transactional_memory. * c-pretty-print.c (pp_c_attributes_display): Don't print transaction_safe in C++. gcc/c/ * c-parser.c (c_lex_one_token): Handle @synchronized. * c-decl.c (match_builtin_function_types): A declaration of a built-in can change whether the function is transaction_safe. gcc/cp/ * cp-tree.h (struct cp_declarator): Add tx_qualifier field. (BCS_NORMAL, BCS_TRANSACTION): New enumerators. * lex.c (init_reswords): Limit TM kewords to -fgnu-tm. * parser.c (cp_lexer_get_preprocessor_token): Fix @synchronized. (make_call_declarator): Take tx_qualifier. (cp_parser_tx_qualifier_opt): New. (cp_parser_lambda_declarator_opt): Use it. (cp_parser_direct_declarator): Likewise. (cp_parser_statement): Handle atomic_noexcept, atomic_cancel. (cp_parser_compound_statement): Change in_try parameter to bcs_flags. (cp_parser_std_attribute): Map optimize_for_synchronized to transaction_callable. (cp_parser_transaction): Take the token. Handle atomic_noexcept. * lambda.c (maybe_add_lambda_conv_op): Handle transaction-safety. * call.c (enum conversion_kind): Add ck_tsafe. (standard_conversion): Handle transaction-safety conversion. (convert_like_real, resolve_address_of_overloaded_function): Likewise. (check_methods): Diagnose transaction_safe_dynamic on non-virtual function. (look_for_tm_attr_overrides): Don't inherit transaction_safe_dynamic. * cvt.c (tx_safe_fn_type_p, tx_unsafe_fn_variant) (can_convert_tx_safety): New. * typeck.c (composite_pointer_type): Handle transaction-safety. * name-lookup.h (enum scope_kind): Add sk_transaction. * name-lookup.c (begin_scope): Handle it. * semantics.c (begin_compound_stmt): Pass it. * decl.c (check_previous_goto_1): Check it. (struct named_label_entry): Add in_transaction_scope. (poplevel_named_label_1): Set it. (check_goto): Check it. (duplicate_decls): A specialization can be transaction_safe independently of its template. (grokdeclarator): Handle tx-qualifier. * rtti.c (ptr_initializer): Handle transaction-safe. * search.c (check_final_overrider): Check transaction_safe_dynamic. Don't check transaction_safe. * mangle.c (write_function_type): Mangle transaction_safe here. (write_CV_qualifiers_for_type): Not here. (write_type): Preserve transaction_safe when stripping attributes. * error.c (dump_type_suffix): Print transaction_safe. libiberty/ * cp-demangle.c (d_cv_qualifiers): Dx means transaction_safe. (cplus_demangle_type): Let d_cv_qualifiers handle it. (d_dump, d_make_comp, has_return_type, d_encoding) (d_count_templates_scopes, d_print_comp_inner) (d_print_mod_list, d_print_mod, d_print_function_type) (is_ctor_or_dtor): Handle DEMANGLE_COMPONENT_TRANSACTION_SAFE. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@228462 138bc75d-0d04-0410-961f-82ee72b054a4
2015-11-28 17:39:30 +01:00
else if (peek == 'K')
2003-12-22 17:03:32 +01:00
{
2004-01-12 22:24:38 +01:00
t = (member_fn
? DEMANGLE_COMPONENT_CONST_THIS
: DEMANGLE_COMPONENT_CONST);
2003-12-22 17:03:32 +01:00
di->expansion += sizeof "const";
}
Implement N4514, C++ Extensions for Transactional Memory. gcc/ * builtins.def (BUILT_IN_ABORT): Add transaction_pure attribute. gcc/c-family/ * c-common.c (c_common_reswords): Add C++ TM TS keywords. (c_common_attribute_table): Add transaction_safe_dynamic. transaction_safe now affects type identity. (handle_tm_attribute): Handle transaction_safe_dynamic. * c-common.h (enum rid): Add RID_ATOMIC_NOEXCEPT, RID_ATOMIC_CANCEL, RID_SYNCHRONIZED. (OBJC_IS_CXX_KEYWORD): Add RID_SYNCHRONIZED. (D_TRANSMEM): New. * c-cppbuiltin.c (c_cpp_builtins): Define __cpp_transactional_memory. * c-pretty-print.c (pp_c_attributes_display): Don't print transaction_safe in C++. gcc/c/ * c-parser.c (c_lex_one_token): Handle @synchronized. * c-decl.c (match_builtin_function_types): A declaration of a built-in can change whether the function is transaction_safe. gcc/cp/ * cp-tree.h (struct cp_declarator): Add tx_qualifier field. (BCS_NORMAL, BCS_TRANSACTION): New enumerators. * lex.c (init_reswords): Limit TM kewords to -fgnu-tm. * parser.c (cp_lexer_get_preprocessor_token): Fix @synchronized. (make_call_declarator): Take tx_qualifier. (cp_parser_tx_qualifier_opt): New. (cp_parser_lambda_declarator_opt): Use it. (cp_parser_direct_declarator): Likewise. (cp_parser_statement): Handle atomic_noexcept, atomic_cancel. (cp_parser_compound_statement): Change in_try parameter to bcs_flags. (cp_parser_std_attribute): Map optimize_for_synchronized to transaction_callable. (cp_parser_transaction): Take the token. Handle atomic_noexcept. * lambda.c (maybe_add_lambda_conv_op): Handle transaction-safety. * call.c (enum conversion_kind): Add ck_tsafe. (standard_conversion): Handle transaction-safety conversion. (convert_like_real, resolve_address_of_overloaded_function): Likewise. (check_methods): Diagnose transaction_safe_dynamic on non-virtual function. (look_for_tm_attr_overrides): Don't inherit transaction_safe_dynamic. * cvt.c (tx_safe_fn_type_p, tx_unsafe_fn_variant) (can_convert_tx_safety): New. * typeck.c (composite_pointer_type): Handle transaction-safety. * name-lookup.h (enum scope_kind): Add sk_transaction. * name-lookup.c (begin_scope): Handle it. * semantics.c (begin_compound_stmt): Pass it. * decl.c (check_previous_goto_1): Check it. (struct named_label_entry): Add in_transaction_scope. (poplevel_named_label_1): Set it. (check_goto): Check it. (duplicate_decls): A specialization can be transaction_safe independently of its template. (grokdeclarator): Handle tx-qualifier. * rtti.c (ptr_initializer): Handle transaction-safe. * search.c (check_final_overrider): Check transaction_safe_dynamic. Don't check transaction_safe. * mangle.c (write_function_type): Mangle transaction_safe here. (write_CV_qualifiers_for_type): Not here. (write_type): Preserve transaction_safe when stripping attributes. * error.c (dump_type_suffix): Print transaction_safe. libiberty/ * cp-demangle.c (d_cv_qualifiers): Dx means transaction_safe. (cplus_demangle_type): Let d_cv_qualifiers handle it. (d_dump, d_make_comp, has_return_type, d_encoding) (d_count_templates_scopes, d_print_comp_inner) (d_print_mod_list, d_print_mod, d_print_function_type) (is_ctor_or_dtor): Handle DEMANGLE_COMPONENT_TRANSACTION_SAFE. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@228462 138bc75d-0d04-0410-961f-82ee72b054a4
2015-11-28 17:39:30 +01:00
else
{
peek = d_next_char (di);
if (peek == 'x')
{
t = DEMANGLE_COMPONENT_TRANSACTION_SAFE;
di->expansion += sizeof "transaction_safe";
}
else if (peek == 'o'
|| peek == 'O')
{
t = DEMANGLE_COMPONENT_NOEXCEPT;
di->expansion += sizeof "noexcept";
if (peek == 'O')
{
right = d_expression (di);
if (right == NULL)
return NULL;
if (! d_check_char (di, 'E'))
return NULL;
}
}
else if (peek == 'w')
{
t = DEMANGLE_COMPONENT_THROW_SPEC;
di->expansion += sizeof "throw";
right = d_parmlist (di);
if (right == NULL)
return NULL;
if (! d_check_char (di, 'E'))
return NULL;
}
else
return NULL;
Implement N4514, C++ Extensions for Transactional Memory. gcc/ * builtins.def (BUILT_IN_ABORT): Add transaction_pure attribute. gcc/c-family/ * c-common.c (c_common_reswords): Add C++ TM TS keywords. (c_common_attribute_table): Add transaction_safe_dynamic. transaction_safe now affects type identity. (handle_tm_attribute): Handle transaction_safe_dynamic. * c-common.h (enum rid): Add RID_ATOMIC_NOEXCEPT, RID_ATOMIC_CANCEL, RID_SYNCHRONIZED. (OBJC_IS_CXX_KEYWORD): Add RID_SYNCHRONIZED. (D_TRANSMEM): New. * c-cppbuiltin.c (c_cpp_builtins): Define __cpp_transactional_memory. * c-pretty-print.c (pp_c_attributes_display): Don't print transaction_safe in C++. gcc/c/ * c-parser.c (c_lex_one_token): Handle @synchronized. * c-decl.c (match_builtin_function_types): A declaration of a built-in can change whether the function is transaction_safe. gcc/cp/ * cp-tree.h (struct cp_declarator): Add tx_qualifier field. (BCS_NORMAL, BCS_TRANSACTION): New enumerators. * lex.c (init_reswords): Limit TM kewords to -fgnu-tm. * parser.c (cp_lexer_get_preprocessor_token): Fix @synchronized. (make_call_declarator): Take tx_qualifier. (cp_parser_tx_qualifier_opt): New. (cp_parser_lambda_declarator_opt): Use it. (cp_parser_direct_declarator): Likewise. (cp_parser_statement): Handle atomic_noexcept, atomic_cancel. (cp_parser_compound_statement): Change in_try parameter to bcs_flags. (cp_parser_std_attribute): Map optimize_for_synchronized to transaction_callable. (cp_parser_transaction): Take the token. Handle atomic_noexcept. * lambda.c (maybe_add_lambda_conv_op): Handle transaction-safety. * call.c (enum conversion_kind): Add ck_tsafe. (standard_conversion): Handle transaction-safety conversion. (convert_like_real, resolve_address_of_overloaded_function): Likewise. (check_methods): Diagnose transaction_safe_dynamic on non-virtual function. (look_for_tm_attr_overrides): Don't inherit transaction_safe_dynamic. * cvt.c (tx_safe_fn_type_p, tx_unsafe_fn_variant) (can_convert_tx_safety): New. * typeck.c (composite_pointer_type): Handle transaction-safety. * name-lookup.h (enum scope_kind): Add sk_transaction. * name-lookup.c (begin_scope): Handle it. * semantics.c (begin_compound_stmt): Pass it. * decl.c (check_previous_goto_1): Check it. (struct named_label_entry): Add in_transaction_scope. (poplevel_named_label_1): Set it. (check_goto): Check it. (duplicate_decls): A specialization can be transaction_safe independently of its template. (grokdeclarator): Handle tx-qualifier. * rtti.c (ptr_initializer): Handle transaction-safe. * search.c (check_final_overrider): Check transaction_safe_dynamic. Don't check transaction_safe. * mangle.c (write_function_type): Mangle transaction_safe here. (write_CV_qualifiers_for_type): Not here. (write_type): Preserve transaction_safe when stripping attributes. * error.c (dump_type_suffix): Print transaction_safe. libiberty/ * cp-demangle.c (d_cv_qualifiers): Dx means transaction_safe. (cplus_demangle_type): Let d_cv_qualifiers handle it. (d_dump, d_make_comp, has_return_type, d_encoding) (d_count_templates_scopes, d_print_comp_inner) (d_print_mod_list, d_print_mod, d_print_function_type) (is_ctor_or_dtor): Handle DEMANGLE_COMPONENT_TRANSACTION_SAFE. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@228462 138bc75d-0d04-0410-961f-82ee72b054a4
2015-11-28 17:39:30 +01:00
}
*pret = d_make_comp (di, t, NULL, right);
2003-11-21 18:42:45 +01:00
if (*pret == NULL)
return NULL;
pret = &d_left (*pret);
2003-11-21 18:42:45 +01:00
peek = d_peek_char (di);
}
2011-10-10 23:02:57 +02:00
if (!member_fn && peek == 'F')
{
while (pstart != pret)
{
switch ((*pstart)->type)
{
case DEMANGLE_COMPONENT_RESTRICT:
(*pstart)->type = DEMANGLE_COMPONENT_RESTRICT_THIS;
break;
case DEMANGLE_COMPONENT_VOLATILE:
(*pstart)->type = DEMANGLE_COMPONENT_VOLATILE_THIS;
break;
case DEMANGLE_COMPONENT_CONST:
(*pstart)->type = DEMANGLE_COMPONENT_CONST_THIS;
break;
default:
break;
}
pstart = &d_left (*pstart);
}
}
2003-11-21 18:42:45 +01:00
return pret;
}
2013-04-03 20:21:49 +02:00
/* <ref-qualifier> ::= R
::= O */
static struct demangle_component *
d_ref_qualifier (struct d_info *di, struct demangle_component *sub)
{
struct demangle_component *ret = sub;
char peek;
peek = d_peek_char (di);
if (peek == 'R' || peek == 'O')
{
enum demangle_component_type t;
if (peek == 'R')
{
t = DEMANGLE_COMPONENT_REFERENCE_THIS;
di->expansion += sizeof "&";
}
else
{
t = DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS;
di->expansion += sizeof "&&";
}
d_advance (di, 1);
ret = d_make_comp (di, t, ret, NULL);
}
return ret;
}
Implement N4514, C++ Extensions for Transactional Memory. gcc/ * builtins.def (BUILT_IN_ABORT): Add transaction_pure attribute. gcc/c-family/ * c-common.c (c_common_reswords): Add C++ TM TS keywords. (c_common_attribute_table): Add transaction_safe_dynamic. transaction_safe now affects type identity. (handle_tm_attribute): Handle transaction_safe_dynamic. * c-common.h (enum rid): Add RID_ATOMIC_NOEXCEPT, RID_ATOMIC_CANCEL, RID_SYNCHRONIZED. (OBJC_IS_CXX_KEYWORD): Add RID_SYNCHRONIZED. (D_TRANSMEM): New. * c-cppbuiltin.c (c_cpp_builtins): Define __cpp_transactional_memory. * c-pretty-print.c (pp_c_attributes_display): Don't print transaction_safe in C++. gcc/c/ * c-parser.c (c_lex_one_token): Handle @synchronized. * c-decl.c (match_builtin_function_types): A declaration of a built-in can change whether the function is transaction_safe. gcc/cp/ * cp-tree.h (struct cp_declarator): Add tx_qualifier field. (BCS_NORMAL, BCS_TRANSACTION): New enumerators. * lex.c (init_reswords): Limit TM kewords to -fgnu-tm. * parser.c (cp_lexer_get_preprocessor_token): Fix @synchronized. (make_call_declarator): Take tx_qualifier. (cp_parser_tx_qualifier_opt): New. (cp_parser_lambda_declarator_opt): Use it. (cp_parser_direct_declarator): Likewise. (cp_parser_statement): Handle atomic_noexcept, atomic_cancel. (cp_parser_compound_statement): Change in_try parameter to bcs_flags. (cp_parser_std_attribute): Map optimize_for_synchronized to transaction_callable. (cp_parser_transaction): Take the token. Handle atomic_noexcept. * lambda.c (maybe_add_lambda_conv_op): Handle transaction-safety. * call.c (enum conversion_kind): Add ck_tsafe. (standard_conversion): Handle transaction-safety conversion. (convert_like_real, resolve_address_of_overloaded_function): Likewise. (check_methods): Diagnose transaction_safe_dynamic on non-virtual function. (look_for_tm_attr_overrides): Don't inherit transaction_safe_dynamic. * cvt.c (tx_safe_fn_type_p, tx_unsafe_fn_variant) (can_convert_tx_safety): New. * typeck.c (composite_pointer_type): Handle transaction-safety. * name-lookup.h (enum scope_kind): Add sk_transaction. * name-lookup.c (begin_scope): Handle it. * semantics.c (begin_compound_stmt): Pass it. * decl.c (check_previous_goto_1): Check it. (struct named_label_entry): Add in_transaction_scope. (poplevel_named_label_1): Set it. (check_goto): Check it. (duplicate_decls): A specialization can be transaction_safe independently of its template. (grokdeclarator): Handle tx-qualifier. * rtti.c (ptr_initializer): Handle transaction-safe. * search.c (check_final_overrider): Check transaction_safe_dynamic. Don't check transaction_safe. * mangle.c (write_function_type): Mangle transaction_safe here. (write_CV_qualifiers_for_type): Not here. (write_type): Preserve transaction_safe when stripping attributes. * error.c (dump_type_suffix): Print transaction_safe. libiberty/ * cp-demangle.c (d_cv_qualifiers): Dx means transaction_safe. (cplus_demangle_type): Let d_cv_qualifiers handle it. (d_dump, d_make_comp, has_return_type, d_encoding) (d_count_templates_scopes, d_print_comp_inner) (d_print_mod_list, d_print_mod, d_print_function_type) (is_ctor_or_dtor): Handle DEMANGLE_COMPONENT_TRANSACTION_SAFE. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@228462 138bc75d-0d04-0410-961f-82ee72b054a4
2015-11-28 17:39:30 +01:00
/* <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] [T] E */
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_function_type (struct d_info *di)
{
Synchronize libiberty with gcc and add --no-recruse-limit option to tools that support name demangling. This patch addresses the multitude of bug reports about resource exhaustion in libiberty's name demangling code. It adds a limit to the amount of recursion that is allowed, before an error is triggered. It also adds a new demangling option to disable this limit. (The limit is enabled by default). PR 87681 PR 87675 PR 87636 PR 87335 libiberty * cp-demangle.h (struct d_info): Add recursion_limit field. * cp-demangle.c (d_function_type): If the recursion limit is enabled and reached, return with a failure result. (d_demangle_callback): If the recursion limit is enabled, check for a mangled string that is so long that there is not enough stack space for the local arrays. * cplus-dem.c (struct work): Add recursion_level field. (demangle_nested_args): If the recursion limit is enabled and reached, return with a failure result. include * demangle.h (DMGL_RECURSE_LIMIT): Define. (DEMANGLE_RECURSION_LIMIT): Prototype. binutuils * addr2line.c (demangle_flags): New static variable. (long_options): Add --recurse-limit and --no-recurse-limit. (translate_address): Pass demangle_flags to bfd_demangle. (main): Handle --recurse-limit and --no-recurse-limit options. * cxxfilt.c (flags): Add DMGL_RECURSE_LIMIT. (long_options): Add --recurse-limit and --no-recurse-limit. (main): Handle new options. * dlltool.c (gen_def_file): Include DMGL_RECURSE_LIMIT in flags passed to cplus_demangle. * nm.c (demangle_flags): New static variable. (long_options): Add --recurse-limit and --no-recurse-limit. (main): Handle new options. * objdump.c (demangle_flags): New static variable. (usage): Add --recurse-limit and --no-recurse-limit. (long_options): Likewise. (objdump_print_symname): Pass demangle_flags to bfd_demangle. (disassemble_section): Likewise. (dump_dymbols): Likewise. (main): Handle new options. * prdbg.c (demangle_flags): New static variable. (tg_variable): Pass demangle_flags to demangler. (tg_start_function): Likewise. * stabs.c (demangle_flags): New static variable. (stab_demangle_template): Pass demangle_flags to demangler. (stab_demangle_v3_argtypes): Likewise. (stab_demangle_v3_arg): Likewise. * doc/binutuls.texi: Document new command line options. * NEWS: Mention the new feature. * testsuite/config/default.exp (CXXFILT): Define if not already defined. (CXXFILTFLAGS): Likewise. * testsuite/binutils-all/cxxfilt.exp: New file. Runs a few simple tests of the cxxfilt program.
2018-12-07 12:32:55 +01:00
struct demangle_component *ret = NULL;
Synchronize libiberty with gcc and add --no-recruse-limit option to tools that support name demangling. This patch addresses the multitude of bug reports about resource exhaustion in libiberty's name demangling code. It adds a limit to the amount of recursion that is allowed, before an error is triggered. It also adds a new demangling option to disable this limit. (The limit is enabled by default). PR 87681 PR 87675 PR 87636 PR 87335 libiberty * cp-demangle.h (struct d_info): Add recursion_limit field. * cp-demangle.c (d_function_type): If the recursion limit is enabled and reached, return with a failure result. (d_demangle_callback): If the recursion limit is enabled, check for a mangled string that is so long that there is not enough stack space for the local arrays. * cplus-dem.c (struct work): Add recursion_level field. (demangle_nested_args): If the recursion limit is enabled and reached, return with a failure result. include * demangle.h (DMGL_RECURSE_LIMIT): Define. (DEMANGLE_RECURSION_LIMIT): Prototype. binutuils * addr2line.c (demangle_flags): New static variable. (long_options): Add --recurse-limit and --no-recurse-limit. (translate_address): Pass demangle_flags to bfd_demangle. (main): Handle --recurse-limit and --no-recurse-limit options. * cxxfilt.c (flags): Add DMGL_RECURSE_LIMIT. (long_options): Add --recurse-limit and --no-recurse-limit. (main): Handle new options. * dlltool.c (gen_def_file): Include DMGL_RECURSE_LIMIT in flags passed to cplus_demangle. * nm.c (demangle_flags): New static variable. (long_options): Add --recurse-limit and --no-recurse-limit. (main): Handle new options. * objdump.c (demangle_flags): New static variable. (usage): Add --recurse-limit and --no-recurse-limit. (long_options): Likewise. (objdump_print_symname): Pass demangle_flags to bfd_demangle. (disassemble_section): Likewise. (dump_dymbols): Likewise. (main): Handle new options. * prdbg.c (demangle_flags): New static variable. (tg_variable): Pass demangle_flags to demangler. (tg_start_function): Likewise. * stabs.c (demangle_flags): New static variable. (stab_demangle_template): Pass demangle_flags to demangler. (stab_demangle_v3_argtypes): Likewise. (stab_demangle_v3_arg): Likewise. * doc/binutuls.texi: Document new command line options. * NEWS: Mention the new feature. * testsuite/config/default.exp (CXXFILT): Define if not already defined. (CXXFILTFLAGS): Likewise. * testsuite/binutils-all/cxxfilt.exp: New file. Runs a few simple tests of the cxxfilt program.
2018-12-07 12:32:55 +01:00
if ((di->options & DMGL_NO_RECURSE_LIMIT) == 0)
2003-11-21 18:42:45 +01:00
{
Synchronize libiberty with gcc and add --no-recruse-limit option to tools that support name demangling. This patch addresses the multitude of bug reports about resource exhaustion in libiberty's name demangling code. It adds a limit to the amount of recursion that is allowed, before an error is triggered. It also adds a new demangling option to disable this limit. (The limit is enabled by default). PR 87681 PR 87675 PR 87636 PR 87335 libiberty * cp-demangle.h (struct d_info): Add recursion_limit field. * cp-demangle.c (d_function_type): If the recursion limit is enabled and reached, return with a failure result. (d_demangle_callback): If the recursion limit is enabled, check for a mangled string that is so long that there is not enough stack space for the local arrays. * cplus-dem.c (struct work): Add recursion_level field. (demangle_nested_args): If the recursion limit is enabled and reached, return with a failure result. include * demangle.h (DMGL_RECURSE_LIMIT): Define. (DEMANGLE_RECURSION_LIMIT): Prototype. binutuils * addr2line.c (demangle_flags): New static variable. (long_options): Add --recurse-limit and --no-recurse-limit. (translate_address): Pass demangle_flags to bfd_demangle. (main): Handle --recurse-limit and --no-recurse-limit options. * cxxfilt.c (flags): Add DMGL_RECURSE_LIMIT. (long_options): Add --recurse-limit and --no-recurse-limit. (main): Handle new options. * dlltool.c (gen_def_file): Include DMGL_RECURSE_LIMIT in flags passed to cplus_demangle. * nm.c (demangle_flags): New static variable. (long_options): Add --recurse-limit and --no-recurse-limit. (main): Handle new options. * objdump.c (demangle_flags): New static variable. (usage): Add --recurse-limit and --no-recurse-limit. (long_options): Likewise. (objdump_print_symname): Pass demangle_flags to bfd_demangle. (disassemble_section): Likewise. (dump_dymbols): Likewise. (main): Handle new options. * prdbg.c (demangle_flags): New static variable. (tg_variable): Pass demangle_flags to demangler. (tg_start_function): Likewise. * stabs.c (demangle_flags): New static variable. (stab_demangle_template): Pass demangle_flags to demangler. (stab_demangle_v3_argtypes): Likewise. (stab_demangle_v3_arg): Likewise. * doc/binutuls.texi: Document new command line options. * NEWS: Mention the new feature. * testsuite/config/default.exp (CXXFILT): Define if not already defined. (CXXFILTFLAGS): Likewise. * testsuite/binutils-all/cxxfilt.exp: New file. Runs a few simple tests of the cxxfilt program.
2018-12-07 12:32:55 +01:00
if (di->recursion_level > DEMANGLE_RECURSION_LIMIT)
/* FIXME: There ought to be a way to report
that the recursion limit has been reached. */
return NULL;
di->recursion_level ++;
2003-11-21 18:42:45 +01:00
}
2013-04-03 20:21:49 +02:00
Synchronize libiberty with gcc and add --no-recruse-limit option to tools that support name demangling. This patch addresses the multitude of bug reports about resource exhaustion in libiberty's name demangling code. It adds a limit to the amount of recursion that is allowed, before an error is triggered. It also adds a new demangling option to disable this limit. (The limit is enabled by default). PR 87681 PR 87675 PR 87636 PR 87335 libiberty * cp-demangle.h (struct d_info): Add recursion_limit field. * cp-demangle.c (d_function_type): If the recursion limit is enabled and reached, return with a failure result. (d_demangle_callback): If the recursion limit is enabled, check for a mangled string that is so long that there is not enough stack space for the local arrays. * cplus-dem.c (struct work): Add recursion_level field. (demangle_nested_args): If the recursion limit is enabled and reached, return with a failure result. include * demangle.h (DMGL_RECURSE_LIMIT): Define. (DEMANGLE_RECURSION_LIMIT): Prototype. binutuils * addr2line.c (demangle_flags): New static variable. (long_options): Add --recurse-limit and --no-recurse-limit. (translate_address): Pass demangle_flags to bfd_demangle. (main): Handle --recurse-limit and --no-recurse-limit options. * cxxfilt.c (flags): Add DMGL_RECURSE_LIMIT. (long_options): Add --recurse-limit and --no-recurse-limit. (main): Handle new options. * dlltool.c (gen_def_file): Include DMGL_RECURSE_LIMIT in flags passed to cplus_demangle. * nm.c (demangle_flags): New static variable. (long_options): Add --recurse-limit and --no-recurse-limit. (main): Handle new options. * objdump.c (demangle_flags): New static variable. (usage): Add --recurse-limit and --no-recurse-limit. (long_options): Likewise. (objdump_print_symname): Pass demangle_flags to bfd_demangle. (disassemble_section): Likewise. (dump_dymbols): Likewise. (main): Handle new options. * prdbg.c (demangle_flags): New static variable. (tg_variable): Pass demangle_flags to demangler. (tg_start_function): Likewise. * stabs.c (demangle_flags): New static variable. (stab_demangle_template): Pass demangle_flags to demangler. (stab_demangle_v3_argtypes): Likewise. (stab_demangle_v3_arg): Likewise. * doc/binutuls.texi: Document new command line options. * NEWS: Mention the new feature. * testsuite/config/default.exp (CXXFILT): Define if not already defined. (CXXFILTFLAGS): Likewise. * testsuite/binutils-all/cxxfilt.exp: New file. Runs a few simple tests of the cxxfilt program.
2018-12-07 12:32:55 +01:00
if (d_check_char (di, 'F'))
{
if (d_peek_char (di) == 'Y')
{
/* Function has C linkage. We don't print this information.
FIXME: We should print it in verbose mode. */
d_advance (di, 1);
}
ret = d_bare_function_type (di, 1);
ret = d_ref_qualifier (di, ret);
if (! d_check_char (di, 'E'))
ret = NULL;
}
if ((di->options & DMGL_NO_RECURSE_LIMIT) == 0)
di->recursion_level --;
2003-11-21 18:42:45 +01:00
return ret;
}
2000-10-12 04:16:48 +02:00
2009-10-02 20:23:01 +02:00
/* <type>+ */
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2009-10-02 20:23:01 +02:00
d_parmlist (struct d_info *di)
2003-11-21 18:42:45 +01:00
{
2004-01-12 22:24:38 +01:00
struct demangle_component *tl;
struct demangle_component **ptl;
2005-12-11 03:16:09 +01:00
2003-11-21 18:42:45 +01:00
tl = NULL;
ptl = &tl;
while (1)
{
2004-01-12 22:24:38 +01:00
struct demangle_component *type;
2009-10-02 20:23:01 +02:00
char peek = d_peek_char (di);
2011-09-24 00:21:36 +02:00
if (peek == '\0' || peek == 'E' || peek == '.')
2003-11-21 18:42:45 +01:00
break;
2013-04-03 20:21:49 +02:00
if ((peek == 'R' || peek == 'O')
&& d_peek_next_char (di) == 'E')
/* Function ref-qualifier, not a ref prefix for a parameter type. */
break;
2004-01-12 22:24:38 +01:00
type = cplus_demangle_type (di);
2003-11-21 18:42:45 +01:00
if (type == NULL)
return NULL;
2009-10-02 20:23:01 +02:00
*ptl = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, type, NULL);
if (*ptl == NULL)
return NULL;
ptl = &d_right (*ptl);
}
2003-11-21 18:42:45 +01:00
/* There should be at least one parameter type besides the optional
return type. A function which takes no arguments will have a
single parameter type void. */
if (tl == NULL)
return NULL;
2003-11-21 18:42:45 +01:00
/* If we have a single parameter type void, omit it. */
if (d_right (tl) == NULL
2004-01-12 22:24:38 +01:00
&& d_left (tl)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
2003-11-21 18:42:45 +01:00
&& d_left (tl)->u.s_builtin.type->print == D_PRINT_VOID)
2003-12-22 17:03:32 +01:00
{
di->expansion -= d_left (tl)->u.s_builtin.type->len;
2009-10-02 20:23:01 +02:00
d_left (tl) = NULL;
2003-12-22 17:03:32 +01:00
}
2009-10-02 20:23:01 +02:00
return tl;
}
/* <bare-function-type> ::= [J]<type>+ */
static struct demangle_component *
d_bare_function_type (struct d_info *di, int has_return_type)
{
struct demangle_component *return_type;
struct demangle_component *tl;
char peek;
/* Detect special qualifier indicating that the first argument
is the return type. */
peek = d_peek_char (di);
if (peek == 'J')
{
d_advance (di, 1);
has_return_type = 1;
}
if (has_return_type)
{
return_type = cplus_demangle_type (di);
if (return_type == NULL)
return NULL;
}
else
return_type = NULL;
tl = d_parmlist (di);
if (tl == NULL)
return NULL;
return d_make_comp (di, DEMANGLE_COMPONENT_FUNCTION_TYPE,
return_type, tl);
2003-11-21 18:42:45 +01:00
}
2003-11-21 18:42:45 +01:00
/* <class-enum-type> ::= <name> */
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_class_enum_type (struct d_info *di)
2003-11-21 18:42:45 +01:00
{
Update the libiberty sources with the latest patches found in the master sources. 2017-01-02 Richard Biener <rguenther@suse.de> PR lto/83452 * simple-object-elf.c (simple_object_elf_copy_lto_debug_section): Do not use UNDEF locals for removed symbols but instead just define them in the first prevailing section and with no name. Use the same gnu_lto_v1 name for all removed globals we promote to WEAK UNDEFs so hpux can use a stub to provide this symbol. Clear sh_info and sh_link in removed sections. 2017-10-30 Richard Biener <rguenther@suse.de> PR lto/82757 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Strip two leading _s from the __gnu_lto_* symbols. 2017-10-24 Alan Modra <amodra@gmail.com> PR lto/82687 PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Only make __gnu_lto symbols hidden. 2017-10-20 Alan Modra <amodra@gmail.com> PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Make discarded non-local symbols weak and hidden. 2017-10-18 Jakub Jelinek <jakub@redhat.com> PR lto/82598 * simple-object.c (handle_lto_debug_sections): Copy over also .note.GNU-stack section with unchanged name. * simple-object-elf.c (SHF_EXECINSTR): Define. (simple_object_elf_copy_lto_debug_section): Drop SHF_EXECINSTR bit on .note.GNU-stack section. 2017-09-25 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_encoding): Strip return type when name is a LOCAL_NAME. (d_local_name): Strip return type of enclosing TYPED_NAME. * testsuite/demangle-expected: Add and adjust tests. 2017-09-21 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Revert addition of 'toplevel' parm. (has_return_type): Recurse for DEMANGLE_COMPONENT_LOCAL_NAME. (d_encoding): Revert d_name change. Use is_fnqual_component_type to strip modifiers that do not belong. (d_special_name, d_class_enum_type): Revert d_name call change. (d_expresion_1): Commonize DEMANGLE_COMPONENT_UNARY building. (d_local_name): Revert parsing of a function type. (d_print_comp_inner): An inner LOCAL_NAME might contain a TEMPLATE. * testsuite/demangle-expected: Add & adjust tests
2018-01-10 14:57:48 +01:00
return d_name (di);
2003-11-21 18:42:45 +01:00
}
2000-10-12 04:16:48 +02:00
2003-11-21 18:42:45 +01:00
/* <array-type> ::= A <(positive dimension) number> _ <(element) type>
::= A [<(dimension) expression>] _ <(element) type>
*/
2000-10-12 04:16:48 +02:00
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_array_type (struct d_info *di)
2003-11-21 18:42:45 +01:00
{
char peek;
2004-01-12 22:24:38 +01:00
struct demangle_component *dim;
2000-10-12 04:16:48 +02:00
if (! d_check_char (di, 'A'))
2003-11-21 18:42:45 +01:00
return NULL;
peek = d_peek_char (di);
if (peek == '_')
dim = NULL;
else if (IS_DIGIT (peek))
2000-10-12 04:16:48 +02:00
{
2003-11-21 18:42:45 +01:00
const char *s;
2000-10-12 04:16:48 +02:00
2003-11-21 18:42:45 +01:00
s = d_str (di);
do
{
d_advance (di, 1);
peek = d_peek_char (di);
}
while (IS_DIGIT (peek));
dim = d_make_name (di, s, d_str (di) - s);
2003-11-27 02:17:34 +01:00
if (dim == NULL)
return NULL;
2000-10-12 04:16:48 +02:00
}
else
2003-11-21 18:42:45 +01:00
{
dim = d_expression (di);
if (dim == NULL)
return NULL;
}
if (! d_check_char (di, '_'))
2003-11-21 18:42:45 +01:00
return NULL;
2004-01-12 22:24:38 +01:00
return d_make_comp (di, DEMANGLE_COMPONENT_ARRAY_TYPE, dim,
cplus_demangle_type (di));
2003-11-21 18:42:45 +01:00
}
2010-02-04 00:28:01 +01:00
/* <vector-type> ::= Dv <number> _ <type>
::= Dv _ <expression> _ <type> */
static struct demangle_component *
d_vector_type (struct d_info *di)
{
char peek;
struct demangle_component *dim;
peek = d_peek_char (di);
if (peek == '_')
{
d_advance (di, 1);
dim = d_expression (di);
}
else
dim = d_number_component (di);
if (dim == NULL)
return NULL;
if (! d_check_char (di, '_'))
return NULL;
return d_make_comp (di, DEMANGLE_COMPONENT_VECTOR_TYPE, dim,
cplus_demangle_type (di));
}
2003-11-21 18:42:45 +01:00
/* <pointer-to-member-type> ::= M <(class) type> <(member) type> */
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_pointer_to_member_type (struct d_info *di)
{
2004-01-12 22:24:38 +01:00
struct demangle_component *cl;
struct demangle_component *mem;
if (! d_check_char (di, 'M'))
2003-11-21 18:42:45 +01:00
return NULL;
2004-01-12 22:24:38 +01:00
cl = cplus_demangle_type (di);
2013-04-04 03:03:01 +02:00
if (cl == NULL)
return NULL;
2013-04-04 03:03:01 +02:00
/* The ABI says, "The type of a non-static member function is considered
to be different, for the purposes of substitution, from the type of a
namespace-scope or static member function whose type appears
similar. The types of two non-static member functions are considered
to be different, for the purposes of substitution, if the functions
are members of different classes. In other words, for the purposes of
substitution, the class of which the function is a member is
considered part of the type of function."
For a pointer to member function, this call to cplus_demangle_type
will end up adding a (possibly qualified) non-member function type to
the substitution table, which is not correct; however, the member
function type will never be used in a substitution, so putting the
wrong type in the substitution table is harmless. */
mem = cplus_demangle_type (di);
if (mem == NULL)
return NULL;
2006-08-28 02:56:25 +02:00
2004-01-12 22:24:38 +01:00
return d_make_comp (di, DEMANGLE_COMPONENT_PTRMEM_TYPE, cl, mem);
}
2009-10-02 20:23:01 +02:00
/* <non-negative number> _ */
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
static int
2009-10-02 20:23:01 +02:00
d_compact_number (struct d_info *di)
{
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
int num;
2009-10-02 20:23:01 +02:00
if (d_peek_char (di) == '_')
num = 0;
else if (d_peek_char (di) == 'n')
return -1;
else
num = d_number (di) + 1;
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
if (num < 0 || ! d_check_char (di, '_'))
2009-10-02 20:23:01 +02:00
return -1;
return num;
}
2003-11-21 18:42:45 +01:00
/* <template-param> ::= T_
::= T <(parameter-2 non-negative) number> _
*/
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_template_param (struct d_info *di)
{
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
int param;
if (! d_check_char (di, 'T'))
2003-11-21 18:42:45 +01:00
return NULL;
2009-10-02 20:23:01 +02:00
param = d_compact_number (di);
if (param < 0)
2003-11-21 18:42:45 +01:00
return NULL;
2003-11-21 18:42:45 +01:00
return d_make_template_param (di, param);
}
2003-11-21 18:42:45 +01:00
/* <template-args> ::= I <template-arg>+ E */
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_template_args (struct d_info *di)
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
{
if (d_peek_char (di) != 'I'
&& d_peek_char (di) != 'J')
return NULL;
d_advance (di, 1);
return d_template_args_1 (di);
}
/* <template-arg>* E */
static struct demangle_component *
d_template_args_1 (struct d_info *di)
{
2004-01-12 22:24:38 +01:00
struct demangle_component *hold_last_name;
struct demangle_component *al;
struct demangle_component **pal;
2003-11-21 18:42:45 +01:00
/* Preserve the last name we saw--don't let the template arguments
clobber it, as that would give us the wrong name for a subsequent
constructor or destructor. */
hold_last_name = di->last_name;
2008-10-07 03:28:01 +02:00
if (d_peek_char (di) == 'E')
{
/* An argument pack can be empty. */
d_advance (di, 1);
return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, NULL, NULL);
}
2003-11-21 18:42:45 +01:00
al = NULL;
pal = &al;
while (1)
{
2004-01-12 22:24:38 +01:00
struct demangle_component *a;
2003-11-21 18:42:45 +01:00
a = d_template_arg (di);
if (a == NULL)
return NULL;
2004-01-12 22:24:38 +01:00
*pal = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, a, NULL);
2003-11-27 02:17:34 +01:00
if (*pal == NULL)
return NULL;
2003-11-21 18:42:45 +01:00
pal = &d_right (*pal);
if (d_peek_char (di) == 'E')
2000-07-20 20:56:16 +02:00
{
2003-11-21 18:42:45 +01:00
d_advance (di, 1);
break;
2000-07-20 20:56:16 +02:00
}
}
2003-11-21 18:42:45 +01:00
di->last_name = hold_last_name;
return al;
}
2003-11-21 18:42:45 +01:00
/* <template-arg> ::= <type>
::= X <expression> E
::= <expr-primary>
*/
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_template_arg (struct d_info *di)
{
2004-01-12 22:24:38 +01:00
struct demangle_component *ret;
2000-07-20 20:56:16 +02:00
2003-11-21 18:42:45 +01:00
switch (d_peek_char (di))
{
2003-11-21 18:42:45 +01:00
case 'X':
d_advance (di, 1);
ret = d_expression (di);
if (! d_check_char (di, 'E'))
2003-11-21 18:42:45 +01:00
return NULL;
return ret;
2002-07-10 02:01:58 +02:00
2003-11-21 18:42:45 +01:00
case 'L':
return d_expr_primary (di);
2008-10-07 03:28:01 +02:00
case 'I':
2012-01-06 23:04:43 +01:00
case 'J':
2008-10-07 03:28:01 +02:00
/* An argument pack. */
return d_template_args (di);
2003-11-21 18:42:45 +01:00
default:
2004-01-12 22:24:38 +01:00
return cplus_demangle_type (di);
2000-10-12 04:16:48 +02:00
}
}
2012-01-06 23:04:43 +01:00
/* Parse a sequence of expressions until we hit the terminator
character. */
2008-09-09 20:21:49 +02:00
static struct demangle_component *
2012-01-06 23:04:43 +01:00
d_exprlist (struct d_info *di, char terminator)
2008-09-09 20:21:49 +02:00
{
struct demangle_component *list = NULL;
struct demangle_component **p = &list;
2012-01-06 23:04:43 +01:00
if (d_peek_char (di) == terminator)
2008-10-07 03:28:01 +02:00
{
d_advance (di, 1);
return d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, NULL, NULL);
}
2008-09-09 20:21:49 +02:00
while (1)
{
struct demangle_component *arg = d_expression (di);
if (arg == NULL)
return NULL;
*p = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, arg, NULL);
if (*p == NULL)
return NULL;
p = &d_right (*p);
2012-01-06 23:04:43 +01:00
if (d_peek_char (di) == terminator)
2008-09-09 20:21:49 +02:00
{
d_advance (di, 1);
break;
}
}
return list;
}
2012-07-18 22:09:08 +02:00
/* Returns nonzero iff OP is an operator for a C++ cast: const_cast,
dynamic_cast, static_cast or reinterpret_cast. */
static int
op_is_new_cast (struct demangle_component *op)
{
const char *code = op->u.s_operator.op->code;
return (code[1] == 'c'
&& (code[0] == 's' || code[0] == 'd'
|| code[0] == 'c' || code[0] == 'r'));
}
2003-11-21 18:42:45 +01:00
/* <expression> ::= <(unary) operator-name> <expression>
::= <(binary) operator-name> <expression> <expression>
::= <(trinary) operator-name> <expression> <expression> <expression>
2008-09-09 20:21:49 +02:00
::= cl <expression>+ E
2003-11-21 18:42:45 +01:00
::= st <type>
::= <template-param>
::= sr <type> <unqualified-name>
::= sr <type> <unqualified-name> <template-args>
::= <expr-primary>
*/
static inline struct demangle_component *
d_expression_1 (struct d_info *di)
{
2003-11-21 18:42:45 +01:00
char peek;
2003-11-21 18:42:45 +01:00
peek = d_peek_char (di);
if (peek == 'L')
return d_expr_primary (di);
else if (peek == 'T')
return d_template_param (di);
else if (peek == 's' && d_peek_next_char (di) == 'r')
{
2004-01-12 22:24:38 +01:00
struct demangle_component *type;
struct demangle_component *name;
2003-11-21 18:42:45 +01:00
d_advance (di, 2);
2004-01-12 22:24:38 +01:00
type = cplus_demangle_type (di);
2003-11-21 18:42:45 +01:00
name = d_unqualified_name (di);
if (d_peek_char (di) != 'I')
2004-01-12 22:24:38 +01:00
return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type, name);
2003-11-21 18:42:45 +01:00
else
2004-01-12 22:24:38 +01:00
return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type,
d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
2003-11-21 18:42:45 +01:00
d_template_args (di)));
2002-07-02 06:09:35 +02:00
}
2009-03-23 23:05:12 +01:00
else if (peek == 's' && d_peek_next_char (di) == 'p')
{
d_advance (di, 2);
return d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
d_expression_1 (di), NULL);
2009-03-23 23:05:12 +01:00
}
2009-03-18 01:07:49 +01:00
else if (peek == 'f' && d_peek_next_char (di) == 'p')
2008-09-09 20:21:49 +02:00
{
2009-03-18 01:07:49 +01:00
/* Function parameter used in a late-specified return type. */
int index;
2008-09-09 20:21:49 +02:00
d_advance (di, 2);
2011-07-05 17:40:17 +02:00
if (d_peek_char (di) == 'T')
{
/* 'this' parameter. */
d_advance (di, 1);
index = 0;
}
else
{
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
index = d_compact_number (di);
if (index == INT_MAX || index == -1)
2011-07-05 17:40:17 +02:00
return NULL;
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
index++;
2011-07-05 17:40:17 +02:00
}
2009-03-18 01:07:49 +01:00
return d_make_function_param (di, index);
2008-09-09 20:21:49 +02:00
}
2010-02-04 00:28:01 +01:00
else if (IS_DIGIT (peek)
|| (peek == 'o' && d_peek_next_char (di) == 'n'))
2008-10-07 03:28:01 +02:00
{
/* We can get an unqualified name as an expression in the case of
2010-02-04 00:28:01 +01:00
a dependent function call, i.e. decltype(f(t)). */
struct demangle_component *name;
if (peek == 'o')
/* operator-function-id, i.e. operator+(t). */
d_advance (di, 2);
name = d_unqualified_name (di);
2008-10-07 03:28:01 +02:00
if (name == NULL)
return NULL;
if (d_peek_char (di) == 'I')
return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
d_template_args (di));
else
return name;
}
2012-01-06 23:04:43 +01:00
else if ((peek == 'i' || peek == 't')
&& d_peek_next_char (di) == 'l')
{
/* Brace-enclosed initializer list, untyped or typed. */
struct demangle_component *type = NULL;
Synchronize libiberty with gcc and add --no-recruse-limit option to tools that support name demangling. This patch addresses the multitude of bug reports about resource exhaustion in libiberty's name demangling code. It adds a limit to the amount of recursion that is allowed, before an error is triggered. It also adds a new demangling option to disable this limit. (The limit is enabled by default). PR 87681 PR 87675 PR 87636 PR 87335 libiberty * cp-demangle.h (struct d_info): Add recursion_limit field. * cp-demangle.c (d_function_type): If the recursion limit is enabled and reached, return with a failure result. (d_demangle_callback): If the recursion limit is enabled, check for a mangled string that is so long that there is not enough stack space for the local arrays. * cplus-dem.c (struct work): Add recursion_level field. (demangle_nested_args): If the recursion limit is enabled and reached, return with a failure result. include * demangle.h (DMGL_RECURSE_LIMIT): Define. (DEMANGLE_RECURSION_LIMIT): Prototype. binutuils * addr2line.c (demangle_flags): New static variable. (long_options): Add --recurse-limit and --no-recurse-limit. (translate_address): Pass demangle_flags to bfd_demangle. (main): Handle --recurse-limit and --no-recurse-limit options. * cxxfilt.c (flags): Add DMGL_RECURSE_LIMIT. (long_options): Add --recurse-limit and --no-recurse-limit. (main): Handle new options. * dlltool.c (gen_def_file): Include DMGL_RECURSE_LIMIT in flags passed to cplus_demangle. * nm.c (demangle_flags): New static variable. (long_options): Add --recurse-limit and --no-recurse-limit. (main): Handle new options. * objdump.c (demangle_flags): New static variable. (usage): Add --recurse-limit and --no-recurse-limit. (long_options): Likewise. (objdump_print_symname): Pass demangle_flags to bfd_demangle. (disassemble_section): Likewise. (dump_dymbols): Likewise. (main): Handle new options. * prdbg.c (demangle_flags): New static variable. (tg_variable): Pass demangle_flags to demangler. (tg_start_function): Likewise. * stabs.c (demangle_flags): New static variable. (stab_demangle_template): Pass demangle_flags to demangler. (stab_demangle_v3_argtypes): Likewise. (stab_demangle_v3_arg): Likewise. * doc/binutuls.texi: Document new command line options. * NEWS: Mention the new feature. * testsuite/config/default.exp (CXXFILT): Define if not already defined. (CXXFILTFLAGS): Likewise. * testsuite/binutils-all/cxxfilt.exp: New file. Runs a few simple tests of the cxxfilt program.
2018-12-07 12:32:55 +01:00
d_advance (di, 2);
2012-01-06 23:04:43 +01:00
if (peek == 't')
type = cplus_demangle_type (di);
if (!d_peek_next_char (di))
return NULL;
2012-01-06 23:04:43 +01:00
return d_make_comp (di, DEMANGLE_COMPONENT_INITIALIZER_LIST,
type, d_exprlist (di, 'E'));
}
2003-11-21 18:42:45 +01:00
else
{
2004-01-12 22:24:38 +01:00
struct demangle_component *op;
2012-01-06 23:04:43 +01:00
const char *code = NULL;
2003-11-21 18:42:45 +01:00
int args;
2003-11-21 18:42:45 +01:00
op = d_operator_name (di);
if (op == NULL)
return NULL;
2004-01-12 22:24:38 +01:00
if (op->type == DEMANGLE_COMPONENT_OPERATOR)
2012-01-06 23:04:43 +01:00
{
code = op->u.s_operator.op->code;
di->expansion += op->u.s_operator.op->len - 2;
if (strcmp (code, "st") == 0)
return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
cplus_demangle_type (di));
}
2003-11-21 18:42:45 +01:00
switch (op->type)
{
default:
return NULL;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_OPERATOR:
2003-11-21 18:42:45 +01:00
args = op->u.s_operator.op->args;
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
2003-11-21 18:42:45 +01:00
args = op->u.s_extended_operator.args;
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_CAST:
2009-01-07 19:52:57 +01:00
args = 1;
2003-11-21 18:42:45 +01:00
break;
}
switch (args)
{
2012-01-06 23:04:43 +01:00
case 0:
return d_make_comp (di, DEMANGLE_COMPONENT_NULLARY, op, NULL);
2003-11-21 18:42:45 +01:00
case 1:
2009-03-18 01:07:49 +01:00
{
struct demangle_component *operand;
2012-01-06 23:04:43 +01:00
int suffix = 0;
if (code && (code[0] == 'p' || code[0] == 'm')
&& code[1] == code[0])
/* pp_ and mm_ are the prefix variants. */
suffix = !d_check_char (di, '_');
2009-03-18 01:07:49 +01:00
if (op->type == DEMANGLE_COMPONENT_CAST
&& d_check_char (di, '_'))
2012-01-06 23:04:43 +01:00
operand = d_exprlist (di, 'E');
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
else if (code && !strcmp (code, "sP"))
operand = d_template_args_1 (di);
2009-03-18 01:07:49 +01:00
else
operand = d_expression_1 (di);
2012-01-06 23:04:43 +01:00
if (suffix)
/* Indicate the suffix variant for d_print_comp. */
Update the libiberty sources with the latest patches found in the master sources. 2017-01-02 Richard Biener <rguenther@suse.de> PR lto/83452 * simple-object-elf.c (simple_object_elf_copy_lto_debug_section): Do not use UNDEF locals for removed symbols but instead just define them in the first prevailing section and with no name. Use the same gnu_lto_v1 name for all removed globals we promote to WEAK UNDEFs so hpux can use a stub to provide this symbol. Clear sh_info and sh_link in removed sections. 2017-10-30 Richard Biener <rguenther@suse.de> PR lto/82757 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Strip two leading _s from the __gnu_lto_* symbols. 2017-10-24 Alan Modra <amodra@gmail.com> PR lto/82687 PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Only make __gnu_lto symbols hidden. 2017-10-20 Alan Modra <amodra@gmail.com> PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Make discarded non-local symbols weak and hidden. 2017-10-18 Jakub Jelinek <jakub@redhat.com> PR lto/82598 * simple-object.c (handle_lto_debug_sections): Copy over also .note.GNU-stack section with unchanged name. * simple-object-elf.c (SHF_EXECINSTR): Define. (simple_object_elf_copy_lto_debug_section): Drop SHF_EXECINSTR bit on .note.GNU-stack section. 2017-09-25 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_encoding): Strip return type when name is a LOCAL_NAME. (d_local_name): Strip return type of enclosing TYPED_NAME. * testsuite/demangle-expected: Add and adjust tests. 2017-09-21 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Revert addition of 'toplevel' parm. (has_return_type): Recurse for DEMANGLE_COMPONENT_LOCAL_NAME. (d_encoding): Revert d_name change. Use is_fnqual_component_type to strip modifiers that do not belong. (d_special_name, d_class_enum_type): Revert d_name call change. (d_expresion_1): Commonize DEMANGLE_COMPONENT_UNARY building. (d_local_name): Revert parsing of a function type. (d_print_comp_inner): An inner LOCAL_NAME might contain a TEMPLATE. * testsuite/demangle-expected: Add & adjust tests
2018-01-10 14:57:48 +01:00
operand = d_make_comp (di, DEMANGLE_COMPONENT_BINARY_ARGS,
operand, operand);
return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op, operand);
2009-03-18 01:07:49 +01:00
}
2003-11-21 18:42:45 +01:00
case 2:
{
2004-01-12 22:24:38 +01:00
struct demangle_component *left;
2008-09-09 20:21:49 +02:00
struct demangle_component *right;
2003-11-21 18:42:45 +01:00
if (code == NULL)
return NULL;
2012-07-18 22:09:08 +02:00
if (op_is_new_cast (op))
left = cplus_demangle_type (di);
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
else if (code[0] == 'f')
/* fold-expression. */
left = d_operator_name (di);
2012-07-18 22:09:08 +02:00
else
left = d_expression_1 (di);
2010-02-04 00:28:01 +01:00
if (!strcmp (code, "cl"))
2012-01-06 23:04:43 +01:00
right = d_exprlist (di, 'E');
2010-02-04 00:28:01 +01:00
else if (!strcmp (code, "dt") || !strcmp (code, "pt"))
{
right = d_unqualified_name (di);
if (d_peek_char (di) == 'I')
right = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE,
right, d_template_args (di));
}
2008-09-09 20:21:49 +02:00
else
right = d_expression_1 (di);
2008-09-09 20:21:49 +02:00
2004-01-12 22:24:38 +01:00
return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op,
d_make_comp (di,
DEMANGLE_COMPONENT_BINARY_ARGS,
2008-09-09 20:21:49 +02:00
left, right));
2003-11-21 18:42:45 +01:00
}
case 3:
{
2004-01-12 22:24:38 +01:00
struct demangle_component *first;
struct demangle_component *second;
2012-01-06 23:04:43 +01:00
struct demangle_component *third;
2003-11-21 18:42:45 +01:00
if (code == NULL)
return NULL;
else if (!strcmp (code, "qu"))
2012-01-06 23:04:43 +01:00
{
/* ?: expression. */
first = d_expression_1 (di);
second = d_expression_1 (di);
third = d_expression_1 (di);
if (third == NULL)
return NULL;
2012-01-06 23:04:43 +01:00
}
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
else if (code[0] == 'f')
{
/* fold-expression. */
first = d_operator_name (di);
second = d_expression_1 (di);
third = d_expression_1 (di);
if (third == NULL)
return NULL;
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
}
2012-01-06 23:04:43 +01:00
else if (code[0] == 'n')
{
/* new-expression. */
if (code[1] != 'w' && code[1] != 'a')
return NULL;
first = d_exprlist (di, '_');
second = cplus_demangle_type (di);
if (d_peek_char (di) == 'E')
{
d_advance (di, 1);
third = NULL;
}
else if (d_peek_char (di) == 'p'
&& d_peek_next_char (di) == 'i')
{
/* Parenthesized initializer. */
d_advance (di, 2);
third = d_exprlist (di, 'E');
}
else if (d_peek_char (di) == 'i'
&& d_peek_next_char (di) == 'l')
/* initializer-list. */
third = d_expression_1 (di);
2012-01-06 23:04:43 +01:00
else
return NULL;
}
else
return NULL;
2004-01-12 22:24:38 +01:00
return d_make_comp (di, DEMANGLE_COMPONENT_TRINARY, op,
d_make_comp (di,
DEMANGLE_COMPONENT_TRINARY_ARG1,
first,
2003-11-21 18:42:45 +01:00
d_make_comp (di,
2004-01-12 22:24:38 +01:00
DEMANGLE_COMPONENT_TRINARY_ARG2,
2012-01-06 23:04:43 +01:00
second, third)));
2003-11-21 18:42:45 +01:00
}
default:
return NULL;
}
}
}
static struct demangle_component *
d_expression (struct d_info *di)
{
struct demangle_component *ret;
int was_expression = di->is_expression;
di->is_expression = 1;
ret = d_expression_1 (di);
di->is_expression = was_expression;
return ret;
}
2003-11-21 18:42:45 +01:00
/* <expr-primary> ::= L <type> <(value) number> E
::= L <type> <(value) float> E
::= L <mangled-name> E
*/
2000-10-12 04:16:48 +02:00
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_expr_primary (struct d_info *di)
2000-10-12 04:16:48 +02:00
{
2004-01-12 22:24:38 +01:00
struct demangle_component *ret;
2000-10-12 04:16:48 +02:00
if (! d_check_char (di, 'L'))
2003-11-21 18:42:45 +01:00
return NULL;
2009-03-18 01:07:49 +01:00
if (d_peek_char (di) == '_'
/* Workaround for G++ bug; see comment in write_template_arg. */
|| d_peek_char (di) == 'Z')
2004-01-12 22:24:38 +01:00
ret = cplus_demangle_mangled_name (di, 0);
2003-11-21 18:42:45 +01:00
else
2000-10-12 04:16:48 +02:00
{
2004-01-12 22:24:38 +01:00
struct demangle_component *type;
enum demangle_component_type t;
2003-11-21 18:42:45 +01:00
const char *s;
2004-01-12 22:24:38 +01:00
type = cplus_demangle_type (di);
2004-06-28 20:01:46 +02:00
if (type == NULL)
return NULL;
2003-11-21 18:42:45 +01:00
2003-12-22 17:03:32 +01:00
/* If we have a type we know how to print, we aren't going to
print the type name itself. */
2004-01-12 22:24:38 +01:00
if (type->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
2003-12-22 17:03:32 +01:00
&& type->u.s_builtin.type->print != D_PRINT_DEFAULT)
di->expansion -= type->u.s_builtin.type->len;
2003-11-21 18:42:45 +01:00
/* Rather than try to interpret the literal value, we just
collect it as a string. Note that it's possible to have a
floating point literal here. The ABI specifies that the
format of such literals is machine independent. That's fine,
but what's not fine is that versions of g++ up to 3.2 with
-fabi-version=1 used upper case letters in the hex constant,
and dumped out gcc's internal representation. That makes it
hard to tell where the constant ends, and hard to dump the
constant in any readable form anyhow. We don't attempt to
handle these cases. */
2004-01-12 22:24:38 +01:00
t = DEMANGLE_COMPONENT_LITERAL;
2003-12-15 18:45:42 +01:00
if (d_peek_char (di) == 'n')
{
2004-01-12 22:24:38 +01:00
t = DEMANGLE_COMPONENT_LITERAL_NEG;
2003-12-15 18:45:42 +01:00
d_advance (di, 1);
}
2003-11-21 18:42:45 +01:00
s = d_str (di);
while (d_peek_char (di) != 'E')
2005-07-03 21:16:20 +02:00
{
if (d_peek_char (di) == '\0')
return NULL;
d_advance (di, 1);
}
2003-12-15 18:45:42 +01:00
ret = d_make_comp (di, t, type, d_make_name (di, s, d_str (di) - s));
2003-11-21 18:42:45 +01:00
}
if (! d_check_char (di, 'E'))
2003-11-21 18:42:45 +01:00
return NULL;
return ret;
2000-10-12 04:16:48 +02:00
}
2003-11-21 18:42:45 +01:00
/* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
::= Z <(function) encoding> E s [<discriminator>]
2013-02-15 03:48:33 +01:00
::= Z <(function) encoding> E d [<parameter> number>] _ <entity name>
2003-11-21 18:42:45 +01:00
*/
2000-10-12 04:16:48 +02:00
2004-01-12 22:24:38 +01:00
static struct demangle_component *
Update the libiberty sources with the latest patches found in the master sources. 2017-01-02 Richard Biener <rguenther@suse.de> PR lto/83452 * simple-object-elf.c (simple_object_elf_copy_lto_debug_section): Do not use UNDEF locals for removed symbols but instead just define them in the first prevailing section and with no name. Use the same gnu_lto_v1 name for all removed globals we promote to WEAK UNDEFs so hpux can use a stub to provide this symbol. Clear sh_info and sh_link in removed sections. 2017-10-30 Richard Biener <rguenther@suse.de> PR lto/82757 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Strip two leading _s from the __gnu_lto_* symbols. 2017-10-24 Alan Modra <amodra@gmail.com> PR lto/82687 PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Only make __gnu_lto symbols hidden. 2017-10-20 Alan Modra <amodra@gmail.com> PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Make discarded non-local symbols weak and hidden. 2017-10-18 Jakub Jelinek <jakub@redhat.com> PR lto/82598 * simple-object.c (handle_lto_debug_sections): Copy over also .note.GNU-stack section with unchanged name. * simple-object-elf.c (SHF_EXECINSTR): Define. (simple_object_elf_copy_lto_debug_section): Drop SHF_EXECINSTR bit on .note.GNU-stack section. 2017-09-25 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_encoding): Strip return type when name is a LOCAL_NAME. (d_local_name): Strip return type of enclosing TYPED_NAME. * testsuite/demangle-expected: Add and adjust tests. 2017-09-21 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Revert addition of 'toplevel' parm. (has_return_type): Recurse for DEMANGLE_COMPONENT_LOCAL_NAME. (d_encoding): Revert d_name change. Use is_fnqual_component_type to strip modifiers that do not belong. (d_special_name, d_class_enum_type): Revert d_name call change. (d_expresion_1): Commonize DEMANGLE_COMPONENT_UNARY building. (d_local_name): Revert parsing of a function type. (d_print_comp_inner): An inner LOCAL_NAME might contain a TEMPLATE. * testsuite/demangle-expected: Add & adjust tests
2018-01-10 14:57:48 +01:00
d_local_name (struct d_info *di)
2000-10-12 04:16:48 +02:00
{
2004-01-12 22:24:38 +01:00
struct demangle_component *function;
Sync libiberty/ & include/ with GCC Note this brings in the interface files for libcc1/G++ as well, which we will be needing in GDB soon anyway. That commit renamed a method in the C interface and that required a small update to GDB's compile/ code, which I've included that in this patch to keep the tree building. include/ChangeLog: 2017-09-15 Pedro Alves <palves@redhat.com> * ansidecl.h (DISABLE_COPY_AND_ASSIGN): New macro. 2017-09-12 Jiong Wang <jiong.wang@arm.com> * dwarf2.def (DW_CFA_AARCH64_negate_ra_state): New DW_CFA_DUP. * dwarf2.h (DW_CFA_DUP): New define. 2017-08-21 Richard Biener <rguenther@suse.de> * simple-object.h (simple_object_copy_lto_debug_sections): New function. 2017-05-18 Martin Liska <mliska@suse.cz> * ansidecl.h: Define CONSTEXPR macro. 2017-05-24 Nathan Sidwell <nathan@acm.org> * libiberty.h (ASTRDUP): Adjust cast to avoid warning. 2017-01-30 Alexandre Oliva <aoliva@redhat.com> Introduce C++ support in libcc1. * gcc-c-fe.def (int_type_v0): Rename from... (int_type): ... this. Introduce new version. (float_type_v0): Rename from... (float_type): ... this. Introduce new version. (char_type): New. * gcc-c-interface.h (gcc_c_api_version): Add GCC_C_FE_VERSION_1. (gcc_type_array): Move... * gcc-interface.h: ... here. * gcc-cp-fe.def: New. * gcc-cp-interface.h: New. 2016-04-29 Oleg Endo <olegendo@gcc.gnu.org> * longlong.h (umul_ppmm): Remove SHMEDIA checks. (__umulsidi3, count_leading_zeros): Remove SHMEDIA implementations. 2017-09-15 Yao Qi <yao.qi@linaro.org> Pedro Alves <palves@redhat.com> * ansidecl.h (DISABLE_COPY_AND_ASSIGN): New macro. 2017-09-12 Jiong Wang <jiong.wang@arm.com> * dwarf2.def (DW_CFA_AARCH64_negate_ra_state): New DW_CFA_DUP. * dwarf2.h (DW_CFA_DUP): New define. 2017-08-21 Richard Biener <rguenther@suse.de> * simple-object.h (simple_object_copy_lto_debug_sections): New function. 2017-05-18 Martin Liska <mliska@suse.cz> * ansidecl.h: Define CONSTEXPR macro. 2017-05-24 Nathan Sidwell <nathan@acm.org> * libiberty.h (ASTRDUP): Adjust cast to avoid warning. 2017-01-30 Alexandre Oliva <aoliva@redhat.com> Introduce C++ support in libcc1. * gcc-c-fe.def (int_type_v0): Rename from... (int_type): ... this. Introduce new version. (float_type_v0): Rename from... (float_type): ... this. Introduce new version. (char_type): New. * gcc-c-interface.h (gcc_c_api_version): Add GCC_C_FE_VERSION_1. (gcc_type_array): Move... * gcc-interface.h: ... here. * gcc-cp-fe.def: New. * gcc-cp-interface.h: New. 2016-04-29 Oleg Endo <olegendo@gcc.gnu.org> * longlong.h (umul_ppmm): Remove SHMEDIA checks. (__umulsidi3, count_leading_zeros): Remove SHMEDIA implementations. libiberty/ChangeLog: 2017-09-15 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Add 'toplevel' parm. Pass to ... (d_local_name): ... here. Parse trailing function args on nested local_name. (d_encoding, d_special_name, d_class_enum_type): Adjust d_name calls. * testsuite/demangle-expected: Add tests. 2017-09-15 Richard Biener <rguenther@suse.de> PR lto/81968 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Iterate marking dependent sections necessary. 2017-09-15 Nathan Sidwell <nathan@acm.org> * cp-demangle.c (is_fnqual_component_type): Reimplement using FNQUAL_COMPONENT_CASE. (d_encoding): Hold bare_function_type in local var. (d_local_name): Build name in both cases and build result once. Collapse switch-if to single conditional. (d_local_name): * testsuite/demangle-expected: Realign blank lines with tests. 2017-09-12 Jiong Wang <jiong.wang@arm.com> * dwarfnames.c (DW_CFA_DUP): New define. gdb/ChangeLog: 2017-09-15 Pedro Alves <palves@redhat.com> * compile/compile-c-types.c (convert_enum, convert_int) (convert_float): Adjust to refer to int_type_v0 and float_type_v0.
2017-09-15 18:40:33 +02:00
struct demangle_component *name;
2000-10-12 04:16:48 +02:00
if (! d_check_char (di, 'Z'))
2003-11-21 18:42:45 +01:00
return NULL;
2000-10-12 04:16:48 +02:00
2003-11-24 20:33:33 +01:00
function = d_encoding (di, 0);
Update the libiberty sources with the latest patches found in the master sources. 2017-01-02 Richard Biener <rguenther@suse.de> PR lto/83452 * simple-object-elf.c (simple_object_elf_copy_lto_debug_section): Do not use UNDEF locals for removed symbols but instead just define them in the first prevailing section and with no name. Use the same gnu_lto_v1 name for all removed globals we promote to WEAK UNDEFs so hpux can use a stub to provide this symbol. Clear sh_info and sh_link in removed sections. 2017-10-30 Richard Biener <rguenther@suse.de> PR lto/82757 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Strip two leading _s from the __gnu_lto_* symbols. 2017-10-24 Alan Modra <amodra@gmail.com> PR lto/82687 PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Only make __gnu_lto symbols hidden. 2017-10-20 Alan Modra <amodra@gmail.com> PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Make discarded non-local symbols weak and hidden. 2017-10-18 Jakub Jelinek <jakub@redhat.com> PR lto/82598 * simple-object.c (handle_lto_debug_sections): Copy over also .note.GNU-stack section with unchanged name. * simple-object-elf.c (SHF_EXECINSTR): Define. (simple_object_elf_copy_lto_debug_section): Drop SHF_EXECINSTR bit on .note.GNU-stack section. 2017-09-25 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_encoding): Strip return type when name is a LOCAL_NAME. (d_local_name): Strip return type of enclosing TYPED_NAME. * testsuite/demangle-expected: Add and adjust tests. 2017-09-21 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Revert addition of 'toplevel' parm. (has_return_type): Recurse for DEMANGLE_COMPONENT_LOCAL_NAME. (d_encoding): Revert d_name change. Use is_fnqual_component_type to strip modifiers that do not belong. (d_special_name, d_class_enum_type): Revert d_name call change. (d_expresion_1): Commonize DEMANGLE_COMPONENT_UNARY building. (d_local_name): Revert parsing of a function type. (d_print_comp_inner): An inner LOCAL_NAME might contain a TEMPLATE. * testsuite/demangle-expected: Add & adjust tests
2018-01-10 14:57:48 +01:00
if (!function)
return NULL;
2000-10-12 04:16:48 +02:00
if (! d_check_char (di, 'E'))
2003-11-21 18:42:45 +01:00
return NULL;
2000-10-12 04:16:48 +02:00
2003-11-21 18:42:45 +01:00
if (d_peek_char (di) == 's')
2000-10-12 04:16:48 +02:00
{
2003-11-21 18:42:45 +01:00
d_advance (di, 1);
if (! d_discriminator (di))
return NULL;
Sync libiberty/ & include/ with GCC Note this brings in the interface files for libcc1/G++ as well, which we will be needing in GDB soon anyway. That commit renamed a method in the C interface and that required a small update to GDB's compile/ code, which I've included that in this patch to keep the tree building. include/ChangeLog: 2017-09-15 Pedro Alves <palves@redhat.com> * ansidecl.h (DISABLE_COPY_AND_ASSIGN): New macro. 2017-09-12 Jiong Wang <jiong.wang@arm.com> * dwarf2.def (DW_CFA_AARCH64_negate_ra_state): New DW_CFA_DUP. * dwarf2.h (DW_CFA_DUP): New define. 2017-08-21 Richard Biener <rguenther@suse.de> * simple-object.h (simple_object_copy_lto_debug_sections): New function. 2017-05-18 Martin Liska <mliska@suse.cz> * ansidecl.h: Define CONSTEXPR macro. 2017-05-24 Nathan Sidwell <nathan@acm.org> * libiberty.h (ASTRDUP): Adjust cast to avoid warning. 2017-01-30 Alexandre Oliva <aoliva@redhat.com> Introduce C++ support in libcc1. * gcc-c-fe.def (int_type_v0): Rename from... (int_type): ... this. Introduce new version. (float_type_v0): Rename from... (float_type): ... this. Introduce new version. (char_type): New. * gcc-c-interface.h (gcc_c_api_version): Add GCC_C_FE_VERSION_1. (gcc_type_array): Move... * gcc-interface.h: ... here. * gcc-cp-fe.def: New. * gcc-cp-interface.h: New. 2016-04-29 Oleg Endo <olegendo@gcc.gnu.org> * longlong.h (umul_ppmm): Remove SHMEDIA checks. (__umulsidi3, count_leading_zeros): Remove SHMEDIA implementations. 2017-09-15 Yao Qi <yao.qi@linaro.org> Pedro Alves <palves@redhat.com> * ansidecl.h (DISABLE_COPY_AND_ASSIGN): New macro. 2017-09-12 Jiong Wang <jiong.wang@arm.com> * dwarf2.def (DW_CFA_AARCH64_negate_ra_state): New DW_CFA_DUP. * dwarf2.h (DW_CFA_DUP): New define. 2017-08-21 Richard Biener <rguenther@suse.de> * simple-object.h (simple_object_copy_lto_debug_sections): New function. 2017-05-18 Martin Liska <mliska@suse.cz> * ansidecl.h: Define CONSTEXPR macro. 2017-05-24 Nathan Sidwell <nathan@acm.org> * libiberty.h (ASTRDUP): Adjust cast to avoid warning. 2017-01-30 Alexandre Oliva <aoliva@redhat.com> Introduce C++ support in libcc1. * gcc-c-fe.def (int_type_v0): Rename from... (int_type): ... this. Introduce new version. (float_type_v0): Rename from... (float_type): ... this. Introduce new version. (char_type): New. * gcc-c-interface.h (gcc_c_api_version): Add GCC_C_FE_VERSION_1. (gcc_type_array): Move... * gcc-interface.h: ... here. * gcc-cp-fe.def: New. * gcc-cp-interface.h: New. 2016-04-29 Oleg Endo <olegendo@gcc.gnu.org> * longlong.h (umul_ppmm): Remove SHMEDIA checks. (__umulsidi3, count_leading_zeros): Remove SHMEDIA implementations. libiberty/ChangeLog: 2017-09-15 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Add 'toplevel' parm. Pass to ... (d_local_name): ... here. Parse trailing function args on nested local_name. (d_encoding, d_special_name, d_class_enum_type): Adjust d_name calls. * testsuite/demangle-expected: Add tests. 2017-09-15 Richard Biener <rguenther@suse.de> PR lto/81968 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Iterate marking dependent sections necessary. 2017-09-15 Nathan Sidwell <nathan@acm.org> * cp-demangle.c (is_fnqual_component_type): Reimplement using FNQUAL_COMPONENT_CASE. (d_encoding): Hold bare_function_type in local var. (d_local_name): Build name in both cases and build result once. Collapse switch-if to single conditional. (d_local_name): * testsuite/demangle-expected: Realign blank lines with tests. 2017-09-12 Jiong Wang <jiong.wang@arm.com> * dwarfnames.c (DW_CFA_DUP): New define. gdb/ChangeLog: 2017-09-15 Pedro Alves <palves@redhat.com> * compile/compile-c-types.c (convert_enum, convert_int) (convert_float): Adjust to refer to int_type_v0 and float_type_v0.
2017-09-15 18:40:33 +02:00
name = d_make_name (di, "string literal", sizeof "string literal" - 1);
2000-10-12 04:16:48 +02:00
}
2003-11-21 18:42:45 +01:00
else
2000-10-12 04:16:48 +02:00
{
2009-10-02 20:23:01 +02:00
int num = -1;
if (d_peek_char (di) == 'd')
{
/* Default argument scope: d <number> _. */
d_advance (di, 1);
num = d_compact_number (di);
if (num < 0)
return NULL;
}
2000-10-12 04:16:48 +02:00
Update the libiberty sources with the latest patches found in the master sources. 2017-01-02 Richard Biener <rguenther@suse.de> PR lto/83452 * simple-object-elf.c (simple_object_elf_copy_lto_debug_section): Do not use UNDEF locals for removed symbols but instead just define them in the first prevailing section and with no name. Use the same gnu_lto_v1 name for all removed globals we promote to WEAK UNDEFs so hpux can use a stub to provide this symbol. Clear sh_info and sh_link in removed sections. 2017-10-30 Richard Biener <rguenther@suse.de> PR lto/82757 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Strip two leading _s from the __gnu_lto_* symbols. 2017-10-24 Alan Modra <amodra@gmail.com> PR lto/82687 PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Only make __gnu_lto symbols hidden. 2017-10-20 Alan Modra <amodra@gmail.com> PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Make discarded non-local symbols weak and hidden. 2017-10-18 Jakub Jelinek <jakub@redhat.com> PR lto/82598 * simple-object.c (handle_lto_debug_sections): Copy over also .note.GNU-stack section with unchanged name. * simple-object-elf.c (SHF_EXECINSTR): Define. (simple_object_elf_copy_lto_debug_section): Drop SHF_EXECINSTR bit on .note.GNU-stack section. 2017-09-25 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_encoding): Strip return type when name is a LOCAL_NAME. (d_local_name): Strip return type of enclosing TYPED_NAME. * testsuite/demangle-expected: Add and adjust tests. 2017-09-21 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Revert addition of 'toplevel' parm. (has_return_type): Recurse for DEMANGLE_COMPONENT_LOCAL_NAME. (d_encoding): Revert d_name change. Use is_fnqual_component_type to strip modifiers that do not belong. (d_special_name, d_class_enum_type): Revert d_name call change. (d_expresion_1): Commonize DEMANGLE_COMPONENT_UNARY building. (d_local_name): Revert parsing of a function type. (d_print_comp_inner): An inner LOCAL_NAME might contain a TEMPLATE. * testsuite/demangle-expected: Add & adjust tests
2018-01-10 14:57:48 +01:00
name = d_name (di);
Sync libiberty/ & include/ with GCC Note this brings in the interface files for libcc1/G++ as well, which we will be needing in GDB soon anyway. That commit renamed a method in the C interface and that required a small update to GDB's compile/ code, which I've included that in this patch to keep the tree building. include/ChangeLog: 2017-09-15 Pedro Alves <palves@redhat.com> * ansidecl.h (DISABLE_COPY_AND_ASSIGN): New macro. 2017-09-12 Jiong Wang <jiong.wang@arm.com> * dwarf2.def (DW_CFA_AARCH64_negate_ra_state): New DW_CFA_DUP. * dwarf2.h (DW_CFA_DUP): New define. 2017-08-21 Richard Biener <rguenther@suse.de> * simple-object.h (simple_object_copy_lto_debug_sections): New function. 2017-05-18 Martin Liska <mliska@suse.cz> * ansidecl.h: Define CONSTEXPR macro. 2017-05-24 Nathan Sidwell <nathan@acm.org> * libiberty.h (ASTRDUP): Adjust cast to avoid warning. 2017-01-30 Alexandre Oliva <aoliva@redhat.com> Introduce C++ support in libcc1. * gcc-c-fe.def (int_type_v0): Rename from... (int_type): ... this. Introduce new version. (float_type_v0): Rename from... (float_type): ... this. Introduce new version. (char_type): New. * gcc-c-interface.h (gcc_c_api_version): Add GCC_C_FE_VERSION_1. (gcc_type_array): Move... * gcc-interface.h: ... here. * gcc-cp-fe.def: New. * gcc-cp-interface.h: New. 2016-04-29 Oleg Endo <olegendo@gcc.gnu.org> * longlong.h (umul_ppmm): Remove SHMEDIA checks. (__umulsidi3, count_leading_zeros): Remove SHMEDIA implementations. 2017-09-15 Yao Qi <yao.qi@linaro.org> Pedro Alves <palves@redhat.com> * ansidecl.h (DISABLE_COPY_AND_ASSIGN): New macro. 2017-09-12 Jiong Wang <jiong.wang@arm.com> * dwarf2.def (DW_CFA_AARCH64_negate_ra_state): New DW_CFA_DUP. * dwarf2.h (DW_CFA_DUP): New define. 2017-08-21 Richard Biener <rguenther@suse.de> * simple-object.h (simple_object_copy_lto_debug_sections): New function. 2017-05-18 Martin Liska <mliska@suse.cz> * ansidecl.h: Define CONSTEXPR macro. 2017-05-24 Nathan Sidwell <nathan@acm.org> * libiberty.h (ASTRDUP): Adjust cast to avoid warning. 2017-01-30 Alexandre Oliva <aoliva@redhat.com> Introduce C++ support in libcc1. * gcc-c-fe.def (int_type_v0): Rename from... (int_type): ... this. Introduce new version. (float_type_v0): Rename from... (float_type): ... this. Introduce new version. (char_type): New. * gcc-c-interface.h (gcc_c_api_version): Add GCC_C_FE_VERSION_1. (gcc_type_array): Move... * gcc-interface.h: ... here. * gcc-cp-fe.def: New. * gcc-cp-interface.h: New. 2016-04-29 Oleg Endo <olegendo@gcc.gnu.org> * longlong.h (umul_ppmm): Remove SHMEDIA checks. (__umulsidi3, count_leading_zeros): Remove SHMEDIA implementations. libiberty/ChangeLog: 2017-09-15 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Add 'toplevel' parm. Pass to ... (d_local_name): ... here. Parse trailing function args on nested local_name. (d_encoding, d_special_name, d_class_enum_type): Adjust d_name calls. * testsuite/demangle-expected: Add tests. 2017-09-15 Richard Biener <rguenther@suse.de> PR lto/81968 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Iterate marking dependent sections necessary. 2017-09-15 Nathan Sidwell <nathan@acm.org> * cp-demangle.c (is_fnqual_component_type): Reimplement using FNQUAL_COMPONENT_CASE. (d_encoding): Hold bare_function_type in local var. (d_local_name): Build name in both cases and build result once. Collapse switch-if to single conditional. (d_local_name): * testsuite/demangle-expected: Realign blank lines with tests. 2017-09-12 Jiong Wang <jiong.wang@arm.com> * dwarfnames.c (DW_CFA_DUP): New define. gdb/ChangeLog: 2017-09-15 Pedro Alves <palves@redhat.com> * compile/compile-c-types.c (convert_enum, convert_int) (convert_float): Adjust to refer to int_type_v0 and float_type_v0.
2017-09-15 18:40:33 +02:00
if (name
/* Lambdas and unnamed types have internal discriminators
and are not functions. */
&& name->type != DEMANGLE_COMPONENT_LAMBDA
&& name->type != DEMANGLE_COMPONENT_UNNAMED_TYPE)
{
/* Read and ignore an optional discriminator. */
if (! d_discriminator (di))
return NULL;
}
2009-10-02 20:23:01 +02:00
if (num >= 0)
name = d_make_default_arg (di, num, name);
2000-10-12 04:16:48 +02:00
}
Sync libiberty/ & include/ with GCC Note this brings in the interface files for libcc1/G++ as well, which we will be needing in GDB soon anyway. That commit renamed a method in the C interface and that required a small update to GDB's compile/ code, which I've included that in this patch to keep the tree building. include/ChangeLog: 2017-09-15 Pedro Alves <palves@redhat.com> * ansidecl.h (DISABLE_COPY_AND_ASSIGN): New macro. 2017-09-12 Jiong Wang <jiong.wang@arm.com> * dwarf2.def (DW_CFA_AARCH64_negate_ra_state): New DW_CFA_DUP. * dwarf2.h (DW_CFA_DUP): New define. 2017-08-21 Richard Biener <rguenther@suse.de> * simple-object.h (simple_object_copy_lto_debug_sections): New function. 2017-05-18 Martin Liska <mliska@suse.cz> * ansidecl.h: Define CONSTEXPR macro. 2017-05-24 Nathan Sidwell <nathan@acm.org> * libiberty.h (ASTRDUP): Adjust cast to avoid warning. 2017-01-30 Alexandre Oliva <aoliva@redhat.com> Introduce C++ support in libcc1. * gcc-c-fe.def (int_type_v0): Rename from... (int_type): ... this. Introduce new version. (float_type_v0): Rename from... (float_type): ... this. Introduce new version. (char_type): New. * gcc-c-interface.h (gcc_c_api_version): Add GCC_C_FE_VERSION_1. (gcc_type_array): Move... * gcc-interface.h: ... here. * gcc-cp-fe.def: New. * gcc-cp-interface.h: New. 2016-04-29 Oleg Endo <olegendo@gcc.gnu.org> * longlong.h (umul_ppmm): Remove SHMEDIA checks. (__umulsidi3, count_leading_zeros): Remove SHMEDIA implementations. 2017-09-15 Yao Qi <yao.qi@linaro.org> Pedro Alves <palves@redhat.com> * ansidecl.h (DISABLE_COPY_AND_ASSIGN): New macro. 2017-09-12 Jiong Wang <jiong.wang@arm.com> * dwarf2.def (DW_CFA_AARCH64_negate_ra_state): New DW_CFA_DUP. * dwarf2.h (DW_CFA_DUP): New define. 2017-08-21 Richard Biener <rguenther@suse.de> * simple-object.h (simple_object_copy_lto_debug_sections): New function. 2017-05-18 Martin Liska <mliska@suse.cz> * ansidecl.h: Define CONSTEXPR macro. 2017-05-24 Nathan Sidwell <nathan@acm.org> * libiberty.h (ASTRDUP): Adjust cast to avoid warning. 2017-01-30 Alexandre Oliva <aoliva@redhat.com> Introduce C++ support in libcc1. * gcc-c-fe.def (int_type_v0): Rename from... (int_type): ... this. Introduce new version. (float_type_v0): Rename from... (float_type): ... this. Introduce new version. (char_type): New. * gcc-c-interface.h (gcc_c_api_version): Add GCC_C_FE_VERSION_1. (gcc_type_array): Move... * gcc-interface.h: ... here. * gcc-cp-fe.def: New. * gcc-cp-interface.h: New. 2016-04-29 Oleg Endo <olegendo@gcc.gnu.org> * longlong.h (umul_ppmm): Remove SHMEDIA checks. (__umulsidi3, count_leading_zeros): Remove SHMEDIA implementations. libiberty/ChangeLog: 2017-09-15 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Add 'toplevel' parm. Pass to ... (d_local_name): ... here. Parse trailing function args on nested local_name. (d_encoding, d_special_name, d_class_enum_type): Adjust d_name calls. * testsuite/demangle-expected: Add tests. 2017-09-15 Richard Biener <rguenther@suse.de> PR lto/81968 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Iterate marking dependent sections necessary. 2017-09-15 Nathan Sidwell <nathan@acm.org> * cp-demangle.c (is_fnqual_component_type): Reimplement using FNQUAL_COMPONENT_CASE. (d_encoding): Hold bare_function_type in local var. (d_local_name): Build name in both cases and build result once. Collapse switch-if to single conditional. (d_local_name): * testsuite/demangle-expected: Realign blank lines with tests. 2017-09-12 Jiong Wang <jiong.wang@arm.com> * dwarfnames.c (DW_CFA_DUP): New define. gdb/ChangeLog: 2017-09-15 Pedro Alves <palves@redhat.com> * compile/compile-c-types.c (convert_enum, convert_int) (convert_float): Adjust to refer to int_type_v0 and float_type_v0.
2017-09-15 18:40:33 +02:00
Update the libiberty sources with the latest patches found in the master sources. 2017-01-02 Richard Biener <rguenther@suse.de> PR lto/83452 * simple-object-elf.c (simple_object_elf_copy_lto_debug_section): Do not use UNDEF locals for removed symbols but instead just define them in the first prevailing section and with no name. Use the same gnu_lto_v1 name for all removed globals we promote to WEAK UNDEFs so hpux can use a stub to provide this symbol. Clear sh_info and sh_link in removed sections. 2017-10-30 Richard Biener <rguenther@suse.de> PR lto/82757 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Strip two leading _s from the __gnu_lto_* symbols. 2017-10-24 Alan Modra <amodra@gmail.com> PR lto/82687 PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Only make __gnu_lto symbols hidden. 2017-10-20 Alan Modra <amodra@gmail.com> PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Make discarded non-local symbols weak and hidden. 2017-10-18 Jakub Jelinek <jakub@redhat.com> PR lto/82598 * simple-object.c (handle_lto_debug_sections): Copy over also .note.GNU-stack section with unchanged name. * simple-object-elf.c (SHF_EXECINSTR): Define. (simple_object_elf_copy_lto_debug_section): Drop SHF_EXECINSTR bit on .note.GNU-stack section. 2017-09-25 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_encoding): Strip return type when name is a LOCAL_NAME. (d_local_name): Strip return type of enclosing TYPED_NAME. * testsuite/demangle-expected: Add and adjust tests. 2017-09-21 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Revert addition of 'toplevel' parm. (has_return_type): Recurse for DEMANGLE_COMPONENT_LOCAL_NAME. (d_encoding): Revert d_name change. Use is_fnqual_component_type to strip modifiers that do not belong. (d_special_name, d_class_enum_type): Revert d_name call change. (d_expresion_1): Commonize DEMANGLE_COMPONENT_UNARY building. (d_local_name): Revert parsing of a function type. (d_print_comp_inner): An inner LOCAL_NAME might contain a TEMPLATE. * testsuite/demangle-expected: Add & adjust tests
2018-01-10 14:57:48 +01:00
/* Elide the return type of the containing function so as to not
confuse the user thinking it is the return type of whatever local
function we might be containing. */
if (function->type == DEMANGLE_COMPONENT_TYPED_NAME
&& d_right (function)->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
d_left (d_right (function)) = NULL;
Sync libiberty/ & include/ with GCC Note this brings in the interface files for libcc1/G++ as well, which we will be needing in GDB soon anyway. That commit renamed a method in the C interface and that required a small update to GDB's compile/ code, which I've included that in this patch to keep the tree building. include/ChangeLog: 2017-09-15 Pedro Alves <palves@redhat.com> * ansidecl.h (DISABLE_COPY_AND_ASSIGN): New macro. 2017-09-12 Jiong Wang <jiong.wang@arm.com> * dwarf2.def (DW_CFA_AARCH64_negate_ra_state): New DW_CFA_DUP. * dwarf2.h (DW_CFA_DUP): New define. 2017-08-21 Richard Biener <rguenther@suse.de> * simple-object.h (simple_object_copy_lto_debug_sections): New function. 2017-05-18 Martin Liska <mliska@suse.cz> * ansidecl.h: Define CONSTEXPR macro. 2017-05-24 Nathan Sidwell <nathan@acm.org> * libiberty.h (ASTRDUP): Adjust cast to avoid warning. 2017-01-30 Alexandre Oliva <aoliva@redhat.com> Introduce C++ support in libcc1. * gcc-c-fe.def (int_type_v0): Rename from... (int_type): ... this. Introduce new version. (float_type_v0): Rename from... (float_type): ... this. Introduce new version. (char_type): New. * gcc-c-interface.h (gcc_c_api_version): Add GCC_C_FE_VERSION_1. (gcc_type_array): Move... * gcc-interface.h: ... here. * gcc-cp-fe.def: New. * gcc-cp-interface.h: New. 2016-04-29 Oleg Endo <olegendo@gcc.gnu.org> * longlong.h (umul_ppmm): Remove SHMEDIA checks. (__umulsidi3, count_leading_zeros): Remove SHMEDIA implementations. 2017-09-15 Yao Qi <yao.qi@linaro.org> Pedro Alves <palves@redhat.com> * ansidecl.h (DISABLE_COPY_AND_ASSIGN): New macro. 2017-09-12 Jiong Wang <jiong.wang@arm.com> * dwarf2.def (DW_CFA_AARCH64_negate_ra_state): New DW_CFA_DUP. * dwarf2.h (DW_CFA_DUP): New define. 2017-08-21 Richard Biener <rguenther@suse.de> * simple-object.h (simple_object_copy_lto_debug_sections): New function. 2017-05-18 Martin Liska <mliska@suse.cz> * ansidecl.h: Define CONSTEXPR macro. 2017-05-24 Nathan Sidwell <nathan@acm.org> * libiberty.h (ASTRDUP): Adjust cast to avoid warning. 2017-01-30 Alexandre Oliva <aoliva@redhat.com> Introduce C++ support in libcc1. * gcc-c-fe.def (int_type_v0): Rename from... (int_type): ... this. Introduce new version. (float_type_v0): Rename from... (float_type): ... this. Introduce new version. (char_type): New. * gcc-c-interface.h (gcc_c_api_version): Add GCC_C_FE_VERSION_1. (gcc_type_array): Move... * gcc-interface.h: ... here. * gcc-cp-fe.def: New. * gcc-cp-interface.h: New. 2016-04-29 Oleg Endo <olegendo@gcc.gnu.org> * longlong.h (umul_ppmm): Remove SHMEDIA checks. (__umulsidi3, count_leading_zeros): Remove SHMEDIA implementations. libiberty/ChangeLog: 2017-09-15 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Add 'toplevel' parm. Pass to ... (d_local_name): ... here. Parse trailing function args on nested local_name. (d_encoding, d_special_name, d_class_enum_type): Adjust d_name calls. * testsuite/demangle-expected: Add tests. 2017-09-15 Richard Biener <rguenther@suse.de> PR lto/81968 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Iterate marking dependent sections necessary. 2017-09-15 Nathan Sidwell <nathan@acm.org> * cp-demangle.c (is_fnqual_component_type): Reimplement using FNQUAL_COMPONENT_CASE. (d_encoding): Hold bare_function_type in local var. (d_local_name): Build name in both cases and build result once. Collapse switch-if to single conditional. (d_local_name): * testsuite/demangle-expected: Realign blank lines with tests. 2017-09-12 Jiong Wang <jiong.wang@arm.com> * dwarfnames.c (DW_CFA_DUP): New define. gdb/ChangeLog: 2017-09-15 Pedro Alves <palves@redhat.com> * compile/compile-c-types.c (convert_enum, convert_int) (convert_float): Adjust to refer to int_type_v0 and float_type_v0.
2017-09-15 18:40:33 +02:00
return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, name);
2000-10-12 04:16:48 +02:00
}
/* <discriminator> ::= _ <number> # when number < 10
::= __ <number> _ # when number >= 10
<discriminator> ::= _ <number> # when number >=10
is also accepted to support gcc versions that wrongly mangled that way.
2003-11-21 18:42:45 +01:00
We demangle the discriminator, but we don't print it out. FIXME:
We should print it out in verbose mode. */
2000-10-12 04:16:48 +02:00
2003-11-21 18:42:45 +01:00
static int
2005-03-27 07:28:42 +02:00
d_discriminator (struct d_info *di)
2003-11-21 18:42:45 +01:00
{
int discrim, num_underscores = 1;
2000-10-12 04:16:48 +02:00
2003-11-21 18:42:45 +01:00
if (d_peek_char (di) != '_')
return 1;
d_advance (di, 1);
if (d_peek_char (di) == '_')
{
++num_underscores;
d_advance (di, 1);
}
2003-11-21 18:42:45 +01:00
discrim = d_number (di);
if (discrim < 0)
return 0;
if (num_underscores > 1 && discrim >= 10)
{
if (d_peek_char (di) == '_')
d_advance (di, 1);
else
return 0;
}
2003-11-21 18:42:45 +01:00
return 1;
}
2009-10-02 20:23:01 +02:00
/* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _ */
static struct demangle_component *
d_lambda (struct d_info *di)
{
struct demangle_component *tl;
struct demangle_component *ret;
int num;
if (! d_check_char (di, 'U'))
return NULL;
if (! d_check_char (di, 'l'))
return NULL;
tl = d_parmlist (di);
if (tl == NULL)
return NULL;
if (! d_check_char (di, 'E'))
return NULL;
num = d_compact_number (di);
if (num < 0)
return NULL;
ret = d_make_empty (di);
if (ret)
{
ret->type = DEMANGLE_COMPONENT_LAMBDA;
ret->u.s_unary_num.sub = tl;
ret->u.s_unary_num.num = num;
}
if (! d_add_substitution (di, ret))
return NULL;
return ret;
}
/* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
static struct demangle_component *
d_unnamed_type (struct d_info *di)
{
struct demangle_component *ret;
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
int num;
2009-10-02 20:23:01 +02:00
if (! d_check_char (di, 'U'))
return NULL;
if (! d_check_char (di, 't'))
return NULL;
num = d_compact_number (di);
if (num < 0)
return NULL;
ret = d_make_empty (di);
if (ret)
{
ret->type = DEMANGLE_COMPONENT_UNNAMED_TYPE;
ret->u.s_number.number = num;
}
if (! d_add_substitution (di, ret))
return NULL;
return ret;
}
2011-09-24 00:21:36 +02:00
/* <clone-suffix> ::= [ . <clone-type-identifier> ] [ . <nonnegative number> ]*
*/
static struct demangle_component *
d_clone_suffix (struct d_info *di, struct demangle_component *encoding)
{
const char *suffix = d_str (di);
const char *pend = suffix;
struct demangle_component *n;
if (*pend == '.' && (IS_LOWER (pend[1]) || pend[1] == '_'))
{
pend += 2;
while (IS_LOWER (*pend) || *pend == '_')
++pend;
}
while (*pend == '.' && IS_DIGIT (pend[1]))
{
pend += 2;
while (IS_DIGIT (*pend))
++pend;
}
d_advance (di, pend - suffix);
n = d_make_name (di, suffix, pend - suffix);
return d_make_comp (di, DEMANGLE_COMPONENT_CLONE, encoding, n);
}
2003-11-21 18:42:45 +01:00
/* Add a new substitution. */
2003-11-21 18:42:45 +01:00
static int
2005-03-27 07:28:42 +02:00
d_add_substitution (struct d_info *di, struct demangle_component *dc)
{
2003-11-27 02:17:34 +01:00
if (dc == NULL)
return 0;
2003-11-21 18:42:45 +01:00
if (di->next_sub >= di->num_subs)
return 0;
di->subs[di->next_sub] = dc;
++di->next_sub;
return 1;
}
/* <substitution> ::= S <seq-id> _
::= S_
::= St
::= Sa
::= Sb
::= Ss
::= Si
::= So
::= Sd
2003-12-15 18:45:42 +01:00
If PREFIX is non-zero, then this type is being used as a prefix in
a qualified name. In this case, for the standard substitutions, we
need to check whether we are being used as a prefix for a
constructor or destructor, and return a full template name.
Otherwise we will get something like std::iostream::~iostream()
which does not correspond particularly well to any function which
actually appears in the source.
2003-11-21 18:42:45 +01:00
*/
2003-12-15 18:45:42 +01:00
static const struct d_standard_sub_info standard_subs[] =
{
2003-12-22 17:03:32 +01:00
{ 't', NL ("std"),
NL ("std"),
NULL, 0 },
{ 'a', NL ("std::allocator"),
NL ("std::allocator"),
NL ("allocator") },
{ 'b', NL ("std::basic_string"),
NL ("std::basic_string"),
NL ("basic_string") },
{ 's', NL ("std::string"),
NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
NL ("basic_string") },
{ 'i', NL ("std::istream"),
NL ("std::basic_istream<char, std::char_traits<char> >"),
NL ("basic_istream") },
{ 'o', NL ("std::ostream"),
NL ("std::basic_ostream<char, std::char_traits<char> >"),
NL ("basic_ostream") },
{ 'd', NL ("std::iostream"),
NL ("std::basic_iostream<char, std::char_traits<char> >"),
NL ("basic_iostream") }
2003-12-15 18:45:42 +01:00
};
2004-01-12 22:24:38 +01:00
static struct demangle_component *
2005-03-27 07:28:42 +02:00
d_substitution (struct d_info *di, int prefix)
2003-11-21 18:42:45 +01:00
{
char c;
if (! d_check_char (di, 'S'))
2003-11-21 18:42:45 +01:00
return NULL;
2001-08-09 02:05:37 +02:00
2003-11-21 18:42:45 +01:00
c = d_next_char (di);
2003-12-04 21:03:39 +01:00
if (c == '_' || IS_DIGIT (c) || IS_UPPER (c))
{
2008-03-31 20:11:50 +02:00
unsigned int id;
2003-11-21 18:42:45 +01:00
id = 0;
if (c != '_')
{
2003-11-21 18:42:45 +01:00
do
{
2008-03-31 20:11:50 +02:00
unsigned int new_id;
2003-11-21 18:42:45 +01:00
if (IS_DIGIT (c))
2008-03-31 20:11:50 +02:00
new_id = id * 36 + c - '0';
2003-12-04 21:03:39 +01:00
else if (IS_UPPER (c))
2008-03-31 20:11:50 +02:00
new_id = id * 36 + c - 'A' + 10;
2003-11-21 18:42:45 +01:00
else
return NULL;
2008-03-31 20:11:50 +02:00
if (new_id < id)
2006-09-22 21:19:32 +02:00
return NULL;
2008-03-31 20:11:50 +02:00
id = new_id;
2003-11-21 18:42:45 +01:00
c = d_next_char (di);
}
2003-11-21 18:42:45 +01:00
while (c != '_');
2003-11-21 18:42:45 +01:00
++id;
}
2008-03-31 20:11:50 +02:00
if (id >= (unsigned int) di->next_sub)
2003-11-21 18:42:45 +01:00
return NULL;
2003-11-21 18:42:45 +01:00
return di->subs[id];
}
2003-11-21 18:42:45 +01:00
else
{
2003-12-15 18:45:42 +01:00
int verbose;
const struct d_standard_sub_info *p;
const struct d_standard_sub_info *pend;
verbose = (di->options & DMGL_VERBOSE) != 0;
if (! verbose && prefix)
{
2003-12-15 18:45:42 +01:00
char peek;
peek = d_peek_char (di);
if (peek == 'C' || peek == 'D')
verbose = 1;
}
2003-12-15 18:45:42 +01:00
pend = (&standard_subs[0]
+ sizeof standard_subs / sizeof standard_subs[0]);
for (p = &standard_subs[0]; p < pend; ++p)
{
if (c == p->code)
{
2003-12-22 17:03:32 +01:00
const char *s;
int len;
struct demangle_component *dc;
2003-12-22 17:03:32 +01:00
2003-12-15 18:45:42 +01:00
if (p->set_last_name != NULL)
2003-12-22 17:03:32 +01:00
di->last_name = d_make_sub (di, p->set_last_name,
p->set_last_name_len);
2003-12-15 18:45:42 +01:00
if (verbose)
2003-12-22 17:03:32 +01:00
{
s = p->full_expansion;
len = p->full_len;
}
2003-12-15 18:45:42 +01:00
else
2003-12-22 17:03:32 +01:00
{
s = p->simple_expansion;
len = p->simple_len;
}
di->expansion += len;
dc = d_make_sub (di, s, len);
Sync libiberty with upstream GCC. include/ChangeLog * libiberty.h (PEX_STDOUT_APPEND): New flag. (PEX_STDERR_APPEND): Likewise. * demangle.h (DMGL_DLANG): New macro. (DMGL_STYLE_MASK): Add DMGL_DLANG. (demangling_styles): Add dlang_demangling. (DLANG_DEMANGLING_STYLE_STRING): New macro. (DLANG_DEMANGLING): New macro. (dlang_demangle): New prototype. * longlong.h: Add __udiv_w_sdiv prototype. libiberty/ChangeLog * cp-demangle.c (d_substitution): Handle abi tags on abbreviation. * pex-common.h (struct pex_funcs): Add new parameter for open_write field. * pex-unix.c (pex_unix_open_write): Add support for new parameter. * pex-djgpp.c (pex_djgpp_open_write): Likewise. * pex-win32.c (pex_win32_open_write): Likewise. * pex-common.c (pex_run_in_environment): Likewise. * Makefile.in (CFILES): Add d-demangle.c. (REQUIRED_OFILES): Add d-demangle.o. * cplus-dem.c (libiberty_demanglers): Add dlang_demangling case. (cplus_demangle): Likewise. * d-demangle.c: New file. * testsuite/Makefile.in (really-check): Add check-d-demangle. * testsuite/d-demangle-expected: New file. * simple-object-elf.c (simple_object_elf_write_ehdr): Correctly handle objects with more than SHN_LORESERVE sections. (simple_object_elf_write_shdr): Add sh_link parameter. (simple_object_elf_write_to_file): Correctly handle objects with more than SHN_LORESERVE sections. * cp-demangle.c (d_dump): Only access field from s_fixed part of the union for DEMANGLE_COMPONENT_FIXED_TYPE. (d_count_templates_scopes): Likewise. * testsuite/demangler-fuzzer.c: New file. * testsuite/Makefile.in (fuzz-demangler): New rule. (demangler-fuzzer): Likewise. (mostlyclean): Clean up demangler fuzzer.
2014-10-11 11:29:10 +02:00
if (d_peek_char (di) == 'B')
{
/* If there are ABI tags on the abbreviation, it becomes
a substitution candidate. */
dc = d_abi_tags (di, dc);
if (! d_add_substitution (di, dc))
return NULL;
Sync libiberty with upstream GCC. include/ChangeLog * libiberty.h (PEX_STDOUT_APPEND): New flag. (PEX_STDERR_APPEND): Likewise. * demangle.h (DMGL_DLANG): New macro. (DMGL_STYLE_MASK): Add DMGL_DLANG. (demangling_styles): Add dlang_demangling. (DLANG_DEMANGLING_STYLE_STRING): New macro. (DLANG_DEMANGLING): New macro. (dlang_demangle): New prototype. * longlong.h: Add __udiv_w_sdiv prototype. libiberty/ChangeLog * cp-demangle.c (d_substitution): Handle abi tags on abbreviation. * pex-common.h (struct pex_funcs): Add new parameter for open_write field. * pex-unix.c (pex_unix_open_write): Add support for new parameter. * pex-djgpp.c (pex_djgpp_open_write): Likewise. * pex-win32.c (pex_win32_open_write): Likewise. * pex-common.c (pex_run_in_environment): Likewise. * Makefile.in (CFILES): Add d-demangle.c. (REQUIRED_OFILES): Add d-demangle.o. * cplus-dem.c (libiberty_demanglers): Add dlang_demangling case. (cplus_demangle): Likewise. * d-demangle.c: New file. * testsuite/Makefile.in (really-check): Add check-d-demangle. * testsuite/d-demangle-expected: New file. * simple-object-elf.c (simple_object_elf_write_ehdr): Correctly handle objects with more than SHN_LORESERVE sections. (simple_object_elf_write_shdr): Add sh_link parameter. (simple_object_elf_write_to_file): Correctly handle objects with more than SHN_LORESERVE sections. * cp-demangle.c (d_dump): Only access field from s_fixed part of the union for DEMANGLE_COMPONENT_FIXED_TYPE. (d_count_templates_scopes): Likewise. * testsuite/demangler-fuzzer.c: New file. * testsuite/Makefile.in (fuzz-demangler): New rule. (demangler-fuzzer): Likewise. (mostlyclean): Clean up demangler fuzzer.
2014-10-11 11:29:10 +02:00
}
return dc;
2003-12-15 18:45:42 +01:00
}
}
return NULL;
}
}
static void
d_checkpoint (struct d_info *di, struct d_info_checkpoint *checkpoint)
{
checkpoint->n = di->n;
checkpoint->next_comp = di->next_comp;
checkpoint->next_sub = di->next_sub;
checkpoint->expansion = di->expansion;
}
static void
d_backtrack (struct d_info *di, struct d_info_checkpoint *checkpoint)
{
di->n = checkpoint->n;
di->next_comp = checkpoint->next_comp;
di->next_sub = checkpoint->next_sub;
di->expansion = checkpoint->expansion;
}
2007-01-31 00:16:58 +01:00
/* Initialize a growable string. */
2003-11-21 18:42:45 +01:00
static void
2007-01-31 00:16:58 +01:00
d_growable_string_init (struct d_growable_string *dgs, size_t estimate)
2003-11-21 18:42:45 +01:00
{
2007-01-31 00:16:58 +01:00
dgs->buf = NULL;
dgs->len = 0;
dgs->alc = 0;
dgs->allocation_failure = 0;
2007-01-31 00:16:58 +01:00
if (estimate > 0)
d_growable_string_resize (dgs, estimate);
}
/* Grow a growable string to a given size. */
static inline void
d_growable_string_resize (struct d_growable_string *dgs, size_t need)
{
size_t newalc;
char *newbuf;
if (dgs->allocation_failure)
2003-11-27 02:17:34 +01:00
return;
2007-01-31 00:16:58 +01:00
/* Start allocation at two bytes to avoid any possibility of confusion
with the special value of 1 used as a return in *palc to indicate
allocation failures. */
newalc = dgs->alc > 0 ? dgs->alc : 2;
while (newalc < need)
newalc <<= 1;
newbuf = (char *) realloc (dgs->buf, newalc);
if (newbuf == NULL)
{
free (dgs->buf);
dgs->buf = NULL;
dgs->len = 0;
dgs->alc = 0;
dgs->allocation_failure = 1;
return;
}
2007-01-31 00:16:58 +01:00
dgs->buf = newbuf;
dgs->alc = newalc;
2003-11-21 18:42:45 +01:00
}
2003-11-19 17:19:14 +01:00
2007-01-31 00:16:58 +01:00
/* Append a buffer to a growable string. */
2003-11-19 17:19:14 +01:00
2007-01-31 00:16:58 +01:00
static inline void
d_growable_string_append_buffer (struct d_growable_string *dgs,
const char *s, size_t l)
2003-11-21 18:42:45 +01:00
{
2007-01-31 00:16:58 +01:00
size_t need;
2003-11-19 17:19:14 +01:00
2007-01-31 00:16:58 +01:00
need = dgs->len + l + 1;
if (need > dgs->alc)
d_growable_string_resize (dgs, need);
if (dgs->allocation_failure)
return;
memcpy (dgs->buf + dgs->len, s, l);
dgs->buf[dgs->len + l] = '\0';
dgs->len += l;
}
2007-01-31 00:16:58 +01:00
/* Bridge growable strings to the callback mechanism. */
2003-11-21 18:42:45 +01:00
static void
2007-01-31 00:16:58 +01:00
d_growable_string_callback_adapter (const char *s, size_t l, void *opaque)
{
2007-01-31 00:16:58 +01:00
struct d_growable_string *dgs = (struct d_growable_string*) opaque;
2007-01-31 00:16:58 +01:00
d_growable_string_append_buffer (dgs, s, l);
}
/* Walk the tree, counting the number of templates encountered, and
the number of times a scope might be saved. These counts will be
used to allocate data structures for d_print_comp, so the logic
here must mirror the logic d_print_comp will use. It is not
important that the resulting numbers are exact, so long as they
are larger than the actual numbers encountered. */
static void
d_count_templates_scopes (struct d_print_info *dpi,
const struct demangle_component *dc)
{
if (dc == NULL)
return;
switch (dc->type)
{
case DEMANGLE_COMPONENT_NAME:
case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
case DEMANGLE_COMPONENT_FUNCTION_PARAM:
case DEMANGLE_COMPONENT_SUB_STD:
case DEMANGLE_COMPONENT_BUILTIN_TYPE:
case DEMANGLE_COMPONENT_OPERATOR:
case DEMANGLE_COMPONENT_CHARACTER:
case DEMANGLE_COMPONENT_NUMBER:
case DEMANGLE_COMPONENT_UNNAMED_TYPE:
break;
case DEMANGLE_COMPONENT_TEMPLATE:
dpi->num_copy_templates++;
goto recurse_left_right;
case DEMANGLE_COMPONENT_REFERENCE:
case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
if (d_left (dc)->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM)
dpi->num_saved_scopes++;
goto recurse_left_right;
case DEMANGLE_COMPONENT_QUAL_NAME:
case DEMANGLE_COMPONENT_LOCAL_NAME:
case DEMANGLE_COMPONENT_TYPED_NAME:
case DEMANGLE_COMPONENT_VTABLE:
case DEMANGLE_COMPONENT_VTT:
case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
case DEMANGLE_COMPONENT_TYPEINFO:
case DEMANGLE_COMPONENT_TYPEINFO_NAME:
case DEMANGLE_COMPONENT_TYPEINFO_FN:
case DEMANGLE_COMPONENT_THUNK:
case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
case DEMANGLE_COMPONENT_COVARIANT_THUNK:
case DEMANGLE_COMPONENT_JAVA_CLASS:
case DEMANGLE_COMPONENT_GUARD:
case DEMANGLE_COMPONENT_TLS_INIT:
case DEMANGLE_COMPONENT_TLS_WRAPPER:
case DEMANGLE_COMPONENT_REFTEMP:
case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
case DEMANGLE_COMPONENT_RESTRICT:
case DEMANGLE_COMPONENT_VOLATILE:
case DEMANGLE_COMPONENT_CONST:
case DEMANGLE_COMPONENT_RESTRICT_THIS:
case DEMANGLE_COMPONENT_VOLATILE_THIS:
case DEMANGLE_COMPONENT_CONST_THIS:
case DEMANGLE_COMPONENT_REFERENCE_THIS:
case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
Implement N4514, C++ Extensions for Transactional Memory. gcc/ * builtins.def (BUILT_IN_ABORT): Add transaction_pure attribute. gcc/c-family/ * c-common.c (c_common_reswords): Add C++ TM TS keywords. (c_common_attribute_table): Add transaction_safe_dynamic. transaction_safe now affects type identity. (handle_tm_attribute): Handle transaction_safe_dynamic. * c-common.h (enum rid): Add RID_ATOMIC_NOEXCEPT, RID_ATOMIC_CANCEL, RID_SYNCHRONIZED. (OBJC_IS_CXX_KEYWORD): Add RID_SYNCHRONIZED. (D_TRANSMEM): New. * c-cppbuiltin.c (c_cpp_builtins): Define __cpp_transactional_memory. * c-pretty-print.c (pp_c_attributes_display): Don't print transaction_safe in C++. gcc/c/ * c-parser.c (c_lex_one_token): Handle @synchronized. * c-decl.c (match_builtin_function_types): A declaration of a built-in can change whether the function is transaction_safe. gcc/cp/ * cp-tree.h (struct cp_declarator): Add tx_qualifier field. (BCS_NORMAL, BCS_TRANSACTION): New enumerators. * lex.c (init_reswords): Limit TM kewords to -fgnu-tm. * parser.c (cp_lexer_get_preprocessor_token): Fix @synchronized. (make_call_declarator): Take tx_qualifier. (cp_parser_tx_qualifier_opt): New. (cp_parser_lambda_declarator_opt): Use it. (cp_parser_direct_declarator): Likewise. (cp_parser_statement): Handle atomic_noexcept, atomic_cancel. (cp_parser_compound_statement): Change in_try parameter to bcs_flags. (cp_parser_std_attribute): Map optimize_for_synchronized to transaction_callable. (cp_parser_transaction): Take the token. Handle atomic_noexcept. * lambda.c (maybe_add_lambda_conv_op): Handle transaction-safety. * call.c (enum conversion_kind): Add ck_tsafe. (standard_conversion): Handle transaction-safety conversion. (convert_like_real, resolve_address_of_overloaded_function): Likewise. (check_methods): Diagnose transaction_safe_dynamic on non-virtual function. (look_for_tm_attr_overrides): Don't inherit transaction_safe_dynamic. * cvt.c (tx_safe_fn_type_p, tx_unsafe_fn_variant) (can_convert_tx_safety): New. * typeck.c (composite_pointer_type): Handle transaction-safety. * name-lookup.h (enum scope_kind): Add sk_transaction. * name-lookup.c (begin_scope): Handle it. * semantics.c (begin_compound_stmt): Pass it. * decl.c (check_previous_goto_1): Check it. (struct named_label_entry): Add in_transaction_scope. (poplevel_named_label_1): Set it. (check_goto): Check it. (duplicate_decls): A specialization can be transaction_safe independently of its template. (grokdeclarator): Handle tx-qualifier. * rtti.c (ptr_initializer): Handle transaction-safe. * search.c (check_final_overrider): Check transaction_safe_dynamic. Don't check transaction_safe. * mangle.c (write_function_type): Mangle transaction_safe here. (write_CV_qualifiers_for_type): Not here. (write_type): Preserve transaction_safe when stripping attributes. * error.c (dump_type_suffix): Print transaction_safe. libiberty/ * cp-demangle.c (d_cv_qualifiers): Dx means transaction_safe. (cplus_demangle_type): Let d_cv_qualifiers handle it. (d_dump, d_make_comp, has_return_type, d_encoding) (d_count_templates_scopes, d_print_comp_inner) (d_print_mod_list, d_print_mod, d_print_function_type) (is_ctor_or_dtor): Handle DEMANGLE_COMPONENT_TRANSACTION_SAFE. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@228462 138bc75d-0d04-0410-961f-82ee72b054a4
2015-11-28 17:39:30 +01:00
case DEMANGLE_COMPONENT_TRANSACTION_SAFE:
case DEMANGLE_COMPONENT_NOEXCEPT:
case DEMANGLE_COMPONENT_THROW_SPEC:
case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
case DEMANGLE_COMPONENT_POINTER:
case DEMANGLE_COMPONENT_COMPLEX:
case DEMANGLE_COMPONENT_IMAGINARY:
case DEMANGLE_COMPONENT_VENDOR_TYPE:
case DEMANGLE_COMPONENT_FUNCTION_TYPE:
case DEMANGLE_COMPONENT_ARRAY_TYPE:
case DEMANGLE_COMPONENT_PTRMEM_TYPE:
case DEMANGLE_COMPONENT_VECTOR_TYPE:
case DEMANGLE_COMPONENT_ARGLIST:
case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
Synchronize libiberty with gcc and add --no-recruse-limit option to tools that support name demangling. This patch addresses the multitude of bug reports about resource exhaustion in libiberty's name demangling code. It adds a limit to the amount of recursion that is allowed, before an error is triggered. It also adds a new demangling option to disable this limit. (The limit is enabled by default). PR 87681 PR 87675 PR 87636 PR 87335 libiberty * cp-demangle.h (struct d_info): Add recursion_limit field. * cp-demangle.c (d_function_type): If the recursion limit is enabled and reached, return with a failure result. (d_demangle_callback): If the recursion limit is enabled, check for a mangled string that is so long that there is not enough stack space for the local arrays. * cplus-dem.c (struct work): Add recursion_level field. (demangle_nested_args): If the recursion limit is enabled and reached, return with a failure result. include * demangle.h (DMGL_RECURSE_LIMIT): Define. (DEMANGLE_RECURSION_LIMIT): Prototype. binutuils * addr2line.c (demangle_flags): New static variable. (long_options): Add --recurse-limit and --no-recurse-limit. (translate_address): Pass demangle_flags to bfd_demangle. (main): Handle --recurse-limit and --no-recurse-limit options. * cxxfilt.c (flags): Add DMGL_RECURSE_LIMIT. (long_options): Add --recurse-limit and --no-recurse-limit. (main): Handle new options. * dlltool.c (gen_def_file): Include DMGL_RECURSE_LIMIT in flags passed to cplus_demangle. * nm.c (demangle_flags): New static variable. (long_options): Add --recurse-limit and --no-recurse-limit. (main): Handle new options. * objdump.c (demangle_flags): New static variable. (usage): Add --recurse-limit and --no-recurse-limit. (long_options): Likewise. (objdump_print_symname): Pass demangle_flags to bfd_demangle. (disassemble_section): Likewise. (dump_dymbols): Likewise. (main): Handle new options. * prdbg.c (demangle_flags): New static variable. (tg_variable): Pass demangle_flags to demangler. (tg_start_function): Likewise. * stabs.c (demangle_flags): New static variable. (stab_demangle_template): Pass demangle_flags to demangler. (stab_demangle_v3_argtypes): Likewise. (stab_demangle_v3_arg): Likewise. * doc/binutuls.texi: Document new command line options. * NEWS: Mention the new feature. * testsuite/config/default.exp (CXXFILT): Define if not already defined. (CXXFILTFLAGS): Likewise. * testsuite/binutils-all/cxxfilt.exp: New file. Runs a few simple tests of the cxxfilt program.
2018-12-07 12:32:55 +01:00
case DEMANGLE_COMPONENT_TPARM_OBJ:
case DEMANGLE_COMPONENT_INITIALIZER_LIST:
case DEMANGLE_COMPONENT_CAST:
PR other/61321 - demangler crash on casts in template parameters The fix for bug 59195: [C++ demangler handles conversion operator incorrectly] https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59195 unfortunately makes the demangler crash due to infinite recursion, in case of casts in template parameters. For example, with: template<int> struct A {}; template <typename Y> void function_temp(A<sizeof ((Y)(999))>) {} template void function_temp<int>(A<sizeof (int)>); The 'function_temp<int>' instantiation above mangles to: _Z13function_tempIiEv1AIXszcvT_Li999EEE The demangler parses this as: typed name template name 'function_temp' template argument list builtin type int function type builtin type void argument list template (*) name 'A' template argument list unary operator operator sizeof unary operator cast template parameter 0 (**) literal builtin type int name '999' And after the fix for 59195, due to: static void d_print_cast (struct d_print_info *dpi, int options, const struct demangle_component *dc) { ... /* For a cast operator, we need the template parameters from the enclosing template in scope for processing the type. */ if (dpi->current_template != NULL) { dpt.next = dpi->templates; dpi->templates = &dpt; dpt.template_decl = dpi->current_template; } when printing the template argument list of A (what should be "<sizeof (int)>"), the template parameter 0 (that is, "T_", the '**' above) now refers to the first parameter of the the template argument list of the 'A' template (the '*' above), exactly what we were already trying to print. This leads to infinite recursion, and stack exaustion. The template parameter 0 should actually refer to the first parameter of the 'function_temp' template. Where it reads "for the cast operator" in the comment in d_print_cast (above), it's really talking about a conversion operator, like: struct A { template <typename U> explicit operator U(); }; We don't want to inject the template parameters from the enclosing template in scope when processing a cast _expression_, only when handling a conversion operator. The problem is that DEMANGLE_COMPONENT_CAST is currently ambiguous, and means _both_ 'conversion operator' and 'cast expression'. Fix this by adding a new DEMANGLE_COMPONENT_CONVERSION component type, which does what DEMANGLE_COMPONENT_CAST does today, and making DEMANGLE_COMPONENT_CAST just simply print its component subtree. I think we could instead reuse DEMANGLE_COMPONENT_CAST and in d_print_comp_inner still do: @@ -5001,9 +5013,9 @@ d_print_comp_inner (struct d_print_info *dpi, int options, d_print_comp (dpi, options, dc->u.s_extended_operator.name); return; case DEMANGLE_COMPONENT_CAST: d_append_string (dpi, "operator "); - d_print_cast (dpi, options, dc); + d_print_conversion (dpi, options, dc); return; leaving the unary cast case below calling d_print_cast, but seems to me that spliting the component types makes it easier to reason about the code. g++'s testsuite actually generates three symbols that crash the demangler in the same way. I've added those as tests in the demangler testsuite as well. And then this fixes PR other/61233 too, which happens to be a demangler crash originally reported to GDB, at: https://sourceware.org/bugzilla/show_bug.cgi?id=16957 Bootstrapped and regtested on x86_64 Fedora 20. Also ran this through GDB's testsuite. GDB will require a small update to use DEMANGLE_COMPONENT_CONVERSION in one place it's using DEMANGLE_COMPONENT_CAST in its sources. libiberty/ 2015-11-27 Pedro Alves <palves@redhat.com> PR other/61321 PR other/61233 * demangle.h (enum demangle_component_type) <DEMANGLE_COMPONENT_CONVERSION>: New value. * cp-demangle.c (d_demangle_callback, d_make_comp): Handle DEMANGLE_COMPONENT_CONVERSION. (is_ctor_dtor_or_conversion): Handle DEMANGLE_COMPONENT_CONVERSION instead of DEMANGLE_COMPONENT_CAST. (d_operator_name): Return a DEMANGLE_COMPONENT_CONVERSION component if handling a conversion. (d_count_templates_scopes, d_print_comp_inner): Handle DEMANGLE_COMPONENT_CONVERSION. (d_print_comp_inner): Handle DEMANGLE_COMPONENT_CONVERSION instead of DEMANGLE_COMPONENT_CAST. (d_print_cast): Rename as ... (d_print_conversion): ... this. Adjust comments. (d_print_cast): Rewrite - simply print the left subcomponent. * cp-demint.c (cplus_demangle_fill_component): Handle DEMANGLE_COMPONENT_CONVERSION. * testsuite/demangle-expected: Add tests. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@231020 138bc75d-0d04-0410-961f-82ee72b054a4
2015-11-28 17:39:31 +01:00
case DEMANGLE_COMPONENT_CONVERSION:
case DEMANGLE_COMPONENT_NULLARY:
case DEMANGLE_COMPONENT_UNARY:
case DEMANGLE_COMPONENT_BINARY:
case DEMANGLE_COMPONENT_BINARY_ARGS:
case DEMANGLE_COMPONENT_TRINARY:
case DEMANGLE_COMPONENT_TRINARY_ARG1:
case DEMANGLE_COMPONENT_TRINARY_ARG2:
case DEMANGLE_COMPONENT_LITERAL:
case DEMANGLE_COMPONENT_LITERAL_NEG:
case DEMANGLE_COMPONENT_JAVA_RESOURCE:
case DEMANGLE_COMPONENT_COMPOUND_NAME:
case DEMANGLE_COMPONENT_DECLTYPE:
case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
case DEMANGLE_COMPONENT_PACK_EXPANSION:
case DEMANGLE_COMPONENT_TAGGED_NAME:
case DEMANGLE_COMPONENT_CLONE:
recurse_left_right:
/* PR 89394 - Check for too much recursion. */
if (dpi->recursion > DEMANGLE_RECURSION_LIMIT)
/* FIXME: There ought to be a way to report to the
user that the recursion limit has been reached. */
return;
++ dpi->recursion;
d_count_templates_scopes (dpi, d_left (dc));
d_count_templates_scopes (dpi, d_right (dc));
-- dpi->recursion;
break;
case DEMANGLE_COMPONENT_CTOR:
d_count_templates_scopes (dpi, dc->u.s_ctor.name);
break;
case DEMANGLE_COMPONENT_DTOR:
d_count_templates_scopes (dpi, dc->u.s_dtor.name);
break;
case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
d_count_templates_scopes (dpi, dc->u.s_extended_operator.name);
break;
Sync libiberty with upstream GCC. include/ChangeLog * libiberty.h (PEX_STDOUT_APPEND): New flag. (PEX_STDERR_APPEND): Likewise. * demangle.h (DMGL_DLANG): New macro. (DMGL_STYLE_MASK): Add DMGL_DLANG. (demangling_styles): Add dlang_demangling. (DLANG_DEMANGLING_STYLE_STRING): New macro. (DLANG_DEMANGLING): New macro. (dlang_demangle): New prototype. * longlong.h: Add __udiv_w_sdiv prototype. libiberty/ChangeLog * cp-demangle.c (d_substitution): Handle abi tags on abbreviation. * pex-common.h (struct pex_funcs): Add new parameter for open_write field. * pex-unix.c (pex_unix_open_write): Add support for new parameter. * pex-djgpp.c (pex_djgpp_open_write): Likewise. * pex-win32.c (pex_win32_open_write): Likewise. * pex-common.c (pex_run_in_environment): Likewise. * Makefile.in (CFILES): Add d-demangle.c. (REQUIRED_OFILES): Add d-demangle.o. * cplus-dem.c (libiberty_demanglers): Add dlang_demangling case. (cplus_demangle): Likewise. * d-demangle.c: New file. * testsuite/Makefile.in (really-check): Add check-d-demangle. * testsuite/d-demangle-expected: New file. * simple-object-elf.c (simple_object_elf_write_ehdr): Correctly handle objects with more than SHN_LORESERVE sections. (simple_object_elf_write_shdr): Add sh_link parameter. (simple_object_elf_write_to_file): Correctly handle objects with more than SHN_LORESERVE sections. * cp-demangle.c (d_dump): Only access field from s_fixed part of the union for DEMANGLE_COMPONENT_FIXED_TYPE. (d_count_templates_scopes): Likewise. * testsuite/demangler-fuzzer.c: New file. * testsuite/Makefile.in (fuzz-demangler): New rule. (demangler-fuzzer): Likewise. (mostlyclean): Clean up demangler fuzzer.
2014-10-11 11:29:10 +02:00
case DEMANGLE_COMPONENT_FIXED_TYPE:
d_count_templates_scopes (dpi, dc->u.s_fixed.length);
Sync libiberty with upstream GCC. include/ChangeLog * libiberty.h (PEX_STDOUT_APPEND): New flag. (PEX_STDERR_APPEND): Likewise. * demangle.h (DMGL_DLANG): New macro. (DMGL_STYLE_MASK): Add DMGL_DLANG. (demangling_styles): Add dlang_demangling. (DLANG_DEMANGLING_STYLE_STRING): New macro. (DLANG_DEMANGLING): New macro. (dlang_demangle): New prototype. * longlong.h: Add __udiv_w_sdiv prototype. libiberty/ChangeLog * cp-demangle.c (d_substitution): Handle abi tags on abbreviation. * pex-common.h (struct pex_funcs): Add new parameter for open_write field. * pex-unix.c (pex_unix_open_write): Add support for new parameter. * pex-djgpp.c (pex_djgpp_open_write): Likewise. * pex-win32.c (pex_win32_open_write): Likewise. * pex-common.c (pex_run_in_environment): Likewise. * Makefile.in (CFILES): Add d-demangle.c. (REQUIRED_OFILES): Add d-demangle.o. * cplus-dem.c (libiberty_demanglers): Add dlang_demangling case. (cplus_demangle): Likewise. * d-demangle.c: New file. * testsuite/Makefile.in (really-check): Add check-d-demangle. * testsuite/d-demangle-expected: New file. * simple-object-elf.c (simple_object_elf_write_ehdr): Correctly handle objects with more than SHN_LORESERVE sections. (simple_object_elf_write_shdr): Add sh_link parameter. (simple_object_elf_write_to_file): Correctly handle objects with more than SHN_LORESERVE sections. * cp-demangle.c (d_dump): Only access field from s_fixed part of the union for DEMANGLE_COMPONENT_FIXED_TYPE. (d_count_templates_scopes): Likewise. * testsuite/demangler-fuzzer.c: New file. * testsuite/Makefile.in (fuzz-demangler): New rule. (demangler-fuzzer): Likewise. (mostlyclean): Clean up demangler fuzzer.
2014-10-11 11:29:10 +02:00
break;
case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
d_count_templates_scopes (dpi, d_left (dc));
break;
case DEMANGLE_COMPONENT_LAMBDA:
case DEMANGLE_COMPONENT_DEFAULT_ARG:
d_count_templates_scopes (dpi, dc->u.s_unary_num.sub);
break;
}
}
2007-01-31 00:16:58 +01:00
/* Initialize a print information structure. */
2003-11-21 18:42:45 +01:00
static void
2011-06-14 01:01:48 +02:00
d_print_init (struct d_print_info *dpi, demangle_callbackref callback,
void *opaque, const struct demangle_component *dc)
2007-01-31 00:16:58 +01:00
{
dpi->len = 0;
dpi->last_char = '\0';
dpi->templates = NULL;
dpi->modifiers = NULL;
2011-07-26 18:04:38 +02:00
dpi->pack_index = 0;
dpi->flush_count = 0;
2007-01-31 00:16:58 +01:00
dpi->callback = callback;
dpi->opaque = opaque;
dpi->demangle_failure = 0;
dpi->recursion = 0;
dpi->is_lambda_arg = 0;
dpi->component_stack = NULL;
dpi->saved_scopes = NULL;
dpi->next_saved_scope = 0;
dpi->num_saved_scopes = 0;
dpi->copy_templates = NULL;
dpi->next_copy_template = 0;
dpi->num_copy_templates = 0;
d_count_templates_scopes (dpi, dc);
/* If we did not reach the recursion limit, then reset the
current recursion value back to 0, so that we can print
the templates. */
if (dpi->recursion < DEMANGLE_RECURSION_LIMIT)
dpi->recursion = 0;
dpi->num_copy_templates *= dpi->num_saved_scopes;
dpi->current_template = NULL;
2007-01-31 00:16:58 +01:00
}
/* Indicate that an error occurred during printing, and test for error. */
static inline void
2005-03-27 07:28:42 +02:00
d_print_error (struct d_print_info *dpi)
2001-02-02 19:58:51 +01:00
{
2007-01-31 00:16:58 +01:00
dpi->demangle_failure = 1;
}
static inline int
d_print_saw_error (struct d_print_info *dpi)
{
return dpi->demangle_failure != 0;
}
/* Flush buffered characters to the callback. */
static inline void
d_print_flush (struct d_print_info *dpi)
{
dpi->buf[dpi->len] = '\0';
dpi->callback (dpi->buf, dpi->len, dpi->opaque);
dpi->len = 0;
dpi->flush_count++;
2007-01-31 00:16:58 +01:00
}
/* Append characters and buffers for printing. */
static inline void
d_append_char (struct d_print_info *dpi, char c)
{
if (dpi->len == sizeof (dpi->buf) - 1)
d_print_flush (dpi);
dpi->buf[dpi->len++] = c;
dpi->last_char = c;
}
static inline void
d_append_buffer (struct d_print_info *dpi, const char *s, size_t l)
{
size_t i;
for (i = 0; i < l; i++)
d_append_char (dpi, s[i]);
}
static inline void
d_append_string (struct d_print_info *dpi, const char *s)
{
d_append_buffer (dpi, s, strlen (s));
}
2009-10-02 20:23:01 +02:00
static inline void
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
d_append_num (struct d_print_info *dpi, int l)
2009-10-02 20:23:01 +02:00
{
char buf[25];
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
sprintf (buf,"%d", l);
2009-10-02 20:23:01 +02:00
d_append_string (dpi, buf);
}
2007-01-31 00:16:58 +01:00
static inline char
d_last_char (struct d_print_info *dpi)
{
return dpi->last_char;
}
/* Turn components into a human readable string. OPTIONS is the
options bits passed to the demangler. DC is the tree to print.
CALLBACK is a function to call to flush demangled string segments
as they fill the intermediate buffer, and OPAQUE is a generalized
callback argument. On success, this returns 1. On failure,
it returns 0, indicating a bad parse. It does not use heap
memory to build an output string, so cannot encounter memory
allocation failure. */
CP_STATIC_IF_GLIBCPP_V3
int
cplus_demangle_print_callback (int options,
struct demangle_component *dc,
2007-01-31 00:16:58 +01:00
demangle_callbackref callback, void *opaque)
{
struct d_print_info dpi;
d_print_init (&dpi, callback, opaque, dc);
2007-01-31 00:16:58 +01:00
{
#ifdef CP_DYNAMIC_ARRAYS
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
/* Avoid zero-length VLAs, which are prohibited by the C99 standard
and flagged as errors by Address Sanitizer. */
__extension__ struct d_saved_scope scopes[(dpi.num_saved_scopes > 0)
? dpi.num_saved_scopes : 1];
__extension__ struct d_print_template temps[(dpi.num_copy_templates > 0)
? dpi.num_copy_templates : 1];
dpi.saved_scopes = scopes;
dpi.copy_templates = temps;
#else
dpi.saved_scopes = alloca (dpi.num_saved_scopes
* sizeof (*dpi.saved_scopes));
dpi.copy_templates = alloca (dpi.num_copy_templates
* sizeof (*dpi.copy_templates));
#endif
d_print_comp (&dpi, options, dc);
}
2007-01-31 00:16:58 +01:00
d_print_flush (&dpi);
return ! d_print_saw_error (&dpi);
2003-11-21 18:42:45 +01:00
}
2001-02-02 19:58:51 +01:00
2003-12-22 17:03:32 +01:00
/* Turn components into a human readable string. OPTIONS is the
options bits passed to the demangler. DC is the tree to print.
ESTIMATE is a guess at the length of the result. This returns a
string allocated by malloc, or NULL on error. On success, this
sets *PALC to the size of the allocated buffer. On failure, this
sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
failure. */
2004-01-12 22:24:38 +01:00
CP_STATIC_IF_GLIBCPP_V3
char *
cplus_demangle_print (int options, struct demangle_component *dc,
2005-03-27 07:28:42 +02:00
int estimate, size_t *palc)
2003-11-21 18:42:45 +01:00
{
2007-01-31 00:16:58 +01:00
struct d_growable_string dgs;
2007-01-31 00:16:58 +01:00
d_growable_string_init (&dgs, estimate);
2007-01-31 00:16:58 +01:00
if (! cplus_demangle_print_callback (options, dc,
d_growable_string_callback_adapter,
&dgs))
{
2007-01-31 00:16:58 +01:00
free (dgs.buf);
*palc = 0;
2003-11-21 18:42:45 +01:00
return NULL;
}
2007-01-31 00:16:58 +01:00
*palc = dgs.allocation_failure ? 1 : dgs.alc;
return dgs.buf;
}
2008-10-07 03:28:01 +02:00
/* Returns the I'th element of the template arglist ARGS, or NULL on
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
failure. If I is negative, return the entire arglist. */
2008-10-07 03:28:01 +02:00
static struct demangle_component *
d_index_template_argument (struct demangle_component *args, int i)
{
struct demangle_component *a;
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
if (i < 0)
/* Print the whole argument pack. */
return args;
2008-10-07 03:28:01 +02:00
for (a = args;
a != NULL;
a = d_right (a))
{
if (a->type != DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
return NULL;
if (i <= 0)
break;
--i;
}
if (i != 0 || a == NULL)
return NULL;
return d_left (a);
}
/* Returns the template argument from the current context indicated by DC,
which is a DEMANGLE_COMPONENT_TEMPLATE_PARAM, or NULL. */
static struct demangle_component *
d_lookup_template_argument (struct d_print_info *dpi,
const struct demangle_component *dc)
{
if (dpi->templates == NULL)
{
d_print_error (dpi);
return NULL;
}
return d_index_template_argument
(d_right (dpi->templates->template_decl),
dc->u.s_number.number);
}
/* Returns a template argument pack used in DC (any will do), or NULL. */
static struct demangle_component *
d_find_pack (struct d_print_info *dpi,
const struct demangle_component *dc)
{
struct demangle_component *a;
if (dc == NULL)
return NULL;
switch (dc->type)
{
case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
a = d_lookup_template_argument (dpi, dc);
if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
return a;
return NULL;
case DEMANGLE_COMPONENT_PACK_EXPANSION:
return NULL;
case DEMANGLE_COMPONENT_LAMBDA:
2008-10-07 03:28:01 +02:00
case DEMANGLE_COMPONENT_NAME:
2012-11-11 23:37:30 +01:00
case DEMANGLE_COMPONENT_TAGGED_NAME:
2008-10-07 03:28:01 +02:00
case DEMANGLE_COMPONENT_OPERATOR:
case DEMANGLE_COMPONENT_BUILTIN_TYPE:
case DEMANGLE_COMPONENT_SUB_STD:
case DEMANGLE_COMPONENT_CHARACTER:
2009-03-23 23:05:12 +01:00
case DEMANGLE_COMPONENT_FUNCTION_PARAM:
2012-05-22 20:05:41 +02:00
case DEMANGLE_COMPONENT_UNNAMED_TYPE:
case DEMANGLE_COMPONENT_FIXED_TYPE:
case DEMANGLE_COMPONENT_DEFAULT_ARG:
case DEMANGLE_COMPONENT_NUMBER:
2008-10-07 03:28:01 +02:00
return NULL;
case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
return d_find_pack (dpi, dc->u.s_extended_operator.name);
case DEMANGLE_COMPONENT_CTOR:
return d_find_pack (dpi, dc->u.s_ctor.name);
case DEMANGLE_COMPONENT_DTOR:
return d_find_pack (dpi, dc->u.s_dtor.name);
default:
a = d_find_pack (dpi, d_left (dc));
if (a)
return a;
return d_find_pack (dpi, d_right (dc));
}
}
/* Returns the length of the template argument pack DC. */
static int
d_pack_length (const struct demangle_component *dc)
{
int count = 0;
while (dc && dc->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
&& d_left (dc) != NULL)
{
++count;
dc = d_right (dc);
}
return count;
}
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
/* Returns the number of template args in DC, expanding any pack expansions
found there. */
static int
d_args_length (struct d_print_info *dpi, const struct demangle_component *dc)
{
int count = 0;
for (; dc && dc->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST;
dc = d_right (dc))
{
struct demangle_component *elt = d_left (dc);
if (elt == NULL)
break;
if (elt->type == DEMANGLE_COMPONENT_PACK_EXPANSION)
{
struct demangle_component *a = d_find_pack (dpi, d_left (elt));
count += d_pack_length (a);
}
else
++count;
}
return count;
}
2008-10-07 03:28:01 +02:00
/* DC is a component of a mangled expression. Print it, wrapped in parens
if needed. */
static void
2011-06-14 01:01:48 +02:00
d_print_subexpr (struct d_print_info *dpi, int options,
struct demangle_component *dc)
2008-10-07 03:28:01 +02:00
{
int simple = 0;
2009-03-23 23:05:12 +01:00
if (dc->type == DEMANGLE_COMPONENT_NAME
2012-01-06 23:04:43 +01:00
|| dc->type == DEMANGLE_COMPONENT_QUAL_NAME
|| dc->type == DEMANGLE_COMPONENT_INITIALIZER_LIST
2009-03-23 23:05:12 +01:00
|| dc->type == DEMANGLE_COMPONENT_FUNCTION_PARAM)
2008-10-07 03:28:01 +02:00
simple = 1;
if (!simple)
d_append_char (dpi, '(');
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, dc);
2008-10-07 03:28:01 +02:00
if (!simple)
d_append_char (dpi, ')');
}
/* Save the current scope. */
static void
d_save_scope (struct d_print_info *dpi,
const struct demangle_component *container)
{
struct d_saved_scope *scope;
struct d_print_template *src, **link;
if (dpi->next_saved_scope >= dpi->num_saved_scopes)
{
d_print_error (dpi);
return;
}
scope = &dpi->saved_scopes[dpi->next_saved_scope];
dpi->next_saved_scope++;
scope->container = container;
link = &scope->templates;
for (src = dpi->templates; src != NULL; src = src->next)
{
struct d_print_template *dst;
if (dpi->next_copy_template >= dpi->num_copy_templates)
{
d_print_error (dpi);
return;
}
dst = &dpi->copy_templates[dpi->next_copy_template];
dpi->next_copy_template++;
dst->template_decl = src->template_decl;
*link = dst;
link = &dst->next;
}
*link = NULL;
}
/* Attempt to locate a previously saved scope. Returns NULL if no
corresponding saved scope was found. */
static struct d_saved_scope *
d_get_saved_scope (struct d_print_info *dpi,
const struct demangle_component *container)
{
int i;
for (i = 0; i < dpi->next_saved_scope; i++)
if (dpi->saved_scopes[i].container == container)
return &dpi->saved_scopes[i];
return NULL;
}
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
/* If DC is a C++17 fold-expression, print it and return true; otherwise
return false. */
static int
d_maybe_print_fold_expression (struct d_print_info *dpi, int options,
struct demangle_component *dc)
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
{
struct demangle_component *ops, *operator_, *op1, *op2;
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
int save_idx;
const char *fold_code = d_left (dc)->u.s_operator.op->code;
if (fold_code[0] != 'f')
return 0;
ops = d_right (dc);
operator_ = d_left (ops);
op1 = d_right (ops);
op2 = 0;
if (op1->type == DEMANGLE_COMPONENT_TRINARY_ARG2)
{
op2 = d_right (op1);
op1 = d_left (op1);
}
/* Print the whole pack. */
save_idx = dpi->pack_index;
dpi->pack_index = -1;
switch (fold_code[1])
{
/* Unary left fold, (... + X). */
case 'l':
d_append_string (dpi, "(...");
d_print_expr_op (dpi, options, operator_);
d_print_subexpr (dpi, options, op1);
d_append_char (dpi, ')');
break;
/* Unary right fold, (X + ...). */
case 'r':
d_append_char (dpi, '(');
d_print_subexpr (dpi, options, op1);
d_print_expr_op (dpi, options, operator_);
d_append_string (dpi, "...)");
break;
/* Binary left fold, (42 + ... + X). */
case 'L':
/* Binary right fold, (X + ... + 42). */
case 'R':
d_append_char (dpi, '(');
d_print_subexpr (dpi, options, op1);
d_print_expr_op (dpi, options, operator_);
d_append_string (dpi, "...");
d_print_expr_op (dpi, options, operator_);
d_print_subexpr (dpi, options, op2);
d_append_char (dpi, ')');
break;
}
dpi->pack_index = save_idx;
return 1;
}
2003-11-21 18:42:45 +01:00
/* Subroutine to handle components. */
2003-11-21 18:42:45 +01:00
static void
d_print_comp_inner (struct d_print_info *dpi, int options,
struct demangle_component *dc)
{
2011-06-22 21:13:44 +02:00
/* Magic variable to let reference smashing skip over the next modifier
without needing to modify *dc. */
struct demangle_component *mod_inner = NULL;
2011-06-22 21:13:44 +02:00
/* Variable used to store the current templates while a previously
captured scope is used. */
struct d_print_template *saved_templates;
/* Nonzero if templates have been stored in the above variable. */
int need_template_restore = 0;
2003-11-21 18:42:45 +01:00
if (dc == NULL)
{
2003-11-21 18:42:45 +01:00
d_print_error (dpi);
return;
}
2003-11-21 18:42:45 +01:00
if (d_print_saw_error (dpi))
return;
2003-11-21 18:42:45 +01:00
switch (dc->type)
{
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_NAME:
2011-06-14 01:01:48 +02:00
if ((options & DMGL_JAVA) == 0)
2003-12-22 17:03:32 +01:00
d_append_buffer (dpi, dc->u.s_name.s, dc->u.s_name.len);
else
d_print_java_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len);
2003-11-21 18:42:45 +01:00
return;
2012-11-11 23:37:30 +01:00
case DEMANGLE_COMPONENT_TAGGED_NAME:
d_print_comp (dpi, options, d_left (dc));
d_append_string (dpi, "[abi:");
d_print_comp (dpi, options, d_right (dc));
d_append_char (dpi, ']');
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_QUAL_NAME:
case DEMANGLE_COMPONENT_LOCAL_NAME:
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_left (dc));
if ((options & DMGL_JAVA) == 0)
2007-01-31 00:16:58 +01:00
d_append_string (dpi, "::");
2003-12-22 17:03:32 +01:00
else
d_append_char (dpi, '.');
2013-02-15 03:48:33 +01:00
{
struct demangle_component *local_name = d_right (dc);
if (local_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
{
d_append_string (dpi, "{default arg#");
d_append_num (dpi, local_name->u.s_unary_num.num + 1);
d_append_string (dpi, "}::");
local_name = local_name->u.s_unary_num.sub;
}
d_print_comp (dpi, options, local_name);
}
2003-11-21 18:42:45 +01:00
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_TYPED_NAME:
2003-11-21 18:42:45 +01:00
{
2003-12-04 21:03:39 +01:00
struct d_print_mod *hold_modifiers;
2004-01-12 22:24:38 +01:00
struct demangle_component *typed_name;
2003-12-04 21:03:39 +01:00
struct d_print_mod adpm[4];
unsigned int i;
2003-11-21 18:42:45 +01:00
struct d_print_template dpt;
/* Pass the name down to the type so that it can be printed in
2003-12-04 21:03:39 +01:00
the right place for the type. We also have to pass down
any CV-qualifiers, which apply to the this parameter. */
hold_modifiers = dpi->modifiers;
2009-03-18 01:07:49 +01:00
dpi->modifiers = 0;
2003-12-04 21:03:39 +01:00
i = 0;
2003-11-21 18:42:45 +01:00
typed_name = d_left (dc);
2003-12-04 21:03:39 +01:00
while (typed_name != NULL)
{
if (i >= sizeof adpm / sizeof adpm[0])
{
d_print_error (dpi);
return;
}
2003-11-21 18:42:45 +01:00
2003-12-04 21:03:39 +01:00
adpm[i].next = dpi->modifiers;
dpi->modifiers = &adpm[i];
adpm[i].mod = typed_name;
adpm[i].printed = 0;
adpm[i].templates = dpi->templates;
++i;
if (!is_fnqual_component_type (typed_name->type))
2003-12-04 21:03:39 +01:00
break;
typed_name = d_left (typed_name);
}
2003-11-21 18:42:45 +01:00
if (typed_name == NULL)
{
d_print_error (dpi);
return;
}
2004-01-12 22:24:38 +01:00
/* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
there may be CV-qualifiers on its right argument which
Update the libiberty sources with the latest patches found in the master sources. 2017-01-02 Richard Biener <rguenther@suse.de> PR lto/83452 * simple-object-elf.c (simple_object_elf_copy_lto_debug_section): Do not use UNDEF locals for removed symbols but instead just define them in the first prevailing section and with no name. Use the same gnu_lto_v1 name for all removed globals we promote to WEAK UNDEFs so hpux can use a stub to provide this symbol. Clear sh_info and sh_link in removed sections. 2017-10-30 Richard Biener <rguenther@suse.de> PR lto/82757 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Strip two leading _s from the __gnu_lto_* symbols. 2017-10-24 Alan Modra <amodra@gmail.com> PR lto/82687 PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Only make __gnu_lto symbols hidden. 2017-10-20 Alan Modra <amodra@gmail.com> PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Make discarded non-local symbols weak and hidden. 2017-10-18 Jakub Jelinek <jakub@redhat.com> PR lto/82598 * simple-object.c (handle_lto_debug_sections): Copy over also .note.GNU-stack section with unchanged name. * simple-object-elf.c (SHF_EXECINSTR): Define. (simple_object_elf_copy_lto_debug_section): Drop SHF_EXECINSTR bit on .note.GNU-stack section. 2017-09-25 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_encoding): Strip return type when name is a LOCAL_NAME. (d_local_name): Strip return type of enclosing TYPED_NAME. * testsuite/demangle-expected: Add and adjust tests. 2017-09-21 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Revert addition of 'toplevel' parm. (has_return_type): Recurse for DEMANGLE_COMPONENT_LOCAL_NAME. (d_encoding): Revert d_name change. Use is_fnqual_component_type to strip modifiers that do not belong. (d_special_name, d_class_enum_type): Revert d_name call change. (d_expresion_1): Commonize DEMANGLE_COMPONENT_UNARY building. (d_local_name): Revert parsing of a function type. (d_print_comp_inner): An inner LOCAL_NAME might contain a TEMPLATE. * testsuite/demangle-expected: Add & adjust tests
2018-01-10 14:57:48 +01:00
really apply here; this happens when parsing a class that
2004-01-12 22:24:38 +01:00
is local to a function. */
if (typed_name->type == DEMANGLE_COMPONENT_LOCAL_NAME)
2003-12-19 23:03:41 +01:00
{
Update the libiberty sources with the latest patches found in the master sources. 2017-01-02 Richard Biener <rguenther@suse.de> PR lto/83452 * simple-object-elf.c (simple_object_elf_copy_lto_debug_section): Do not use UNDEF locals for removed symbols but instead just define them in the first prevailing section and with no name. Use the same gnu_lto_v1 name for all removed globals we promote to WEAK UNDEFs so hpux can use a stub to provide this symbol. Clear sh_info and sh_link in removed sections. 2017-10-30 Richard Biener <rguenther@suse.de> PR lto/82757 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Strip two leading _s from the __gnu_lto_* symbols. 2017-10-24 Alan Modra <amodra@gmail.com> PR lto/82687 PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Only make __gnu_lto symbols hidden. 2017-10-20 Alan Modra <amodra@gmail.com> PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Make discarded non-local symbols weak and hidden. 2017-10-18 Jakub Jelinek <jakub@redhat.com> PR lto/82598 * simple-object.c (handle_lto_debug_sections): Copy over also .note.GNU-stack section with unchanged name. * simple-object-elf.c (SHF_EXECINSTR): Define. (simple_object_elf_copy_lto_debug_section): Drop SHF_EXECINSTR bit on .note.GNU-stack section. 2017-09-25 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_encoding): Strip return type when name is a LOCAL_NAME. (d_local_name): Strip return type of enclosing TYPED_NAME. * testsuite/demangle-expected: Add and adjust tests. 2017-09-21 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Revert addition of 'toplevel' parm. (has_return_type): Recurse for DEMANGLE_COMPONENT_LOCAL_NAME. (d_encoding): Revert d_name change. Use is_fnqual_component_type to strip modifiers that do not belong. (d_special_name, d_class_enum_type): Revert d_name call change. (d_expresion_1): Commonize DEMANGLE_COMPONENT_UNARY building. (d_local_name): Revert parsing of a function type. (d_print_comp_inner): An inner LOCAL_NAME might contain a TEMPLATE. * testsuite/demangle-expected: Add & adjust tests
2018-01-10 14:57:48 +01:00
typed_name = d_right (typed_name);
if (typed_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
typed_name = typed_name->u.s_unary_num.sub;
if (typed_name == NULL)
{
d_print_error (dpi);
return;
}
Update the libiberty sources with the latest patches found in the master sources. 2017-01-02 Richard Biener <rguenther@suse.de> PR lto/83452 * simple-object-elf.c (simple_object_elf_copy_lto_debug_section): Do not use UNDEF locals for removed symbols but instead just define them in the first prevailing section and with no name. Use the same gnu_lto_v1 name for all removed globals we promote to WEAK UNDEFs so hpux can use a stub to provide this symbol. Clear sh_info and sh_link in removed sections. 2017-10-30 Richard Biener <rguenther@suse.de> PR lto/82757 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Strip two leading _s from the __gnu_lto_* symbols. 2017-10-24 Alan Modra <amodra@gmail.com> PR lto/82687 PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Only make __gnu_lto symbols hidden. 2017-10-20 Alan Modra <amodra@gmail.com> PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Make discarded non-local symbols weak and hidden. 2017-10-18 Jakub Jelinek <jakub@redhat.com> PR lto/82598 * simple-object.c (handle_lto_debug_sections): Copy over also .note.GNU-stack section with unchanged name. * simple-object-elf.c (SHF_EXECINSTR): Define. (simple_object_elf_copy_lto_debug_section): Drop SHF_EXECINSTR bit on .note.GNU-stack section. 2017-09-25 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_encoding): Strip return type when name is a LOCAL_NAME. (d_local_name): Strip return type of enclosing TYPED_NAME. * testsuite/demangle-expected: Add and adjust tests. 2017-09-21 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Revert addition of 'toplevel' parm. (has_return_type): Recurse for DEMANGLE_COMPONENT_LOCAL_NAME. (d_encoding): Revert d_name change. Use is_fnqual_component_type to strip modifiers that do not belong. (d_special_name, d_class_enum_type): Revert d_name call change. (d_expresion_1): Commonize DEMANGLE_COMPONENT_UNARY building. (d_local_name): Revert parsing of a function type. (d_print_comp_inner): An inner LOCAL_NAME might contain a TEMPLATE. * testsuite/demangle-expected: Add & adjust tests
2018-01-10 14:57:48 +01:00
while (is_fnqual_component_type (typed_name->type))
2003-12-19 23:03:41 +01:00
{
if (i >= sizeof adpm / sizeof adpm[0])
{
d_print_error (dpi);
return;
}
adpm[i] = adpm[i - 1];
adpm[i].next = &adpm[i - 1];
dpi->modifiers = &adpm[i];
Update the libiberty sources with the latest patches found in the master sources. 2017-01-02 Richard Biener <rguenther@suse.de> PR lto/83452 * simple-object-elf.c (simple_object_elf_copy_lto_debug_section): Do not use UNDEF locals for removed symbols but instead just define them in the first prevailing section and with no name. Use the same gnu_lto_v1 name for all removed globals we promote to WEAK UNDEFs so hpux can use a stub to provide this symbol. Clear sh_info and sh_link in removed sections. 2017-10-30 Richard Biener <rguenther@suse.de> PR lto/82757 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Strip two leading _s from the __gnu_lto_* symbols. 2017-10-24 Alan Modra <amodra@gmail.com> PR lto/82687 PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Only make __gnu_lto symbols hidden. 2017-10-20 Alan Modra <amodra@gmail.com> PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Make discarded non-local symbols weak and hidden. 2017-10-18 Jakub Jelinek <jakub@redhat.com> PR lto/82598 * simple-object.c (handle_lto_debug_sections): Copy over also .note.GNU-stack section with unchanged name. * simple-object-elf.c (SHF_EXECINSTR): Define. (simple_object_elf_copy_lto_debug_section): Drop SHF_EXECINSTR bit on .note.GNU-stack section. 2017-09-25 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_encoding): Strip return type when name is a LOCAL_NAME. (d_local_name): Strip return type of enclosing TYPED_NAME. * testsuite/demangle-expected: Add and adjust tests. 2017-09-21 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Revert addition of 'toplevel' parm. (has_return_type): Recurse for DEMANGLE_COMPONENT_LOCAL_NAME. (d_encoding): Revert d_name change. Use is_fnqual_component_type to strip modifiers that do not belong. (d_special_name, d_class_enum_type): Revert d_name call change. (d_expresion_1): Commonize DEMANGLE_COMPONENT_UNARY building. (d_local_name): Revert parsing of a function type. (d_print_comp_inner): An inner LOCAL_NAME might contain a TEMPLATE. * testsuite/demangle-expected: Add & adjust tests
2018-01-10 14:57:48 +01:00
adpm[i - 1].mod = typed_name;
2003-12-19 23:03:41 +01:00
adpm[i - 1].printed = 0;
adpm[i - 1].templates = dpi->templates;
++i;
Update the libiberty sources with the latest patches found in the master sources. 2017-01-02 Richard Biener <rguenther@suse.de> PR lto/83452 * simple-object-elf.c (simple_object_elf_copy_lto_debug_section): Do not use UNDEF locals for removed symbols but instead just define them in the first prevailing section and with no name. Use the same gnu_lto_v1 name for all removed globals we promote to WEAK UNDEFs so hpux can use a stub to provide this symbol. Clear sh_info and sh_link in removed sections. 2017-10-30 Richard Biener <rguenther@suse.de> PR lto/82757 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Strip two leading _s from the __gnu_lto_* symbols. 2017-10-24 Alan Modra <amodra@gmail.com> PR lto/82687 PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Only make __gnu_lto symbols hidden. 2017-10-20 Alan Modra <amodra@gmail.com> PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Make discarded non-local symbols weak and hidden. 2017-10-18 Jakub Jelinek <jakub@redhat.com> PR lto/82598 * simple-object.c (handle_lto_debug_sections): Copy over also .note.GNU-stack section with unchanged name. * simple-object-elf.c (SHF_EXECINSTR): Define. (simple_object_elf_copy_lto_debug_section): Drop SHF_EXECINSTR bit on .note.GNU-stack section. 2017-09-25 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_encoding): Strip return type when name is a LOCAL_NAME. (d_local_name): Strip return type of enclosing TYPED_NAME. * testsuite/demangle-expected: Add and adjust tests. 2017-09-21 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Revert addition of 'toplevel' parm. (has_return_type): Recurse for DEMANGLE_COMPONENT_LOCAL_NAME. (d_encoding): Revert d_name change. Use is_fnqual_component_type to strip modifiers that do not belong. (d_special_name, d_class_enum_type): Revert d_name call change. (d_expresion_1): Commonize DEMANGLE_COMPONENT_UNARY building. (d_local_name): Revert parsing of a function type. (d_print_comp_inner): An inner LOCAL_NAME might contain a TEMPLATE. * testsuite/demangle-expected: Add & adjust tests
2018-01-10 14:57:48 +01:00
typed_name = d_left (typed_name);
2003-12-19 23:03:41 +01:00
}
}
Update the libiberty sources with the latest patches found in the master sources. 2017-01-02 Richard Biener <rguenther@suse.de> PR lto/83452 * simple-object-elf.c (simple_object_elf_copy_lto_debug_section): Do not use UNDEF locals for removed symbols but instead just define them in the first prevailing section and with no name. Use the same gnu_lto_v1 name for all removed globals we promote to WEAK UNDEFs so hpux can use a stub to provide this symbol. Clear sh_info and sh_link in removed sections. 2017-10-30 Richard Biener <rguenther@suse.de> PR lto/82757 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Strip two leading _s from the __gnu_lto_* symbols. 2017-10-24 Alan Modra <amodra@gmail.com> PR lto/82687 PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Only make __gnu_lto symbols hidden. 2017-10-20 Alan Modra <amodra@gmail.com> PR lto/82575 * simple-object-elf.c (simple_object_elf_copy_lto_debug_sections): Make discarded non-local symbols weak and hidden. 2017-10-18 Jakub Jelinek <jakub@redhat.com> PR lto/82598 * simple-object.c (handle_lto_debug_sections): Copy over also .note.GNU-stack section with unchanged name. * simple-object-elf.c (SHF_EXECINSTR): Define. (simple_object_elf_copy_lto_debug_section): Drop SHF_EXECINSTR bit on .note.GNU-stack section. 2017-09-25 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_encoding): Strip return type when name is a LOCAL_NAME. (d_local_name): Strip return type of enclosing TYPED_NAME. * testsuite/demangle-expected: Add and adjust tests. 2017-09-21 Nathan Sidwell <nathan@acm.org> PR demangler/82195 * cp-demangle.c (d_name): Revert addition of 'toplevel' parm. (has_return_type): Recurse for DEMANGLE_COMPONENT_LOCAL_NAME. (d_encoding): Revert d_name change. Use is_fnqual_component_type to strip modifiers that do not belong. (d_special_name, d_class_enum_type): Revert d_name call change. (d_expresion_1): Commonize DEMANGLE_COMPONENT_UNARY building. (d_local_name): Revert parsing of a function type. (d_print_comp_inner): An inner LOCAL_NAME might contain a TEMPLATE. * testsuite/demangle-expected: Add & adjust tests
2018-01-10 14:57:48 +01:00
/* If typed_name is a template, then it applies to the
function type as well. */
if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
{
dpt.next = dpi->templates;
dpi->templates = &dpt;
dpt.template_decl = typed_name;
}
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_right (dc));
2000-10-12 04:16:48 +02:00
2004-01-12 22:24:38 +01:00
if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
2003-11-21 18:42:45 +01:00
dpi->templates = dpt.next;
2003-12-04 21:03:39 +01:00
/* If the modifiers didn't get printed by the type, print them
2003-11-21 18:42:45 +01:00
now. */
2003-12-04 21:03:39 +01:00
while (i > 0)
2003-11-21 18:42:45 +01:00
{
2003-12-04 21:03:39 +01:00
--i;
if (! adpm[i].printed)
{
d_append_char (dpi, ' ');
2011-06-14 01:01:48 +02:00
d_print_mod (dpi, options, adpm[i].mod);
2003-12-04 21:03:39 +01:00
}
2003-11-21 18:42:45 +01:00
}
2003-12-04 21:03:39 +01:00
dpi->modifiers = hold_modifiers;
2003-11-21 18:42:45 +01:00
return;
}
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_TEMPLATE:
2003-11-27 02:17:34 +01:00
{
struct d_print_mod *hold_dpm;
2007-01-31 00:16:58 +01:00
struct demangle_component *dcl;
const struct demangle_component *hold_current;
/* This template may need to be referenced by a cast operator
contained in its subtree. */
hold_current = dpi->current_template;
dpi->current_template = dc;
2003-11-27 02:17:34 +01:00
/* Don't push modifiers into a template definition. Doing so
could give the wrong definition for a template argument.
Instead, treat the template essentially as a name. */
hold_dpm = dpi->modifiers;
dpi->modifiers = NULL;
2007-01-31 00:16:58 +01:00
dcl = d_left (dc);
2011-06-14 01:01:48 +02:00
if ((options & DMGL_JAVA) != 0
2007-01-31 00:16:58 +01:00
&& dcl->type == DEMANGLE_COMPONENT_NAME
&& dcl->u.s_name.len == 6
&& strncmp (dcl->u.s_name.s, "JArray", 6) == 0)
{
/* Special-case Java arrays, so that JArray<TYPE> appears
instead as TYPE[]. */
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_right (dc));
2007-01-31 00:16:58 +01:00
d_append_string (dpi, "[]");
}
else
{
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, dcl);
2007-01-31 00:16:58 +01:00
if (d_last_char (dpi) == '<')
d_append_char (dpi, ' ');
d_append_char (dpi, '<');
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_right (dc));
2007-01-31 00:16:58 +01:00
/* Avoid generating two consecutive '>' characters, to avoid
the C++ syntactic ambiguity. */
if (d_last_char (dpi) == '>')
d_append_char (dpi, ' ');
d_append_char (dpi, '>');
}
2003-11-27 02:17:34 +01:00
dpi->modifiers = hold_dpm;
dpi->current_template = hold_current;
2003-11-27 02:17:34 +01:00
return;
}
2003-11-21 18:42:45 +01:00
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
if (dpi->is_lambda_arg)
{
/* Show the template parm index, as that's how g++ displays
these, and future proofs us against potential
'[]<typename T> (T *a, T *b) {...}'. */
d_append_buffer (dpi, "auto:", 5);
d_append_num (dpi, dc->u.s_number.number + 1);
}
else
{
struct d_print_template *hold_dpt;
struct demangle_component *a = d_lookup_template_argument (dpi, dc);
2008-10-07 03:28:01 +02:00
if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
a = d_index_template_argument (a, dpi->pack_index);
if (a == NULL)
{
d_print_error (dpi);
return;
}
/* While processing this parameter, we need to pop the list
of templates. This is because the template parameter may
itself be a reference to a parameter of an outer
template. */
hold_dpt = dpi->templates;
dpi->templates = hold_dpt->next;
2000-07-20 20:56:16 +02:00
d_print_comp (dpi, options, a);
dpi->templates = hold_dpt;
}
return;
Synchronize libiberty with gcc and add --no-recruse-limit option to tools that support name demangling. This patch addresses the multitude of bug reports about resource exhaustion in libiberty's name demangling code. It adds a limit to the amount of recursion that is allowed, before an error is triggered. It also adds a new demangling option to disable this limit. (The limit is enabled by default). PR 87681 PR 87675 PR 87636 PR 87335 libiberty * cp-demangle.h (struct d_info): Add recursion_limit field. * cp-demangle.c (d_function_type): If the recursion limit is enabled and reached, return with a failure result. (d_demangle_callback): If the recursion limit is enabled, check for a mangled string that is so long that there is not enough stack space for the local arrays. * cplus-dem.c (struct work): Add recursion_level field. (demangle_nested_args): If the recursion limit is enabled and reached, return with a failure result. include * demangle.h (DMGL_RECURSE_LIMIT): Define. (DEMANGLE_RECURSION_LIMIT): Prototype. binutuils * addr2line.c (demangle_flags): New static variable. (long_options): Add --recurse-limit and --no-recurse-limit. (translate_address): Pass demangle_flags to bfd_demangle. (main): Handle --recurse-limit and --no-recurse-limit options. * cxxfilt.c (flags): Add DMGL_RECURSE_LIMIT. (long_options): Add --recurse-limit and --no-recurse-limit. (main): Handle new options. * dlltool.c (gen_def_file): Include DMGL_RECURSE_LIMIT in flags passed to cplus_demangle. * nm.c (demangle_flags): New static variable. (long_options): Add --recurse-limit and --no-recurse-limit. (main): Handle new options. * objdump.c (demangle_flags): New static variable. (usage): Add --recurse-limit and --no-recurse-limit. (long_options): Likewise. (objdump_print_symname): Pass demangle_flags to bfd_demangle. (disassemble_section): Likewise. (dump_dymbols): Likewise. (main): Handle new options. * prdbg.c (demangle_flags): New static variable. (tg_variable): Pass demangle_flags to demangler. (tg_start_function): Likewise. * stabs.c (demangle_flags): New static variable. (stab_demangle_template): Pass demangle_flags to demangler. (stab_demangle_v3_argtypes): Likewise. (stab_demangle_v3_arg): Likewise. * doc/binutuls.texi: Document new command line options. * NEWS: Mention the new feature. * testsuite/config/default.exp (CXXFILT): Define if not already defined. (CXXFILTFLAGS): Likewise. * testsuite/binutils-all/cxxfilt.exp: New file. Runs a few simple tests of the cxxfilt program.
2018-12-07 12:32:55 +01:00
case DEMANGLE_COMPONENT_TPARM_OBJ:
d_append_string (dpi, "template parameter object for ");
d_print_comp (dpi, options, d_left (dc));
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_CTOR:
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, dc->u.s_ctor.name);
2003-11-21 18:42:45 +01:00
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_DTOR:
2003-11-21 18:42:45 +01:00
d_append_char (dpi, '~');
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, dc->u.s_dtor.name);
2003-11-21 18:42:45 +01:00
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_VTABLE:
2007-01-31 00:16:58 +01:00
d_append_string (dpi, "vtable for ");
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_left (dc));
2003-11-21 18:42:45 +01:00
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_VTT:
2007-01-31 00:16:58 +01:00
d_append_string (dpi, "VTT for ");
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_left (dc));
2003-11-21 18:42:45 +01:00
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
2007-01-31 00:16:58 +01:00
d_append_string (dpi, "construction vtable for ");
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_left (dc));
2007-01-31 00:16:58 +01:00
d_append_string (dpi, "-in-");
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_right (dc));
2003-11-21 18:42:45 +01:00
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_TYPEINFO:
2007-01-31 00:16:58 +01:00
d_append_string (dpi, "typeinfo for ");
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_left (dc));
2003-11-21 18:42:45 +01:00
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_TYPEINFO_NAME:
2007-01-31 00:16:58 +01:00
d_append_string (dpi, "typeinfo name for ");
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_left (dc));
2003-11-21 18:42:45 +01:00
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_TYPEINFO_FN:
2007-01-31 00:16:58 +01:00
d_append_string (dpi, "typeinfo fn for ");
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_left (dc));
2003-11-21 18:42:45 +01:00
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_THUNK:
2007-01-31 00:16:58 +01:00
d_append_string (dpi, "non-virtual thunk to ");
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_left (dc));
2003-11-21 18:42:45 +01:00
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
2007-01-31 00:16:58 +01:00
d_append_string (dpi, "virtual thunk to ");
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_left (dc));
2003-11-21 18:42:45 +01:00
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_COVARIANT_THUNK:
2007-01-31 00:16:58 +01:00
d_append_string (dpi, "covariant return thunk to ");
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_left (dc));
2003-11-21 18:42:45 +01:00
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_JAVA_CLASS:
2007-01-31 00:16:58 +01:00
d_append_string (dpi, "java Class for ");
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_left (dc));
2003-11-21 18:42:45 +01:00
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_GUARD:
2007-01-31 00:16:58 +01:00
d_append_string (dpi, "guard variable for ");
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_left (dc));
2003-11-21 18:42:45 +01:00
return;
2012-10-10 05:11:33 +02:00
case DEMANGLE_COMPONENT_TLS_INIT:
d_append_string (dpi, "TLS init function for ");
d_print_comp (dpi, options, d_left (dc));
return;
case DEMANGLE_COMPONENT_TLS_WRAPPER:
d_append_string (dpi, "TLS wrapper function for ");
d_print_comp (dpi, options, d_left (dc));
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_REFTEMP:
2011-11-04 15:32:13 +01:00
d_append_string (dpi, "reference temporary #");
d_print_comp (dpi, options, d_right (dc));
d_append_string (dpi, " for ");
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_left (dc));
2003-11-21 18:42:45 +01:00
return;
case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
2007-01-31 00:16:58 +01:00
d_append_string (dpi, "hidden alias for ");
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_left (dc));
return;
2011-11-08 17:01:58 +01:00
case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
d_append_string (dpi, "transaction clone for ");
d_print_comp (dpi, options, d_left (dc));
return;
case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
d_append_string (dpi, "non-transaction clone for ");
d_print_comp (dpi, options, d_left (dc));
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_SUB_STD:
2003-12-22 17:03:32 +01:00
d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len);
2003-11-21 18:42:45 +01:00
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_RESTRICT:
case DEMANGLE_COMPONENT_VOLATILE:
case DEMANGLE_COMPONENT_CONST:
2004-02-24 17:30:50 +01:00
{
struct d_print_mod *pdpm;
/* When printing arrays, it's possible to have cases where the
same CV-qualifier gets pushed on the stack multiple times.
We only need to print it once. */
for (pdpm = dpi->modifiers; pdpm != NULL; pdpm = pdpm->next)
{
if (! pdpm->printed)
{
if (pdpm->mod->type != DEMANGLE_COMPONENT_RESTRICT
&& pdpm->mod->type != DEMANGLE_COMPONENT_VOLATILE
&& pdpm->mod->type != DEMANGLE_COMPONENT_CONST)
break;
if (pdpm->mod->type == dc->type)
{
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_left (dc));
2004-02-24 17:30:50 +01:00
return;
}
}
}
}
2011-06-22 21:13:44 +02:00
goto modifier;
case DEMANGLE_COMPONENT_REFERENCE:
case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
{
/* Handle reference smashing: & + && = &. */
struct demangle_component *sub = d_left (dc);
if (!dpi->is_lambda_arg
&& sub->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM)
2011-06-22 21:13:44 +02:00
{
struct d_saved_scope *scope = d_get_saved_scope (dpi, sub);
struct demangle_component *a;
if (scope == NULL)
{
/* This is the first time SUB has been traversed.
We need to capture the current templates so
they can be restored if SUB is reentered as a
substitution. */
d_save_scope (dpi, sub);
if (d_print_saw_error (dpi))
return;
}
else
{
const struct d_component_stack *dcse;
int found_self_or_parent = 0;
/* This traversal is reentering SUB as a substition.
If we are not beneath SUB or DC in the tree then we
need to restore SUB's template stack temporarily. */
for (dcse = dpi->component_stack; dcse != NULL;
dcse = dcse->parent)
{
if (dcse->dc == sub
|| (dcse->dc == dc
&& dcse != dpi->component_stack))
{
found_self_or_parent = 1;
break;
}
}
if (!found_self_or_parent)
{
saved_templates = dpi->templates;
dpi->templates = scope->templates;
need_template_restore = 1;
}
}
a = d_lookup_template_argument (dpi, sub);
2011-06-22 21:13:44 +02:00
if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
a = d_index_template_argument (a, dpi->pack_index);
2011-07-26 18:04:38 +02:00
if (a == NULL)
{
if (need_template_restore)
dpi->templates = saved_templates;
2011-07-26 18:04:38 +02:00
d_print_error (dpi);
return;
}
2011-06-22 21:13:44 +02:00
sub = a;
}
if (sub->type == DEMANGLE_COMPONENT_REFERENCE
|| sub->type == dc->type)
dc = sub;
else if (sub->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE)
mod_inner = d_left (sub);
}
2004-02-24 17:30:50 +01:00
/* Fall through. */
2011-06-22 21:13:44 +02:00
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
case DEMANGLE_COMPONENT_POINTER:
case DEMANGLE_COMPONENT_COMPLEX:
case DEMANGLE_COMPONENT_IMAGINARY:
FNQUAL_COMPONENT_CASE:
2011-06-22 21:13:44 +02:00
modifier:
2003-11-21 18:42:45 +01:00
{
/* We keep a list of modifiers on the stack. */
struct d_print_mod dpm;
2003-11-21 18:42:45 +01:00
dpm.next = dpi->modifiers;
dpi->modifiers = &dpm;
dpm.mod = dc;
dpm.printed = 0;
2003-11-27 02:17:34 +01:00
dpm.templates = dpi->templates;
2011-06-22 21:13:44 +02:00
if (!mod_inner)
mod_inner = d_left (dc);
d_print_comp (dpi, options, mod_inner);
2003-11-21 18:42:45 +01:00
/* If the modifier didn't get printed by the type, print it
now. */
if (! dpm.printed)
2011-06-14 01:01:48 +02:00
d_print_mod (dpi, options, dc);
2003-11-21 18:42:45 +01:00
dpi->modifiers = dpm.next;
if (need_template_restore)
dpi->templates = saved_templates;
2003-11-21 18:42:45 +01:00
return;
}
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_BUILTIN_TYPE:
2011-06-14 01:01:48 +02:00
if ((options & DMGL_JAVA) == 0)
2003-12-22 17:03:32 +01:00
d_append_buffer (dpi, dc->u.s_builtin.type->name,
dc->u.s_builtin.type->len);
2003-11-21 18:42:45 +01:00
else
2003-12-22 17:03:32 +01:00
d_append_buffer (dpi, dc->u.s_builtin.type->java_name,
dc->u.s_builtin.type->java_len);
2003-11-21 18:42:45 +01:00
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_VENDOR_TYPE:
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_left (dc));
2003-11-21 18:42:45 +01:00
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_FUNCTION_TYPE:
2003-11-21 18:42:45 +01:00
{
2011-06-14 01:01:48 +02:00
if ((options & DMGL_RET_POSTFIX) != 0)
d_print_function_type (dpi,
options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
dc, dpi->modifiers);
2005-12-11 03:16:09 +01:00
/* Print return type if present */
2011-06-14 01:01:48 +02:00
if (d_left (dc) != NULL && (options & DMGL_RET_POSTFIX) != 0)
d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
d_left (dc));
else if (d_left (dc) != NULL && (options & DMGL_RET_DROP) == 0)
2003-11-21 18:42:45 +01:00
{
struct d_print_mod dpm;
2003-11-21 18:42:45 +01:00
/* We must pass this type down as a modifier in order to
print it in the right location. */
dpm.next = dpi->modifiers;
dpi->modifiers = &dpm;
dpm.mod = dc;
dpm.printed = 0;
2003-11-27 02:17:34 +01:00
dpm.templates = dpi->templates;
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
d_left (dc));
2003-11-21 18:42:45 +01:00
dpi->modifiers = dpm.next;
2003-11-21 18:42:45 +01:00
if (dpm.printed)
return;
2005-12-11 03:16:09 +01:00
/* In standard prefix notation, there is a space between the
return type and the function signature. */
2011-06-14 01:01:48 +02:00
if ((options & DMGL_RET_POSTFIX) == 0)
2005-12-11 03:16:09 +01:00
d_append_char (dpi, ' ');
2003-11-21 18:42:45 +01:00
}
2011-06-14 01:01:48 +02:00
if ((options & DMGL_RET_POSTFIX) == 0)
d_print_function_type (dpi,
options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
dc, dpi->modifiers);
2000-07-20 20:56:16 +02:00
2003-11-21 18:42:45 +01:00
return;
}
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_ARRAY_TYPE:
2003-11-21 18:42:45 +01:00
{
2004-02-24 17:30:50 +01:00
struct d_print_mod *hold_modifiers;
struct d_print_mod adpm[4];
unsigned int i;
struct d_print_mod *pdpm;
2003-11-21 18:42:45 +01:00
/* We must pass this type down as a modifier in order to print
2004-02-24 17:30:50 +01:00
multi-dimensional arrays correctly. If the array itself is
CV-qualified, we act as though the element type were
CV-qualified. We do this by copying the modifiers down
rather than fiddling pointers, so that we don't wind up
with a d_print_mod higher on the stack pointing into our
stack frame after we return. */
2000-07-20 20:56:16 +02:00
2004-02-24 17:30:50 +01:00
hold_modifiers = dpi->modifiers;
adpm[0].next = hold_modifiers;
dpi->modifiers = &adpm[0];
adpm[0].mod = dc;
adpm[0].printed = 0;
adpm[0].templates = dpi->templates;
i = 1;
pdpm = hold_modifiers;
while (pdpm != NULL
&& (pdpm->mod->type == DEMANGLE_COMPONENT_RESTRICT
|| pdpm->mod->type == DEMANGLE_COMPONENT_VOLATILE
|| pdpm->mod->type == DEMANGLE_COMPONENT_CONST))
{
if (! pdpm->printed)
{
if (i >= sizeof adpm / sizeof adpm[0])
{
d_print_error (dpi);
return;
}
adpm[i] = *pdpm;
adpm[i].next = dpi->modifiers;
dpi->modifiers = &adpm[i];
pdpm->printed = 1;
++i;
}
pdpm = pdpm->next;
}
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_right (dc));
2004-02-24 17:30:50 +01:00
dpi->modifiers = hold_modifiers;
2004-02-24 17:30:50 +01:00
if (adpm[0].printed)
2003-11-21 18:42:45 +01:00
return;
2004-02-24 17:30:50 +01:00
while (i > 1)
{
--i;
2011-06-14 01:01:48 +02:00
d_print_mod (dpi, options, adpm[i].mod);
2004-02-24 17:30:50 +01:00
}
2011-06-14 01:01:48 +02:00
d_print_array_type (dpi, options, dc, dpi->modifiers);
2003-11-21 18:42:45 +01:00
return;
}
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_PTRMEM_TYPE:
2010-02-04 00:28:01 +01:00
case DEMANGLE_COMPONENT_VECTOR_TYPE:
2003-11-21 18:42:45 +01:00
{
struct d_print_mod dpm;
dpm.next = dpi->modifiers;
dpi->modifiers = &dpm;
dpm.mod = dc;
dpm.printed = 0;
2003-11-27 02:17:34 +01:00
dpm.templates = dpi->templates;
2003-11-21 18:42:45 +01:00
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_right (dc));
2003-11-21 18:42:45 +01:00
/* If the modifier didn't get printed by the type, print it
now. */
if (! dpm.printed)
2011-06-14 01:01:48 +02:00
d_print_mod (dpi, options, dc);
2003-11-21 18:42:45 +01:00
dpi->modifiers = dpm.next;
2003-11-21 18:42:45 +01:00
return;
}
2008-12-11 00:28:19 +01:00
case DEMANGLE_COMPONENT_FIXED_TYPE:
if (dc->u.s_fixed.sat)
d_append_string (dpi, "_Sat ");
/* Don't print "int _Accum". */
if (dc->u.s_fixed.length->u.s_builtin.type
!= &cplus_demangle_builtin_types['i'-'a'])
{
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, dc->u.s_fixed.length);
2008-12-11 00:28:19 +01:00
d_append_char (dpi, ' ');
}
if (dc->u.s_fixed.accum)
d_append_string (dpi, "_Accum");
else
d_append_string (dpi, "_Fract");
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_ARGLIST:
case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
2008-10-07 03:28:01 +02:00
if (d_left (dc) != NULL)
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_left (dc));
2003-11-21 18:42:45 +01:00
if (d_right (dc) != NULL)
{
2008-12-18 16:56:12 +01:00
size_t len;
unsigned long int flush_count;
/* Make sure ", " isn't flushed by d_append_string, otherwise
dpi->len -= 2 wouldn't work. */
if (dpi->len >= sizeof (dpi->buf) - 2)
d_print_flush (dpi);
2007-01-31 00:16:58 +01:00
d_append_string (dpi, ", ");
2008-12-18 16:56:12 +01:00
len = dpi->len;
flush_count = dpi->flush_count;
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_right (dc));
2008-12-18 16:56:12 +01:00
/* If that didn't print anything (which can happen with empty
template argument packs), remove the comma and space. */
if (dpi->flush_count == flush_count && dpi->len == len)
2008-12-18 16:56:12 +01:00
dpi->len -= 2;
2003-11-21 18:42:45 +01:00
}
return;
2012-01-06 23:04:43 +01:00
case DEMANGLE_COMPONENT_INITIALIZER_LIST:
{
struct demangle_component *type = d_left (dc);
struct demangle_component *list = d_right (dc);
if (type)
d_print_comp (dpi, options, type);
d_append_char (dpi, '{');
d_print_comp (dpi, options, list);
d_append_char (dpi, '}');
}
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_OPERATOR:
2003-11-21 18:42:45 +01:00
{
2012-01-10 19:15:34 +01:00
const struct demangle_operator_info *op = dc->u.s_operator.op;
int len = op->len;
2003-11-21 18:42:45 +01:00
2007-01-31 00:16:58 +01:00
d_append_string (dpi, "operator");
2012-01-10 19:15:34 +01:00
/* Add a space before new/delete. */
if (IS_LOWER (op->name[0]))
2003-11-21 18:42:45 +01:00
d_append_char (dpi, ' ');
2012-01-10 19:15:34 +01:00
/* Omit a trailing space. */
if (op->name[len-1] == ' ')
--len;
d_append_buffer (dpi, op->name, len);
2003-11-21 18:42:45 +01:00
return;
}
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
2007-01-31 00:16:58 +01:00
d_append_string (dpi, "operator ");
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, dc->u.s_extended_operator.name);
2003-11-21 18:42:45 +01:00
return;
PR other/61321 - demangler crash on casts in template parameters The fix for bug 59195: [C++ demangler handles conversion operator incorrectly] https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59195 unfortunately makes the demangler crash due to infinite recursion, in case of casts in template parameters. For example, with: template<int> struct A {}; template <typename Y> void function_temp(A<sizeof ((Y)(999))>) {} template void function_temp<int>(A<sizeof (int)>); The 'function_temp<int>' instantiation above mangles to: _Z13function_tempIiEv1AIXszcvT_Li999EEE The demangler parses this as: typed name template name 'function_temp' template argument list builtin type int function type builtin type void argument list template (*) name 'A' template argument list unary operator operator sizeof unary operator cast template parameter 0 (**) literal builtin type int name '999' And after the fix for 59195, due to: static void d_print_cast (struct d_print_info *dpi, int options, const struct demangle_component *dc) { ... /* For a cast operator, we need the template parameters from the enclosing template in scope for processing the type. */ if (dpi->current_template != NULL) { dpt.next = dpi->templates; dpi->templates = &dpt; dpt.template_decl = dpi->current_template; } when printing the template argument list of A (what should be "<sizeof (int)>"), the template parameter 0 (that is, "T_", the '**' above) now refers to the first parameter of the the template argument list of the 'A' template (the '*' above), exactly what we were already trying to print. This leads to infinite recursion, and stack exaustion. The template parameter 0 should actually refer to the first parameter of the 'function_temp' template. Where it reads "for the cast operator" in the comment in d_print_cast (above), it's really talking about a conversion operator, like: struct A { template <typename U> explicit operator U(); }; We don't want to inject the template parameters from the enclosing template in scope when processing a cast _expression_, only when handling a conversion operator. The problem is that DEMANGLE_COMPONENT_CAST is currently ambiguous, and means _both_ 'conversion operator' and 'cast expression'. Fix this by adding a new DEMANGLE_COMPONENT_CONVERSION component type, which does what DEMANGLE_COMPONENT_CAST does today, and making DEMANGLE_COMPONENT_CAST just simply print its component subtree. I think we could instead reuse DEMANGLE_COMPONENT_CAST and in d_print_comp_inner still do: @@ -5001,9 +5013,9 @@ d_print_comp_inner (struct d_print_info *dpi, int options, d_print_comp (dpi, options, dc->u.s_extended_operator.name); return; case DEMANGLE_COMPONENT_CAST: d_append_string (dpi, "operator "); - d_print_cast (dpi, options, dc); + d_print_conversion (dpi, options, dc); return; leaving the unary cast case below calling d_print_cast, but seems to me that spliting the component types makes it easier to reason about the code. g++'s testsuite actually generates three symbols that crash the demangler in the same way. I've added those as tests in the demangler testsuite as well. And then this fixes PR other/61233 too, which happens to be a demangler crash originally reported to GDB, at: https://sourceware.org/bugzilla/show_bug.cgi?id=16957 Bootstrapped and regtested on x86_64 Fedora 20. Also ran this through GDB's testsuite. GDB will require a small update to use DEMANGLE_COMPONENT_CONVERSION in one place it's using DEMANGLE_COMPONENT_CAST in its sources. libiberty/ 2015-11-27 Pedro Alves <palves@redhat.com> PR other/61321 PR other/61233 * demangle.h (enum demangle_component_type) <DEMANGLE_COMPONENT_CONVERSION>: New value. * cp-demangle.c (d_demangle_callback, d_make_comp): Handle DEMANGLE_COMPONENT_CONVERSION. (is_ctor_dtor_or_conversion): Handle DEMANGLE_COMPONENT_CONVERSION instead of DEMANGLE_COMPONENT_CAST. (d_operator_name): Return a DEMANGLE_COMPONENT_CONVERSION component if handling a conversion. (d_count_templates_scopes, d_print_comp_inner): Handle DEMANGLE_COMPONENT_CONVERSION. (d_print_comp_inner): Handle DEMANGLE_COMPONENT_CONVERSION instead of DEMANGLE_COMPONENT_CAST. (d_print_cast): Rename as ... (d_print_conversion): ... this. Adjust comments. (d_print_cast): Rewrite - simply print the left subcomponent. * cp-demint.c (cplus_demangle_fill_component): Handle DEMANGLE_COMPONENT_CONVERSION. * testsuite/demangle-expected: Add tests. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@231020 138bc75d-0d04-0410-961f-82ee72b054a4
2015-11-28 17:39:31 +01:00
case DEMANGLE_COMPONENT_CONVERSION:
2007-01-31 00:16:58 +01:00
d_append_string (dpi, "operator ");
PR other/61321 - demangler crash on casts in template parameters The fix for bug 59195: [C++ demangler handles conversion operator incorrectly] https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59195 unfortunately makes the demangler crash due to infinite recursion, in case of casts in template parameters. For example, with: template<int> struct A {}; template <typename Y> void function_temp(A<sizeof ((Y)(999))>) {} template void function_temp<int>(A<sizeof (int)>); The 'function_temp<int>' instantiation above mangles to: _Z13function_tempIiEv1AIXszcvT_Li999EEE The demangler parses this as: typed name template name 'function_temp' template argument list builtin type int function type builtin type void argument list template (*) name 'A' template argument list unary operator operator sizeof unary operator cast template parameter 0 (**) literal builtin type int name '999' And after the fix for 59195, due to: static void d_print_cast (struct d_print_info *dpi, int options, const struct demangle_component *dc) { ... /* For a cast operator, we need the template parameters from the enclosing template in scope for processing the type. */ if (dpi->current_template != NULL) { dpt.next = dpi->templates; dpi->templates = &dpt; dpt.template_decl = dpi->current_template; } when printing the template argument list of A (what should be "<sizeof (int)>"), the template parameter 0 (that is, "T_", the '**' above) now refers to the first parameter of the the template argument list of the 'A' template (the '*' above), exactly what we were already trying to print. This leads to infinite recursion, and stack exaustion. The template parameter 0 should actually refer to the first parameter of the 'function_temp' template. Where it reads "for the cast operator" in the comment in d_print_cast (above), it's really talking about a conversion operator, like: struct A { template <typename U> explicit operator U(); }; We don't want to inject the template parameters from the enclosing template in scope when processing a cast _expression_, only when handling a conversion operator. The problem is that DEMANGLE_COMPONENT_CAST is currently ambiguous, and means _both_ 'conversion operator' and 'cast expression'. Fix this by adding a new DEMANGLE_COMPONENT_CONVERSION component type, which does what DEMANGLE_COMPONENT_CAST does today, and making DEMANGLE_COMPONENT_CAST just simply print its component subtree. I think we could instead reuse DEMANGLE_COMPONENT_CAST and in d_print_comp_inner still do: @@ -5001,9 +5013,9 @@ d_print_comp_inner (struct d_print_info *dpi, int options, d_print_comp (dpi, options, dc->u.s_extended_operator.name); return; case DEMANGLE_COMPONENT_CAST: d_append_string (dpi, "operator "); - d_print_cast (dpi, options, dc); + d_print_conversion (dpi, options, dc); return; leaving the unary cast case below calling d_print_cast, but seems to me that spliting the component types makes it easier to reason about the code. g++'s testsuite actually generates three symbols that crash the demangler in the same way. I've added those as tests in the demangler testsuite as well. And then this fixes PR other/61233 too, which happens to be a demangler crash originally reported to GDB, at: https://sourceware.org/bugzilla/show_bug.cgi?id=16957 Bootstrapped and regtested on x86_64 Fedora 20. Also ran this through GDB's testsuite. GDB will require a small update to use DEMANGLE_COMPONENT_CONVERSION in one place it's using DEMANGLE_COMPONENT_CAST in its sources. libiberty/ 2015-11-27 Pedro Alves <palves@redhat.com> PR other/61321 PR other/61233 * demangle.h (enum demangle_component_type) <DEMANGLE_COMPONENT_CONVERSION>: New value. * cp-demangle.c (d_demangle_callback, d_make_comp): Handle DEMANGLE_COMPONENT_CONVERSION. (is_ctor_dtor_or_conversion): Handle DEMANGLE_COMPONENT_CONVERSION instead of DEMANGLE_COMPONENT_CAST. (d_operator_name): Return a DEMANGLE_COMPONENT_CONVERSION component if handling a conversion. (d_count_templates_scopes, d_print_comp_inner): Handle DEMANGLE_COMPONENT_CONVERSION. (d_print_comp_inner): Handle DEMANGLE_COMPONENT_CONVERSION instead of DEMANGLE_COMPONENT_CAST. (d_print_cast): Rename as ... (d_print_conversion): ... this. Adjust comments. (d_print_cast): Rewrite - simply print the left subcomponent. * cp-demint.c (cplus_demangle_fill_component): Handle DEMANGLE_COMPONENT_CONVERSION. * testsuite/demangle-expected: Add tests. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@231020 138bc75d-0d04-0410-961f-82ee72b054a4
2015-11-28 17:39:31 +01:00
d_print_conversion (dpi, options, dc);
2003-11-21 18:42:45 +01:00
return;
2012-01-06 23:04:43 +01:00
case DEMANGLE_COMPONENT_NULLARY:
d_print_expr_op (dpi, options, d_left (dc));
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_UNARY:
2012-01-06 23:04:43 +01:00
{
struct demangle_component *op = d_left (dc);
struct demangle_component *operand = d_right (dc);
const char *code = NULL;
2012-01-06 23:04:43 +01:00
if (op->type == DEMANGLE_COMPONENT_OPERATOR)
{
code = op->u.s_operator.op->code;
if (!strcmp (code, "ad"))
{
/* Don't print the argument list for the address of a
function. */
if (operand->type == DEMANGLE_COMPONENT_TYPED_NAME
&& d_left (operand)->type == DEMANGLE_COMPONENT_QUAL_NAME
&& d_right (operand)->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
operand = d_left (operand);
}
if (operand->type == DEMANGLE_COMPONENT_BINARY_ARGS)
{
/* This indicates a suffix operator. */
operand = d_left (operand);
d_print_subexpr (dpi, options, operand);
d_print_expr_op (dpi, options, op);
return;
}
}
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
/* For sizeof..., just print the pack length. */
if (code && !strcmp (code, "sZ"))
{
struct demangle_component *a = d_find_pack (dpi, operand);
int len = d_pack_length (a);
d_append_num (dpi, len);
return;
}
else if (code && !strcmp (code, "sP"))
{
int len = d_args_length (dpi, operand);
d_append_num (dpi, len);
return;
}
2012-01-06 23:04:43 +01:00
if (op->type != DEMANGLE_COMPONENT_CAST)
d_print_expr_op (dpi, options, op);
else
{
d_append_char (dpi, '(');
d_print_cast (dpi, options, op);
d_append_char (dpi, ')');
}
if (code && !strcmp (code, "gs"))
/* Avoid parens after '::'. */
d_print_comp (dpi, options, operand);
else if (code && !strcmp (code, "st"))
/* Always print parens for sizeof (type). */
{
d_append_char (dpi, '(');
d_print_comp (dpi, options, operand);
d_append_char (dpi, ')');
}
else
d_print_subexpr (dpi, options, operand);
}
2003-11-21 18:42:45 +01:00
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_BINARY:
if (d_right (dc)->type != DEMANGLE_COMPONENT_BINARY_ARGS)
{
2003-11-21 18:42:45 +01:00
d_print_error (dpi);
return;
}
2003-12-04 21:03:39 +01:00
2012-07-18 22:09:08 +02:00
if (op_is_new_cast (d_left (dc)))
{
d_print_expr_op (dpi, options, d_left (dc));
d_append_char (dpi, '<');
d_print_comp (dpi, options, d_left (d_right (dc)));
d_append_string (dpi, ">(");
d_print_comp (dpi, options, d_right (d_right (dc)));
d_append_char (dpi, ')');
return;
}
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
if (d_maybe_print_fold_expression (dpi, options, dc))
return;
2003-12-04 21:03:39 +01:00
/* We wrap an expression which uses the greater-than operator in
an extra layer of parens so that it does not get confused
with the '>' which ends the template parameters. */
2004-01-12 22:24:38 +01:00
if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
2003-12-22 17:03:32 +01:00
&& d_left (dc)->u.s_operator.op->len == 1
&& d_left (dc)->u.s_operator.op->name[0] == '>')
2003-12-04 21:03:39 +01:00
d_append_char (dpi, '(');
if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") == 0
&& d_left (d_right (dc))->type == DEMANGLE_COMPONENT_TYPED_NAME)
{
/* Function call used in an expression should not have printed types
of the function arguments. Values of the function arguments still
get printed below. */
const struct demangle_component *func = d_left (d_right (dc));
if (d_right (func)->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
d_print_error (dpi);
d_print_subexpr (dpi, options, d_left (func));
}
else
d_print_subexpr (dpi, options, d_left (d_right (dc)));
2010-01-21 03:05:11 +01:00
if (strcmp (d_left (dc)->u.s_operator.op->code, "ix") == 0)
{
d_append_char (dpi, '[');
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_right (d_right (dc)));
2010-01-21 03:05:11 +01:00
d_append_char (dpi, ']');
}
else
{
if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") != 0)
2011-06-14 01:01:48 +02:00
d_print_expr_op (dpi, options, d_left (dc));
d_print_subexpr (dpi, options, d_right (d_right (dc)));
2010-01-21 03:05:11 +01:00
}
2003-12-04 21:03:39 +01:00
2004-01-12 22:24:38 +01:00
if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
2003-12-22 17:03:32 +01:00
&& d_left (dc)->u.s_operator.op->len == 1
&& d_left (dc)->u.s_operator.op->name[0] == '>')
2003-12-04 21:03:39 +01:00
d_append_char (dpi, ')');
2003-11-21 18:42:45 +01:00
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_BINARY_ARGS:
/* We should only see this as part of DEMANGLE_COMPONENT_BINARY. */
2003-11-21 18:42:45 +01:00
d_print_error (dpi);
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_TRINARY:
if (d_right (dc)->type != DEMANGLE_COMPONENT_TRINARY_ARG1
|| d_right (d_right (dc))->type != DEMANGLE_COMPONENT_TRINARY_ARG2)
2003-11-21 18:42:45 +01:00
{
d_print_error (dpi);
return;
}
Synchronize libiberty sources with FSF GCC mainline version. include * libiberty.h (MAX_ALLOCA_SIZE): New macro. libiberty * make-relative-prefix.c (make_relative_prefix_1): Fall back to malloc if alloca argument is greater than MAX_ALLOCA_SIZE. * cp-demangle.c (cplus_demangle_operators): Add f[lrLR]. (d_expression_1): Handle them. (d_maybe_print_fold_expression): New. (d_print_comp_inner): Use it. (d_index_template_argument): Handle negative index. * cp-demangle.c (cplus_demangle_operators): Add sP and sZ. (d_print_comp_inner): Handle them. (d_template_args_1): Split out from d_template_args. (d_args_length): New. PR c++/70926 * cplus-dem.c: Handle large values and overflow when demangling length variables. (demangle_template_value_parm): Read only until end of mangled string. (do_hpacc_template_literal): Likewise. (do_type): Handle overflow when demangling array indices. * cp-demangle.c (cplus_demangle_print_callback): Avoid zero-length VLAs. PR c++/70498 * cp-demangle.c (d_expression_1): Formatting fix. * cplus-dem.c (enum type_kind_t): Add tk_rvalue_reference constant. (demangle_template_value_parm): Handle tk_rvalue_reference type kind. (do_type): Support 'O' type id (rvalue references). * testsuite/demangle-expected: Add tests. PR c++/70498 * cp-demangle.c: Parse numbers as integer instead of long to avoid overflow after sanity checks. Include <limits.h> if available. (INT_MAX): Define if necessary. (d_make_template_param): Takes integer argument instead of long. (d_make_function_param): Likewise. (d_append_num): Likewise. (d_identifier): Likewise. (d_number): Parse as and return integer. (d_compact_number): Handle overflow. (d_source_name): Change variable type to integer for parsed number. (d_java_resource): Likewise. (d_special_name): Likewise. (d_discriminator): Likewise. (d_unnamed_type): Likewise. * testsuite/demangle-expected: Add regression test cases. * configure: Remove SH5 support. PR c++/69687 * cplus-dem.c: Include <limits.h> if available. (INT_MAX): Define if necessary. (remember_type, remember_Ktype, register_Btype, string_need): Abort if we detect cases where we the size of the allocation would overflow. PR c++/70492 * cplus-dem.c (gnu_special): Handle case where consume_count returns -1. PR c++/67394 PR c++/70481 * cplus-dem.c (squangle_mop_up): Zero bsize/ksize after freeing btypevec/ktypevec. * testsuite/demangle-expected: Add coverage tests.
2016-08-02 14:26:28 +02:00
if (d_maybe_print_fold_expression (dpi, options, dc))
return;
2012-01-06 23:04:43 +01:00
{
struct demangle_component *op = d_left (dc);
struct demangle_component *first = d_left (d_right (dc));
struct demangle_component *second = d_left (d_right (d_right (dc)));
struct demangle_component *third = d_right (d_right (d_right (dc)));
if (!strcmp (op->u.s_operator.op->code, "qu"))
{
d_print_subexpr (dpi, options, first);
d_print_expr_op (dpi, options, op);
d_print_subexpr (dpi, options, second);
d_append_string (dpi, " : ");
d_print_subexpr (dpi, options, third);
}
else
{
d_append_string (dpi, "new ");
if (d_left (first) != NULL)
{
d_print_subexpr (dpi, options, first);
d_append_char (dpi, ' ');
}
d_print_comp (dpi, options, second);
if (third)
d_print_subexpr (dpi, options, third);
}
}
2003-11-21 18:42:45 +01:00
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_TRINARY_ARG1:
case DEMANGLE_COMPONENT_TRINARY_ARG2:
/* We should only see these are part of DEMANGLE_COMPONENT_TRINARY. */
2003-11-21 18:42:45 +01:00
d_print_error (dpi);
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_LITERAL:
case DEMANGLE_COMPONENT_LITERAL_NEG:
2004-02-25 06:40:03 +01:00
{
enum d_builtin_type_print tp;
2003-11-21 18:42:45 +01:00
2004-02-25 06:40:03 +01:00
/* For some builtin types, produce simpler output. */
tp = D_PRINT_DEFAULT;
if (d_left (dc)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE)
{
tp = d_left (dc)->u.s_builtin.type->print;
switch (tp)
{
case D_PRINT_INT:
case D_PRINT_UNSIGNED:
case D_PRINT_LONG:
case D_PRINT_UNSIGNED_LONG:
case D_PRINT_LONG_LONG:
case D_PRINT_UNSIGNED_LONG_LONG:
if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME)
{
if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
d_append_char (dpi, '-');
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_right (dc));
2004-02-25 06:40:03 +01:00
switch (tp)
{
default:
break;
case D_PRINT_UNSIGNED:
d_append_char (dpi, 'u');
break;
case D_PRINT_LONG:
d_append_char (dpi, 'l');
break;
case D_PRINT_UNSIGNED_LONG:
2007-01-31 00:16:58 +01:00
d_append_string (dpi, "ul");
2004-02-25 06:40:03 +01:00
break;
case D_PRINT_LONG_LONG:
2007-01-31 00:16:58 +01:00
d_append_string (dpi, "ll");
2004-02-25 06:40:03 +01:00
break;
case D_PRINT_UNSIGNED_LONG_LONG:
2007-01-31 00:16:58 +01:00
d_append_string (dpi, "ull");
2004-02-25 06:40:03 +01:00
break;
}
return;
}
break;
2004-02-25 06:40:03 +01:00
case D_PRINT_BOOL:
if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME
&& d_right (dc)->u.s_name.len == 1
&& dc->type == DEMANGLE_COMPONENT_LITERAL)
{
switch (d_right (dc)->u.s_name.s[0])
{
case '0':
2007-01-31 00:16:58 +01:00
d_append_string (dpi, "false");
2004-02-25 06:40:03 +01:00
return;
case '1':
2007-01-31 00:16:58 +01:00
d_append_string (dpi, "true");
2004-02-25 06:40:03 +01:00
return;
default:
break;
}
}
break;
2000-07-20 20:56:16 +02:00
2004-02-25 06:40:03 +01:00
default:
break;
}
}
2004-02-25 06:40:03 +01:00
d_append_char (dpi, '(');
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_left (dc));
2004-02-25 06:40:03 +01:00
d_append_char (dpi, ')');
if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
d_append_char (dpi, '-');
if (tp == D_PRINT_FLOAT)
d_append_char (dpi, '[');
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_right (dc));
2004-02-25 06:40:03 +01:00
if (tp == D_PRINT_FLOAT)
d_append_char (dpi, ']');
}
2003-11-21 18:42:45 +01:00
return;
2010-02-04 00:28:01 +01:00
case DEMANGLE_COMPONENT_NUMBER:
d_append_num (dpi, dc->u.s_number.number);
return;
case DEMANGLE_COMPONENT_JAVA_RESOURCE:
d_append_string (dpi, "java resource ");
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_left (dc));
return;
case DEMANGLE_COMPONENT_COMPOUND_NAME:
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_left (dc));
d_print_comp (dpi, options, d_right (dc));
return;
case DEMANGLE_COMPONENT_CHARACTER:
d_append_char (dpi, dc->u.s_character.character);
return;
2008-09-09 20:21:49 +02:00
case DEMANGLE_COMPONENT_DECLTYPE:
d_append_string (dpi, "decltype (");
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_left (dc));
2008-09-09 20:21:49 +02:00
d_append_char (dpi, ')');
return;
2008-10-07 03:28:01 +02:00
case DEMANGLE_COMPONENT_PACK_EXPANSION:
{
2009-03-23 23:05:12 +01:00
int len;
2008-10-07 03:28:01 +02:00
int i;
2009-03-23 23:05:12 +01:00
struct demangle_component *a = d_find_pack (dpi, d_left (dc));
if (a == NULL)
{
/* d_find_pack won't find anything if the only packs involved
in this expansion are function parameter packs; in that
case, just print the pattern and "...". */
2011-06-14 01:01:48 +02:00
d_print_subexpr (dpi, options, d_left (dc));
2009-03-23 23:05:12 +01:00
d_append_string (dpi, "...");
return;
}
2008-10-07 03:28:01 +02:00
2009-03-23 23:05:12 +01:00
len = d_pack_length (a);
2008-10-07 03:28:01 +02:00
dc = d_left (dc);
for (i = 0; i < len; ++i)
{
dpi->pack_index = i;
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, dc);
2008-10-07 03:28:01 +02:00
if (i < len-1)
d_append_string (dpi, ", ");
}
}
return;
2009-03-18 01:07:49 +01:00
case DEMANGLE_COMPONENT_FUNCTION_PARAM:
2011-07-05 17:40:17 +02:00
{
long num = dc->u.s_number.number;
if (num == 0)
d_append_string (dpi, "this");
else
{
d_append_string (dpi, "{parm#");
d_append_num (dpi, num);
d_append_char (dpi, '}');
}
}
2009-10-02 20:23:01 +02:00
return;
2009-03-18 01:07:49 +01:00
2009-07-17 22:20:45 +02:00
case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
d_append_string (dpi, "global constructors keyed to ");
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, dc->u.s_binary.left);
2009-07-17 22:20:45 +02:00
return;
case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
d_append_string (dpi, "global destructors keyed to ");
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, dc->u.s_binary.left);
2009-07-17 22:20:45 +02:00
return;
2009-10-02 20:23:01 +02:00
case DEMANGLE_COMPONENT_LAMBDA:
d_append_string (dpi, "{lambda(");
/* Generic lambda auto parms are mangled as the template type
parm they are. */
dpi->is_lambda_arg++;
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, dc->u.s_unary_num.sub);
dpi->is_lambda_arg--;
2009-10-02 20:23:01 +02:00
d_append_string (dpi, ")#");
d_append_num (dpi, dc->u.s_unary_num.num + 1);
d_append_char (dpi, '}');
return;
case DEMANGLE_COMPONENT_UNNAMED_TYPE:
d_append_string (dpi, "{unnamed type#");
d_append_num (dpi, dc->u.s_number.number + 1);
d_append_char (dpi, '}');
return;
2011-09-24 00:21:36 +02:00
case DEMANGLE_COMPONENT_CLONE:
d_print_comp (dpi, options, d_left (dc));
d_append_string (dpi, " [clone ");
d_print_comp (dpi, options, d_right (dc));
d_append_char (dpi, ']');
return;
2003-11-21 18:42:45 +01:00
default:
d_print_error (dpi);
return;
}
}
static void
d_print_comp (struct d_print_info *dpi, int options,
struct demangle_component *dc)
{
struct d_component_stack self;
if (dc == NULL || dc->d_printing > 1 || dpi->recursion > MAX_RECURSION_COUNT)
{
d_print_error (dpi);
return;
}
dc->d_printing++;
dpi->recursion++;
self.dc = dc;
self.parent = dpi->component_stack;
dpi->component_stack = &self;
d_print_comp_inner (dpi, options, dc);
dpi->component_stack = self.parent;
dc->d_printing--;
dpi->recursion--;
}
2003-12-22 17:03:32 +01:00
/* Print a Java dentifier. For Java we try to handle encoded extended
Unicode characters. The C++ ABI doesn't mention Unicode encoding,
so we don't it for C++. Characters are encoded as
__U<hex-char>+_. */
2003-11-21 18:42:45 +01:00
static void
2005-03-27 07:28:42 +02:00
d_print_java_identifier (struct d_print_info *dpi, const char *name, int len)
{
2003-12-22 17:03:32 +01:00
const char *p;
const char *end;
2003-12-22 17:03:32 +01:00
end = name + len;
for (p = name; p < end; ++p)
{
if (end - p > 3
&& p[0] == '_'
&& p[1] == '_'
&& p[2] == 'U')
{
2003-12-22 17:03:32 +01:00
unsigned long c;
const char *q;
c = 0;
for (q = p + 3; q < end; ++q)
2003-11-21 18:42:45 +01:00
{
2003-12-22 17:03:32 +01:00
int dig;
if (IS_DIGIT (*q))
dig = *q - '0';
else if (*q >= 'A' && *q <= 'F')
dig = *q - 'A' + 10;
else if (*q >= 'a' && *q <= 'f')
dig = *q - 'a' + 10;
else
break;
2003-12-22 17:03:32 +01:00
c = c * 16 + dig;
}
/* If the Unicode character is larger than 256, we don't try
to deal with it here. FIXME. */
if (q < end && *q == '_' && c < 256)
{
d_append_char (dpi, c);
p = q;
continue;
2003-11-21 18:42:45 +01:00
}
}
2003-12-22 17:03:32 +01:00
d_append_char (dpi, *p);
}
}
2003-12-04 21:03:39 +01:00
/* Print a list of modifiers. SUFFIX is 1 if we are printing
qualifiers on this after printing a function. */
2003-11-21 18:42:45 +01:00
static void
2011-06-14 01:01:48 +02:00
d_print_mod_list (struct d_print_info *dpi, int options,
2005-03-27 07:28:42 +02:00
struct d_print_mod *mods, int suffix)
{
2003-11-27 02:17:34 +01:00
struct d_print_template *hold_dpt;
2003-12-04 21:03:39 +01:00
if (mods == NULL || d_print_saw_error (dpi))
2003-11-21 18:42:45 +01:00
return;
2003-12-04 21:03:39 +01:00
if (mods->printed
|| (! suffix
&& (is_fnqual_component_type (mods->mod->type))))
2003-12-04 21:03:39 +01:00
{
2011-06-14 01:01:48 +02:00
d_print_mod_list (dpi, options, mods->next, suffix);
2003-12-04 21:03:39 +01:00
return;
}
2003-11-27 02:17:34 +01:00
mods->printed = 1;
hold_dpt = dpi->templates;
dpi->templates = mods->templates;
2004-01-12 22:24:38 +01:00
if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
{
2011-06-14 01:01:48 +02:00
d_print_function_type (dpi, options, mods->mod, mods->next);
2003-11-27 02:17:34 +01:00
dpi->templates = hold_dpt;
2003-11-21 18:42:45 +01:00
return;
}
2004-01-12 22:24:38 +01:00
else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
2003-11-21 18:42:45 +01:00
{
2011-06-14 01:01:48 +02:00
d_print_array_type (dpi, options, mods->mod, mods->next);
2003-11-27 02:17:34 +01:00
dpi->templates = hold_dpt;
2003-11-21 18:42:45 +01:00
return;
}
2004-01-12 22:24:38 +01:00
else if (mods->mod->type == DEMANGLE_COMPONENT_LOCAL_NAME)
2003-12-19 23:03:41 +01:00
{
struct d_print_mod *hold_modifiers;
2004-01-12 22:24:38 +01:00
struct demangle_component *dc;
2003-12-19 23:03:41 +01:00
/* When this is on the modifier stack, we have pulled any
qualifiers off the right argument already. Otherwise, we
print it as usual, but don't let the left argument see any
modifiers. */
hold_modifiers = dpi->modifiers;
dpi->modifiers = NULL;
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_left (mods->mod));
2003-12-19 23:03:41 +01:00
dpi->modifiers = hold_modifiers;
2011-06-14 01:01:48 +02:00
if ((options & DMGL_JAVA) == 0)
2007-01-31 00:16:58 +01:00
d_append_string (dpi, "::");
2003-12-22 17:03:32 +01:00
else
d_append_char (dpi, '.');
2003-12-19 23:03:41 +01:00
dc = d_right (mods->mod);
2009-10-02 20:23:01 +02:00
if (dc->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
{
d_append_string (dpi, "{default arg#");
d_append_num (dpi, dc->u.s_unary_num.num + 1);
d_append_string (dpi, "}::");
dc = dc->u.s_unary_num.sub;
}
while (is_fnqual_component_type (dc->type))
2003-12-19 23:03:41 +01:00
dc = d_left (dc);
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, dc);
2003-12-19 23:03:41 +01:00
dpi->templates = hold_dpt;
return;
}
2011-06-14 01:01:48 +02:00
d_print_mod (dpi, options, mods->mod);
2003-11-27 02:17:34 +01:00
dpi->templates = hold_dpt;
2011-06-14 01:01:48 +02:00
d_print_mod_list (dpi, options, mods->next, suffix);
}
2003-11-27 02:17:34 +01:00
2003-11-21 18:42:45 +01:00
/* Print a modifier. */
2003-11-21 18:42:45 +01:00
static void
2011-06-14 01:01:48 +02:00
d_print_mod (struct d_print_info *dpi, int options,
struct demangle_component *mod)
2003-11-21 18:42:45 +01:00
{
switch (mod->type)
{
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_RESTRICT:
case DEMANGLE_COMPONENT_RESTRICT_THIS:
2007-01-31 00:16:58 +01:00
d_append_string (dpi, " restrict");
2003-11-21 18:42:45 +01:00
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_VOLATILE:
case DEMANGLE_COMPONENT_VOLATILE_THIS:
2007-01-31 00:16:58 +01:00
d_append_string (dpi, " volatile");
2003-11-21 18:42:45 +01:00
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_CONST:
case DEMANGLE_COMPONENT_CONST_THIS:
2007-01-31 00:16:58 +01:00
d_append_string (dpi, " const");
2003-11-21 18:42:45 +01:00
return;
Implement N4514, C++ Extensions for Transactional Memory. gcc/ * builtins.def (BUILT_IN_ABORT): Add transaction_pure attribute. gcc/c-family/ * c-common.c (c_common_reswords): Add C++ TM TS keywords. (c_common_attribute_table): Add transaction_safe_dynamic. transaction_safe now affects type identity. (handle_tm_attribute): Handle transaction_safe_dynamic. * c-common.h (enum rid): Add RID_ATOMIC_NOEXCEPT, RID_ATOMIC_CANCEL, RID_SYNCHRONIZED. (OBJC_IS_CXX_KEYWORD): Add RID_SYNCHRONIZED. (D_TRANSMEM): New. * c-cppbuiltin.c (c_cpp_builtins): Define __cpp_transactional_memory. * c-pretty-print.c (pp_c_attributes_display): Don't print transaction_safe in C++. gcc/c/ * c-parser.c (c_lex_one_token): Handle @synchronized. * c-decl.c (match_builtin_function_types): A declaration of a built-in can change whether the function is transaction_safe. gcc/cp/ * cp-tree.h (struct cp_declarator): Add tx_qualifier field. (BCS_NORMAL, BCS_TRANSACTION): New enumerators. * lex.c (init_reswords): Limit TM kewords to -fgnu-tm. * parser.c (cp_lexer_get_preprocessor_token): Fix @synchronized. (make_call_declarator): Take tx_qualifier. (cp_parser_tx_qualifier_opt): New. (cp_parser_lambda_declarator_opt): Use it. (cp_parser_direct_declarator): Likewise. (cp_parser_statement): Handle atomic_noexcept, atomic_cancel. (cp_parser_compound_statement): Change in_try parameter to bcs_flags. (cp_parser_std_attribute): Map optimize_for_synchronized to transaction_callable. (cp_parser_transaction): Take the token. Handle atomic_noexcept. * lambda.c (maybe_add_lambda_conv_op): Handle transaction-safety. * call.c (enum conversion_kind): Add ck_tsafe. (standard_conversion): Handle transaction-safety conversion. (convert_like_real, resolve_address_of_overloaded_function): Likewise. (check_methods): Diagnose transaction_safe_dynamic on non-virtual function. (look_for_tm_attr_overrides): Don't inherit transaction_safe_dynamic. * cvt.c (tx_safe_fn_type_p, tx_unsafe_fn_variant) (can_convert_tx_safety): New. * typeck.c (composite_pointer_type): Handle transaction-safety. * name-lookup.h (enum scope_kind): Add sk_transaction. * name-lookup.c (begin_scope): Handle it. * semantics.c (begin_compound_stmt): Pass it. * decl.c (check_previous_goto_1): Check it. (struct named_label_entry): Add in_transaction_scope. (poplevel_named_label_1): Set it. (check_goto): Check it. (duplicate_decls): A specialization can be transaction_safe independently of its template. (grokdeclarator): Handle tx-qualifier. * rtti.c (ptr_initializer): Handle transaction-safe. * search.c (check_final_overrider): Check transaction_safe_dynamic. Don't check transaction_safe. * mangle.c (write_function_type): Mangle transaction_safe here. (write_CV_qualifiers_for_type): Not here. (write_type): Preserve transaction_safe when stripping attributes. * error.c (dump_type_suffix): Print transaction_safe. libiberty/ * cp-demangle.c (d_cv_qualifiers): Dx means transaction_safe. (cplus_demangle_type): Let d_cv_qualifiers handle it. (d_dump, d_make_comp, has_return_type, d_encoding) (d_count_templates_scopes, d_print_comp_inner) (d_print_mod_list, d_print_mod, d_print_function_type) (is_ctor_or_dtor): Handle DEMANGLE_COMPONENT_TRANSACTION_SAFE. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@228462 138bc75d-0d04-0410-961f-82ee72b054a4
2015-11-28 17:39:30 +01:00
case DEMANGLE_COMPONENT_TRANSACTION_SAFE:
d_append_string (dpi, " transaction_safe");
return;
case DEMANGLE_COMPONENT_NOEXCEPT:
d_append_string (dpi, " noexcept");
if (d_right (mod))
{
d_append_char (dpi, '(');
d_print_comp (dpi, options, d_right (mod));
d_append_char (dpi, ')');
}
return;
case DEMANGLE_COMPONENT_THROW_SPEC:
d_append_string (dpi, " throw");
if (d_right (mod))
{
d_append_char (dpi, '(');
d_print_comp (dpi, options, d_right (mod));
d_append_char (dpi, ')');
}
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
2003-11-21 18:42:45 +01:00
d_append_char (dpi, ' ');
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_right (mod));
2003-11-21 18:42:45 +01:00
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_POINTER:
2003-11-21 18:42:45 +01:00
/* There is no pointer symbol in Java. */
2011-06-14 01:01:48 +02:00
if ((options & DMGL_JAVA) == 0)
2003-11-21 18:42:45 +01:00
d_append_char (dpi, '*');
return;
2013-04-03 20:21:49 +02:00
case DEMANGLE_COMPONENT_REFERENCE_THIS:
/* For the ref-qualifier, put a space before the &. */
d_append_char (dpi, ' ');
/* FALLTHRU */
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_REFERENCE:
2003-11-21 18:42:45 +01:00
d_append_char (dpi, '&');
return;
2013-04-03 20:21:49 +02:00
case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
d_append_char (dpi, ' ');
/* FALLTHRU */
2007-08-31 22:20:49 +02:00
case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
d_append_string (dpi, "&&");
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_COMPLEX:
2007-01-31 00:16:58 +01:00
d_append_string (dpi, "complex ");
2003-11-21 18:42:45 +01:00
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_IMAGINARY:
2007-01-31 00:16:58 +01:00
d_append_string (dpi, "imaginary ");
2003-11-21 18:42:45 +01:00
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_PTRMEM_TYPE:
2003-12-04 21:03:39 +01:00
if (d_last_char (dpi) != '(')
2003-11-21 18:42:45 +01:00
d_append_char (dpi, ' ');
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_left (mod));
2007-01-31 00:16:58 +01:00
d_append_string (dpi, "::*");
2003-11-21 18:42:45 +01:00
return;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_TYPED_NAME:
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_left (mod));
2003-11-21 18:42:45 +01:00
return;
2010-02-04 00:28:01 +01:00
case DEMANGLE_COMPONENT_VECTOR_TYPE:
2010-03-22 22:39:44 +01:00
d_append_string (dpi, " __vector(");
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_left (mod));
2010-03-22 22:39:44 +01:00
d_append_char (dpi, ')');
2010-02-04 00:28:01 +01:00
return;
2003-11-21 18:42:45 +01:00
default:
/* Otherwise, we have something that won't go back on the
modifier stack, so we can just print it. */
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, mod);
2003-11-21 18:42:45 +01:00
return;
}
}
2003-11-21 18:42:45 +01:00
/* Print a function type, except for the return type. */
2003-11-21 18:42:45 +01:00
static void
2011-06-14 01:01:48 +02:00
d_print_function_type (struct d_print_info *dpi, int options,
struct demangle_component *dc,
2005-03-27 07:28:42 +02:00
struct d_print_mod *mods)
{
2003-11-27 02:17:34 +01:00
int need_paren;
2004-02-25 06:40:03 +01:00
int need_space;
2003-11-27 02:17:34 +01:00
struct d_print_mod *p;
2003-12-19 23:03:41 +01:00
struct d_print_mod *hold_modifiers;
2003-11-27 02:17:34 +01:00
need_paren = 0;
2004-02-25 06:40:03 +01:00
need_space = 0;
2003-11-27 02:17:34 +01:00
for (p = mods; p != NULL; p = p->next)
2003-11-21 18:42:45 +01:00
{
2003-11-27 02:17:34 +01:00
if (p->printed)
break;
2003-11-27 02:17:34 +01:00
switch (p->mod->type)
2003-11-21 18:42:45 +01:00
{
2004-02-25 06:40:03 +01:00
case DEMANGLE_COMPONENT_POINTER:
case DEMANGLE_COMPONENT_REFERENCE:
2007-08-31 22:20:49 +02:00
case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
2004-02-25 06:40:03 +01:00
need_paren = 1;
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_RESTRICT:
case DEMANGLE_COMPONENT_VOLATILE:
case DEMANGLE_COMPONENT_CONST:
case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
case DEMANGLE_COMPONENT_COMPLEX:
case DEMANGLE_COMPONENT_IMAGINARY:
case DEMANGLE_COMPONENT_PTRMEM_TYPE:
2004-02-25 06:40:03 +01:00
need_space = 1;
2003-11-27 02:17:34 +01:00
need_paren = 1;
break;
FNQUAL_COMPONENT_CASE:
2003-12-04 21:03:39 +01:00
break;
2003-11-27 02:17:34 +01:00
default:
break;
2003-11-21 18:42:45 +01:00
}
2003-11-27 02:17:34 +01:00
if (need_paren)
break;
}
2003-11-27 02:17:34 +01:00
if (need_paren)
2003-12-04 21:03:39 +01:00
{
2004-02-25 06:40:03 +01:00
if (! need_space)
2003-12-04 21:03:39 +01:00
{
2004-02-25 06:40:03 +01:00
if (d_last_char (dpi) != '('
&& d_last_char (dpi) != '*')
need_space = 1;
2003-12-04 21:03:39 +01:00
}
2004-02-25 06:40:03 +01:00
if (need_space && d_last_char (dpi) != ' ')
d_append_char (dpi, ' ');
2003-12-04 21:03:39 +01:00
d_append_char (dpi, '(');
}
2003-12-19 23:03:41 +01:00
hold_modifiers = dpi->modifiers;
dpi->modifiers = NULL;
2011-06-14 01:01:48 +02:00
d_print_mod_list (dpi, options, mods, 0);
2003-11-27 02:17:34 +01:00
if (need_paren)
d_append_char (dpi, ')');
2003-11-21 18:42:45 +01:00
d_append_char (dpi, '(');
2003-11-21 18:42:45 +01:00
if (d_right (dc) != NULL)
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_right (dc));
2003-11-21 18:42:45 +01:00
d_append_char (dpi, ')');
2003-12-04 21:03:39 +01:00
2011-06-14 01:01:48 +02:00
d_print_mod_list (dpi, options, mods, 1);
2003-12-19 23:03:41 +01:00
dpi->modifiers = hold_modifiers;
2003-11-21 18:42:45 +01:00
}
2003-11-21 18:42:45 +01:00
/* Print an array type, except for the element type. */
2003-11-21 18:42:45 +01:00
static void
2011-06-14 01:01:48 +02:00
d_print_array_type (struct d_print_info *dpi, int options,
struct demangle_component *dc,
2005-03-27 07:28:42 +02:00
struct d_print_mod *mods)
2003-11-21 18:42:45 +01:00
{
int need_space;
2003-11-21 18:42:45 +01:00
need_space = 1;
if (mods != NULL)
{
2003-11-21 18:42:45 +01:00
int need_paren;
struct d_print_mod *p;
2000-07-20 20:56:16 +02:00
2003-11-21 18:42:45 +01:00
need_paren = 0;
for (p = mods; p != NULL; p = p->next)
{
2004-02-24 17:30:50 +01:00
if (! p->printed)
{
2004-02-24 17:30:50 +01:00
if (p->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
{
need_space = 0;
break;
}
else
{
need_paren = 1;
need_space = 1;
break;
}
}
2003-11-21 18:42:45 +01:00
}
2003-11-21 18:42:45 +01:00
if (need_paren)
2007-01-31 00:16:58 +01:00
d_append_string (dpi, " (");
2011-06-14 01:01:48 +02:00
d_print_mod_list (dpi, options, mods, 0);
2003-11-21 18:42:45 +01:00
if (need_paren)
d_append_char (dpi, ')');
}
2003-11-21 18:42:45 +01:00
if (need_space)
d_append_char (dpi, ' ');
2000-07-20 20:56:16 +02:00
2003-11-21 18:42:45 +01:00
d_append_char (dpi, '[');
2000-07-20 20:56:16 +02:00
2003-11-21 18:42:45 +01:00
if (d_left (dc) != NULL)
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_left (dc));
2003-11-21 18:42:45 +01:00
d_append_char (dpi, ']');
}
2003-11-21 18:42:45 +01:00
/* Print an operator in an expression. */
2003-11-21 18:42:45 +01:00
static void
2011-06-14 01:01:48 +02:00
d_print_expr_op (struct d_print_info *dpi, int options,
struct demangle_component *dc)
2003-11-21 18:42:45 +01:00
{
2004-01-12 22:24:38 +01:00
if (dc->type == DEMANGLE_COMPONENT_OPERATOR)
2003-12-22 17:03:32 +01:00
d_append_buffer (dpi, dc->u.s_operator.op->name,
dc->u.s_operator.op->len);
2003-11-21 18:42:45 +01:00
else
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, dc);
}
2003-11-21 18:42:45 +01:00
/* Print a cast. */
2003-11-21 18:42:45 +01:00
static void
2011-06-14 01:01:48 +02:00
d_print_cast (struct d_print_info *dpi, int options,
struct demangle_component *dc)
PR other/61321 - demangler crash on casts in template parameters The fix for bug 59195: [C++ demangler handles conversion operator incorrectly] https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59195 unfortunately makes the demangler crash due to infinite recursion, in case of casts in template parameters. For example, with: template<int> struct A {}; template <typename Y> void function_temp(A<sizeof ((Y)(999))>) {} template void function_temp<int>(A<sizeof (int)>); The 'function_temp<int>' instantiation above mangles to: _Z13function_tempIiEv1AIXszcvT_Li999EEE The demangler parses this as: typed name template name 'function_temp' template argument list builtin type int function type builtin type void argument list template (*) name 'A' template argument list unary operator operator sizeof unary operator cast template parameter 0 (**) literal builtin type int name '999' And after the fix for 59195, due to: static void d_print_cast (struct d_print_info *dpi, int options, const struct demangle_component *dc) { ... /* For a cast operator, we need the template parameters from the enclosing template in scope for processing the type. */ if (dpi->current_template != NULL) { dpt.next = dpi->templates; dpi->templates = &dpt; dpt.template_decl = dpi->current_template; } when printing the template argument list of A (what should be "<sizeof (int)>"), the template parameter 0 (that is, "T_", the '**' above) now refers to the first parameter of the the template argument list of the 'A' template (the '*' above), exactly what we were already trying to print. This leads to infinite recursion, and stack exaustion. The template parameter 0 should actually refer to the first parameter of the 'function_temp' template. Where it reads "for the cast operator" in the comment in d_print_cast (above), it's really talking about a conversion operator, like: struct A { template <typename U> explicit operator U(); }; We don't want to inject the template parameters from the enclosing template in scope when processing a cast _expression_, only when handling a conversion operator. The problem is that DEMANGLE_COMPONENT_CAST is currently ambiguous, and means _both_ 'conversion operator' and 'cast expression'. Fix this by adding a new DEMANGLE_COMPONENT_CONVERSION component type, which does what DEMANGLE_COMPONENT_CAST does today, and making DEMANGLE_COMPONENT_CAST just simply print its component subtree. I think we could instead reuse DEMANGLE_COMPONENT_CAST and in d_print_comp_inner still do: @@ -5001,9 +5013,9 @@ d_print_comp_inner (struct d_print_info *dpi, int options, d_print_comp (dpi, options, dc->u.s_extended_operator.name); return; case DEMANGLE_COMPONENT_CAST: d_append_string (dpi, "operator "); - d_print_cast (dpi, options, dc); + d_print_conversion (dpi, options, dc); return; leaving the unary cast case below calling d_print_cast, but seems to me that spliting the component types makes it easier to reason about the code. g++'s testsuite actually generates three symbols that crash the demangler in the same way. I've added those as tests in the demangler testsuite as well. And then this fixes PR other/61233 too, which happens to be a demangler crash originally reported to GDB, at: https://sourceware.org/bugzilla/show_bug.cgi?id=16957 Bootstrapped and regtested on x86_64 Fedora 20. Also ran this through GDB's testsuite. GDB will require a small update to use DEMANGLE_COMPONENT_CONVERSION in one place it's using DEMANGLE_COMPONENT_CAST in its sources. libiberty/ 2015-11-27 Pedro Alves <palves@redhat.com> PR other/61321 PR other/61233 * demangle.h (enum demangle_component_type) <DEMANGLE_COMPONENT_CONVERSION>: New value. * cp-demangle.c (d_demangle_callback, d_make_comp): Handle DEMANGLE_COMPONENT_CONVERSION. (is_ctor_dtor_or_conversion): Handle DEMANGLE_COMPONENT_CONVERSION instead of DEMANGLE_COMPONENT_CAST. (d_operator_name): Return a DEMANGLE_COMPONENT_CONVERSION component if handling a conversion. (d_count_templates_scopes, d_print_comp_inner): Handle DEMANGLE_COMPONENT_CONVERSION. (d_print_comp_inner): Handle DEMANGLE_COMPONENT_CONVERSION instead of DEMANGLE_COMPONENT_CAST. (d_print_cast): Rename as ... (d_print_conversion): ... this. Adjust comments. (d_print_cast): Rewrite - simply print the left subcomponent. * cp-demint.c (cplus_demangle_fill_component): Handle DEMANGLE_COMPONENT_CONVERSION. * testsuite/demangle-expected: Add tests. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@231020 138bc75d-0d04-0410-961f-82ee72b054a4
2015-11-28 17:39:31 +01:00
{
d_print_comp (dpi, options, d_left (dc));
}
/* Print a conversion operator. */
static void
d_print_conversion (struct d_print_info *dpi, int options,
struct demangle_component *dc)
{
struct d_print_template dpt;
2003-11-27 02:17:34 +01:00
PR other/61321 - demangler crash on casts in template parameters The fix for bug 59195: [C++ demangler handles conversion operator incorrectly] https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59195 unfortunately makes the demangler crash due to infinite recursion, in case of casts in template parameters. For example, with: template<int> struct A {}; template <typename Y> void function_temp(A<sizeof ((Y)(999))>) {} template void function_temp<int>(A<sizeof (int)>); The 'function_temp<int>' instantiation above mangles to: _Z13function_tempIiEv1AIXszcvT_Li999EEE The demangler parses this as: typed name template name 'function_temp' template argument list builtin type int function type builtin type void argument list template (*) name 'A' template argument list unary operator operator sizeof unary operator cast template parameter 0 (**) literal builtin type int name '999' And after the fix for 59195, due to: static void d_print_cast (struct d_print_info *dpi, int options, const struct demangle_component *dc) { ... /* For a cast operator, we need the template parameters from the enclosing template in scope for processing the type. */ if (dpi->current_template != NULL) { dpt.next = dpi->templates; dpi->templates = &dpt; dpt.template_decl = dpi->current_template; } when printing the template argument list of A (what should be "<sizeof (int)>"), the template parameter 0 (that is, "T_", the '**' above) now refers to the first parameter of the the template argument list of the 'A' template (the '*' above), exactly what we were already trying to print. This leads to infinite recursion, and stack exaustion. The template parameter 0 should actually refer to the first parameter of the 'function_temp' template. Where it reads "for the cast operator" in the comment in d_print_cast (above), it's really talking about a conversion operator, like: struct A { template <typename U> explicit operator U(); }; We don't want to inject the template parameters from the enclosing template in scope when processing a cast _expression_, only when handling a conversion operator. The problem is that DEMANGLE_COMPONENT_CAST is currently ambiguous, and means _both_ 'conversion operator' and 'cast expression'. Fix this by adding a new DEMANGLE_COMPONENT_CONVERSION component type, which does what DEMANGLE_COMPONENT_CAST does today, and making DEMANGLE_COMPONENT_CAST just simply print its component subtree. I think we could instead reuse DEMANGLE_COMPONENT_CAST and in d_print_comp_inner still do: @@ -5001,9 +5013,9 @@ d_print_comp_inner (struct d_print_info *dpi, int options, d_print_comp (dpi, options, dc->u.s_extended_operator.name); return; case DEMANGLE_COMPONENT_CAST: d_append_string (dpi, "operator "); - d_print_cast (dpi, options, dc); + d_print_conversion (dpi, options, dc); return; leaving the unary cast case below calling d_print_cast, but seems to me that spliting the component types makes it easier to reason about the code. g++'s testsuite actually generates three symbols that crash the demangler in the same way. I've added those as tests in the demangler testsuite as well. And then this fixes PR other/61233 too, which happens to be a demangler crash originally reported to GDB, at: https://sourceware.org/bugzilla/show_bug.cgi?id=16957 Bootstrapped and regtested on x86_64 Fedora 20. Also ran this through GDB's testsuite. GDB will require a small update to use DEMANGLE_COMPONENT_CONVERSION in one place it's using DEMANGLE_COMPONENT_CAST in its sources. libiberty/ 2015-11-27 Pedro Alves <palves@redhat.com> PR other/61321 PR other/61233 * demangle.h (enum demangle_component_type) <DEMANGLE_COMPONENT_CONVERSION>: New value. * cp-demangle.c (d_demangle_callback, d_make_comp): Handle DEMANGLE_COMPONENT_CONVERSION. (is_ctor_dtor_or_conversion): Handle DEMANGLE_COMPONENT_CONVERSION instead of DEMANGLE_COMPONENT_CAST. (d_operator_name): Return a DEMANGLE_COMPONENT_CONVERSION component if handling a conversion. (d_count_templates_scopes, d_print_comp_inner): Handle DEMANGLE_COMPONENT_CONVERSION. (d_print_comp_inner): Handle DEMANGLE_COMPONENT_CONVERSION instead of DEMANGLE_COMPONENT_CAST. (d_print_cast): Rename as ... (d_print_conversion): ... this. Adjust comments. (d_print_cast): Rewrite - simply print the left subcomponent. * cp-demint.c (cplus_demangle_fill_component): Handle DEMANGLE_COMPONENT_CONVERSION. * testsuite/demangle-expected: Add tests. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@231020 138bc75d-0d04-0410-961f-82ee72b054a4
2015-11-28 17:39:31 +01:00
/* For a conversion operator, we need the template parameters from
the enclosing template in scope for processing the type. */
if (dpi->current_template != NULL)
{
2003-11-21 18:42:45 +01:00
dpt.next = dpi->templates;
dpi->templates = &dpt;
dpt.template_decl = dpi->current_template;
}
2003-11-19 17:19:14 +01:00
if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE)
{
d_print_comp (dpi, options, d_left (dc));
if (dpi->current_template != NULL)
dpi->templates = dpt.next;
}
else
{
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_left (d_left (dc)));
2003-11-19 17:19:14 +01:00
/* For a templated cast operator, we need to remove the template
parameters from scope after printing the operator name,
so we need to handle the template printing here. */
if (dpi->current_template != NULL)
dpi->templates = dpt.next;
2003-12-04 21:03:39 +01:00
if (d_last_char (dpi) == '<')
d_append_char (dpi, ' ');
2003-11-21 18:42:45 +01:00
d_append_char (dpi, '<');
2011-06-14 01:01:48 +02:00
d_print_comp (dpi, options, d_right (d_left (dc)));
2003-11-21 18:42:45 +01:00
/* Avoid generating two consecutive '>' characters, to avoid
the C++ syntactic ambiguity. */
2003-12-04 21:03:39 +01:00
if (d_last_char (dpi) == '>')
2003-11-21 18:42:45 +01:00
d_append_char (dpi, ' ');
d_append_char (dpi, '>');
}
2003-11-21 18:42:45 +01:00
}
/* Initialize the information structure we use to pass around
information. */
2004-01-12 22:24:38 +01:00
CP_STATIC_IF_GLIBCPP_V3
void
2005-03-27 07:28:42 +02:00
cplus_demangle_init_info (const char *mangled, int options, size_t len,
struct d_info *di)
{
2003-11-21 18:42:45 +01:00
di->s = mangled;
2003-12-22 17:03:32 +01:00
di->send = mangled + len;
2003-11-21 18:42:45 +01:00
di->options = options;
2003-11-21 18:42:45 +01:00
di->n = mangled;
2019-04-07 13:11:49 +02:00
/* We cannot need more components than twice the number of chars in
2003-11-21 18:42:45 +01:00
the mangled string. Most components correspond directly to
chars, but the ARGLIST types are exceptions. */
di->num_comps = 2 * len;
di->next_comp = 0;
2019-04-07 13:11:49 +02:00
/* Similarly, we cannot need more substitutions than there are
2003-11-27 02:17:34 +01:00
chars in the mangled string. */
di->num_subs = len;
2003-11-21 18:42:45 +01:00
di->next_sub = 0;
di->last_name = NULL;
2003-12-22 17:03:32 +01:00
di->expansion = 0;
di->is_expression = 0;
di->is_conversion = 0;
Synchronize libiberty with gcc and add --no-recruse-limit option to tools that support name demangling. This patch addresses the multitude of bug reports about resource exhaustion in libiberty's name demangling code. It adds a limit to the amount of recursion that is allowed, before an error is triggered. It also adds a new demangling option to disable this limit. (The limit is enabled by default). PR 87681 PR 87675 PR 87636 PR 87335 libiberty * cp-demangle.h (struct d_info): Add recursion_limit field. * cp-demangle.c (d_function_type): If the recursion limit is enabled and reached, return with a failure result. (d_demangle_callback): If the recursion limit is enabled, check for a mangled string that is so long that there is not enough stack space for the local arrays. * cplus-dem.c (struct work): Add recursion_level field. (demangle_nested_args): If the recursion limit is enabled and reached, return with a failure result. include * demangle.h (DMGL_RECURSE_LIMIT): Define. (DEMANGLE_RECURSION_LIMIT): Prototype. binutuils * addr2line.c (demangle_flags): New static variable. (long_options): Add --recurse-limit and --no-recurse-limit. (translate_address): Pass demangle_flags to bfd_demangle. (main): Handle --recurse-limit and --no-recurse-limit options. * cxxfilt.c (flags): Add DMGL_RECURSE_LIMIT. (long_options): Add --recurse-limit and --no-recurse-limit. (main): Handle new options. * dlltool.c (gen_def_file): Include DMGL_RECURSE_LIMIT in flags passed to cplus_demangle. * nm.c (demangle_flags): New static variable. (long_options): Add --recurse-limit and --no-recurse-limit. (main): Handle new options. * objdump.c (demangle_flags): New static variable. (usage): Add --recurse-limit and --no-recurse-limit. (long_options): Likewise. (objdump_print_symname): Pass demangle_flags to bfd_demangle. (disassemble_section): Likewise. (dump_dymbols): Likewise. (main): Handle new options. * prdbg.c (demangle_flags): New static variable. (tg_variable): Pass demangle_flags to demangler. (tg_start_function): Likewise. * stabs.c (demangle_flags): New static variable. (stab_demangle_template): Pass demangle_flags to demangler. (stab_demangle_v3_argtypes): Likewise. (stab_demangle_v3_arg): Likewise. * doc/binutuls.texi: Document new command line options. * NEWS: Mention the new feature. * testsuite/config/default.exp (CXXFILT): Define if not already defined. (CXXFILTFLAGS): Likewise. * testsuite/binutils-all/cxxfilt.exp: New file. Runs a few simple tests of the cxxfilt program.
2018-12-07 12:32:55 +01:00
di->recursion_level = 0;
}
2007-01-31 00:16:58 +01:00
/* Internal implementation for the demangler. If MANGLED is a g++ v3 ABI
mangled name, return strings in repeated callback giving the demangled
name. OPTIONS is the usual libiberty demangler options. On success,
this returns 1. On failure, returns 0. */
2007-01-31 00:16:58 +01:00
static int
d_demangle_callback (const char *mangled, int options,
demangle_callbackref callback, void *opaque)
{
2009-07-17 22:20:45 +02:00
enum
{
DCT_TYPE,
DCT_MANGLED,
DCT_GLOBAL_CTORS,
DCT_GLOBAL_DTORS
}
type;
2003-11-21 18:42:45 +01:00
struct d_info di;
2004-01-12 22:24:38 +01:00
struct demangle_component *dc;
2007-01-31 00:16:58 +01:00
int status;
2003-11-21 18:42:45 +01:00
if (mangled[0] == '_' && mangled[1] == 'Z')
2009-07-17 22:20:45 +02:00
type = DCT_MANGLED;
2003-11-21 18:42:45 +01:00
else if (strncmp (mangled, "_GLOBAL_", 8) == 0
&& (mangled[8] == '.' || mangled[8] == '_' || mangled[8] == '$')
&& (mangled[9] == 'D' || mangled[9] == 'I')
&& mangled[10] == '_')
2009-07-17 22:20:45 +02:00
type = mangled[9] == 'I' ? DCT_GLOBAL_CTORS : DCT_GLOBAL_DTORS;
else
{
2003-11-21 18:42:45 +01:00
if ((options & DMGL_TYPES) == 0)
2007-01-31 00:16:58 +01:00
return 0;
2009-07-17 22:20:45 +02:00
type = DCT_TYPE;
}
2007-01-31 00:16:58 +01:00
cplus_demangle_init_info (mangled, options, strlen (mangled), &di);
2000-07-20 20:56:16 +02:00
Synchronize libiberty with gcc and add --no-recruse-limit option to tools that support name demangling. This patch addresses the multitude of bug reports about resource exhaustion in libiberty's name demangling code. It adds a limit to the amount of recursion that is allowed, before an error is triggered. It also adds a new demangling option to disable this limit. (The limit is enabled by default). PR 87681 PR 87675 PR 87636 PR 87335 libiberty * cp-demangle.h (struct d_info): Add recursion_limit field. * cp-demangle.c (d_function_type): If the recursion limit is enabled and reached, return with a failure result. (d_demangle_callback): If the recursion limit is enabled, check for a mangled string that is so long that there is not enough stack space for the local arrays. * cplus-dem.c (struct work): Add recursion_level field. (demangle_nested_args): If the recursion limit is enabled and reached, return with a failure result. include * demangle.h (DMGL_RECURSE_LIMIT): Define. (DEMANGLE_RECURSION_LIMIT): Prototype. binutuils * addr2line.c (demangle_flags): New static variable. (long_options): Add --recurse-limit and --no-recurse-limit. (translate_address): Pass demangle_flags to bfd_demangle. (main): Handle --recurse-limit and --no-recurse-limit options. * cxxfilt.c (flags): Add DMGL_RECURSE_LIMIT. (long_options): Add --recurse-limit and --no-recurse-limit. (main): Handle new options. * dlltool.c (gen_def_file): Include DMGL_RECURSE_LIMIT in flags passed to cplus_demangle. * nm.c (demangle_flags): New static variable. (long_options): Add --recurse-limit and --no-recurse-limit. (main): Handle new options. * objdump.c (demangle_flags): New static variable. (usage): Add --recurse-limit and --no-recurse-limit. (long_options): Likewise. (objdump_print_symname): Pass demangle_flags to bfd_demangle. (disassemble_section): Likewise. (dump_dymbols): Likewise. (main): Handle new options. * prdbg.c (demangle_flags): New static variable. (tg_variable): Pass demangle_flags to demangler. (tg_start_function): Likewise. * stabs.c (demangle_flags): New static variable. (stab_demangle_template): Pass demangle_flags to demangler. (stab_demangle_v3_argtypes): Likewise. (stab_demangle_v3_arg): Likewise. * doc/binutuls.texi: Document new command line options. * NEWS: Mention the new feature. * testsuite/config/default.exp (CXXFILT): Define if not already defined. (CXXFILTFLAGS): Likewise. * testsuite/binutils-all/cxxfilt.exp: New file. Runs a few simple tests of the cxxfilt program.
2018-12-07 12:32:55 +01:00
/* PR 87675 - Check for a mangled string that is so long
that we do not have enough stack space to demangle it. */
if (((options & DMGL_NO_RECURSE_LIMIT) == 0)
/* This check is a bit arbitrary, since what we really want to do is to
compare the sizes of the di.comps and di.subs arrays against the
amount of stack space remaining. But there is no portable way to do
this, so instead we use the recursion limit as a guide to the maximum
size of the arrays. */
&& (unsigned long) di.num_comps > DEMANGLE_RECURSION_LIMIT)
{
/* FIXME: We need a way to indicate that a stack limit has been reached. */
return 0;
}
2003-12-22 17:03:32 +01:00
{
#ifdef CP_DYNAMIC_ARRAYS
2004-01-12 22:24:38 +01:00
__extension__ struct demangle_component comps[di.num_comps];
__extension__ struct demangle_component *subs[di.num_subs];
2003-12-22 17:03:32 +01:00
2007-01-31 00:16:58 +01:00
di.comps = comps;
di.subs = subs;
2003-12-22 17:03:32 +01:00
#else
2007-01-31 00:16:58 +01:00
di.comps = alloca (di.num_comps * sizeof (*di.comps));
di.subs = alloca (di.num_subs * sizeof (*di.subs));
2003-12-22 17:03:32 +01:00
#endif
2009-07-17 22:20:45 +02:00
switch (type)
{
case DCT_TYPE:
dc = cplus_demangle_type (&di);
break;
case DCT_MANGLED:
dc = cplus_demangle_mangled_name (&di, 1);
break;
case DCT_GLOBAL_CTORS:
case DCT_GLOBAL_DTORS:
d_advance (&di, 11);
dc = d_make_comp (&di,
(type == DCT_GLOBAL_CTORS
? DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
: DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS),
d_make_demangle_mangled_name (&di, d_str (&di)),
2009-07-17 22:20:45 +02:00
NULL);
d_advance (&di, strlen (d_str (&di)));
break;
default:
abort (); /* We have listed all the cases. */
2009-07-17 22:20:45 +02:00
}
2003-11-21 18:42:45 +01:00
2003-12-22 17:03:32 +01:00
/* If DMGL_PARAMS is set, then if we didn't consume the entire
mangled string, then we didn't successfully demangle it. If
DMGL_PARAMS is not set, we didn't look at the trailing
parameters. */
if (((options & DMGL_PARAMS) != 0) && d_peek_char (&di) != '\0')
dc = NULL;
2003-12-02 00:54:49 +01:00
2003-11-21 18:42:45 +01:00
#ifdef CP_DEMANGLE_DEBUG
2007-01-31 00:16:58 +01:00
d_dump (dc, 0);
2003-11-21 18:42:45 +01:00
#endif
2007-01-31 00:16:58 +01:00
status = (dc != NULL)
? cplus_demangle_print_callback (options, dc, callback, opaque)
: 0;
}
2000-07-20 20:56:16 +02:00
2007-01-31 00:16:58 +01:00
return status;
}
2000-07-20 20:56:16 +02:00
2007-01-31 00:16:58 +01:00
/* Entry point for the demangler. If MANGLED is a g++ v3 ABI mangled
name, return a buffer allocated with malloc holding the demangled
name. OPTIONS is the usual libiberty demangler options. On
success, this sets *PALC to the allocated size of the returned
buffer. On failure, this sets *PALC to 0 for a bad name, or 1 for
a memory allocation failure, and returns NULL. */
2003-12-22 17:03:32 +01:00
2007-01-31 00:16:58 +01:00
static char *
d_demangle (const char *mangled, int options, size_t *palc)
{
struct d_growable_string dgs;
int status;
2000-07-20 20:56:16 +02:00
2007-01-31 00:16:58 +01:00
d_growable_string_init (&dgs, 0);
status = d_demangle_callback (mangled, options,
d_growable_string_callback_adapter, &dgs);
if (status == 0)
{
free (dgs.buf);
*palc = 0;
return NULL;
}
*palc = dgs.allocation_failure ? 1 : dgs.alc;
2007-01-31 00:16:58 +01:00
return dgs.buf;
}
2002-04-02 00:01:20 +02:00
#if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
2003-11-21 18:42:45 +01:00
2005-03-27 07:28:42 +02:00
extern char *__cxa_demangle (const char *, char *, size_t *, int *);
2000-07-20 20:56:16 +02:00
2003-11-21 18:42:45 +01:00
/* ia64 ABI-mandated entry point in the C++ runtime library for
performing demangling. MANGLED_NAME is a NUL-terminated character
string containing the name to be demangled.
2000-07-20 20:56:16 +02:00
OUTPUT_BUFFER is a region of memory, allocated with malloc, of
*LENGTH bytes, into which the demangled name is stored. If
OUTPUT_BUFFER is not long enough, it is expanded using realloc.
OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
2003-11-21 18:42:45 +01:00
is placed in a region of memory allocated with malloc.
2000-07-20 20:56:16 +02:00
2007-01-31 00:16:58 +01:00
If LENGTH is non-NULL, the length of the buffer containing the
2003-11-21 18:42:45 +01:00
demangled name, is placed in *LENGTH.
2000-07-20 20:56:16 +02:00
The return value is a pointer to the start of the NUL-terminated
demangled name, or NULL if the demangling fails. The caller is
2003-11-21 18:42:45 +01:00
responsible for deallocating this memory using free.
2000-07-20 20:56:16 +02:00
*STATUS is set to one of the following values:
0: The demangling operation succeeded.
2003-11-21 18:42:45 +01:00
-1: A memory allocation failure occurred.
2000-07-20 20:56:16 +02:00
-2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
-3: One of the arguments is invalid.
2003-11-21 18:42:45 +01:00
The demangling is performed using the C++ ABI mangling rules, with
2000-07-20 20:56:16 +02:00
GNU extensions. */
char *
2005-03-27 07:28:42 +02:00
__cxa_demangle (const char *mangled_name, char *output_buffer,
size_t *length, int *status)
2000-07-20 20:56:16 +02:00
{
2003-11-21 18:42:45 +01:00
char *demangled;
size_t alc;
2000-07-20 20:56:16 +02:00
2003-11-21 18:42:45 +01:00
if (mangled_name == NULL)
{
2004-02-24 17:30:50 +01:00
if (status != NULL)
*status = -3;
2000-07-20 20:56:16 +02:00
return NULL;
}
2003-11-21 18:42:45 +01:00
if (output_buffer != NULL && length == NULL)
2000-07-20 20:56:16 +02:00
{
2004-02-24 17:30:50 +01:00
if (status != NULL)
*status = -3;
2003-11-21 18:42:45 +01:00
return NULL;
2000-07-20 20:56:16 +02:00
}
2003-11-21 18:42:45 +01:00
2004-02-24 17:30:50 +01:00
demangled = d_demangle (mangled_name, DMGL_PARAMS | DMGL_TYPES, &alc);
2003-11-21 18:42:45 +01:00
if (demangled == NULL)
2000-07-20 20:56:16 +02:00
{
2004-02-24 17:30:50 +01:00
if (status != NULL)
{
if (alc == 1)
*status = -1;
else
*status = -2;
}
2000-07-20 20:56:16 +02:00
return NULL;
}
2003-11-21 18:42:45 +01:00
if (output_buffer == NULL)
{
if (length != NULL)
*length = alc;
}
2000-07-20 20:56:16 +02:00
else
{
2003-11-21 18:42:45 +01:00
if (strlen (demangled) < *length)
{
strcpy (output_buffer, demangled);
free (demangled);
demangled = output_buffer;
}
else
{
free (output_buffer);
*length = alc;
}
2000-07-20 20:56:16 +02:00
}
2003-11-21 18:42:45 +01:00
2004-02-24 17:30:50 +01:00
if (status != NULL)
*status = 0;
2003-11-21 18:42:45 +01:00
return demangled;
2000-07-20 20:56:16 +02:00
}
2007-01-31 00:16:58 +01:00
extern int __gcclibcxx_demangle_callback (const char *,
void (*)
(const char *, size_t, void *),
void *);
/* Alternative, allocationless entry point in the C++ runtime library
for performing demangling. MANGLED_NAME is a NUL-terminated character
string containing the name to be demangled.
CALLBACK is a callback function, called with demangled string
segments as demangling progresses; it is called at least once,
but may be called more than once. OPAQUE is a generalized pointer
used as a callback argument.
The return code is one of the following values, equivalent to
the STATUS values of __cxa_demangle() (excluding -1, since this
function performs no memory allocations):
0: The demangling operation succeeded.
-2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
-3: One of the arguments is invalid.
The demangling is performed using the C++ ABI mangling rules, with
GNU extensions. */
int
__gcclibcxx_demangle_callback (const char *mangled_name,
void (*callback) (const char *, size_t, void *),
void *opaque)
{
int status;
if (mangled_name == NULL || callback == NULL)
return -3;
status = d_demangle_callback (mangled_name, DMGL_PARAMS | DMGL_TYPES,
callback, opaque);
if (status == 0)
return -2;
return 0;
}
2002-04-02 00:01:20 +02:00
#else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
2000-07-20 20:56:16 +02:00
2003-11-21 18:42:45 +01:00
/* Entry point for libiberty demangler. If MANGLED is a g++ v3 ABI
mangled name, return a buffer allocated with malloc holding the
demangled name. Otherwise, return NULL. */
char *
2007-01-31 00:16:58 +01:00
cplus_demangle_v3 (const char *mangled, int options)
{
2003-11-21 18:42:45 +01:00
size_t alc;
2003-11-21 18:42:45 +01:00
return d_demangle (mangled, options, &alc);
}
2007-01-31 00:16:58 +01:00
int
cplus_demangle_v3_callback (const char *mangled, int options,
demangle_callbackref callback, void *opaque)
{
return d_demangle_callback (mangled, options, callback, opaque);
}
2001-02-02 19:58:51 +01:00
/* Demangle a Java symbol. Java uses a subset of the V3 ABI C++ mangling
conventions, but the output formatting is a little different.
2007-01-31 00:16:58 +01:00
This instructs the C++ demangler not to emit pointer characters ("*"), to
use Java's namespace separator symbol ("." instead of "::"), and to output
JArray<TYPE> as TYPE[]. */
2001-02-02 19:58:51 +01:00
char *
2007-01-31 00:16:58 +01:00
java_demangle_v3 (const char *mangled)
2001-02-02 19:58:51 +01:00
{
2003-11-21 18:42:45 +01:00
size_t alc;
2001-02-02 19:58:51 +01:00
2007-01-31 00:16:58 +01:00
return d_demangle (mangled, DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX, &alc);
}
2002-03-30 07:17:57 +01:00
2007-01-31 00:16:58 +01:00
int
java_demangle_v3_callback (const char *mangled,
demangle_callbackref callback, void *opaque)
{
return d_demangle_callback (mangled,
DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX,
callback, opaque);
2001-02-02 19:58:51 +01:00
}
2002-04-02 00:01:20 +02:00
#endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
2000-07-20 20:56:16 +02:00
2002-07-09 03:01:18 +02:00
#ifndef IN_GLIBCPP_V3
2003-11-21 18:42:45 +01:00
/* Demangle a string in order to find out whether it is a constructor
or destructor. Return non-zero on success. Set *CTOR_KIND and
*DTOR_KIND appropriately. */
static int
2005-03-27 07:28:42 +02:00
is_ctor_or_dtor (const char *mangled,
enum gnu_v3_ctor_kinds *ctor_kind,
enum gnu_v3_dtor_kinds *dtor_kind)
{
2003-11-21 18:42:45 +01:00
struct d_info di;
2004-01-12 22:24:38 +01:00
struct demangle_component *dc;
2003-12-04 21:03:39 +01:00
int ret;
2003-11-21 18:42:45 +01:00
*ctor_kind = (enum gnu_v3_ctor_kinds) 0;
*dtor_kind = (enum gnu_v3_dtor_kinds) 0;
2004-01-12 22:24:38 +01:00
cplus_demangle_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di);
2003-12-22 17:03:32 +01:00
{
#ifdef CP_DYNAMIC_ARRAYS
2004-01-12 22:24:38 +01:00
__extension__ struct demangle_component comps[di.num_comps];
__extension__ struct demangle_component *subs[di.num_subs];
2003-12-22 17:03:32 +01:00
2007-01-31 00:16:58 +01:00
di.comps = comps;
di.subs = subs;
2003-12-22 17:03:32 +01:00
#else
2007-01-31 00:16:58 +01:00
di.comps = alloca (di.num_comps * sizeof (*di.comps));
di.subs = alloca (di.num_subs * sizeof (*di.subs));
2003-12-22 17:03:32 +01:00
#endif
2003-11-21 18:42:45 +01:00
2004-01-12 22:24:38 +01:00
dc = cplus_demangle_mangled_name (&di, 1);
2003-12-16 01:58:45 +01:00
2003-12-22 17:03:32 +01:00
/* Note that because we did not pass DMGL_PARAMS, we don't expect
to demangle the entire string. */
2003-12-22 17:03:32 +01:00
ret = 0;
while (dc != NULL)
{
switch (dc->type)
{
2013-04-03 20:21:49 +02:00
/* These cannot appear on a constructor or destructor. */
case DEMANGLE_COMPONENT_RESTRICT_THIS:
case DEMANGLE_COMPONENT_VOLATILE_THIS:
case DEMANGLE_COMPONENT_CONST_THIS:
case DEMANGLE_COMPONENT_REFERENCE_THIS:
case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
2003-12-22 17:03:32 +01:00
default:
dc = NULL;
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_TYPED_NAME:
case DEMANGLE_COMPONENT_TEMPLATE:
2003-12-22 17:03:32 +01:00
dc = d_left (dc);
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_QUAL_NAME:
case DEMANGLE_COMPONENT_LOCAL_NAME:
2003-12-22 17:03:32 +01:00
dc = d_right (dc);
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_CTOR:
2003-12-22 17:03:32 +01:00
*ctor_kind = dc->u.s_ctor.kind;
ret = 1;
dc = NULL;
break;
2004-01-12 22:24:38 +01:00
case DEMANGLE_COMPONENT_DTOR:
2003-12-22 17:03:32 +01:00
*dtor_kind = dc->u.s_dtor.kind;
ret = 1;
dc = NULL;
break;
}
}
}
2003-12-04 21:03:39 +01:00
return ret;
}
2003-11-21 18:42:45 +01:00
/* Return whether NAME is the mangled form of a g++ V3 ABI constructor
name. A non-zero return indicates the type of constructor. */
enum gnu_v3_ctor_kinds
2005-03-27 07:28:42 +02:00
is_gnu_v3_mangled_ctor (const char *name)
{
2003-11-21 18:42:45 +01:00
enum gnu_v3_ctor_kinds ctor_kind;
enum gnu_v3_dtor_kinds dtor_kind;
2003-11-21 18:42:45 +01:00
if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
2002-09-20 15:45:20 +02:00
return (enum gnu_v3_ctor_kinds) 0;
2003-11-21 18:42:45 +01:00
return ctor_kind;
}
2003-11-21 18:42:45 +01:00
/* Return whether NAME is the mangled form of a g++ V3 ABI destructor
name. A non-zero return indicates the type of destructor. */
enum gnu_v3_dtor_kinds
2005-03-27 07:28:42 +02:00
is_gnu_v3_mangled_dtor (const char *name)
{
2003-11-21 18:42:45 +01:00
enum gnu_v3_ctor_kinds ctor_kind;
enum gnu_v3_dtor_kinds dtor_kind;
2003-11-21 18:42:45 +01:00
if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
2002-09-20 15:45:20 +02:00
return (enum gnu_v3_dtor_kinds) 0;
2003-11-21 18:42:45 +01:00
return dtor_kind;
}
2003-11-21 18:42:45 +01:00
#endif /* IN_GLIBCPP_V3 */
#ifdef STANDALONE_DEMANGLER
#include "getopt.h"
2003-11-21 18:42:45 +01:00
#include "dyn-string.h"
2005-03-28 19:14:34 +02:00
static void print_usage (FILE* fp, int exit_value);
2003-11-21 18:42:45 +01:00
#define IS_ALPHA(CHAR) \
(((CHAR) >= 'a' && (CHAR) <= 'z') \
|| ((CHAR) >= 'A' && (CHAR) <= 'Z'))
/* Non-zero if CHAR is a character than can occur in a mangled name. */
#define is_mangled_char(CHAR) \
2000-10-12 04:16:48 +02:00
(IS_ALPHA (CHAR) || IS_DIGIT (CHAR) \
|| (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
/* The name of this program, as invoked. */
const char* program_name;
/* Prints usage summary to FP and then exits with EXIT_VALUE. */
static void
2005-03-27 07:28:42 +02:00
print_usage (FILE* fp, int exit_value)
{
fprintf (fp, "Usage: %s [options] [names ...]\n", program_name);
2000-10-12 04:16:48 +02:00
fprintf (fp, "Options:\n");
fprintf (fp, " -h,--help Display this message.\n");
2003-11-24 20:33:33 +01:00
fprintf (fp, " -p,--no-params Don't display function parameters\n");
fprintf (fp, " -v,--verbose Produce verbose demanglings.\n");
fprintf (fp, "If names are provided, they are demangled. Otherwise filters standard input.\n");
exit (exit_value);
}
/* Option specification for getopt_long. */
2002-01-03 01:25:57 +01:00
static const struct option long_options[] =
{
2003-11-24 20:33:33 +01:00
{ "help", no_argument, NULL, 'h' },
{ "no-params", no_argument, NULL, 'p' },
{ "verbose", no_argument, NULL, 'v' },
{ NULL, no_argument, NULL, 0 },
};
/* Main entry for a demangling filter executable. It will demangle
its command line arguments, if any. If none are provided, it will
filter stdin to stdout, replacing any recognized mangled C++ names
with their demangled equivalents. */
int
2005-03-27 07:28:42 +02:00
main (int argc, char *argv[])
{
int i;
int opt_char;
2003-11-21 18:42:45 +01:00
int options = DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES;
/* Use the program name of this program, as invoked. */
program_name = argv[0];
/* Parse options. */
do
{
2003-11-24 20:33:33 +01:00
opt_char = getopt_long (argc, argv, "hpv", long_options, NULL);
switch (opt_char)
{
case '?': /* Unrecognized option. */
print_usage (stderr, 1);
break;
case 'h':
print_usage (stdout, 0);
break;
2003-11-24 20:33:33 +01:00
case 'p':
options &= ~ DMGL_PARAMS;
break;
case 'v':
2003-11-21 18:42:45 +01:00
options |= DMGL_VERBOSE;
break;
}
}
while (opt_char != -1);
if (optind == argc)
/* No command line arguments were provided. Filter stdin. */
{
dyn_string_t mangled = dyn_string_new (3);
2003-11-21 18:42:45 +01:00
char *s;
/* Read all of input. */
while (!feof (stdin))
{
2003-11-21 18:42:45 +01:00
char c;
/* Pile characters into mangled until we hit one that can't
occur in a mangled name. */
c = getchar ();
while (!feof (stdin) && is_mangled_char (c))
{
dyn_string_append_char (mangled, c);
if (feof (stdin))
break;
c = getchar ();
}
2003-11-21 18:42:45 +01:00
if (dyn_string_length (mangled) > 0)
2000-07-20 20:56:16 +02:00
{
2004-02-24 17:30:50 +01:00
#ifdef IN_GLIBCPP_V3
s = __cxa_demangle (dyn_string_buf (mangled), NULL, NULL, NULL);
#else
2003-11-21 18:42:45 +01:00
s = cplus_demangle_v3 (dyn_string_buf (mangled), options);
2004-02-24 17:30:50 +01:00
#endif
2003-11-21 18:42:45 +01:00
if (s != NULL)
{
fputs (s, stdout);
free (s);
}
else
{
/* It might not have been a mangled name. Print the
original text. */
fputs (dyn_string_buf (mangled), stdout);
}
dyn_string_clear (mangled);
2000-07-20 20:56:16 +02:00
}
/* If we haven't hit EOF yet, we've read one character that
can't occur in a mangled name, so print it out. */
if (!feof (stdin))
putchar (c);
}
dyn_string_delete (mangled);
}
else
/* Demangle command line arguments. */
{
/* Loop over command line arguments. */
for (i = optind; i < argc; ++i)
{
2003-11-21 18:42:45 +01:00
char *s;
2004-02-24 17:30:50 +01:00
#ifdef IN_GLIBCPP_V3
int status;
#endif
2003-11-21 18:42:45 +01:00
/* Attempt to demangle. */
2004-02-24 17:30:50 +01:00
#ifdef IN_GLIBCPP_V3
s = __cxa_demangle (argv[i], NULL, NULL, &status);
#else
2003-11-21 18:42:45 +01:00
s = cplus_demangle_v3 (argv[i], options);
2004-02-24 17:30:50 +01:00
#endif
/* If it worked, print the demangled name. */
2003-11-21 18:42:45 +01:00
if (s != NULL)
2000-07-20 20:56:16 +02:00
{
2003-11-21 18:42:45 +01:00
printf ("%s\n", s);
free (s);
2000-07-20 20:56:16 +02:00
}
2003-11-21 18:42:45 +01:00
else
2004-02-24 17:30:50 +01:00
{
#ifdef IN_GLIBCPP_V3
fprintf (stderr, "Failed: %s (status %d)\n", argv[i], status);
#else
fprintf (stderr, "Failed: %s\n", argv[i]);
#endif
}
}
}
return 0;
}
#endif /* STANDALONE_DEMANGLER */