MatCat.OpenSource/8sa1-binutils-gdb
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Update libiberty with latest sources from gcc mainline

Browse Source
This commit is contained in:
Nick Clifton 2021-01-05 12:36:09 +00:00
parent 5f8c2a1507
commit d750c713c9
13 changed files with 1466 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

86
ChangeLog
View File

@ -1,3 +1,89 @@
2021-01-05 Nick Clifton <nickc@redhat.com>
* libiberty: Sync with gcc. Bring in:
2021-01-04 Martin Liska <mliska@suse.cz>
* strverscmp.c: Convert to utf8 from iso8859.
2020-12-22 Jason Merrill <jason@redhat.com>
PR c++/67343
* cp-demangle.h (struct d_info): Add unresolved_name_state.
* cp-demangle.c (d_prefix): Add subst parm.
(d_nested_name): Pass it.
(d_unresolved_name): Split out from...
(d_expression_1): ...here.
(d_demangle_callback): Maybe retry with old sr mangling.
* testsuite/demangle-expected: Add test.
2020-12-21 Jason Merrill <jason@redhat.com>
* cp-demangle.c (d_expression_1): Recognize qualified-id
on RHS of dt/pt.
* testsuite/demangle-expected: Add test.
2020-12-21 Jason Merrill <jason@redhat.com>
* cp-demangle.c (d_unqualified_name): Clear is_expression.
* testsuite/demangle-expected: Add tests.
2020-11-25 Matthew Malcomson <matthew.malcomson@arm.com>
* configure: Regenerate.
* configure.ac: Avoid using sanitizer.
2020-11-13 Eduard-Mihai Burtescu <eddyb@lyken.rs>
* rust-demangle.c (struct rust_demangler): Add
skipping_printing and bound_lifetime_depth fields.
(eat): Add (v0-only).
(parse_integer_62): Add (v0-only).
(parse_opt_integer_62): Add (v0-only).
(parse_disambiguator): Add (v0-only).
(struct rust_mangled_ident): Add punycode{,_len} fields.
(parse_ident): Support v0 identifiers.
(print_str): Respect skipping_printing.
(print_uint64): Add (v0-only).
(print_uint64_hex): Add (v0-only).
(print_ident): Respect skipping_printing,
Support v0 identifiers.
(print_lifetime_from_index): Add (v0-only).
(demangle_binder): Add (v0-only).
(demangle_path): Add (v0-only).
(demangle_generic_arg): Add (v0-only).
(demangle_type): Add (v0-only).
(demangle_path_maybe_open_generics): Add (v0-only).
(demangle_dyn_trait): Add (v0-only).
(demangle_const): Add (v0-only).
(demangle_const_uint): Add (v0-only).
(basic_type): Add (v0-only).
(rust_demangle_callback): Support v0 symbols.
* testsuite/rust-demangle-expected: Add v0 testcases.
2020-11-13 Seija Kijin <doremylover456@gmail.com>
* strstr.c (strstr): Make implementation ANSI/POSIX compliant.
2020-11-11 Patrick Palka <ppalka@redhat.com>
PR c++/88115
* cp-demangle.c (d_print_comp_inner)
<case DEMANGLE_COMPONENT_EXTENDED_OPERATOR>: Don't print the
"operator " prefix for __alignof__.
<case DEMANGLE_COMPONENT_UNARY>: Always print parens around the
operand of __alignof__.
* testsuite/demangle-expected: Test demangling for __alignof__.
2020-11-09 Christophe Lyon <christophe.lyon@linaro.org>
* pex-win32.c (pex_win32_exec_child): Initialize orig_err.
2020-10-06 Martin Liska <mliska@suse.cz>
PR lto/97290
* simple-object-elf.c (simple_object_elf_copy_lto_debug_sections):
Use sh_link of a .symtab_shndx section.
2021-01-05 Alan Modra <amodra@gmail.com> 2021-01-05 Alan Modra <amodra@gmail.com>
* config.guess: Import from upstream. * config.guess: Import from upstream.

117
libiberty/ChangeLog
View File

