From cbc4312826248942ee84313c51ffeb6047dfe74f Mon Sep 17 00:00:00 2001 From: DJ Delorie Date: Wed, 3 Feb 2010 23:28:01 +0000 Subject: [PATCH] merge from gcc --- include/demangle.h | 5 ++ libiberty/ChangeLog | 16 ++++- libiberty/cp-demangle.c | 93 ++++++++++++++++++++++++--- libiberty/testsuite/demangle-expected | 18 +++++- 4 files changed, 119 insertions(+), 13 deletions(-) diff --git a/include/demangle.h b/include/demangle.h index 2ab27602be1..8ad073de532 100644 --- a/include/demangle.h +++ b/include/demangle.h @@ -326,6 +326,9 @@ enum demangle_component_type DEMANGLE_COMPONENT_PTRMEM_TYPE, /* A fixed-point type. */ DEMANGLE_COMPONENT_FIXED_TYPE, + /* A vector type. The left subtree is the number of elements, + the right subtree is the element type. */ + DEMANGLE_COMPONENT_VECTOR_TYPE, /* An argument list. The left subtree is the current argument, and the right subtree is either NULL or another ARGLIST node. */ DEMANGLE_COMPONENT_ARGLIST, @@ -378,6 +381,8 @@ enum demangle_component_type DEMANGLE_COMPONENT_COMPOUND_NAME, /* A name formed by a single character. */ DEMANGLE_COMPONENT_CHARACTER, + /* A number. */ + DEMANGLE_COMPONENT_NUMBER, /* A decltype type. */ DEMANGLE_COMPONENT_DECLTYPE, /* Global constructors keyed to name. */ diff --git a/libiberty/ChangeLog b/libiberty/ChangeLog index 1e2fbffdf74..20c88d776c7 100644 --- a/libiberty/ChangeLog +++ b/libiberty/ChangeLog @@ -1,3 +1,17 @@ +2010-02-03 Jason Merrill + + * cp-demangle.c (d_expression): Handle dependent operator name. + + PR c++/12909 + * cp-demangle.c (d_number_component, d_vector_type): New. + (cplus_demangle_type, d_print_comp, d_print_mod): Handle vectors. + +2010-01-25 Ian Lance Taylor + + * cp-demangle.c (cplus_demangle_type): Check for invalid type + after "DF". + * testsuite/demangle-expected: Add test. + 2010-01-20 Jason Merrill PR c++/42338 @@ -294,7 +308,7 @@ with other than 1 operand. (d_print_comp): Handle function parameters. Fix bug with function used in type of function. - * testsuite/demangle-expected: Upate tests. + * testsuite/demangle-expected: Update tests. 2009-02-21 Mark Mitchell diff --git a/libiberty/cp-demangle.c b/libiberty/cp-demangle.c index f28e1636921..b1319cf3b46 100644 --- a/libiberty/cp-demangle.c +++ b/libiberty/cp-demangle.c @@ -1,5 +1,5 @@ /* Demangler for g++ V3 ABI. - Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 + Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. Written by Ian Lance Taylor . @@ -389,6 +389,8 @@ d_class_enum_type (struct d_info *); static struct demangle_component *d_array_type (struct d_info *); +static struct demangle_component *d_vector_type (struct d_info *); + static struct demangle_component * d_pointer_to_member_type (struct d_info *); @@ -796,6 +798,7 @@ d_make_comp (struct d_info *di, enum demangle_component_type type, case DEMANGLE_COMPONENT_LITERAL: case DEMANGLE_COMPONENT_LITERAL_NEG: case DEMANGLE_COMPONENT_COMPOUND_NAME: + case DEMANGLE_COMPONENT_VECTOR_TYPE: if (left == NULL || right == NULL) return NULL; break; @@ -1442,6 +1445,20 @@ d_number (struct d_info *di) } } +/* 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; +} + /* identifier ::= <(unqualified source code identifier)> */ static struct demangle_component * @@ -2193,11 +2210,17 @@ cplus_demangle_type (struct d_info *di) /* For demangling we don't care about the bits. */ d_number (di); ret->u.s_fixed.length = cplus_demangle_type (di); + if (ret->u.s_fixed.length == NULL) + return NULL; d_number (di); peek = d_next_char (di); ret->u.s_fixed.sat = (peek == 's'); break; + case 'v': + ret = d_vector_type (di); + break; + default: return NULL; } @@ -2416,6 +2439,34 @@ d_array_type (struct d_info *di) cplus_demangle_type (di)); } +/* ::= Dv _ + ::= Dv _ _ */ + +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)); +} + /* ::= M <(class) type> <(member) type> */ static struct demangle_component * @@ -2671,11 +2722,18 @@ d_expression (struct d_info *di) return d_make_function_param (di, index); } - else if (IS_DIGIT (peek)) + else if (IS_DIGIT (peek) + || (peek == 'o' && d_peek_next_char (di) == 'n')) { /* We can get an unqualified name as an expression in the case of - a dependent member access, i.e. decltype(T().i). */ - struct demangle_component *name = d_unqualified_name (di); + 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); if (name == NULL) return NULL; if (d_peek_char (di) == 'I') @@ -2733,10 +2791,18 @@ d_expression (struct d_info *di) { struct demangle_component *left; struct demangle_component *right; + const char *code = op->u.s_operator.op->code; left = d_expression (di); - if (!strcmp (op->u.s_operator.op->code, "cl")) + if (!strcmp (code, "cl")) right = d_exprlist (di); + 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)); + } else right = d_expression (di); @@ -3928,6 +3994,7 @@ d_print_comp (struct d_print_info *dpi, } case DEMANGLE_COMPONENT_PTRMEM_TYPE: + case DEMANGLE_COMPONENT_VECTOR_TYPE: { struct d_print_mod dpm; @@ -3942,11 +4009,7 @@ d_print_comp (struct d_print_info *dpi, /* If the modifier didn't get printed by the type, print it now. */ if (! dpm.printed) - { - d_append_char (dpi, ' '); - d_print_comp (dpi, d_left (dc)); - d_append_string (dpi, "::*"); - } + d_print_mod (dpi, dc); dpi->modifiers = dpm.next; @@ -4166,6 +4229,10 @@ d_print_comp (struct d_print_info *dpi, } return; + 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 "); d_print_comp (dpi, d_left (dc)); @@ -4438,6 +4505,12 @@ d_print_mod (struct d_print_info *dpi, case DEMANGLE_COMPONENT_TYPED_NAME: d_print_comp (dpi, d_left (mod)); return; + case DEMANGLE_COMPONENT_VECTOR_TYPE: + d_append_string (dpi, " vector["); + d_print_comp (dpi, d_left (mod)); + d_append_char (dpi, ']'); + return; + default: /* Otherwise, we have something that won't go back on the modifier stack, so we can just print it. */ diff --git a/libiberty/testsuite/demangle-expected b/libiberty/testsuite/demangle-expected index c201a983271..0f85ddc4568 100644 --- a/libiberty/testsuite/demangle-expected +++ b/libiberty/testsuite/demangle-expected @@ -3926,6 +3926,17 @@ S::x::{lambda()#3}::operator()() const --format=gnu-v3 _Z1fN1SUt_E f(S::{unnamed type#1}) +--format=gnu-v3 +_Z1fDv32_f +f(float vector[32]) +--format=gnu-v3 +_Z1fIfLi4EEvDv_T0__T_ +void f(float vector[4]) +_Z1fI1AEDTclonplfp_fp_EET_ +decltype ((operator+)({parm#1}, {parm#1})) f(A) +--format=gnu-v3 +_Z1hI1AEDTcldtfp_miEET_ +decltype (({parm#1}.(operator-))()) h(A) # # Ada (GNAT) tests. # @@ -4019,5 +4030,8 @@ prot.lock.update --format=gnat prot__lock__update_E6s prot.lock.update - - +# +# Used to crash the demangler. +--format=gnu-v3 +DFA +DFA -- 2.30.2