mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-03 23:34:02 +08:00
merge from gcc
This commit is contained in:
DJ Delorie
parent
06fa9cecf1
commit
1c08f2c880
@ -1,3 +1,8 @@
|
||||
2008-10-06 Jason Merrill <jason@redhat.com>
|
||||
|
||||
* demangle.h (enum demangle_component_type): Add
|
||||
DEMANGLE_COMPONENT_PACK_EXPANSION.
|
||||
|
||||
2008-09-24 Richard Henderson <rth@redhat.com>
|
||||
|
||||
* elf/dwarf2.h (DW_OP_GNU_encoded_addr): New.
|
||||
|
||||
@ -372,7 +372,9 @@ enum demangle_component_type
|
||||
/* A name formed by a single character. */
|
||||
DEMANGLE_COMPONENT_CHARACTER,
|
||||
/* A decltype type. */
|
||||
DEMANGLE_COMPONENT_DECLTYPE
|
||||
DEMANGLE_COMPONENT_DECLTYPE,
|
||||
/* A pack expansion. */
|
||||
DEMANGLE_COMPONENT_PACK_EXPANSION
|
||||
};
|
||||
|
||||
/* Types which are only used internally. */
|
||||
|
||||
@ -1,8 +1,21 @@
|
||||
2008-09-11 Jan Kratochvil <jan.kratochvil@redhat.com>
|
||||
2008-10-06 Jason Merrill <jason@redhat.com>
|
||||
|
||||
* configure.in: Call AC_SYS_LARGEFILE.
|
||||
* config.in: Regenerate.
|
||||
* configure: Regenerate.
|
||||
* cp-demangle.c (struct d_print_info): Add pack_index.
|
||||
(d_dump): Add DEMANGLE_COMPONENT_PACK_EXPANSION.
|
||||
(d_make_comp): Likewise. DEMANGLE_COMPONENT_ARGLIST and
|
||||
DEMANGLE_COMPONENT_TEMPLATE_ARGLIST can have two null args.
|
||||
(cplus_demangle_builtin_types): Add char16/32_t.
|
||||
(cplus_demangle_type): Recognize them.
|
||||
(d_template_args): Handle empty argument packs.
|
||||
(d_template_arg): Handle argument packs.
|
||||
(d_expression): Handle dependent name.
|
||||
(d_index_template_argument): New fn.
|
||||
(d_lookup_template_argument): New fn.
|
||||
(d_find_pack, d_pack_length): New fn.
|
||||
(d_print_subexpr): Split out...
|
||||
(d_print_comp): ...from here. Use d_*_template_argument.
|
||||
Handle empty arg lists. Support pack expansions.
|
||||
* cp-demangle.h (D_BUILTIN_TYPE_COUNT): Increase to 32.
|
||||
|
||||
2008-09-09 Jason Merrill <jason@redhat.com>
|
||||
|
||||
|
||||
@ -425,12 +425,6 @@
|
||||
first (like Motorola and SPARC, unlike Intel and VAX). */
|
||||
#undef WORDS_BIGENDIAN
|
||||
|
||||
/* Number of bits in a file offset, on hosts where this is settable. */
|
||||
#undef _FILE_OFFSET_BITS
|
||||
|
||||
/* Define for large files, on AIX-style hosts. */
|
||||
#undef _LARGE_FILES
|
||||
|
||||
/* Define to empty if `const' does not conform to ANSI C. */
|
||||
#undef const
|
||||
|
||||
|
||||
366
libiberty/configure
vendored
366
libiberty/configure
vendored
@ -849,7 +849,6 @@ Optional Features:
|
||||
enable make rules and dependencies not useful
|
||||
(and sometimes confusing) to the casual installer
|
||||
--enable-multilib build many library versions (default)
|
||||
--disable-largefile omit support for large files
|
||||
--enable-install-libiberty Install headers for end users
|
||||
|
||||
Optional Packages:
|
||||
@ -2742,371 +2741,6 @@ ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
||||
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
||||
ac_compiler_gnu=$ac_cv_c_compiler_gnu
|
||||
|
||||
|
||||
# Check whether --enable-largefile or --disable-largefile was given.
|
||||
if test "${enable_largefile+set}" = set; then
|
||||
enableval="$enable_largefile"
|
||||
|
||||
fi;
|
||||
if test "$enable_largefile" != no; then
|
||||
|
||||
echo "$as_me:$LINENO: checking for special C compiler options needed for large files" >&5
|
||||
echo $ECHO_N "checking for special C compiler options needed for large files... $ECHO_C" >&6
|
||||
if test "${ac_cv_sys_largefile_CC+set}" = set; then
|
||||
echo $ECHO_N "(cached) $ECHO_C" >&6
|
||||
else
|
||||
ac_cv_sys_largefile_CC=no
|
||||
if test "$GCC" != yes; then
|
||||
ac_save_CC=$CC
|
||||
while :; do
|
||||
# IRIX 6.2 and later do not support large files by default,
|
||||
# so use the C compiler's -n32 option if that helps.
|
||||
cat >conftest.$ac_ext <<_ACEOF
|
||||
/* confdefs.h. */
|
||||
_ACEOF
|
||||
cat confdefs.h >>conftest.$ac_ext
|
||||
cat >>conftest.$ac_ext <<_ACEOF
|
||||
/* end confdefs.h. */
|
||||
#include <sys/types.h>
|
||||
/* Check that off_t can represent 2**63 - 1 correctly.
|
||||
We can't simply define LARGE_OFF_T to be 9223372036854775807,
|
||||
since some C++ compilers masquerading as C compilers
|
||||
incorrectly reject 9223372036854775807. */
|
||||
#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
|
||||
int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
|
||||
&& LARGE_OFF_T % 2147483647 == 1)
|
||||
? 1 : -1];
|
||||
int
|
||||
main ()
|
||||
{
|
||||
|
||||
;
|
||||
return 0;
|
||||
}
|
||||
_ACEOF
|
||||
rm -f conftest.$ac_objext
|
||||
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
|
||||
(eval $ac_compile) 2>conftest.er1
|
||||
ac_status=$?
|
||||
grep -v '^ *+' conftest.er1 >conftest.err
|
||||
rm -f conftest.er1
|
||||
cat conftest.err >&5
|
||||
echo "$as_me:$LINENO: \$? = $ac_status" >&5
|
||||
(exit $ac_status); } &&
|
||||
{ ac_try='test -z "$ac_c_werror_flag"
|
||||
|| test ! -s conftest.err'
|
||||
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
|
||||
(eval $ac_try) 2>&5
|
||||
ac_status=$?
|
||||
echo "$as_me:$LINENO: \$? = $ac_status" >&5
|
||||
(exit $ac_status); }; } &&
|
||||
{ ac_try='test -s conftest.$ac_objext'
|
||||
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
|
||||
(eval $ac_try) 2>&5
|
||||
ac_status=$?
|
||||
echo "$as_me:$LINENO: \$? = $ac_status" >&5
|
||||
(exit $ac_status); }; }; then
|
||||
break
|
||||
else
|
||||
echo "$as_me: failed program was:" >&5
|
||||
sed 's/^/| /' conftest.$ac_ext >&5
|
||||
|
||||
fi
|
||||
rm -f conftest.err conftest.$ac_objext
|
||||
CC="$CC -n32"
|
||||
rm -f conftest.$ac_objext
|
||||
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
|
||||
(eval $ac_compile) 2>conftest.er1
|
||||
ac_status=$?
|
||||
grep -v '^ *+' conftest.er1 >conftest.err
|
||||
rm -f conftest.er1
|
||||
cat conftest.err >&5
|
||||
echo "$as_me:$LINENO: \$? = $ac_status" >&5
|
||||
(exit $ac_status); } &&
|
||||
{ ac_try='test -z "$ac_c_werror_flag"
|
||||
|| test ! -s conftest.err'
|
||||
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
|
||||
(eval $ac_try) 2>&5
|
||||
ac_status=$?
|
||||
echo "$as_me:$LINENO: \$? = $ac_status" >&5
|
||||
(exit $ac_status); }; } &&
|
||||
{ ac_try='test -s conftest.$ac_objext'
|
||||
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
|
||||
(eval $ac_try) 2>&5
|
||||
ac_status=$?
|
||||
echo "$as_me:$LINENO: \$? = $ac_status" >&5
|
||||
(exit $ac_status); }; }; then
|
||||
ac_cv_sys_largefile_CC=' -n32'; break
|
||||
else
|
||||
echo "$as_me: failed program was:" >&5
|
||||
sed 's/^/| /' conftest.$ac_ext >&5
|
||||
|
||||
fi
|
||||
rm -f conftest.err conftest.$ac_objext
|
||||
break
|
||||
done
|
||||
CC=$ac_save_CC
|
||||
rm -f conftest.$ac_ext
|
||||
fi
|
||||
fi
|
||||
echo "$as_me:$LINENO: result: $ac_cv_sys_largefile_CC" >&5
|
||||
echo "${ECHO_T}$ac_cv_sys_largefile_CC" >&6
|
||||
if test "$ac_cv_sys_largefile_CC" != no; then
|
||||
CC=$CC$ac_cv_sys_largefile_CC
|
||||
fi
|
||||
|
||||
echo "$as_me:$LINENO: checking for _FILE_OFFSET_BITS value needed for large files" >&5
|
||||
echo $ECHO_N "checking for _FILE_OFFSET_BITS value needed for large files... $ECHO_C" >&6
|
||||
if test "${ac_cv_sys_file_offset_bits+set}" = set; then
|
||||
echo $ECHO_N "(cached) $ECHO_C" >&6
|
||||
else
|
||||
while :; do
|
||||
ac_cv_sys_file_offset_bits=no
|
||||
cat >conftest.$ac_ext <<_ACEOF
|
||||
/* confdefs.h. */
|
||||
_ACEOF
|
||||
cat confdefs.h >>conftest.$ac_ext
|
||||
cat >>conftest.$ac_ext <<_ACEOF
|
||||
/* end confdefs.h. */
|
||||
#include <sys/types.h>
|
||||
/* Check that off_t can represent 2**63 - 1 correctly.
|
||||
We can't simply define LARGE_OFF_T to be 9223372036854775807,
|
||||
since some C++ compilers masquerading as C compilers
|
||||
incorrectly reject 9223372036854775807. */
|
||||
#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
|
||||
int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
|
||||
&& LARGE_OFF_T % 2147483647 == 1)
|
||||
? 1 : -1];
|
||||
int
|
||||
main ()
|
||||
{
|
||||
|
||||
;
|
||||
return 0;
|
||||
}
|
||||
_ACEOF
|
||||
rm -f conftest.$ac_objext
|
||||
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
|
||||
(eval $ac_compile) 2>conftest.er1
|
||||
ac_status=$?
|
||||
grep -v '^ *+' conftest.er1 >conftest.err
|
||||
rm -f conftest.er1
|
||||
cat conftest.err >&5
|
||||
echo "$as_me:$LINENO: \$? = $ac_status" >&5
|
||||
(exit $ac_status); } &&
|
||||
{ ac_try='test -z "$ac_c_werror_flag"
|
||||
|| test ! -s conftest.err'
|
||||
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
|
||||
(eval $ac_try) 2>&5
|
||||
ac_status=$?
|
||||
echo "$as_me:$LINENO: \$? = $ac_status" >&5
|
||||
(exit $ac_status); }; } &&
|
||||
{ ac_try='test -s conftest.$ac_objext'
|
||||
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
|
||||
(eval $ac_try) 2>&5
|
||||
ac_status=$?
|
||||
echo "$as_me:$LINENO: \$? = $ac_status" >&5
|
||||
(exit $ac_status); }; }; then
|
||||
break
|
||||
else
|
||||
echo "$as_me: failed program was:" >&5
|
||||
sed 's/^/| /' conftest.$ac_ext >&5
|
||||
|
||||
fi
|
||||
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
|
||||
cat >conftest.$ac_ext <<_ACEOF
|
||||
/* confdefs.h. */
|
||||
_ACEOF
|
||||
cat confdefs.h >>conftest.$ac_ext
|
||||
cat >>conftest.$ac_ext <<_ACEOF
|
||||
/* end confdefs.h. */
|
||||
#define _FILE_OFFSET_BITS 64
|
||||
#include <sys/types.h>
|
||||
/* Check that off_t can represent 2**63 - 1 correctly.
|
||||
We can't simply define LARGE_OFF_T to be 9223372036854775807,
|
||||
since some C++ compilers masquerading as C compilers
|
||||
incorrectly reject 9223372036854775807. */
|
||||
#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
|
||||
int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
|
||||
&& LARGE_OFF_T % 2147483647 == 1)
|
||||
? 1 : -1];
|
||||
int
|
||||
main ()
|
||||
{
|
||||
|
||||
;
|
||||
return 0;
|
||||
}
|
||||
_ACEOF
|
||||
rm -f conftest.$ac_objext
|
||||
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
|
||||
(eval $ac_compile) 2>conftest.er1
|
||||
ac_status=$?
|
||||
grep -v '^ *+' conftest.er1 >conftest.err
|
||||
rm -f conftest.er1
|
||||
cat conftest.err >&5
|
||||
echo "$as_me:$LINENO: \$? = $ac_status" >&5
|
||||
(exit $ac_status); } &&
|
||||
{ ac_try='test -z "$ac_c_werror_flag"
|
||||
|| test ! -s conftest.err'
|
||||
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
|
||||
(eval $ac_try) 2>&5
|
||||
ac_status=$?
|
||||
echo "$as_me:$LINENO: \$? = $ac_status" >&5
|
||||
(exit $ac_status); }; } &&
|
||||
{ ac_try='test -s conftest.$ac_objext'
|
||||
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
|
||||
(eval $ac_try) 2>&5
|
||||
ac_status=$?
|
||||
echo "$as_me:$LINENO: \$? = $ac_status" >&5
|
||||
(exit $ac_status); }; }; then
|
||||
ac_cv_sys_file_offset_bits=64; break
|
||||
else
|
||||
echo "$as_me: failed program was:" >&5
|
||||
sed 's/^/| /' conftest.$ac_ext >&5
|
||||
|
||||
fi
|
||||
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
|
||||
break
|
||||
done
|
||||
fi
|
||||
echo "$as_me:$LINENO: result: $ac_cv_sys_file_offset_bits" >&5
|
||||
echo "${ECHO_T}$ac_cv_sys_file_offset_bits" >&6
|
||||
if test "$ac_cv_sys_file_offset_bits" != no; then
|
||||
|
||||
cat >>confdefs.h <<_ACEOF
|
||||
#define _FILE_OFFSET_BITS $ac_cv_sys_file_offset_bits
|
||||
_ACEOF
|
||||
|
||||
fi
|
||||
rm -f conftest*
|
||||
echo "$as_me:$LINENO: checking for _LARGE_FILES value needed for large files" >&5
|
||||
echo $ECHO_N "checking for _LARGE_FILES value needed for large files... $ECHO_C" >&6
|
||||
if test "${ac_cv_sys_large_files+set}" = set; then
|
||||
echo $ECHO_N "(cached) $ECHO_C" >&6
|
||||
else
|
||||
while :; do
|
||||
ac_cv_sys_large_files=no
|
||||
cat >conftest.$ac_ext <<_ACEOF
|
||||
/* confdefs.h. */
|
||||
_ACEOF
|
||||
cat confdefs.h >>conftest.$ac_ext
|
||||
cat >>conftest.$ac_ext <<_ACEOF
|
||||
/* end confdefs.h. */
|
||||
#include <sys/types.h>
|
||||
/* Check that off_t can represent 2**63 - 1 correctly.
|
||||
We can't simply define LARGE_OFF_T to be 9223372036854775807,
|
||||
since some C++ compilers masquerading as C compilers
|
||||
incorrectly reject 9223372036854775807. */
|
||||
#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
|
||||
int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
|
||||
&& LARGE_OFF_T % 2147483647 == 1)
|
||||
? 1 : -1];
|
||||
int
|
||||
main ()
|
||||
{
|
||||
|
||||
;
|
||||
return 0;
|
||||
}
|
||||
_ACEOF
|
||||
rm -f conftest.$ac_objext
|
||||
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
|
||||
(eval $ac_compile) 2>conftest.er1
|
||||
ac_status=$?
|
||||
grep -v '^ *+' conftest.er1 >conftest.err
|
||||
rm -f conftest.er1
|
||||
cat conftest.err >&5
|
||||
echo "$as_me:$LINENO: \$? = $ac_status" >&5
|
||||
(exit $ac_status); } &&
|
||||
{ ac_try='test -z "$ac_c_werror_flag"
|
||||
|| test ! -s conftest.err'
|
||||
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
|
||||
(eval $ac_try) 2>&5
|
||||
ac_status=$?
|
||||
echo "$as_me:$LINENO: \$? = $ac_status" >&5
|
||||
(exit $ac_status); }; } &&
|
||||
{ ac_try='test -s conftest.$ac_objext'
|
||||
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
|
||||
(eval $ac_try) 2>&5
|
||||
ac_status=$?
|
||||
echo "$as_me:$LINENO: \$? = $ac_status" >&5
|
||||
(exit $ac_status); }; }; then
|
||||
break
|
||||
else
|
||||
echo "$as_me: failed program was:" >&5
|
||||
sed 's/^/| /' conftest.$ac_ext >&5
|
||||
|
||||
fi
|
||||
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
|
||||
cat >conftest.$ac_ext <<_ACEOF
|
||||
/* confdefs.h. */
|
||||
_ACEOF
|
||||
cat confdefs.h >>conftest.$ac_ext
|
||||
cat >>conftest.$ac_ext <<_ACEOF
|
||||
/* end confdefs.h. */
|
||||
#define _LARGE_FILES 1
|
||||
#include <sys/types.h>
|
||||
/* Check that off_t can represent 2**63 - 1 correctly.
|
||||
We can't simply define LARGE_OFF_T to be 9223372036854775807,
|
||||
since some C++ compilers masquerading as C compilers
|
||||
incorrectly reject 9223372036854775807. */
|
||||
#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
|
||||
int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
|
||||
&& LARGE_OFF_T % 2147483647 == 1)
|
||||
? 1 : -1];
|
||||
int
|
||||
main ()
|
||||
{
|
||||
|
||||
;
|
||||
return 0;
|
||||
}
|
||||
_ACEOF
|
||||
rm -f conftest.$ac_objext
|
||||
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
|
||||
(eval $ac_compile) 2>conftest.er1
|
||||
ac_status=$?
|
||||
grep -v '^ *+' conftest.er1 >conftest.err
|
||||
rm -f conftest.er1
|
||||
cat conftest.err >&5
|
||||
echo "$as_me:$LINENO: \$? = $ac_status" >&5
|
||||
(exit $ac_status); } &&
|
||||
{ ac_try='test -z "$ac_c_werror_flag"
|
||||
|| test ! -s conftest.err'
|
||||
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
|
||||
(eval $ac_try) 2>&5
|
||||
ac_status=$?
|
||||
echo "$as_me:$LINENO: \$? = $ac_status" >&5
|
||||
(exit $ac_status); }; } &&
|
||||
{ ac_try='test -s conftest.$ac_objext'
|
||||
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
|
||||
(eval $ac_try) 2>&5
|
||||
ac_status=$?
|
||||
echo "$as_me:$LINENO: \$? = $ac_status" >&5
|
||||
(exit $ac_status); }; }; then
|
||||
ac_cv_sys_large_files=1; break
|
||||
else
|
||||
echo "$as_me: failed program was:" >&5
|
||||
sed 's/^/| /' conftest.$ac_ext >&5
|
||||
|
||||
fi
|
||||
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
|
||||
break
|
||||
done
|
||||
fi
|
||||
echo "$as_me:$LINENO: result: $ac_cv_sys_large_files" >&5
|
||||
echo "${ECHO_T}$ac_cv_sys_large_files" >&6
|
||||
if test "$ac_cv_sys_large_files" != no; then
|
||||
|
||||
cat >>confdefs.h <<_ACEOF
|
||||
#define _LARGE_FILES $ac_cv_sys_large_files
|
||||
_ACEOF
|
||||
|
||||
fi
|
||||
rm -f conftest*
|
||||
fi
|
||||
|
||||
ac_ext=c
|
||||
ac_cpp='$CPP $CPPFLAGS'
|
||||
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
||||
|
||||
@ -130,7 +130,6 @@ fi
|
||||
|
||||
GCC_NO_EXECUTABLES
|
||||
AC_PROG_CC
|
||||
AC_SYS_LARGEFILE
|
||||
AC_PROG_CPP_WERROR
|
||||
|
||||
ACX_PROG_CC_WARNING_OPTS([-W -Wall -Wwrite-strings -Wc++-compat \
|
||||
|
||||
@ -299,6 +299,9 @@ struct d_print_info
|
||||
struct d_print_mod *modifiers;
|
||||
/* Set to 1 if we saw a demangling error. */
|
||||
int demangle_failure;
|
||||
/* The current index into any template argument packs we are using
|
||||
for printing. */
|
||||
int pack_index;
|
||||
};
|
||||
|
||||
#ifdef CP_DEMANGLE_DEBUG
|
||||
@ -663,6 +666,9 @@ d_dump (struct demangle_component *dc, int indent)
|
||||
case DEMANGLE_COMPONENT_DECLTYPE:
|
||||
printf ("decltype\n");
|
||||
break;
|
||||
case DEMANGLE_COMPONENT_PACK_EXPANSION:
|
||||
printf ("pack expansion\n");
|
||||
break;
|
||||
}
|
||||
|
||||
d_dump (d_left (dc), indent + 2);
|
||||
@ -806,11 +812,10 @@ d_make_comp (struct d_info *di, enum demangle_component_type type,
|
||||
case DEMANGLE_COMPONENT_COMPLEX:
|
||||
case DEMANGLE_COMPONENT_IMAGINARY:
|
||||
case DEMANGLE_COMPONENT_VENDOR_TYPE:
|
||||
case DEMANGLE_COMPONENT_ARGLIST:
|
||||
case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
|
||||
case DEMANGLE_COMPONENT_CAST:
|
||||
case DEMANGLE_COMPONENT_JAVA_RESOURCE:
|
||||
case DEMANGLE_COMPONENT_DECLTYPE:
|
||||
case DEMANGLE_COMPONENT_PACK_EXPANSION:
|
||||
if (left == NULL)
|
||||
return NULL;
|
||||
break;
|
||||
@ -831,6 +836,8 @@ d_make_comp (struct d_info *di, enum demangle_component_type type,
|
||||
case DEMANGLE_COMPONENT_RESTRICT_THIS:
|
||||
case DEMANGLE_COMPONENT_VOLATILE_THIS:
|
||||
case DEMANGLE_COMPONENT_CONST_THIS:
|
||||
case DEMANGLE_COMPONENT_ARGLIST:
|
||||
case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
|
||||
break;
|
||||
|
||||
/* Other types should not be seen here. */
|
||||
@ -1433,6 +1440,7 @@ const struct demangle_operator_info cplus_demangle_operators[] =
|
||||
{ "da", NL ("delete[]"), 1 },
|
||||
{ "de", NL ("*"), 1 },
|
||||
{ "dl", NL ("delete"), 1 },
|
||||
{ "dt", NL ("."), 2 },
|
||||
{ "dv", NL ("/"), 2 },
|
||||
{ "eO", NL ("^="), 2 },
|
||||
{ "eo", NL ("^"), 2 },
|
||||
@ -1875,21 +1883,24 @@ cplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT] =
|
||||
/* n */ { NL ("__int128"), NL ("__int128"), D_PRINT_DEFAULT },
|
||||
/* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"),
|
||||
D_PRINT_DEFAULT },
|
||||
/* The decimal floating point and half-precision floating point types
|
||||
don't use the normal builtin type encoding, they're just stuck into
|
||||
holes in the table for convenience. */
|
||||
/* p */ { NL ("decimal32"), NL ("decimal32"), D_PRINT_DEFAULT },
|
||||
/* q */ { NL ("decimal64"), NL ("decimal64"), D_PRINT_DEFAULT },
|
||||
/* r */ { NL ("decimal128"), NL ("decimal128"), D_PRINT_DEFAULT },
|
||||
/* p */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
|
||||
/* q */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
|
||||
/* r */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
|
||||
/* s */ { NL ("short"), NL ("short"), D_PRINT_DEFAULT },
|
||||
/* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_DEFAULT },
|
||||
/* u */ { NL ("half"), NL ("half"), D_PRINT_FLOAT },
|
||||
/* u */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
|
||||
/* v */ { NL ("void"), NL ("void"), D_PRINT_VOID },
|
||||
/* 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 },
|
||||
/* z */ { NL ("..."), NL ("..."), D_PRINT_DEFAULT },
|
||||
/* 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 },
|
||||
/* 30 */ { NL ("char16_t"), NL ("char16_t"), D_PRINT_DEFAULT },
|
||||
/* 31 */ { NL ("char32_t"), NL ("char32_t"), D_PRINT_DEFAULT },
|
||||
};
|
||||
|
||||
CP_STATIC_IF_GLIBCPP_V3
|
||||
@ -2070,30 +2081,38 @@ cplus_demangle_type (struct d_info *di)
|
||||
|
||||
case 'p':
|
||||
/* Pack expansion. */
|
||||
return NULL;
|
||||
ret = d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
|
||||
cplus_demangle_type (di), NULL);
|
||||
break;
|
||||
|
||||
case 'f':
|
||||
/* 32-bit DFP */
|
||||
ret = d_make_builtin_type (di,
|
||||
&cplus_demangle_builtin_types['p' - 'a']);
|
||||
/* 32-bit decimal floating point */
|
||||
ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[26]);
|
||||
di->expansion += ret->u.s_builtin.type->len;
|
||||
break;
|
||||
case 'd':
|
||||
/* 64-bit decimal floating point */
|
||||
ret = d_make_builtin_type (di,
|
||||
&cplus_demangle_builtin_types['q' - 'a']);
|
||||
/* 64-bit DFP */
|
||||
ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[27]);
|
||||
di->expansion += ret->u.s_builtin.type->len;
|
||||
break;
|
||||
case 'e':
|
||||
/* 128-bit DFP */
|
||||
ret = d_make_builtin_type (di,
|
||||
&cplus_demangle_builtin_types['r' - 'a']);
|
||||
ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[28]);
|
||||
di->expansion += ret->u.s_builtin.type->len;
|
||||
break;
|
||||
case 'h':
|
||||
/* 16-bit half-precision FP */
|
||||
ret = d_make_builtin_type (di,
|
||||
&cplus_demangle_builtin_types['u' - 'a']);
|
||||
ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[29]);
|
||||
di->expansion += ret->u.s_builtin.type->len;
|
||||
break;
|
||||
case 's':
|
||||
/* char16_t */
|
||||
ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[30]);
|
||||
di->expansion += ret->u.s_builtin.type->len;
|
||||
break;
|
||||
case 'i':
|
||||
/* char32_t */
|
||||
ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[31]);
|
||||
di->expansion += ret->u.s_builtin.type->len;
|
||||
break;
|
||||
}
|
||||
@ -2390,6 +2409,13 @@ d_template_args (struct d_info *di)
|
||||
if (! d_check_char (di, 'I'))
|
||||
return NULL;
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
al = NULL;
|
||||
pal = &al;
|
||||
while (1)
|
||||
@ -2439,6 +2465,10 @@ d_template_arg (struct d_info *di)
|
||||
case 'L':
|
||||
return d_expr_primary (di);
|
||||
|
||||
case 'I':
|
||||
/* An argument pack. */
|
||||
return d_template_args (di);
|
||||
|
||||
default:
|
||||
return cplus_demangle_type (di);
|
||||
}
|
||||
@ -2452,6 +2482,12 @@ d_exprlist (struct d_info *di)
|
||||
struct demangle_component *list = NULL;
|
||||
struct demangle_component **p = &list;
|
||||
|
||||
if (d_peek_char (di) == 'E')
|
||||
{
|
||||
d_advance (di, 1);
|
||||
return d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, NULL, NULL);
|
||||
}
|
||||
|
||||
while (1)
|
||||
{
|
||||
struct demangle_component *arg = d_expression (di);
|
||||
@ -2515,6 +2551,19 @@ d_expression (struct d_info *di)
|
||||
d_advance (di, 2);
|
||||
return cplus_demangle_type (di);
|
||||
}
|
||||
else if (IS_DIGIT (peek))
|
||||
{
|
||||
/* 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);
|
||||
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;
|
||||
}
|
||||
else
|
||||
{
|
||||
struct demangle_component *op;
|
||||
@ -3067,6 +3116,123 @@ cplus_demangle_print (int options, const struct demangle_component *dc,
|
||||
return dgs.buf;
|
||||
}
|
||||
|
||||
/* Returns the I'th element of the template arglist ARGS, or NULL on
|
||||
failure. */
|
||||
|
||||
static struct demangle_component *
|
||||
d_index_template_argument (struct demangle_component *args, int i)
|
||||
{
|
||||
struct demangle_component *a;
|
||||
|
||||
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_NAME:
|
||||
case DEMANGLE_COMPONENT_OPERATOR:
|
||||
case DEMANGLE_COMPONENT_BUILTIN_TYPE:
|
||||
case DEMANGLE_COMPONENT_SUB_STD:
|
||||
case DEMANGLE_COMPONENT_CHARACTER:
|
||||
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;
|
||||
}
|
||||
|
||||
/* DC is a component of a mangled expression. Print it, wrapped in parens
|
||||
if needed. */
|
||||
|
||||
static void
|
||||
d_print_subexpr (struct d_print_info *dpi,
|
||||
const struct demangle_component *dc)
|
||||
{
|
||||
int simple = 0;
|
||||
if (dc->type == DEMANGLE_COMPONENT_NAME)
|
||||
simple = 1;
|
||||
if (!simple)
|
||||
d_append_char (dpi, '(');
|
||||
d_print_comp (dpi, dc);
|
||||
if (!simple)
|
||||
d_append_char (dpi, ')');
|
||||
}
|
||||
|
||||
/* Subroutine to handle components. */
|
||||
|
||||
static void
|
||||
@ -3252,30 +3418,13 @@ d_print_comp (struct d_print_info *dpi,
|
||||
|
||||
case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
|
||||
{
|
||||
long i;
|
||||
struct demangle_component *a;
|
||||
struct d_print_template *hold_dpt;
|
||||
struct demangle_component *a = d_lookup_template_argument (dpi, dc);
|
||||
|
||||
if (dpi->templates == NULL)
|
||||
{
|
||||
d_print_error (dpi);
|
||||
return;
|
||||
}
|
||||
i = dc->u.s_number.number;
|
||||
for (a = d_right (dpi->templates->template_decl);
|
||||
a != NULL;
|
||||
a = d_right (a))
|
||||
{
|
||||
if (a->type != DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
|
||||
{
|
||||
d_print_error (dpi);
|
||||
return;
|
||||
}
|
||||
if (i <= 0)
|
||||
break;
|
||||
--i;
|
||||
}
|
||||
if (i != 0 || a == NULL)
|
||||
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;
|
||||
@ -3289,7 +3438,7 @@ d_print_comp (struct d_print_info *dpi,
|
||||
hold_dpt = dpi->templates;
|
||||
dpi->templates = hold_dpt->next;
|
||||
|
||||
d_print_comp (dpi, d_left (a));
|
||||
d_print_comp (dpi, a);
|
||||
|
||||
dpi->templates = hold_dpt;
|
||||
|
||||
@ -3578,7 +3727,8 @@ d_print_comp (struct d_print_info *dpi,
|
||||
|
||||
case DEMANGLE_COMPONENT_ARGLIST:
|
||||
case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
|
||||
d_print_comp (dpi, d_left (dc));
|
||||
if (d_left (dc) != NULL)
|
||||
d_print_comp (dpi, d_left (dc));
|
||||
if (d_right (dc) != NULL)
|
||||
{
|
||||
d_append_string (dpi, ", ");
|
||||
@ -3618,11 +3768,12 @@ d_print_comp (struct d_print_info *dpi,
|
||||
d_print_cast (dpi, d_left (dc));
|
||||
d_append_char (dpi, ')');
|
||||
}
|
||||
d_append_char (dpi, '(');
|
||||
if (d_left (dc)->type != DEMANGLE_COMPONENT_CAST
|
||||
|| d_right (dc)->type != DEMANGLE_COMPONENT_BUILTIN_TYPE)
|
||||
d_print_comp (dpi, d_right (dc));
|
||||
d_append_char (dpi, ')');
|
||||
if (d_left (dc)->type == DEMANGLE_COMPONENT_CAST
|
||||
&& d_right (dc)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE)
|
||||
/* type() -- FIXME what about type(multiple,args) */
|
||||
d_append_string (dpi, "()");
|
||||
else
|
||||
d_print_subexpr (dpi, d_right (dc));
|
||||
return;
|
||||
|
||||
case DEMANGLE_COMPONENT_BINARY:
|
||||
@ -3632,15 +3783,6 @@ d_print_comp (struct d_print_info *dpi,
|
||||
return;
|
||||
}
|
||||
|
||||
if (!strcmp (d_left (dc)->u.s_operator.op->code, "cl"))
|
||||
{
|
||||
d_print_comp (dpi, d_left (d_right (dc)));
|
||||
d_append_string (dpi, " (");
|
||||
d_print_comp (dpi, d_right (d_right (dc)));
|
||||
d_append_char (dpi, ')');
|
||||
return;
|
||||
}
|
||||
|
||||
/* 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. */
|
||||
@ -3649,13 +3791,10 @@ d_print_comp (struct d_print_info *dpi,
|
||||
&& d_left (dc)->u.s_operator.op->name[0] == '>')
|
||||
d_append_char (dpi, '(');
|
||||
|
||||
d_append_char (dpi, '(');
|
||||
d_print_comp (dpi, d_left (d_right (dc)));
|
||||
d_append_string (dpi, ") ");
|
||||
d_print_expr_op (dpi, d_left (dc));
|
||||
d_append_string (dpi, " (");
|
||||
d_print_comp (dpi, d_right (d_right (dc)));
|
||||
d_append_char (dpi, ')');
|
||||
d_print_subexpr (dpi, d_left (d_right (dc)));
|
||||
if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") != 0)
|
||||
d_print_expr_op (dpi, d_left (dc));
|
||||
d_print_subexpr (dpi, d_right (d_right (dc)));
|
||||
|
||||
if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
|
||||
&& d_left (dc)->u.s_operator.op->len == 1
|
||||
@ -3676,15 +3815,11 @@ d_print_comp (struct d_print_info *dpi,
|
||||
d_print_error (dpi);
|
||||
return;
|
||||
}
|
||||
d_append_char (dpi, '(');
|
||||
d_print_comp (dpi, d_left (d_right (dc)));
|
||||
d_append_string (dpi, ") ");
|
||||
d_print_subexpr (dpi, d_left (d_right (dc)));
|
||||
d_print_expr_op (dpi, d_left (dc));
|
||||
d_append_string (dpi, " (");
|
||||
d_print_comp (dpi, d_left (d_right (d_right (dc))));
|
||||
d_append_string (dpi, ") : (");
|
||||
d_print_comp (dpi, d_right (d_right (d_right (dc))));
|
||||
d_append_char (dpi, ')');
|
||||
d_print_subexpr (dpi, d_left (d_right (d_right (dc))));
|
||||
d_append_string (dpi, " : ");
|
||||
d_print_subexpr (dpi, d_right (d_right (d_right (dc))));
|
||||
return;
|
||||
|
||||
case DEMANGLE_COMPONENT_TRINARY_ARG1:
|
||||
@ -3797,6 +3932,23 @@ d_print_comp (struct d_print_info *dpi,
|
||||
d_append_char (dpi, ')');
|
||||
return;
|
||||
|
||||
case DEMANGLE_COMPONENT_PACK_EXPANSION:
|
||||
{
|
||||
struct demangle_component *a = d_find_pack (dpi, d_left (dc));
|
||||
int len = d_pack_length (a);
|
||||
int i;
|
||||
|
||||
dc = d_left (dc);
|
||||
for (i = 0; i < len; ++i)
|
||||
{
|
||||
dpi->pack_index = i;
|
||||
d_print_comp (dpi, dc);
|
||||
if (i < len-1)
|
||||
d_append_string (dpi, ", ");
|
||||
}
|
||||
}
|
||||
return;
|
||||
|
||||
default:
|
||||
d_print_error (dpi);
|
||||
return;
|
||||
|
||||
@ -147,7 +147,7 @@ struct d_info
|
||||
extern const struct demangle_operator_info cplus_demangle_operators[];
|
||||
#endif
|
||||
|
||||
#define D_BUILTIN_TYPE_COUNT (26)
|
||||
#define D_BUILTIN_TYPE_COUNT (32)
|
||||
|
||||
CP_STATIC_IF_GLIBCPP_V3
|
||||
const struct demangle_builtin_type_info
|
||||
|
||||
@ -3345,7 +3345,7 @@ f<X>
|
||||
#
|
||||
--format=gnu-v3 --no-params
|
||||
_ZngILi42EEvN1AIXplT_Li2EEE1TE
|
||||
void operator-<42>(A<(42) + (2)>::T)
|
||||
void operator-<42>(A<(42)+(2)>::T)
|
||||
operator-<42>
|
||||
#
|
||||
--format=gnu-v3 --no-params
|
||||
@ -3385,7 +3385,7 @@ int* const volatile restrict _far
|
||||
#
|
||||
--format=gnu-v3 --no-params
|
||||
_Z3fooILi2EEvRAplT_Li1E_i
|
||||
void foo<2>(int (&) [(2) + (1)])
|
||||
void foo<2>(int (&) [(2)+(1)])
|
||||
foo<2>
|
||||
#
|
||||
--format=gnu-v3 --no-params
|
||||
@ -3612,13 +3612,13 @@ hairyfunc5
|
||||
# This is from gcc PR 8861
|
||||
--format=gnu-v3 --no-params
|
||||
_Z1fILi1ELc120EEv1AIXplT_cviLd810000000000000000703DAD7A370C5EEE
|
||||
void f<1, (char)120>(A<(1) + ((int)((double)[810000000000000000703DAD7A370C5]))>)
|
||||
void f<1, (char)120>(A<(1)+((int)((double)[810000000000000000703DAD7A370C5]))>)
|
||||
f<1, (char)120>
|
||||
#
|
||||
# This is also from gcc PR 8861
|
||||
--format=gnu-v3 --no-params
|
||||
_Z1fILi1EEv1AIXplT_cvingLf3f800000EEE
|
||||
void f<1>(A<(1) + ((int)(-((float)[3f800000])))>)
|
||||
void f<1>(A<(1)+((int)(-((float)[3f800000])))>)
|
||||
f<1>
|
||||
#
|
||||
# This is from a libstdc++ debug mode patch.
|
||||
@ -3643,7 +3643,7 @@ f
|
||||
# confusion with the '>' which ends the template parameters.
|
||||
--format=gnu-v3 --no-params
|
||||
_Z4dep9ILi3EEvP3fooIXgtT_Li2EEE
|
||||
void dep9<3>(foo<((3) > (2))>*)
|
||||
void dep9<3>(foo<((3)>(2))>*)
|
||||
dep9<3>
|
||||
#
|
||||
# Watch out for templated version of `operator<'--it needs an extra
|
||||
@ -3885,16 +3885,20 @@ java resource java/util/iso4217.properties
|
||||
# decltype/param placeholder test
|
||||
--format=gnu-v3
|
||||
_Z3addIidEDTplsTT_sTT0_ES0_S1_
|
||||
decltype ((int) + (double)) add<int, double>(int, double)
|
||||
# decltype/T() test
|
||||
--format=gnu-v3
|
||||
_Z4add2IidEDTplcvT_vcvT0_vES0_S1_
|
||||
decltype (((int)()) + ((double)())) add2<int, double>(int, double)
|
||||
decltype ((int)+(double)) add<int, double>(int, double)
|
||||
# decltype/fn call test
|
||||
--format=gnu-v3
|
||||
_Z4add3IidEDTclL_Z1gEsTT_sTT0_EES0_S1_
|
||||
decltype (g (int, double)) add3<int, double>(int, double)
|
||||
# Extended floating point types test
|
||||
decltype (g(int, double)) add3<int, double>(int, double)
|
||||
# new (2008) built in types test
|
||||
--format=gnu-v3
|
||||
_Z1fDfDdDeDh
|
||||
f(decimal32, decimal64, decimal128, half)
|
||||
_Z1fDfDdDeDhDsDi
|
||||
f(decimal32, decimal64, decimal128, half, char16_t, char32_t)
|
||||
# pack expansion test
|
||||
--format=gnu-v3
|
||||
_Z1fIIPiPfPdEEvDpT_
|
||||
void f<int*, float*, double*>(int*, float*, double*)
|
||||
# '.' test
|
||||
--format=gnu-v3
|
||||
_Z1hI1AIiEdEDTcldtsTT_1gIT0_EEES2_S3_
|
||||
decltype (((A<int>).(g<double>))()) h<A<int>, double>(A<int>, double)
|
||||
|
||||
Loading…
Reference in New Issue
Block a user