@ -1,23 +1,98 @@
2020-09-23 Mark Wielaard <mark@klomp.org> 2021-01-04 Martin Liska <mliska@suse.cz>
* strverscmp.c: Convert to utf8 from iso8859.
2020-12-22 Jason Merrill <jason@redhat.com>
PR c++/67343
* cp-demangle.h (struct d_info): Add unresolved_name_state.
* cp-demangle.c (d_prefix): Add subst parm.
(d_nested_name): Pass it.
(d_unresolved_name): Split out from...
(d_expression_1): ...here.
(d_demangle_callback): Maybe retry with old sr mangling.
* testsuite/demangle-expected: Add test.
2020-12-21 Jason Merrill <jason@redhat.com>
* cp-demangle.c (d_expression_1): Recognize qualified-id
on RHS of dt/pt.
* testsuite/demangle-expected: Add test.
2020-12-21 Jason Merrill <jason@redhat.com>
* cp-demangle.c (d_unqualified_name): Clear is_expression.
* testsuite/demangle-expected: Add tests.
2020-11-25 Matthew Malcomson <matthew.malcomson@arm.com>
* configure: Regenerate.
* configure.ac: Avoid using sanitizer.
2020-11-13 Eduard-Mihai Burtescu <eddyb@lyken.rs>
* rust-demangle.c (struct rust_demangler): Add
skipping_printing and bound_lifetime_depth fields.
(eat): Add (v0-only).
(parse_integer_62): Add (v0-only).
(parse_opt_integer_62): Add (v0-only).
(parse_disambiguator): Add (v0-only).
(struct rust_mangled_ident): Add punycode{,_len} fields.
(parse_ident): Support v0 identifiers.
(print_str): Respect skipping_printing.
(print_uint64): Add (v0-only).
(print_uint64_hex): Add (v0-only).
(print_ident): Respect skipping_printing,
Support v0 identifiers.
(print_lifetime_from_index): Add (v0-only).
(demangle_binder): Add (v0-only).
(demangle_path): Add (v0-only).
(demangle_generic_arg): Add (v0-only).
(demangle_type): Add (v0-only).
(demangle_path_maybe_open_generics): Add (v0-only).
(demangle_dyn_trait): Add (v0-only).
(demangle_const): Add (v0-only).
(demangle_const_uint): Add (v0-only).
(basic_type): Add (v0-only).
(rust_demangle_callback): Support v0 symbols.
* testsuite/rust-demangle-expected: Add v0 testcases.
2020-11-13 Seija Kijin <doremylover456@gmail.com>
* strstr.c (strstr): Make implementation ANSI/POSIX compliant.
2020-11-11 Patrick Palka <ppalka@redhat.com>
PR c++/88115
* cp-demangle.c (d_print_comp_inner)
<case DEMANGLE_COMPONENT_EXTENDED_OPERATOR>: Don't print the
"operator " prefix for __alignof__.
<case DEMANGLE_COMPONENT_UNARY>: Always print parens around the
operand of __alignof__.
* testsuite/demangle-expected: Test demangling for __alignof__.
2020-11-09 Christophe Lyon <christophe.lyon@linaro.org>
* pex-win32.c (pex_win32_exec_child): Initialize orig_err.
2020-10-06 Martin Liska <mliska@suse.cz>
PR lto/97290
* simple-object-elf.c (simple_object_elf_copy_lto_debug_sections):
Use sh_link of a .symtab_shndx section.
2020-09-24 Mark Wielaard <mark@klomp.org>
Sync with GCC
* dwarfnames.c (get_DW_UT_name): Define using DW_UT_FIRST, DW_UT * dwarfnames.c (get_DW_UT_name): Define using DW_UT_FIRST, DW_UT
and DW_UT_END. and DW_UT_END.
2020-09-11 Felix Willgerodt <felix.willgerodt@intel.com> 2020-09-08 Felix Willgerodt <felix.willgerodt@intel.com>
Sync with GCC
2020-09-08 Felix Willgerodt <felix.willgerodt@intel.com>
* floatformat.c (floatformat_bfloat16_big): New. * floatformat.c (floatformat_bfloat16_big): New.
(floatformat_bfloat16_little): New. (floatformat_bfloat16_little): New.
2020-09-08 Alan Modra <amodra@gmail.com> 2020-09-08 Alan Modra <amodra@gmail.com>
* configure: Regenerate.
Sync from gcc
2020-09-08 Alan Modra <amodra@gmail.com>
* d-demangle.c: Include limits.h. * d-demangle.c: Include limits.h.
(ULONG_MAX, UINT_MAX): Provide fall-back definition. (ULONG_MAX, UINT_MAX): Provide fall-back definition.
(dlang_number): Simplify and correct overflow test. Only (dlang_number): Simplify and correct overflow test. Only
@ -42,32 +117,42 @@
unsigned long variables. unsigned long variables.
* testsuite/d-demangle-expected: Add new tests. * testsuite/d-demangle-expected: Add new tests.
2020-08-04 Iain Buclaw <ibuclaw@gdcproject.org> 2020-08-26 Iain Buclaw <ibuclaw@gdcproject.org>
* d-demangle.c (dlang_function_args): Handle 'in' and 'in ref' * d-demangle.c (dlang_function_args): Handle 'in' and 'in ref'
parameter storage classes. parameter storage classes.
(dlang_type): Remove identifier type. (dlang_type): Remove identifier type.
* testsuite/d-demangle-expected: Update tests. * testsuite/d-demangle-expected: Update tests.
2020-08-03 Richard Biener <rguenther@suse.de> 2020-08-03 Richard Biener <rguenther@suse.de>
PR lto/96385 PR lto/96385
* simple-object-elf.c * simple-object-elf.c
(simple_object_elf_copy_lto_debug_sections): Localize global (simple_object_elf_copy_lto_debug_sections): Localize global
UNDEFs and reuse the prevailing name. UNDEFs and reuse the prevailing name.
2020-07-10 Ian Lance Taylor <iant@golang.org> 2020-07-30 H.J. Lu <hjl.tools@gmail.com>
PR bootstrap/96202
* configure: Regenerated.
2020-07-14 Ian Lance Taylor <iant@golang.org>
PR demangler/96143 PR demangler/96143
* cp-demangle.c (d_lambda): Don't add substitution candidate. * cp-demangle.c (d_lambda): Don't add substitution candidate.
* testsuite/demangle-expected: Update a few existing test cases * testsuite/demangle-expected: Update a few existing test cases
accordingly, and add a new test case. accordingly, and add a new test case.
2020-07-04 Jason Merrill <jason@redhat.com> 2020-07-10 Jason Merrill <jason@redhat.com>
* cp-demangle.c (cplus_demangle_operators): Add di, dx, dX. * cp-demangle.c (cplus_demangle_operators): Add di, dx, dX.
(d_expression_1): Handle di and dX. (d_expression_1): Handle di and dX.
(is_designated_init, d_maybe_print_designated_init): New. (is_designated_init, d_maybe_print_designated_init): New.
(d_print_comp_inner): Use d_maybe_print_designated_init. (d_print_comp_inner): Use d_maybe_print_designated_init.
* testsuite/demangle-expected: Add designator tests. * testsuite/demangle-expected: Add designator tests.
2020-06-25 Nick Clifton <nickc@redhat.com> 2020-06-26 Nick Clifton <nickc@redhat.com>
* bsearch.c (bsearch): Remove use of register keyword. * bsearch.c (bsearch): Remove use of register keyword.
* bsearch_r.c (bsearch_r): Likewise. * bsearch_r.c (bsearch_r): Likewise.
@ -3296,7 +3381,7 @@
(find_executable): Likewise. (find_executable): Likewise.
(win32_spawn): Cast alloca return to (char**). (win32_spawn): Cast alloca return to (char**).
Replace malloc with XNEWVEC. Replace malloc with XNEWVEC.
bcopy.c (bcopy): Add explicit casts in assignments. bcopy.c (bcopy): Add explict casts in assignments.
2006-10-25 Ben Elliston <bje@au.ibm.com> 2006-10-25 Ben Elliston <bje@au.ibm.com>

1
libiberty/configure vendored
View File

@ -5264,6 +5264,7 @@ fi
NOASANFLAG= NOASANFLAG=
case " ${CFLAGS} " in case " ${CFLAGS} " in
*\ -fsanitize=address\ *) NOASANFLAG=-fno-sanitize=address ;; *\ -fsanitize=address\ *) NOASANFLAG=-fno-sanitize=address ;;
*\ -fsanitize=hwaddress\ *) NOASANFLAG=-fno-sanitize=hwaddress ;;
esac esac

1
libiberty/configure.ac
View File

@ -240,6 +240,7 @@ AC_SUBST(PICFLAG)
NOASANFLAG= NOASANFLAG=
case " ${CFLAGS} " in case " ${CFLAGS} " in
*\ -fsanitize=address\ *) NOASANFLAG=-fno-sanitize=address ;; *\ -fsanitize=address\ *) NOASANFLAG=-fno-sanitize=address ;;
*\ -fsanitize=hwaddress\ *) NOASANFLAG=-fno-sanitize=hwaddress ;;
esac esac
AC_SUBST(NOASANFLAG) AC_SUBST(NOASANFLAG)

140
libiberty/cp-demangle.c
View File

@ -429,7 +429,7 @@ static struct demangle_component *d_name (struct d_info *);
static struct demangle_component *d_nested_name (struct d_info *); static struct demangle_component *d_nested_name (struct d_info *);
static struct demangle_component *d_prefix (struct d_info *); static struct demangle_component *d_prefix (struct d_info *, int);
static struct demangle_component *d_unqualified_name (struct d_info *); static struct demangle_component *d_unqualified_name (struct d_info *);
@ -1510,7 +1510,7 @@ d_nested_name (struct d_info *di)
once we have something to attach it to. */ once we have something to attach it to. */
rqual = d_ref_qualifier (di, NULL); rqual = d_ref_qualifier (di, NULL);
*pret = d_prefix (di); *pret = d_prefix (di, 1);
if (*pret == NULL) if (*pret == NULL)
return NULL; return NULL;
@ -1536,10 +1536,12 @@ d_nested_name (struct d_info *di)
<template-prefix> ::= <prefix> <(template) unqualified-name> <template-prefix> ::= <prefix> <(template) unqualified-name>
::= <template-param> ::= <template-param>
::= <substitution> ::= <substitution>
*/
SUBST is true if we should add substitutions (as normal), false
if not (in an unresolved-name). */
static struct demangle_component * static struct demangle_component *
d_prefix (struct d_info *di) d_prefix (struct d_info *di, int subst)
{ {
struct demangle_component *ret = NULL; struct demangle_component *ret = NULL;
@ -1605,7 +1607,7 @@ d_prefix (struct d_info *di)
else else
ret = d_make_comp (di, comb_type, ret, dc); ret = d_make_comp (di, comb_type, ret, dc);
if (peek != 'S' && d_peek_char (di) != 'E') if (peek != 'S' && d_peek_char (di) != 'E' && subst)
{ {
if (! d_add_substitution (di, ret)) if (! d_add_substitution (di, ret))
return NULL; return NULL;
@ -1632,9 +1634,15 @@ d_unqualified_name (struct d_info *di)
ret = d_source_name (di); ret = d_source_name (di);
else if (IS_LOWER (peek)) else if (IS_LOWER (peek))
{ {
int was_expr = di->is_expression;
if (peek == 'o' && d_peek_next_char (di) == 'n') if (peek == 'o' && d_peek_next_char (di) == 'n')
d_advance (di, 2); {
d_advance (di, 2);
/* Treat cv as naming a conversion operator. */
di->is_expression = 0;
}
ret = d_operator_name (di); ret = d_operator_name (di);
di->is_expression = was_expr;
if (ret != NULL && ret->type == DEMANGLE_COMPONENT_OPERATOR) if (ret != NULL && ret->type == DEMANGLE_COMPONENT_OPERATOR)
{ {
di->expansion += sizeof "operator" + ret->u.s_operator.op->len - 2; di->expansion += sizeof "operator" + ret->u.s_operator.op->len - 2;
@ -3285,14 +3293,58 @@ op_is_new_cast (struct demangle_component *op)
|| code[0] == 'c' || code[0] == 'r')); || code[0] == 'c' || code[0] == 'r'));
} }
/* <unresolved-name> ::= [gs] <base-unresolved-name> # x or (with "gs") ::x
::= sr <unresolved-type> <base-unresolved-name> # T::x / decltype(p)::x
# T::N::x /decltype(p)::N::x
::= srN <unresolved-type> <unresolved-qualifier-level>+ E <base-unresolved-name>
# A::x, N::y, A<T>::z; "gs" means leading "::"
::= [gs] sr <unresolved-qualifier-level>+ E <base-unresolved-name>
"gs" is handled elsewhere, as a unary operator. */
static struct demangle_component *
d_unresolved_name (struct d_info *di)
{
struct demangle_component *type;
struct demangle_component *name;
char peek;
/* Consume the "sr". */
d_advance (di, 2);
peek = d_peek_char (di);
if (di->unresolved_name_state
&& (IS_DIGIT (peek)
|| IS_LOWER (peek)
|| peek == 'C'
|| peek == 'U'
|| peek == 'L'))
{
/* The third production is ambiguous with the old unresolved-name syntax
of <type> <base-unresolved-name>; in the old mangling, A::x was mangled
as sr1A1x, now sr1AE1x. So we first try to demangle using the new
mangling, then with the old if that fails. */
di->unresolved_name_state = -1;
type = d_prefix (di, 0);
if (d_peek_char (di) == 'E')
d_advance (di, 1);
}
else
type = cplus_demangle_type (di);
name = d_unqualified_name (di);
if (d_peek_char (di) == 'I')
name = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
d_template_args (di));
return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type, name);
}
/* <expression> ::= <(unary) operator-name> <expression> /* <expression> ::= <(unary) operator-name> <expression>
::= <(binary) operator-name> <expression> <expression> ::= <(binary) operator-name> <expression> <expression>
::= <(trinary) operator-name> <expression> <expression> <expression> ::= <(trinary) operator-name> <expression> <expression> <expression>
::= cl <expression>+ E ::= cl <expression>+ E
::= st <type> ::= st <type>
::= <template-param> ::= <template-param>
::= sr <type> <unqualified-name> ::= <unresolved-name>
::= sr <type> <unqualified-name> <template-args>
::= <expr-primary> ::= <expr-primary>
<braced-expression> ::= <expression> <braced-expression> ::= <expression>
@ -3302,7 +3354,7 @@ op_is_new_cast (struct demangle_component *op)
# [expr ... expr] = expr # [expr ... expr] = expr
*/ */
static inline struct demangle_component * static struct demangle_component *
d_expression_1 (struct d_info *di) d_expression_1 (struct d_info *di)
{ {
char peek; char peek;
@ -3313,20 +3365,7 @@ d_expression_1 (struct d_info *di)
else if (peek == 'T') else if (peek == 'T')
return d_template_param (di); return d_template_param (di);
else if (peek == 's' && d_peek_next_char (di) == 'r') else if (peek == 's' && d_peek_next_char (di) == 'r')
{ return d_unresolved_name (di);
struct demangle_component *type;
struct demangle_component *name;
d_advance (di, 2);
type = cplus_demangle_type (di);
name = d_unqualified_name (di);
if (d_peek_char (di) != 'I')
return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type, name);
else
return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type,
d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
d_template_args (di)));
}
else if (peek == 's' && d_peek_next_char (di) == 'p') else if (peek == 's' && d_peek_next_char (di) == 'p')
{ {
d_advance (di, 2); d_advance (di, 2);
@ -3470,10 +3509,22 @@ d_expression_1 (struct d_info *di)
right = d_exprlist (di, 'E'); right = d_exprlist (di, 'E');
else if (!strcmp (code, "dt") || !strcmp (code, "pt")) else if (!strcmp (code, "dt") || !strcmp (code, "pt"))
{ {
right = d_unqualified_name (di); peek = d_peek_char (di);
if (d_peek_char (di) == 'I') /* These codes start a qualified name. */
right = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, if ((peek == 'g' && d_peek_next_char (di) == 's')
right, d_template_args (di)); || (peek == 's' && d_peek_next_char (di) == 'r'))
right = d_expression_1 (di);
else
{
/* Otherwise it's an unqualified name. We use
d_unqualified_name rather than d_expression_1 here for
old mangled names that didn't add 'on' before operator
names. */
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 else
right = d_expression_1 (di); right = d_expression_1 (di);
@ -5458,9 +5509,18 @@ d_print_comp_inner (struct d_print_info *dpi, int options,
} }
case DEMANGLE_COMPONENT_EXTENDED_OPERATOR: case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
d_append_string (dpi, "operator "); {
d_print_comp (dpi, options, dc->u.s_extended_operator.name); struct demangle_component *name = dc->u.s_extended_operator.name;
return; if (name->type == DEMANGLE_COMPONENT_NAME
&& !strncmp (name->u.s_name.s, "__alignof__", name->u.s_name.len))
d_print_comp (dpi, options, dc->u.s_extended_operator.name);
else
{
d_append_string (dpi, "operator ");
d_print_comp (dpi, options, dc->u.s_extended_operator.name);
}
return;
}
case DEMANGLE_COMPONENT_CONVERSION: case DEMANGLE_COMPONENT_CONVERSION:
d_append_string (dpi, "operator "); d_append_string (dpi, "operator ");
@ -5525,8 +5585,14 @@ d_print_comp_inner (struct d_print_info *dpi, int options,
if (code && !strcmp (code, "gs")) if (code && !strcmp (code, "gs"))
/* Avoid parens after '::'. */ /* Avoid parens after '::'. */
d_print_comp (dpi, options, operand); d_print_comp (dpi, options, operand);
else if (code && !strcmp (code, "st")) else if ((code && !strcmp (code, "st"))
/* Always print parens for sizeof (type). */ || (op->type == DEMANGLE_COMPONENT_EXTENDED_OPERATOR
&& (op->u.s_extended_operator.name->type
== DEMANGLE_COMPONENT_NAME)
&& !strncmp (op->u.s_extended_operator.name->u.s_name.s,
"__alignof__",
op->u.s_extended_operator.name->u.s_name.len)))
/* Always print parens for sizeof (type) and __alignof__. */
{ {
d_append_char (dpi, '('); d_append_char (dpi, '(');
d_print_comp (dpi, options, operand); d_print_comp (dpi, options, operand);
@ -6364,6 +6430,9 @@ d_demangle_callback (const char *mangled, int options,
type = DCT_TYPE; type = DCT_TYPE;
} }
di.unresolved_name_state = 1;
again:
cplus_demangle_init_info (mangled, options, strlen (mangled), &di); cplus_demangle_init_info (mangled, options, strlen (mangled), &di);
/* PR 87675 - Check for a mangled string that is so long /* PR 87675 - Check for a mangled string that is so long
@ -6422,6 +6491,13 @@ d_demangle_callback (const char *mangled, int options,
if (((options & DMGL_PARAMS) != 0) && d_peek_char (&di) != '\0') if (((options & DMGL_PARAMS) != 0) && d_peek_char (&di) != '\0')
dc = NULL; dc = NULL;
/* See discussion in d_unresolved_name. */
if (dc == NULL && di.unresolved_name_state == -1)
{
di.unresolved_name_state = 0;
goto again;
}
#ifdef CP_DEMANGLE_DEBUG #ifdef CP_DEMANGLE_DEBUG
d_dump (dc, 0); d_dump (dc, 0);
#endif #endif

4
libiberty/cp-demangle.h
View File

@ -122,6 +122,10 @@ struct d_info
/* Non-zero if we are parsing the type operand of a conversion /* Non-zero if we are parsing the type operand of a conversion
operator, but not when in an expression. */ operator, but not when in an expression. */
int is_conversion; int is_conversion;
/* 1: using new unresolved-name grammar.
-1: using new unresolved-name grammar and saw an unresolved-name.
0: using old unresolved-name grammar. */
int unresolved_name_state;
/* If DMGL_NO_RECURSE_LIMIT is not active then this is set to /* If DMGL_NO_RECURSE_LIMIT is not active then this is set to
the current recursion level. */ the current recursion level. */
unsigned int recursion_level; unsigned int recursion_level;

2
libiberty/pex-win32.c
View File

@ -771,7 +771,7 @@ pex_win32_exec_child (struct pex_obj *obj ATTRIBUTE_UNUSED, int flags,
OSVERSIONINFO version_info; OSVERSIONINFO version_info;
STARTUPINFO si; STARTUPINFO si;
PROCESS_INFORMATION pi; PROCESS_INFORMATION pi;
int orig_out, orig_in, orig_err; int orig_out, orig_in, orig_err = 0;
BOOL separate_stderr = !(flags & PEX_STDERR_TO_STDOUT); BOOL separate_stderr = !(flags & PEX_STDERR_TO_STDOUT);
/* Ensure we have inheritable descriptors to pass to the child. */ /* Ensure we have inheritable descriptors to pass to the child. */

1008
libiberty/rust-demangle.c
View File

File diff suppressed because it is too large Load Diff

11
libiberty/simple-object-elf.c
View File

@ -1191,7 +1191,7 @@ simple_object_elf_copy_lto_debug_sections (simple_object_read *sobj,
unsigned int sh_link; unsigned int sh_link;
sh_link = ELF_FETCH_FIELD (type_functions, ei_class, Shdr, sh_link = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
shdr, sh_link, Elf_Word); shdr, sh_link, Elf_Word);
symtab_indices_shndx[sh_link - 1] = i; symtab_indices_shndx[sh_link - 1] = i - 1;
/* Always discard the extended index sections, after /* Always discard the extended index sections, after
copying it will not be needed. This way we don't need to copying it will not be needed. This way we don't need to
update it and deal with the ordering constraints of update it and deal with the ordering constraints of
@ -1372,19 +1372,22 @@ simple_object_elf_copy_lto_debug_sections (simple_object_read *sobj,
{ {
unsigned entsize = ELF_FETCH_FIELD (type_functions, ei_class, Shdr, unsigned entsize = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
shdr, sh_entsize, Elf_Addr); shdr, sh_entsize, Elf_Addr);
unsigned strtab = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
shdr, sh_link, Elf_Word);
size_t prevailing_name_idx = 0; size_t prevailing_name_idx = 0;
unsigned char *ent; unsigned char *ent;
unsigned *shndx_table = NULL; unsigned *shndx_table = NULL;
/* Read the section index table if present. */ /* Read the section index table if present. */
if (symtab_indices_shndx[i - 1] != 0) if (symtab_indices_shndx[i - 1] != 0)
{ {
unsigned char *sidxhdr = shdrs + (strtab - 1) * shdr_size; unsigned char *sidxhdr = shdrs + symtab_indices_shndx[i - 1] * shdr_size;
off_t sidxoff = ELF_FETCH_FIELD (type_functions, ei_class, Shdr, off_t sidxoff = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
sidxhdr, sh_offset, Elf_Addr); sidxhdr, sh_offset, Elf_Addr);
size_t sidxsz = ELF_FETCH_FIELD (type_functions, ei_class, Shdr, size_t sidxsz = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
sidxhdr, sh_size, Elf_Addr); sidxhdr, sh_size, Elf_Addr);
unsigned int shndx_type
= ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
sidxhdr, sh_type, Elf_Word);
if (shndx_type != SHT_SYMTAB_SHNDX)
return "Wrong section type of a SYMTAB SECTION INDICES section";
shndx_table = (unsigned *)XNEWVEC (char, sidxsz); shndx_table = (unsigned *)XNEWVEC (char, sidxsz);
simple_object_internal_read (sobj->descriptor, simple_object_internal_read (sobj->descriptor,
sobj->offset + sidxoff, sobj->offset + sidxoff,

16
libiberty/strstr.c
View File

@ -16,26 +16,20 @@ length, the function returns @var{string}.
*/ */
/* FIXME: The above description is ANSI compiliant. This routine has not
been validated to comply with it. -fnf */
#include <stddef.h> #include <stddef.h>
extern char *strchr (const char *, int); extern int memcmp (const void *, const void *, size_t);
extern int strncmp (const void *, const void *, size_t);
extern size_t strlen (const char *); extern size_t strlen (const char *);
char * char *
strstr (const char *s1, const char *s2) strstr (const char *s1, const char *s2)
{ {
const char *p = s1;
const size_t len = strlen (s2); const size_t len = strlen (s2);
while (*s1)
for (; (p = strchr (p, *s2)) != 0; p++)
{ {
if (strncmp (p, s2, len) == 0) if (!memcmp (s1, s2, len))
return (char *)p; return (char *)s1;
++s1;
} }
return (0); return (0);
} }

2
libiberty/strverscmp.c
View File

@ -1,7 +1,7 @@
/* Compare strings while treating digits characters numerically. /* Compare strings while treating digits characters numerically.
Copyright (C) 1997-2021 Free Software Foundation, Inc. Copyright (C) 1997-2021 Free Software Foundation, Inc.
This file is part of the libiberty library. This file is part of the libiberty library.
Contributed by Jean-François Bignolles <bignolle@ecoledoc.ibp.fr>, 1997. Contributed by Jean-François Bignolles <bignolle@ecoledoc.ibp.fr>, 1997.
Libiberty is free software; you can redistribute it and/or Libiberty is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public modify it under the terms of the GNU Lesser General Public

19
libiberty/testsuite/demangle-expected
View File

@ -1469,3 +1469,22 @@ f(A<X{.a.b[3 ... 4]=(1)}>)
# PR 96143 # PR 96143
_Z2F2IZ1FvEUlvE_EN1AIT_E1XES2_ _Z2F2IZ1FvEUlvE_EN1AIT_E1XES2_
A<F()::{lambda()#1}>::X F2<F()::{lambda()#1}>(F()::{lambda()#1}) A<F()::{lambda()#1}>::X F2<F()::{lambda()#1}>(F()::{lambda()#1})
# PR 88115
_Z1fIiEvDTv111__alignof__T_E
void f<int>(decltype (__alignof__(int)))
_Z1fIiEvDTv111__alignof__tlT_EE
void f<int>(decltype (__alignof__(int{})))
_Z1gI1AEv1SIXadsrT_oncviEE
void g<A>(S<&A::operator int>)
_Z1jI1AEDTcldtfp_oncvPT_EES1_
decltype (({parm#1}.(operator A*))()) j<A>(A)
_Z1fI1AEDtdtfp_srT_1xES1_
decltype ({parm#1}.A::x) f<A>(A)
_Z2f6IP1AEDtptfp_gssr1A1BE1xET_
decltype ({parm#1}->(::A::B::x)) f6<A*>(A*)

134
libiberty/testsuite/rust-demangle-expected
View File

@ -11,7 +11,7 @@
# #
############ ############
# #
# Coverage Tests # Coverage Tests (legacy)
# #
# #
# Demangles as rust symbol. # Demangles as rust symbol.
@ -163,3 +163,135 @@ _ZN63_$LT$core..ptr..Unique$LT$T$GT$$u20$as$u20$core..ops..Deref$GT$5deref17h19f
--format=rust --format=rust
_ZN11issue_609253foo37Foo$LT$issue_60925..llv$u6d$..Foo$GT$3foo17h059a991a004536adE _ZN11issue_609253foo37Foo$LT$issue_60925..llv$u6d$..Foo$GT$3foo17h059a991a004536adE
issue_60925::foo::Foo<issue_60925::llvm::Foo>::foo issue_60925::foo::Foo<issue_60925::llvm::Foo>::foo
--format=rust
_ZN4core3ops8function6FnOnce40call_once$u7b$$u7b$vtable.shim$u7d$$u7d$17h000b1ad6c4f30bd6E
core::ops::function::FnOnce::call_once{{vtable.shim}}
#
############
#
# Coverage Tests (v0)
#
#
# Crate with a leading digit.
--format=rust
_RNvC6_123foo3bar
123foo::bar
# UTF-8 identifiers.
--format=rust
_RNqCs4fqI2P2rA04_11utf8_identsu30____7hkackfecea1cbdathfdh9hlq6y
utf8_idents::საჭმელად_გემრიელი_სადილი
# Closure path elements.
--format=rust
_RNCNCNgCs6DXkGYLi8lr_2cc5spawn00B5_
cc::spawn::{closure#0}::{closure#0}
#
--format=rust
_RNCINkXs25_NgCsbmNqQUJIY6D_4core5sliceINyB9_4IterhENuNgNoBb_4iter8iterator8Iterator9rpositionNCNgNpB9_6memchr7memrchrs_0E0Bb_
<core::slice::Iter<u8> as core::iter::iterator::Iterator>::rposition::<core::slice::memchr::memrchr::{closure#1}>::{closure#0}
# dyn Trait ("trait object") types.
--format=rust
_RINbNbCskIICzLVDPPb_5alloc5alloc8box_freeDINbNiB4_5boxed5FnBoxuEp6OutputuEL_ECs1iopQbuBiw2_3std
alloc::alloc::box_free::<dyn alloc::boxed::FnBox<(), Output = ()>>
# Types with const generics parameters.
--format=rust
_RNvMC0INtC8arrayvec8ArrayVechKj7b_E3new
<arrayvec::ArrayVec<u8, 123>>::new
#
--format=rust
_RMCs4fqI2P2rA04_13const_genericINtB0_8UnsignedKhb_E
<const_generic::Unsigned<11>>
#
--format=rust
_RMCs4fqI2P2rA04_13const_genericINtB0_6SignedKs98_E
<const_generic::Signed<152>>
#
--format=rust
_RMCs4fqI2P2rA04_13const_genericINtB0_6SignedKanb_E
<const_generic::Signed<-11>>
#
--format=rust
_RMCs4fqI2P2rA04_13const_genericINtB0_4BoolKb0_E
<const_generic::Bool<false>>
#
--format=rust
_RMCs4fqI2P2rA04_13const_genericINtB0_4BoolKb1_E
<const_generic::Bool<true>>
#
--format=rust
_RMCs4fqI2P2rA04_13const_genericINtB0_4CharKc76_E
<const_generic::Char<'v'>>
#
--format=rust
_RMCs4fqI2P2rA04_13const_genericINtB0_4CharKca_E
<const_generic::Char<'\n'>>
#
--format=rust
_RMCs4fqI2P2rA04_13const_genericINtB0_4CharKc2202_E
<const_generic::Char<'\u{2202}'>>
#
--format=rust
_RNvNvMCs4fqI2P2rA04_13const_genericINtB4_3FooKpE3foo3FOO
<const_generic::Foo<_>>::foo::FOO
#
# All of the tests above but in auto mode instead:
#
# Crate with a leading digit.
--format=auto
_RNvC6_123foo3bar
123foo::bar
# UTF-8 identifiers.
--format=auto
_RNqCs4fqI2P2rA04_11utf8_identsu30____7hkackfecea1cbdathfdh9hlq6y
utf8_idents::საჭმელად_გემრიელი_სადილი
# Closure path elements.
--format=auto
_RNCNCNgCs6DXkGYLi8lr_2cc5spawn00B5_
cc::spawn::{closure#0}::{closure#0}
#
--format=auto
_RNCINkXs25_NgCsbmNqQUJIY6D_4core5sliceINyB9_4IterhENuNgNoBb_4iter8iterator8Iterator9rpositionNCNgNpB9_6memchr7memrchrs_0E0Bb_
<core::slice::Iter<u8> as core::iter::iterator::Iterator>::rposition::<core::slice::memchr::memrchr::{closure#1}>::{closure#0}
# dyn Trait ("trait object") types.
--format=auto
_RINbNbCskIICzLVDPPb_5alloc5alloc8box_freeDINbNiB4_5boxed5FnBoxuEp6OutputuEL_ECs1iopQbuBiw2_3std
alloc::alloc::box_free::<dyn alloc::boxed::FnBox<(), Output = ()>>
# Types with const generics parameters.
--format=auto
_RNvMC0INtC8arrayvec8ArrayVechKj7b_E3new
<arrayvec::ArrayVec<u8, 123>>::new
#
--format=auto
_RMCs4fqI2P2rA04_13const_genericINtB0_8UnsignedKhb_E
<const_generic::Unsigned<11>>
#
--format=auto
_RMCs4fqI2P2rA04_13const_genericINtB0_6SignedKs98_E
<const_generic::Signed<152>>
#
--format=auto
_RMCs4fqI2P2rA04_13const_genericINtB0_6SignedKanb_E
<const_generic::Signed<-11>>
#
--format=auto
_RMCs4fqI2P2rA04_13const_genericINtB0_4BoolKb0_E
<const_generic::Bool<false>>
#
--format=auto
_RMCs4fqI2P2rA04_13const_genericINtB0_4BoolKb1_E
<const_generic::Bool<true>>
#
--format=auto
_RMCs4fqI2P2rA04_13const_genericINtB0_4CharKc76_E
<const_generic::Char<'v'>>
#
--format=auto
_RMCs4fqI2P2rA04_13const_genericINtB0_4CharKca_E
<const_generic::Char<'\n'>>
#
--format=auto
_RMCs4fqI2P2rA04_13const_genericINtB0_4CharKc2202_E
<const_generic::Char<'\u{2202}'>>
#
--format=auto
_RNvNvMCs4fqI2P2rA04_13const_genericINtB4_3FooKpE3foo3FOO
<const_generic::Foo<_>>::foo::FOO