demangle-expected: Add tests for __int128 and unsigned __int128 types.
libiberty/
2010-05-26 Kai Tietz <kai.tietz@onevision.com>
* testsuite/demangle-expected: Add tests for __int128
and unsigned __int128 types.
gcc/testsuite
2010-05-26 Kai Tietz <kai.tietz@onevision.com>
* lib/target-supports.exp (check_effective_target_int128): New
function to check if __int128 types are available for target.
* testsuite/c-c++-common/int128-types-1.c: New.
* testsuite/c-c++-common/int128-1.c: New.
* testsuite/c-c++-common/int128-2.c: New.
* g++.dg/abi/mangle43.C: New.
* g++.dg/init/enum1.C: Handle __int128 case and add -Wno-overflow.
* g++.dg/cpp0x/nullptr04.C: Use __SIZE_TYPE__ for getting
pointer-wide scalar.
* g++.dg/other/pr25632.C: Likewise.
* g++.dg/other/large-size-array.C (DIM): Use ULLONG_MAX for win64 case.
* g++.dg/warn/pr13358-2.C: Add llp64 for check of special
overflow warnings.
* g++.dg/warn/pr13358-4.C: Likewise.
* g++.dg/warn/Wconversion-null-2.C: Add 'long long' case.
* g++.dg/warn/Wconversion-null.C: Likewise.
gcc/
2010-05-26 Kai Tietz <kai.tietz@onevision.com>
* builtin-types.def (BT_INT128): New primitive type.
(BT_UINT128): Likewise.
* c-common.c (c_common_r): Add __int128 keyword.
(c_common_type_for_size): Handle __int128.
(c_common_type_for_mode): Likewise.
(c_common_signed_or_unsigned_type): Likewise.
(c_common_nodes_and_builtins): Add builtin type
if target supports 128-bit integer scalar.
* c-common.h (enum rid): Add RID_INT128.
* c-cppbuiltin.c (c_cpp_builtins): Define __SIZEOF_INT128__
if target supports 128-bit integer scalar.
* c-decl.c (declspecs_add_type): Handle new keyword
__int128.
(finish_declspecs): Likewise.
* c-parser.c (c_token_starts_typename): Handle RID_INT128.
(c_token_starts_declspecs): Likewise.
(c_parser_declspecs): Likewise.
(c_parser_attributes): Likewise.
(c_parser_objc_selector): Likewise.
* c-pretty-print.c (pp_c_integer_constant): Handle __int128.
* c-tree.h (enum c_typespec_keyword): Add cts_int128.
* gimple.c (gimple_signed_or_unsigned_type): Handle int128 types.
* tree.c (make_or_reuse_type): Likewise.
(make_unsigned_type): Likewise.
(build_common_tree_nodes_2): Likewise.
* tree.h (enum integer_type_kind): Add itk_int128 and
itk_unsigned_int128.
(int128_integer_type_node): New define..
(int128_unsigned_type_node): New define.
* cp/cp-tree.h (cp_decl_specifier_seq): Add new bifield
explicit_int128_p.
* cp/decl.c (grokdeclarator): Handle __int128.
* cp/parser.c (cp_lexer_next_token_is_decl_specifier_ke): Likewise.
(cp_parser_simple_type_specifier): Likewise.
* cp/rtti.c (emit_support_tinfos): Add int128 nodes for rtti.
* cp/typeck.c (cp_common_type): Handle __int128.
* cp/mangle.c (integer_type_codes): Add itk_int128 and
itk_unsigned_int128.
* doc/extend.texi: Add documentation about __int128 type.
From-SVN: r159879
This commit is contained in:
Kai Tietz
Kai Tietz
parent
880ad25fc7
commit
a6766312d3
|
|
@ -1,3 +1,45 @@
|
|||
2010-05-26 Kai Tietz <kai.tietz@onevision.com>
|
||||
|
||||
* builtin-types.def (BT_INT128): New primitive type.
|
||||
(BT_UINT128): Likewise.
|
||||
* c-common.c (c_common_r): Add __int128 keyword.
|
||||
(c_common_type_for_size): Handle __int128.
|
||||
(c_common_type_for_mode): Likewise.
|
||||
(c_common_signed_or_unsigned_type): Likewise.
|
||||
(c_common_nodes_and_builtins): Add builtin type
|
||||
if target supports 128-bit integer scalar.
|
||||
* c-common.h (enum rid): Add RID_INT128.
|
||||
* c-cppbuiltin.c (c_cpp_builtins): Define __SIZEOF_INT128__
|
||||
if target supports 128-bit integer scalar.
|
||||
* c-decl.c (declspecs_add_type): Handle new keyword
|
||||
__int128.
|
||||
(finish_declspecs): Likewise.
|
||||
* c-parser.c (c_token_starts_typename): Handle RID_INT128.
|
||||
(c_token_starts_declspecs): Likewise.
|
||||
(c_parser_declspecs): Likewise.
|
||||
(c_parser_attributes): Likewise.
|
||||
(c_parser_objc_selector): Likewise.
|
||||
* c-pretty-print.c (pp_c_integer_constant): Handle __int128.
|
||||
* c-tree.h (enum c_typespec_keyword): Add cts_int128.
|
||||
* gimple.c (gimple_signed_or_unsigned_type): Handle int128 types.
|
||||
* tree.c (make_or_reuse_type): Likewise.
|
||||
(make_unsigned_type): Likewise.
|
||||
(build_common_tree_nodes_2): Likewise.
|
||||
* tree.h (enum integer_type_kind): Add itk_int128 and
|
||||
itk_unsigned_int128.
|
||||
(int128_integer_type_node): New define..
|
||||
(int128_unsigned_type_node): New define.
|
||||
* cp/cp-tree.h (cp_decl_specifier_seq): Add new bifield
|
||||
explicit_int128_p.
|
||||
* cp/decl.c (grokdeclarator): Handle __int128.
|
||||
* cp/parser.c (cp_lexer_next_token_is_decl_specifier_ke): Likewise.
|
||||
(cp_parser_simple_type_specifier): Likewise.
|
||||
* cp/rtti.c (emit_support_tinfos): Add int128 nodes for rtti.
|
||||
* cp/typeck.c (cp_common_type): Handle __int128.
|
||||
* cp/mangle.c (integer_type_codes): Add itk_int128 and
|
||||
itk_unsigned_int128.
|
||||
* doc/extend.texi: Add documentation about __int128 type.
|
||||
|
||||
2010-05-26 Richard Guenther <rguenther@suse.de>
|
||||
|
||||
* tree-ssa-sccvn.c (copy_nary): Adjust.
|
||||
|
|
|
|||
|
|
@ -72,6 +72,8 @@ DEF_PRIMITIVE_TYPE (BT_LONG, long_integer_type_node)
|
|||
DEF_PRIMITIVE_TYPE (BT_ULONG, long_unsigned_type_node)
|
||||
DEF_PRIMITIVE_TYPE (BT_LONGLONG, long_long_integer_type_node)
|
||||
DEF_PRIMITIVE_TYPE (BT_ULONGLONG, long_long_unsigned_type_node)
|
||||
DEF_PRIMITIVE_TYPE (BT_INT128, int128_integer_type_node)
|
||||
DEF_PRIMITIVE_TYPE (BT_UINT128, int128_unsigned_type_node)
|
||||
DEF_PRIMITIVE_TYPE (BT_INTMAX, intmax_type_node)
|
||||
DEF_PRIMITIVE_TYPE (BT_UINTMAX, uintmax_type_node)
|
||||
DEF_PRIMITIVE_TYPE (BT_UINT32, uint32_type_node)
|
||||
|
|
|
|||
|
|
@ -65,10 +65,12 @@ cpp_reader *parse_in; /* Declared in c-pragma.h. */
|
|||
tree short_integer_type_node;
|
||||
tree long_integer_type_node;
|
||||
tree long_long_integer_type_node;
|
||||
tree int128_integer_type_node;
|
||||
|
||||
tree short_unsigned_type_node;
|
||||
tree long_unsigned_type_node;
|
||||
tree long_long_unsigned_type_node;
|
||||
tree int128_unsigned_type_node;
|
||||
|
||||
tree truthvalue_type_node;
|
||||
tree truthvalue_false_node;
|
||||
|
|
@ -595,6 +597,7 @@ const struct c_common_resword c_common_reswords[] =
|
|||
{ "__has_trivial_copy", RID_HAS_TRIVIAL_COPY, D_CXXONLY },
|
||||
{ "__has_trivial_destructor", RID_HAS_TRIVIAL_DESTRUCTOR, D_CXXONLY },
|
||||
{ "__has_virtual_destructor", RID_HAS_VIRTUAL_DESTRUCTOR, D_CXXONLY },
|
||||
{ "__int128", RID_INT128, 0 },
|
||||
{ "__is_abstract", RID_IS_ABSTRACT, D_CXXONLY },
|
||||
{ "__is_base_of", RID_IS_BASE_OF, D_CXXONLY },
|
||||
{ "__is_class", RID_IS_CLASS, D_CXXONLY },
|
||||
|
|
@ -2857,6 +2860,11 @@ c_common_type_for_size (unsigned int bits, int unsignedp)
|
|||
return (unsignedp ? long_long_unsigned_type_node
|
||||
: long_long_integer_type_node);
|
||||
|
||||
if (int128_integer_type_node
|
||||
&& bits == TYPE_PRECISION (int128_integer_type_node))
|
||||
return (unsignedp ? int128_unsigned_type_node
|
||||
: int128_integer_type_node);
|
||||
|
||||
if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
|
||||
return (unsignedp ? widest_unsigned_literal_type_node
|
||||
: widest_integer_literal_type_node);
|
||||
|
|
@ -2935,6 +2943,10 @@ c_common_type_for_mode (enum machine_mode mode, int unsignedp)
|
|||
if (mode == TYPE_MODE (long_long_integer_type_node))
|
||||
return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
|
||||
|
||||
if (int128_integer_type_node
|
||||
&& mode == TYPE_MODE (int128_integer_type_node))
|
||||
return unsignedp ? int128_unsigned_type_node : int128_integer_type_node;
|
||||
|
||||
if (mode == TYPE_MODE (widest_integer_literal_type_node))
|
||||
return unsignedp ? widest_unsigned_literal_type_node
|
||||
: widest_integer_literal_type_node;
|
||||
|
|
@ -3148,6 +3160,10 @@ c_common_signed_or_unsigned_type (int unsignedp, tree type)
|
|||
return unsignedp ? long_unsigned_type_node : long_integer_type_node;
|
||||
if (type1 == long_long_integer_type_node || type1 == long_long_unsigned_type_node)
|
||||
return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
|
||||
if (int128_integer_type_node
|
||||
&& (type1 == int128_integer_type_node
|
||||
|| type1 == int128_unsigned_type_node))
|
||||
return unsignedp ? int128_unsigned_type_node : int128_integer_type_node;
|
||||
if (type1 == widest_integer_literal_type_node || type1 == widest_unsigned_literal_type_node)
|
||||
return unsignedp ? widest_unsigned_literal_type_node : widest_integer_literal_type_node;
|
||||
#if HOST_BITS_PER_WIDE_INT >= 64
|
||||
|
|
@ -3262,6 +3278,9 @@ c_common_signed_or_unsigned_type (int unsignedp, tree type)
|
|||
if (TYPE_OK (long_long_integer_type_node))
|
||||
return (unsignedp ? long_long_unsigned_type_node
|
||||
: long_long_integer_type_node);
|
||||
if (int128_integer_type_node && TYPE_OK (int128_integer_type_node))
|
||||
return (unsignedp ? int128_unsigned_type_node
|
||||
: int128_integer_type_node);
|
||||
if (TYPE_OK (widest_integer_literal_type_node))
|
||||
return (unsignedp ? widest_unsigned_literal_type_node
|
||||
: widest_integer_literal_type_node);
|
||||
|
|
@ -3305,6 +3324,10 @@ c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
|
|||
if (width == TYPE_PRECISION (long_long_integer_type_node))
|
||||
return (unsignedp ? long_long_unsigned_type_node
|
||||
: long_long_integer_type_node);
|
||||
if (int128_integer_type_node
|
||||
&& width == TYPE_PRECISION (int128_integer_type_node))
|
||||
return (unsignedp ? int128_unsigned_type_node
|
||||
: int128_integer_type_node);
|
||||
return build_nonstandard_integer_type (width, unsignedp);
|
||||
}
|
||||
|
||||
|
|
@ -4697,6 +4720,13 @@ c_common_nodes_and_builtins (void)
|
|||
record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
|
||||
record_builtin_type (RID_MAX, "long unsigned int",
|
||||
long_unsigned_type_node);
|
||||
if (int128_integer_type_node != NULL_TREE)
|
||||
{
|
||||
record_builtin_type (RID_INT128, "__int128",
|
||||
int128_integer_type_node);
|
||||
record_builtin_type (RID_MAX, "__int128 unsigned",
|
||||
int128_unsigned_type_node);
|
||||
}
|
||||
if (c_dialect_cxx ())
|
||||
record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
|
||||
record_builtin_type (RID_MAX, "long long int",
|
||||
|
|
|
|||
|
|
@ -69,6 +69,7 @@ enum rid
|
|||
|
||||
/* C */
|
||||
RID_INT, RID_CHAR, RID_FLOAT, RID_DOUBLE, RID_VOID,
|
||||
RID_INT128,
|
||||
RID_ENUM, RID_STRUCT, RID_UNION, RID_IF, RID_ELSE,
|
||||
RID_WHILE, RID_DO, RID_FOR, RID_SWITCH, RID_CASE,
|
||||
RID_DEFAULT, RID_BREAK, RID_CONTINUE, RID_RETURN, RID_GOTO,
|
||||
|
|
|
|||
|
|
@ -814,6 +814,9 @@ c_cpp_builtins (cpp_reader *pfile)
|
|||
builtin_define_type_sizeof ("__SIZEOF_LONG__", long_integer_type_node);
|
||||
builtin_define_type_sizeof ("__SIZEOF_LONG_LONG__",
|
||||
long_long_integer_type_node);
|
||||
if (int128_integer_type_node != NULL_TREE)
|
||||
builtin_define_type_sizeof ("__SIZEOF_INT128__",
|
||||
int128_integer_type_node);
|
||||
builtin_define_type_sizeof ("__SIZEOF_SHORT__", short_integer_type_node);
|
||||
builtin_define_type_sizeof ("__SIZEOF_FLOAT__", float_type_node);
|
||||
builtin_define_type_sizeof ("__SIZEOF_DOUBLE__", double_type_node);
|
||||
|
|
|
|||
56
gcc/c-decl.c
56
gcc/c-decl.c
|
|
@ -8633,6 +8633,10 @@ declspecs_add_type (location_t loc, struct c_declspecs *specs,
|
|||
error_at (loc,
|
||||
("both %<long%> and %<void%> in "
|
||||
"declaration specifiers"));
|
||||
else if (specs->typespec_word == cts_int128)
|
||||
error_at (loc,
|
||||
("both %<long%> and %<__int128%> in "
|
||||
"declaration specifiers"));
|
||||
else if (specs->typespec_word == cts_bool)
|
||||
error_at (loc,
|
||||
("both %<long%> and %<_Bool%> in "
|
||||
|
|
@ -8670,6 +8674,10 @@ declspecs_add_type (location_t loc, struct c_declspecs *specs,
|
|||
error_at (loc,
|
||||
("both %<short%> and %<void%> in "
|
||||
"declaration specifiers"));
|
||||
else if (specs->typespec_word == cts_int128)
|
||||
error_at (loc,
|
||||
("both %<short%> and %<__int128%> in "
|
||||
"declaration specifiers"));
|
||||
else if (specs->typespec_word == cts_bool)
|
||||
error_at (loc,
|
||||
("both %<short%> and %<_Bool%> in "
|
||||
|
|
@ -8819,7 +8827,13 @@ declspecs_add_type (location_t loc, struct c_declspecs *specs,
|
|||
dupe = specs->saturating_p;
|
||||
pedwarn (loc, OPT_pedantic,
|
||||
"ISO C does not support saturating types");
|
||||
if (specs->typespec_word == cts_void)
|
||||
if (specs->typespec_word == cts_int128)
|
||||
{
|
||||
error_at (loc,
|
||||
("both %<_Sat%> and %<__int128%> in "
|
||||
"declaration specifiers"));
|
||||
}
|
||||
else if (specs->typespec_word == cts_void)
|
||||
error_at (loc,
|
||||
("both %<_Sat%> and %<void%> in "
|
||||
"declaration specifiers"));
|
||||
|
|
@ -8874,7 +8888,7 @@ declspecs_add_type (location_t loc, struct c_declspecs *specs,
|
|||
else
|
||||
{
|
||||
/* "void", "_Bool", "char", "int", "float", "double", "_Decimal32",
|
||||
"_Decimal64", "_Decimal128", "_Fract" or "_Accum". */
|
||||
"__int128", "_Decimal64", "_Decimal128", "_Fract" or "_Accum". */
|
||||
if (specs->typespec_word != cts_none)
|
||||
{
|
||||
error_at (loc,
|
||||
|
|
@ -8883,6 +8897,31 @@ declspecs_add_type (location_t loc, struct c_declspecs *specs,
|
|||
}
|
||||
switch (i)
|
||||
{
|
||||
case RID_INT128:
|
||||
if (int128_integer_type_node == NULL_TREE)
|
||||
{
|
||||
error_at (loc, "%<__int128%> is not supported for this target");
|
||||
return specs;
|
||||
}
|
||||
if (!in_system_header)
|
||||
pedwarn (loc, OPT_pedantic,
|
||||
"ISO C does not support %<__int128%> type");
|
||||
|
||||
if (specs->long_p)
|
||||
error_at (loc,
|
||||
("both %<__int128%> and %<long%> in "
|
||||
"declaration specifiers"));
|
||||
else if (specs->saturating_p)
|
||||
error_at (loc,
|
||||
("both %<_Sat%> and %<__int128%> in "
|
||||
"declaration specifiers"));
|
||||
else if (specs->short_p)
|
||||
error_at (loc,
|
||||
("both %<__int128%> and %<short%> in "
|
||||
"declaration specifiers"));
|
||||
else
|
||||
specs->typespec_word = cts_int128;
|
||||
return specs;
|
||||
case RID_VOID:
|
||||
if (specs->long_p)
|
||||
error_at (loc,
|
||||
|
|
@ -9355,6 +9394,19 @@ finish_declspecs (struct c_declspecs *specs)
|
|||
specs->type = build_complex_type (specs->type);
|
||||
}
|
||||
break;
|
||||
case cts_int128:
|
||||
gcc_assert (!specs->long_p && !specs->short_p && !specs->long_long_p);
|
||||
gcc_assert (!(specs->signed_p && specs->unsigned_p));
|
||||
specs->type = (specs->unsigned_p
|
||||
? int128_unsigned_type_node
|
||||
: int128_integer_type_node);
|
||||
if (specs->complex_p)
|
||||
{
|
||||
pedwarn (input_location, OPT_pedantic,
|
||||
"ISO C does not support complex integer types");
|
||||
specs->type = build_complex_type (specs->type);
|
||||
}
|
||||
break;
|
||||
case cts_int:
|
||||
gcc_assert (!(specs->long_p && specs->short_p));
|
||||
gcc_assert (!(specs->signed_p && specs->unsigned_p));
|
||||
|
|
|
|||
|
|
@ -378,6 +378,7 @@ c_token_starts_typename (c_token *token)
|
|||
{
|
||||
case RID_UNSIGNED:
|
||||
case RID_LONG:
|
||||
case RID_INT128:
|
||||
case RID_SHORT:
|
||||
case RID_SIGNED:
|
||||
case RID_COMPLEX:
|
||||
|
|
@ -457,6 +458,7 @@ c_token_starts_declspecs (c_token *token)
|
|||
case RID_THREAD:
|
||||
case RID_UNSIGNED:
|
||||
case RID_LONG:
|
||||
case RID_INT128:
|
||||
case RID_SHORT:
|
||||
case RID_SIGNED:
|
||||
case RID_COMPLEX:
|
||||
|
|
@ -1574,6 +1576,7 @@ c_parser_static_assert_declaration_no_semi (c_parser *parser)
|
|||
|
||||
type-specifier:
|
||||
typeof-specifier
|
||||
__int128
|
||||
_Decimal32
|
||||
_Decimal64
|
||||
_Decimal128
|
||||
|
|
@ -1691,6 +1694,7 @@ c_parser_declspecs (c_parser *parser, struct c_declspecs *specs,
|
|||
break;
|
||||
case RID_UNSIGNED:
|
||||
case RID_LONG:
|
||||
case RID_INT128:
|
||||
case RID_SHORT:
|
||||
case RID_SIGNED:
|
||||
case RID_COMPLEX:
|
||||
|
|
@ -3005,6 +3009,7 @@ c_parser_attributes (c_parser *parser)
|
|||
case RID_STATIC:
|
||||
case RID_UNSIGNED:
|
||||
case RID_LONG:
|
||||
case RID_INT128:
|
||||
case RID_CONST:
|
||||
case RID_EXTERN:
|
||||
case RID_REGISTER:
|
||||
|
|
@ -6987,6 +6992,7 @@ c_parser_objc_selector (c_parser *parser)
|
|||
case RID_ALIGNOF:
|
||||
case RID_UNSIGNED:
|
||||
case RID_LONG:
|
||||
case RID_INT128:
|
||||
case RID_CONST:
|
||||
case RID_SHORT:
|
||||
case RID_VOLATILE:
|
||||
|
|
|
|||
|
|
@ -864,6 +864,9 @@ pp_c_integer_constant (c_pretty_printer *pp, tree i)
|
|||
else if (type == long_long_integer_type_node
|
||||
|| type == long_long_unsigned_type_node)
|
||||
pp_string (pp, "ll");
|
||||
else if (type == int128_integer_type_node
|
||||
|| type == int128_unsigned_type_node)
|
||||
pp_string (pp, "I128");
|
||||
}
|
||||
|
||||
/* Print out a CHARACTER literal. */
|
||||
|
|
|
|||
|
|
@ -196,6 +196,7 @@ enum c_typespec_keyword {
|
|||
cts_char,
|
||||
cts_int,
|
||||
cts_float,
|
||||
cts_int128,
|
||||
cts_double,
|
||||
cts_dfloat32,
|
||||
cts_dfloat64,
|
||||
|
|
|
|||
|
|
@ -4402,6 +4402,8 @@ typedef struct cp_decl_specifier_seq {
|
|||
BOOL_BITFIELD any_type_specifiers_p : 1;
|
||||
/* True iff "int" was explicitly provided. */
|
||||
BOOL_BITFIELD explicit_int_p : 1;
|
||||
/* True iff "__int128" was explicitly provided. */
|
||||
BOOL_BITFIELD explicit_int128_p : 1;
|
||||
/* True iff "char" was explicitly provided. */
|
||||
BOOL_BITFIELD explicit_char_p : 1;
|
||||
} cp_decl_specifier_seq;
|
||||
|
|
|
|||
|
|
@ -7701,6 +7701,7 @@ grokdeclarator (const cp_declarator *declarator,
|
|||
{
|
||||
tree type = NULL_TREE;
|
||||
int longlong = 0;
|
||||
int explicit_int128 = 0;
|
||||
int virtualp, explicitp, friendp, inlinep, staticp;
|
||||
int explicit_int = 0;
|
||||
int explicit_char = 0;
|
||||
|
|
@ -7764,6 +7765,7 @@ grokdeclarator (const cp_declarator *declarator,
|
|||
short_p = declspecs->specs[(int)ds_short];
|
||||
long_p = declspecs->specs[(int)ds_long];
|
||||
longlong = declspecs->specs[(int)ds_long] >= 2;
|
||||
explicit_int128 = declspecs->explicit_int128_p;
|
||||
thread_p = declspecs->specs[(int)ds_thread];
|
||||
|
||||
if (decl_context == FUNCDEF)
|
||||
|
|
@ -8092,12 +8094,16 @@ grokdeclarator (const cp_declarator *declarator,
|
|||
error ("%<signed%> and %<unsigned%> specified together for %qs", name);
|
||||
else if (longlong && TREE_CODE (type) != INTEGER_TYPE)
|
||||
error ("%<long long%> invalid for %qs", name);
|
||||
else if (explicit_int128 && TREE_CODE (type) != INTEGER_TYPE)
|
||||
error ("%<__int128%> invalid for %qs", name);
|
||||
else if (long_p && TREE_CODE (type) == REAL_TYPE)
|
||||
error ("%<long%> invalid for %qs", name);
|
||||
else if (short_p && TREE_CODE (type) == REAL_TYPE)
|
||||
error ("%<short%> invalid for %qs", name);
|
||||
else if ((long_p || short_p) && TREE_CODE (type) != INTEGER_TYPE)
|
||||
error ("%<long%> or %<short%> invalid for %qs", name);
|
||||
else if ((long_p || short_p || explicit_char || explicit_int) && explicit_int128)
|
||||
error ("%<long%>, %<int%>, %<short%>, or %<char%> invalid for %qs", name);
|
||||
else if ((long_p || short_p) && explicit_char)
|
||||
error ("%<long%> or %<short%> specified with char for %qs", name);
|
||||
else if (long_p && short_p)
|
||||
|
|
@ -8112,7 +8118,7 @@ grokdeclarator (const cp_declarator *declarator,
|
|||
else
|
||||
{
|
||||
ok = 1;
|
||||
if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
|
||||
if (!explicit_int && !defaulted_int && !explicit_char && !explicit_int128 && pedantic)
|
||||
{
|
||||
pedwarn (input_location, OPT_pedantic,
|
||||
"long, short, signed or unsigned used invalidly for %qs",
|
||||
|
|
@ -8120,6 +8126,22 @@ grokdeclarator (const cp_declarator *declarator,
|
|||
if (flag_pedantic_errors)
|
||||
ok = 0;
|
||||
}
|
||||
if (explicit_int128)
|
||||
{
|
||||
if (int128_integer_type_node == NULL_TREE)
|
||||
{
|
||||
error ("%<__int128%> is not supported by this target");
|
||||
ok = 0;
|
||||
}
|
||||
else if (pedantic)
|
||||
{
|
||||
pedwarn (input_location, OPT_pedantic,
|
||||
"ISO C++ does not support %<__int128%> for %qs",
|
||||
name);
|
||||
if (flag_pedantic_errors)
|
||||
ok = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Discard the type modifiers if they are invalid. */
|
||||
|
|
@ -8130,6 +8152,7 @@ grokdeclarator (const cp_declarator *declarator,
|
|||
long_p = false;
|
||||
short_p = false;
|
||||
longlong = 0;
|
||||
explicit_int128 = false;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -8154,7 +8177,9 @@ grokdeclarator (const cp_declarator *declarator,
|
|||
&& TREE_CODE (type) == INTEGER_TYPE
|
||||
&& !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
|
||||
{
|
||||
if (longlong)
|
||||
if (explicit_int128)
|
||||
type = int128_unsigned_type_node;
|
||||
else if (longlong)
|
||||
type = long_long_unsigned_type_node;
|
||||
else if (long_p)
|
||||
type = long_unsigned_type_node;
|
||||
|
|
@ -8169,6 +8194,8 @@ grokdeclarator (const cp_declarator *declarator,
|
|||
}
|
||||
else if (signed_p && type == char_type_node)
|
||||
type = signed_char_type_node;
|
||||
else if (explicit_int128)
|
||||
type = int128_integer_type_node;
|
||||
else if (longlong)
|
||||
type = long_long_integer_type_node;
|
||||
else if (long_p)
|
||||
|
|
@ -8184,8 +8211,7 @@ grokdeclarator (const cp_declarator *declarator,
|
|||
"complex double", but if any modifiers at all are specified it is
|
||||
the complex form of TYPE. E.g, "complex short" is
|
||||
"complex short int". */
|
||||
|
||||
else if (defaulted_int && ! longlong
|
||||
else if (defaulted_int && ! longlong && ! explicit_int128
|
||||
&& ! (long_p || short_p || signed_p || unsigned_p))
|
||||
type = complex_double_type_node;
|
||||
else if (type == integer_type_node)
|
||||
|
|
|
|||
|
|
@ -148,7 +148,9 @@ integer_type_codes[itk_none] =
|
|||
'l', /* itk_long */
|
||||
'm', /* itk_unsigned_long */
|
||||
'x', /* itk_long_long */
|
||||
'y' /* itk_unsigned_long_long */
|
||||
'y', /* itk_unsigned_long_long */
|
||||
'n', /* itk_int128 */
|
||||
'o', /* itk_unsigned_int128 */
|
||||
};
|
||||
|
||||
static int decl_is_template_id (const tree, tree* const);
|
||||
|
|
|
|||
|
|
@ -682,6 +682,7 @@ cp_lexer_next_token_is_decl_specifier_keyword (cp_lexer *lexer)
|
|||
case RID_SHORT:
|
||||
case RID_INT:
|
||||
case RID_LONG:
|
||||
case RID_INT128:
|
||||
case RID_SIGNED:
|
||||
case RID_UNSIGNED:
|
||||
case RID_FLOAT:
|
||||
|
|
@ -12164,6 +12165,7 @@ cp_parser_type_specifier (cp_parser* parser,
|
|||
GNU Extension:
|
||||
|
||||
simple-type-specifier:
|
||||
__int128
|
||||
__typeof__ unary-expression
|
||||
__typeof__ ( type-id )
|
||||
|
||||
|
|
@ -12211,6 +12213,13 @@ cp_parser_simple_type_specifier (cp_parser* parser,
|
|||
decl_specs->explicit_int_p = true;
|
||||
type = integer_type_node;
|
||||
break;
|
||||
case RID_INT128:
|
||||
if (!int128_integer_type_node)
|
||||
break;
|
||||
if (decl_specs)
|
||||
decl_specs->explicit_int128_p = true;
|
||||
type = int128_integer_type_node;
|
||||
break;
|
||||
case RID_LONG:
|
||||
if (decl_specs)
|
||||
++decl_specs->specs[(int) ds_long];
|
||||
|
|
|
|||
|
|
@ -1476,6 +1476,7 @@ emit_support_tinfos (void)
|
|||
&integer_type_node, &unsigned_type_node,
|
||||
&long_integer_type_node, &long_unsigned_type_node,
|
||||
&long_long_integer_type_node, &long_long_unsigned_type_node,
|
||||
&int128_integer_type_node, &int128_unsigned_type_node,
|
||||
&float_type_node, &double_type_node, &long_double_type_node,
|
||||
&dfloat32_type_node, &dfloat64_type_node, &dfloat128_type_node,
|
||||
&nullptr_type_node,
|
||||
|
|
|
|||
|
|
@ -350,6 +350,17 @@ cp_common_type (tree t1, tree t2)
|
|||
: long_long_integer_type_node);
|
||||
return build_type_attribute_variant (t, attributes);
|
||||
}
|
||||
if (int128_integer_type_node != NULL_TREE
|
||||
&& (same_type_p (TYPE_MAIN_VARIANT (t1),
|
||||
int128_integer_type_node)
|
||||
|| same_type_p (TYPE_MAIN_VARIANT (t2),
|
||||
int128_integer_type_node)))
|
||||
{
|
||||
tree t = ((TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
|
||||
? int128_unsigned_type_node
|
||||
: int128_integer_type_node);
|
||||
return build_type_attribute_variant (t, attributes);
|
||||
}
|
||||
|
||||
/* Go through the same procedure, but for longs. */
|
||||
if (same_type_p (TYPE_MAIN_VARIANT (t1), long_unsigned_type_node)
|
||||
|
|
|
|||
|
|
@ -33,6 +33,7 @@ extensions, accepted by GCC in C90 mode and in C++.
|
|||
* Typeof:: @code{typeof}: referring to the type of an expression.
|
||||
* Conditionals:: Omitting the middle operand of a @samp{?:} expression.
|
||||
* Long Long:: Double-word integers---@code{long long int}.
|
||||
* __int128:: 128-bit integers---@code{__int128}.
|
||||
* Complex:: Data types for complex numbers.
|
||||
* Floating Types:: Additional Floating Types.
|
||||
* Half-Precision:: Half-Precision Floating Point.
|
||||
|
|
@ -804,6 +805,17 @@ the operand in the middle would perform the side effect twice. Omitting
|
|||
the middle operand uses the value already computed without the undesirable
|
||||
effects of recomputing it.
|
||||
|
||||
@node __int128
|
||||
@section 128-bits integers
|
||||
@cindex @code{__int128} data types
|
||||
|
||||
As an extension the integer scalar type @code{__int128} is supported for
|
||||
targets having an integer mode wide enough to hold 128-bit.
|
||||
Simply write @code{__int128} for a signed 128-bit integer, or
|
||||
@code{unsigned __int128} for an unsigned 128-bit integer. There is no
|
||||
support in GCC to express an integer constant of type @code{__int128}
|
||||
for targets having @code{long long} integer with less then 128 bit width.
|
||||
|
||||
@node Long Long
|
||||
@section Double-Word Integers
|
||||
@cindex @code{long long} data types
|
||||
|
|
|
|||
|
|
@ -4098,6 +4098,10 @@ gimple_signed_or_unsigned_type (bool unsignedp, tree type)
|
|||
return unsignedp
|
||||
? long_long_unsigned_type_node
|
||||
: long_long_integer_type_node;
|
||||
if (int128_integer_type_node && (type1 == int128_integer_type_node || type1 == int128_unsigned_type_node))
|
||||
return unsignedp
|
||||
? int128_unsigned_type_node
|
||||
: int128_integer_type_node;
|
||||
#if HOST_BITS_PER_WIDE_INT >= 64
|
||||
if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
|
||||
return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
|
||||
|
|
@ -4210,6 +4214,10 @@ gimple_signed_or_unsigned_type (bool unsignedp, tree type)
|
|||
return (unsignedp
|
||||
? long_long_unsigned_type_node
|
||||
: long_long_integer_type_node);
|
||||
if (int128_integer_type_node && TYPE_OK (int128_integer_type_node))
|
||||
return (unsignedp
|
||||
? int128_unsigned_type_node
|
||||
: int128_integer_type_node);
|
||||
|
||||
#if HOST_BITS_PER_WIDE_INT >= 64
|
||||
if (TYPE_OK (intTI_type_node))
|
||||
|
|
|
|||
|
|
@ -1,3 +1,22 @@
|
|||
2010-05-26 Kai Tietz <kai.tietz@onevision.com>
|
||||
|
||||
* lib/target-supports.exp (check_effective_target_int128): New
|
||||
function to check if __int128 types are available for target.
|
||||
* testsuite/c-c++-common/int128-types-1.c: New.
|
||||
* testsuite/c-c++-common/int128-1.c: New.
|
||||
* testsuite/c-c++-common/int128-2.c: New.
|
||||
* g++.dg/abi/mangle43.C: New.
|
||||
* g++.dg/init/enum1.C: Handle __int128 case and add -Wno-overflow.
|
||||
* g++.dg/cpp0x/nullptr04.C: Use __SIZE_TYPE__ for getting
|
||||
pointer-wide scalar.
|
||||
* g++.dg/other/pr25632.C: Likewise.
|
||||
* g++.dg/other/large-size-array.C (DIM): Use ULLONG_MAX for win64 case.
|
||||
* g++.dg/warn/pr13358-2.C: Add llp64 for check of special
|
||||
overflow warnings.
|
||||
* g++.dg/warn/pr13358-4.C: Likewise.
|
||||
* g++.dg/warn/Wconversion-null-2.C: Add 'long long' case.
|
||||
* g++.dg/warn/Wconversion-null.C: Likewise.
|
||||
|
||||
2010-05-26 Jason Merrill <jason@redhat.com>
|
||||
|
||||
PR c++/43382
|
||||
|
|
|
|||
|
|
@ -0,0 +1,41 @@
|
|||
/* { dg-do run { target int128 } } */
|
||||
/* { dg-options "-std=gnu99" { target c } } */
|
||||
/* { dg-options "" { target c++ } } */
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#ifndef __cplusplus
|
||||
extern void abort (void);
|
||||
#else
|
||||
extern "C" void abort (void);
|
||||
#endif
|
||||
|
||||
#define MK_CONST128(A,B,C,D) \
|
||||
( (((unsigned __int128) (unsigned int) A) << 96) \
|
||||
| (((unsigned __int128) (unsigned int) B) << 64) \
|
||||
| (((unsigned __int128) (unsigned int) C) << 32) \
|
||||
| ((unsigned __int128) (unsigned int) D) )
|
||||
|
||||
#define MK_CONST128_SIGNED(A,B,C,D) \
|
||||
((__int128) MK_CONST128(A, B, C, D))
|
||||
|
||||
void foo(int i, ...)
|
||||
{
|
||||
__int128 q;
|
||||
va_list va;
|
||||
|
||||
va_start(va, i);
|
||||
q = va_arg(va, __int128);
|
||||
va_end(va);
|
||||
|
||||
if (q != MK_CONST128_SIGNED (0xfeffffffU, 2U, 3U, 4U))
|
||||
abort();
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
__int128 q = MK_CONST128_SIGNED (0xfeffffffU, 2U, 3U, 4U);
|
||||
|
||||
foo(1, q);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,157 @@
|
|||
/* { dg-do run { target int128 } } */
|
||||
/* { dg-options "-std=gnu99" { target c } } */
|
||||
/* { dg-options "" { target c++ } } */
|
||||
|
||||
#ifndef __cplusplus
|
||||
extern void abort (void);
|
||||
#else
|
||||
extern "C" void abort (void);
|
||||
#endif
|
||||
|
||||
#define MK_CONST128(A,B,C,D) \
|
||||
( (((unsigned __int128) (unsigned int) A) << 96) \
|
||||
| (((unsigned __int128) (unsigned int) B) << 64) \
|
||||
| (((unsigned __int128) (unsigned int) C) << 32) \
|
||||
| ((unsigned __int128) (unsigned int) D) )
|
||||
|
||||
#define MK_CONST128_SIGNED(A,B,C,D) \
|
||||
((__int128) MK_CONST128(A, B, C, D))
|
||||
|
||||
#define MINUS_2 MK_CONST128_SIGNED (0xffffffffu, 0xffffffffu, 0xffffffffu, \
|
||||
0xfffffffeu)
|
||||
#define MINUS_3 MK_CONST128_SIGNED (0xffffffffu, 0xffffffffu, 0xffffffffu, \
|
||||
0xfffffffdu)
|
||||
#define MINUS_6 MK_CONST128_SIGNED (0xffffffffu, 0xffffffffu, 0xffffffffu, \
|
||||
0xfffffffau)
|
||||
#define PLUS_1 MK_CONST128_SIGNED (0, 0, 0, 1)
|
||||
#define PLUS_2 MK_CONST128_SIGNED (0, 0, 0, 2)
|
||||
#define PLUS_3 MK_CONST128_SIGNED (0, 0, 0, 3)
|
||||
#define PLUS_6 MK_CONST128_SIGNED (0, 0, 0, 6)
|
||||
#define PLUS_10 MK_CONST128_SIGNED (0, 0, 0, 10)
|
||||
|
||||
#define U_8 MK_CONST128 (0, 0, 0, 8)
|
||||
#define U_MAX MK_CONST128 (0xffffffff,0xffffffff,0xffffffff,0xffffffff)
|
||||
#define U_CST1 MK_CONST128 (0xbeeffeed, 0xdeafcafe, 0xaffefade, 0x12345678)
|
||||
#define U_CST2 MK_CONST128 (0x41100112, 0x21503501, 0x50010521, 0xedcba987)
|
||||
|
||||
signed __int128 foo_neg (signed __int128 v)
|
||||
{
|
||||
return -v;
|
||||
}
|
||||
|
||||
unsigned __int128 foo_xor (unsigned __int128 x, unsigned __int128 y)
|
||||
{
|
||||
return x ^ y;
|
||||
}
|
||||
|
||||
unsigned __int128 foo_inv (unsigned __int128 v)
|
||||
{
|
||||
return ~v;
|
||||
}
|
||||
|
||||
unsigned __int128 foo_rotate_left (unsigned __int128 v)
|
||||
{
|
||||
unsigned __int128 c;
|
||||
int i;
|
||||
for (i = 0; i < 128; i++)
|
||||
{
|
||||
c = v >> 127;
|
||||
v <<= 1;
|
||||
v |= c;
|
||||
}
|
||||
return v;
|
||||
}
|
||||
|
||||
unsigned __int128 foo_rotate_right (unsigned __int128 v)
|
||||
{
|
||||
unsigned __int128 c;
|
||||
int i;
|
||||
for (i = 0; i < 128; i++)
|
||||
{
|
||||
c = (v & ((unsigned __int128) 1)) << 127;
|
||||
v >>= 1;
|
||||
v |= c;
|
||||
}
|
||||
return v;
|
||||
}
|
||||
|
||||
void foo_swap (unsigned __int128 *x, unsigned __int128 *y)
|
||||
{
|
||||
unsigned __int128 x1 = x[0];
|
||||
unsigned __int128 y1 = y[0];
|
||||
x1 ^= y1 ^= x1 ^= y1;
|
||||
x[0] = x1;
|
||||
y[0] = y1;
|
||||
}
|
||||
|
||||
__int128 foo_add (signed __int128 a, unsigned __int128 b)
|
||||
{
|
||||
return (__int128) (a + (__int128) b);
|
||||
}
|
||||
|
||||
__int128 foo_sub (unsigned __int128 a, signed __int128 b)
|
||||
{
|
||||
return (__int128) ((__int128) a - b);
|
||||
}
|
||||
|
||||
__int128 foo_mul (signed __int128 a, signed __int128 b)
|
||||
{
|
||||
return a * b;
|
||||
}
|
||||
|
||||
__int128 foo_div (signed __int128 a, signed __int128 b)
|
||||
{
|
||||
return a / b;
|
||||
}
|
||||
|
||||
__int128 foo_shl (signed __int128 a, int shift)
|
||||
{
|
||||
return a << (shift & 127);
|
||||
}
|
||||
|
||||
__int128 foo_shr (signed __int128 a, int shift)
|
||||
{
|
||||
return a >> (shift & 127);
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
__int128 rslt;
|
||||
unsigned __int128 u1, u2;
|
||||
|
||||
rslt = foo_add (MINUS_2, U_8);
|
||||
if (rslt != PLUS_6)
|
||||
abort ();
|
||||
rslt = foo_sub (U_8, MINUS_2);
|
||||
if (rslt != PLUS_10)
|
||||
abort ();
|
||||
rslt = foo_sub ((unsigned __int128) foo_mul (MINUS_2, MINUS_2), MINUS_2);
|
||||
if (rslt != PLUS_6)
|
||||
abort ();
|
||||
if (rslt != foo_shl (PLUS_3, 1))
|
||||
abort ();
|
||||
rslt = foo_shl (MINUS_3, 1);
|
||||
if (rslt != MINUS_6)
|
||||
abort ();
|
||||
if (foo_shr (MINUS_6, 1) != MINUS_3)
|
||||
abort ();
|
||||
if (foo_div (MINUS_6, MINUS_3) != PLUS_2)
|
||||
abort ();
|
||||
if (foo_rotate_left (U_CST1) != U_CST1)
|
||||
abort ();
|
||||
if (foo_rotate_right (U_CST1) != U_CST1)
|
||||
abort ();
|
||||
u1 = U_CST1;
|
||||
u2 = U_8;
|
||||
foo_swap (&u1, &u2);
|
||||
if (u1 != U_8 || u2 != U_CST1)
|
||||
abort ();
|
||||
|
||||
if (foo_inv (U_CST2) != U_CST1)
|
||||
abort ();
|
||||
if (foo_neg (PLUS_2) != MINUS_2)
|
||||
abort ();
|
||||
if (foo_neg ((signed __int128) U_CST1) != foo_add (PLUS_1, foo_xor (U_CST1, U_MAX)))
|
||||
abort ();
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,666 @@
|
|||
/* Test for valid and invalid combinations of type specifiers using __int128.
|
||||
*/
|
||||
/* Origin: Kai Tietz <kai.tietz@onevision.com> */
|
||||
/* { dg-do compile { target int128 } } */
|
||||
/* { dg-options "-std=gnu99" { target c } } */
|
||||
/* { dg-options "" { target c++ } } */
|
||||
|
||||
typedef char type;
|
||||
__int128 *x0;
|
||||
void __int128 *x1; /* { dg-error "" } */
|
||||
char __int128 *x2; /* { dg-error "" } */
|
||||
short __int128 *x3; /* { dg-error "" } */
|
||||
int __int128 *x4; /* { dg-error "" } */
|
||||
__int128 void *x5; /* { dg-error "" } */
|
||||
__int128 char *x6; /* { dg-error "" } */
|
||||
__int128 short *x7; /* { dg-error "" } */
|
||||
__int128 int *x8; /* { dg-error "" } */
|
||||
__int128 __int128 *x9; /* { dg-error "" } */
|
||||
__int128 long *x10; /* { dg-error "" } */
|
||||
__int128 float *x11; /* { dg-error "" } */
|
||||
__int128 double *x12; /* { dg-error "" } */
|
||||
__int128 signed *x13;
|
||||
__int128 unsigned *x14;
|
||||
__int128 _Bool *x15; /* { dg-error "" } */
|
||||
__int128 _Complex *x16;
|
||||
long __int128 *x17; /* { dg-error "" } */
|
||||
float __int128 *x18; /* { dg-error "" } */
|
||||
double __int128 *x19; /* { dg-error "" } */
|
||||
signed __int128 *x20;
|
||||
unsigned __int128 *x21;
|
||||
_Bool __int128 *x22; /* { dg-error "" } */
|
||||
_Complex __int128 *x23;
|
||||
type __int128 *x24; /* { dg-error "" } */
|
||||
char signed __int128 *x25; /* { dg-error "" } */
|
||||
char unsigned __int128 *x26; /* { dg-error "" } */
|
||||
char _Complex __int128 *x27; /* { dg-error "" } */
|
||||
short int __int128 *x28; /* { dg-error "" } */
|
||||
short signed __int128 *x29; /* { dg-error "" } */
|
||||
short unsigned __int128 *x30; /* { dg-error "" } */
|
||||
short _Complex __int128 *x31; /* { dg-error "" } */
|
||||
int short __int128 *x32; /* { dg-error "" } */
|
||||
int long __int128 *x33; /* { dg-error "" } */
|
||||
int signed __int128 *x34; /* { dg-error "" } */
|
||||
int unsigned __int128 *x35; /* { dg-error "" } */
|
||||
int _Complex __int128 *x36; /* { dg-error "" } */
|
||||
__int128 signed void *x37; /* { dg-error "" } */
|
||||
__int128 signed char *x38; /* { dg-error "" } */
|
||||
__int128 signed short *x39; /* { dg-error "" } */
|
||||
__int128 signed int *x40; /* { dg-error "" } */
|
||||
__int128 signed __int128 *x41; /* { dg-error "" } */
|
||||
__int128 signed long *x42; /* { dg-error "" } */
|
||||
__int128 signed float *x43; /* { dg-error "" } */
|
||||
__int128 signed double *x44; /* { dg-error "" } */
|
||||
__int128 signed signed *x45; /* { dg-error "" } */
|
||||
__int128 signed unsigned *x46; /* { dg-error "" } */
|
||||
__int128 signed _Bool *x47; /* { dg-error "" } */
|
||||
__int128 signed _Complex *x48;
|
||||
__int128 unsigned void *x49; /* { dg-error "" } */
|
||||
__int128 unsigned char *x50; /* { dg-error "" } */
|
||||
__int128 unsigned short *x51; /* { dg-error "" } */
|
||||
__int128 unsigned int *x52; /* { dg-error "" } */
|
||||
__int128 unsigned __int128 *x53; /* { dg-error "" } */
|
||||
__int128 unsigned long *x54; /* { dg-error "" } */
|
||||
__int128 unsigned float *x55; /* { dg-error "" } */
|
||||
__int128 unsigned double *x56; /* { dg-error "" } */
|
||||
__int128 unsigned signed *x57; /* { dg-error "" } */
|
||||
__int128 unsigned unsigned *x58; /* { dg-error "" } */
|
||||
__int128 unsigned _Bool *x59; /* { dg-error "" } */
|
||||
__int128 unsigned _Complex *x60;
|
||||
__int128 _Complex void *x61; /* { dg-error "" } */
|
||||
__int128 _Complex char *x62; /* { dg-error "" } */
|
||||
__int128 _Complex short *x63; /* { dg-error "" } */
|
||||
__int128 _Complex int *x64; /* { dg-error "" } */
|
||||
__int128 _Complex __int128 *x65; /* { dg-error "" } */
|
||||
__int128 _Complex long *x66; /* { dg-error "" } */
|
||||
__int128 _Complex float *x67; /* { dg-error "" } */
|
||||
__int128 _Complex double *x68; /* { dg-error "" } */
|
||||
__int128 _Complex signed *x69;
|
||||
__int128 _Complex unsigned *x70;
|
||||
__int128 _Complex _Bool *x71; /* { dg-error "" } */
|
||||
__int128 _Complex _Complex *x72; /* { dg-error "" } */
|
||||
long int __int128 *x73; /* { dg-error "" } */
|
||||
long long __int128 *x74; /* { dg-error "" } */
|
||||
long double __int128 *x75; /* { dg-error "" } */
|
||||
long signed __int128 *x76; /* { dg-error "" } */
|
||||
long unsigned __int128 *x77; /* { dg-error "" } */
|
||||
long _Complex __int128 *x78; /* { dg-error "" } */
|
||||
float _Complex __int128 *x79; /* { dg-error "" } */
|
||||
double long __int128 *x80; /* { dg-error "" } */
|
||||
double _Complex __int128 *x81; /* { dg-error "" } */
|
||||
signed char __int128 *x82; /* { dg-error "" } */
|
||||
signed short __int128 *x83; /* { dg-error "" } */
|
||||
signed int __int128 *x84; /* { dg-error "" } */
|
||||
signed __int128 void *x85; /* { dg-error "" } */
|
||||
signed __int128 char *x86; /* { dg-error "" } */
|
||||
signed __int128 short *x87; /* { dg-error "" } */
|
||||
signed __int128 int *x88; /* { dg-error "" } */
|
||||
signed __int128 __int128 *x89; /* { dg-error "" } */
|
||||
signed __int128 long *x90; /* { dg-error "" } */
|
||||
signed __int128 float *x91; /* { dg-error "" } */
|
||||
signed __int128 double *x92; /* { dg-error "" } */
|
||||
signed __int128 signed *x93; /* { dg-error "" } */
|
||||
signed __int128 unsigned *x94; /* { dg-error "" } */
|
||||
signed __int128 _Bool *x95; /* { dg-error "" } */
|
||||
signed __int128 _Complex *x96;
|
||||
signed long __int128 *x97; /* { dg-error "" } */
|
||||
signed _Complex __int128 *x98;
|
||||
unsigned char __int128 *x99; /* { dg-error "" } */
|
||||
unsigned short __int128 *x100; /* { dg-error "" } */
|
||||
unsigned int __int128 *x101; /* { dg-error "" } */
|
||||
unsigned __int128 void *x102; /* { dg-error "" } */
|
||||
unsigned __int128 char *x103; /* { dg-error "" } */
|
||||
unsigned __int128 short *x104; /* { dg-error "" } */
|
||||
unsigned __int128 int *x105; /* { dg-error "" } */
|
||||
unsigned __int128 __int128 *x106; /* { dg-error "" } */
|
||||
unsigned __int128 long *x107; /* { dg-error "" } */
|
||||
unsigned __int128 float *x108; /* { dg-error "" } */
|
||||
unsigned __int128 double *x109; /* { dg-error "" } */
|
||||
unsigned __int128 signed *x110; /* { dg-error "" } */
|
||||
unsigned __int128 unsigned *x111; /* { dg-error "" } */
|
||||
unsigned __int128 _Bool *x112; /* { dg-error "" } */
|
||||
unsigned __int128 _Complex *x113;
|
||||
unsigned long __int128 *x114; /* { dg-error "" } */
|
||||
unsigned _Complex __int128 *x115;
|
||||
_Complex char __int128 *x116; /* { dg-error "" } */
|
||||
_Complex short __int128 *x117; /* { dg-error "" } */
|
||||
_Complex int __int128 *x118; /* { dg-error "" } */
|
||||
_Complex __int128 void *x119; /* { dg-error "" } */
|
||||
_Complex __int128 char *x120; /* { dg-error "" } */
|
||||
_Complex __int128 short *x121; /* { dg-error "" } */
|
||||
_Complex __int128 int *x122; /* { dg-error "" } */
|
||||
_Complex __int128 __int128 *x123; /* { dg-error "" } */
|
||||
_Complex __int128 long *x124; /* { dg-error "" } */
|
||||
_Complex __int128 float *x125; /* { dg-error "" } */
|
||||
_Complex __int128 double *x126; /* { dg-error "" } */
|
||||
_Complex __int128 signed *x127;
|
||||
_Complex __int128 unsigned *x128;
|
||||
_Complex __int128 _Bool *x129; /* { dg-error "" } */
|
||||
_Complex __int128 _Complex *x130; /* { dg-error "" } */
|
||||
_Complex long __int128 *x131; /* { dg-error "" } */
|
||||
_Complex float __int128 *x132; /* { dg-error "" } */
|
||||
_Complex double __int128 *x133; /* { dg-error "" } */
|
||||
_Complex signed __int128 *x134;
|
||||
_Complex unsigned __int128 *x135;
|
||||
char signed _Complex __int128 *x136; /* { dg-error "" } */
|
||||
char unsigned _Complex __int128 *x137; /* { dg-error "" } */
|
||||
char _Complex signed __int128 *x138; /* { dg-error "" } */
|
||||
char _Complex unsigned __int128 *x139; /* { dg-error "" } */
|
||||
short int signed __int128 *x140; /* { dg-error "" } */
|
||||
short int unsigned __int128 *x141; /* { dg-error "" } */
|
||||
short int _Complex __int128 *x142; /* { dg-error "" } */
|
||||
short signed int __int128 *x143; /* { dg-error "" } */
|
||||
short signed _Complex __int128 *x144; /* { dg-error "" } */
|
||||
short unsigned int __int128 *x145; /* { dg-error "" } */
|
||||
short unsigned _Complex __int128 *x146; /* { dg-error "" } */
|
||||
short _Complex int __int128 *x147; /* { dg-error "" } */
|
||||
short _Complex signed __int128 *x148; /* { dg-error "" } */
|
||||
short _Complex unsigned __int128 *x149; /* { dg-error "" } */
|
||||
int short signed __int128 *x150; /* { dg-error "" } */
|
||||
int short unsigned __int128 *x151; /* { dg-error "" } */
|
||||
int short _Complex __int128 *x152; /* { dg-error "" } */
|
||||
int long long __int128 *x153; /* { dg-error "" } */
|
||||
int long signed __int128 *x154; /* { dg-error "" } */
|
||||
int long unsigned __int128 *x155; /* { dg-error "" } */
|
||||
int long _Complex __int128 *x156; /* { dg-error "" } */
|
||||
int signed short __int128 *x157; /* { dg-error "" } */
|
||||
int signed long __int128 *x158; /* { dg-error "" } */
|
||||
int signed _Complex __int128 *x159; /* { dg-error "" } */
|
||||
int unsigned short __int128 *x160; /* { dg-error "" } */
|
||||
int unsigned long __int128 *x161; /* { dg-error "" } */
|
||||
int unsigned _Complex __int128 *x162; /* { dg-error "" } */
|
||||
int _Complex short __int128 *x163; /* { dg-error "" } */
|
||||
int _Complex long __int128 *x164; /* { dg-error "" } */
|
||||
int _Complex signed __int128 *x165; /* { dg-error "" } */
|
||||
int _Complex unsigned __int128 *x166; /* { dg-error "" } */
|
||||
__int128 signed _Complex void *x167; /* { dg-error "" } */
|
||||
__int128 signed _Complex char *x168; /* { dg-error "" } */
|
||||
__int128 signed _Complex short *x169; /* { dg-error "" } */
|
||||
__int128 signed _Complex int *x170; /* { dg-error "" } */
|
||||
__int128 signed _Complex __int128 *x171; /* { dg-error "" } */
|
||||
__int128 signed _Complex long *x172; /* { dg-error "" } */
|
||||
__int128 signed _Complex float *x173; /* { dg-error "" } */
|
||||
__int128 signed _Complex double *x174; /* { dg-error "" } */
|
||||
__int128 signed _Complex signed *x175; /* { dg-error "" } */
|
||||
__int128 signed _Complex unsigned *x176; /* { dg-error "" } */
|
||||
__int128 signed _Complex _Bool *x177; /* { dg-error "" } */
|
||||
__int128 signed _Complex _Complex *x178; /* { dg-error "" } */
|
||||
__int128 unsigned _Complex void *x179; /* { dg-error "" } */
|
||||
__int128 unsigned _Complex char *x180; /* { dg-error "" } */
|
||||
__int128 unsigned _Complex short *x181; /* { dg-error "" } */
|
||||
__int128 unsigned _Complex int *x182; /* { dg-error "" } */
|
||||
__int128 unsigned _Complex __int128 *x183; /* { dg-error "" } */
|
||||
__int128 unsigned _Complex long *x184; /* { dg-error "" } */
|
||||
__int128 unsigned _Complex float *x185; /* { dg-error "" } */
|
||||
__int128 unsigned _Complex double *x186; /* { dg-error "" } */
|
||||
__int128 unsigned _Complex signed *x187; /* { dg-error "" } */
|
||||
__int128 unsigned _Complex unsigned *x188; /* { dg-error "" } */
|
||||
__int128 unsigned _Complex _Bool *x189; /* { dg-error "" } */
|
||||
__int128 unsigned _Complex _Complex *x190; /* { dg-error "" } */
|
||||
__int128 _Complex signed void *x191; /* { dg-error "" } */
|
||||
__int128 _Complex signed char *x192; /* { dg-error "" } */
|
||||
__int128 _Complex signed short *x193; /* { dg-error "" } */
|
||||
__int128 _Complex signed int *x194; /* { dg-error "" } */
|
||||
__int128 _Complex signed __int128 *x195; /* { dg-error "" } */
|
||||
__int128 _Complex signed long *x196; /* { dg-error "" } */
|
||||
__int128 _Complex signed float *x197; /* { dg-error "" } */
|
||||
__int128 _Complex signed double *x198; /* { dg-error "" } */
|
||||
__int128 _Complex signed signed *x199; /* { dg-error "" } */
|
||||
__int128 _Complex signed unsigned *x200; /* { dg-error "" } */
|
||||
__int128 _Complex signed _Bool *x201; /* { dg-error "" } */
|
||||
__int128 _Complex signed _Complex *x202; /* { dg-error "" } */
|
||||
__int128 _Complex unsigned void *x203; /* { dg-error "" } */
|
||||
__int128 _Complex unsigned char *x204; /* { dg-error "" } */
|
||||
__int128 _Complex unsigned short *x205; /* { dg-error "" } */
|
||||
__int128 _Complex unsigned int *x206; /* { dg-error "" } */
|
||||
__int128 _Complex unsigned __int128 *x207; /* { dg-error "" } */
|
||||
__int128 _Complex unsigned long *x208; /* { dg-error "" } */
|
||||
__int128 _Complex unsigned float *x209; /* { dg-error "" } */
|
||||
__int128 _Complex unsigned double *x210; /* { dg-error "" } */
|
||||
__int128 _Complex unsigned signed *x211; /* { dg-error "" } */
|
||||
__int128 _Complex unsigned unsigned *x212; /* { dg-error "" } */
|
||||
__int128 _Complex unsigned _Bool *x213; /* { dg-error "" } */
|
||||
__int128 _Complex unsigned _Complex *x214; /* { dg-error "" } */
|
||||
long int long __int128 *x215; /* { dg-error "" } */
|
||||
long int signed __int128 *x216; /* { dg-error "" } */
|
||||
long int unsigned __int128 *x217; /* { dg-error "" } */
|
||||
long int _Complex __int128 *x218; /* { dg-error "" } */
|
||||
long long int __int128 *x219; /* { dg-error "" } */
|
||||
long long signed __int128 *x220; /* { dg-error "" } */
|
||||
long long unsigned __int128 *x221; /* { dg-error "" } */
|
||||
long long _Complex __int128 *x222; /* { dg-error "" } */
|
||||
long double _Complex __int128 *x223; /* { dg-error "" } */
|
||||
long signed int __int128 *x224; /* { dg-error "" } */
|
||||
long signed long __int128 *x225; /* { dg-error "" } */
|
||||
long signed _Complex __int128 *x226; /* { dg-error "" } */
|
||||
long unsigned int __int128 *x227; /* { dg-error "" } */
|
||||
long unsigned long __int128 *x228; /* { dg-error "" } */
|
||||
long unsigned _Complex __int128 *x229; /* { dg-error "" } */
|
||||
long _Complex int __int128 *x230; /* { dg-error "" } */
|
||||
long _Complex long __int128 *x231; /* { dg-error "" } */
|
||||
long _Complex double __int128 *x232; /* { dg-error "" } */
|
||||
long _Complex signed __int128 *x233; /* { dg-error "" } */
|
||||
long _Complex unsigned __int128 *x234; /* { dg-error "" } */
|
||||
double long _Complex __int128 *x235; /* { dg-error "" } */
|
||||
double _Complex long __int128 *x236; /* { dg-error "" } */
|
||||
signed char _Complex __int128 *x237; /* { dg-error "" } */
|
||||
signed short int __int128 *x238; /* { dg-error "" } */
|
||||
signed short _Complex __int128 *x239; /* { dg-error "" } */
|
||||
signed int short __int128 *x240; /* { dg-error "" } */
|
||||
signed int long __int128 *x241; /* { dg-error "" } */
|
||||
signed int _Complex __int128 *x242; /* { dg-error "" } */
|
||||
signed __int128 _Complex void *x243; /* { dg-error "" } */
|
||||
signed __int128 _Complex char *x244; /* { dg-error "" } */
|
||||
signed __int128 _Complex short *x245; /* { dg-error "" } */
|
||||
signed __int128 _Complex int *x246; /* { dg-error "" } */
|
||||
signed __int128 _Complex __int128 *x247; /* { dg-error "" } */
|
||||
signed __int128 _Complex long *x248; /* { dg-error "" } */
|
||||
signed __int128 _Complex float *x249; /* { dg-error "" } */
|
||||
signed __int128 _Complex double *x250; /* { dg-error "" } */
|
||||
signed __int128 _Complex signed *x251; /* { dg-error "" } */
|
||||
signed __int128 _Complex unsigned *x252; /* { dg-error "" } */
|
||||
signed __int128 _Complex _Bool *x253; /* { dg-error "" } */
|
||||
signed __int128 _Complex _Complex *x254; /* { dg-error "" } */
|
||||
signed long int __int128 *x255; /* { dg-error "" } */
|
||||
signed long long __int128 *x256; /* { dg-error "" } */
|
||||
signed long _Complex __int128 *x257; /* { dg-error "" } */
|
||||
signed _Complex char __int128 *x258; /* { dg-error "" } */
|
||||
signed _Complex short __int128 *x259; /* { dg-error "" } */
|
||||
signed _Complex int __int128 *x260; /* { dg-error "" } */
|
||||
signed _Complex __int128 void *x261; /* { dg-error "" } */
|
||||
signed _Complex __int128 char *x262; /* { dg-error "" } */
|
||||
signed _Complex __int128 short *x263; /* { dg-error "" } */
|
||||
signed _Complex __int128 int *x264; /* { dg-error "" } */
|
||||
signed _Complex __int128 __int128 *x265; /* { dg-error "" } */
|
||||
signed _Complex __int128 long *x266; /* { dg-error "" } */
|
||||
signed _Complex __int128 float *x267; /* { dg-error "" } */
|
||||
signed _Complex __int128 double *x268; /* { dg-error "" } */
|
||||
signed _Complex __int128 signed *x269; /* { dg-error "" } */
|
||||
signed _Complex __int128 unsigned *x270; /* { dg-error "" } */
|
||||
signed _Complex __int128 _Bool *x271; /* { dg-error "" } */
|
||||
signed _Complex __int128 _Complex *x272; /* { dg-error "" } */
|
||||
signed _Complex long __int128 *x273; /* { dg-error "" } */
|
||||
unsigned char _Complex __int128 *x274; /* { dg-error "" } */
|
||||
unsigned short int __int128 *x275; /* { dg-error "" } */
|
||||
unsigned short _Complex __int128 *x276; /* { dg-error "" } */
|
||||
unsigned int short __int128 *x277; /* { dg-error "" } */
|
||||
unsigned int long __int128 *x278; /* { dg-error "" } */
|
||||
unsigned int _Complex __int128 *x279; /* { dg-error "" } */
|
||||
unsigned __int128 _Complex void *x280; /* { dg-error "" } */
|
||||
unsigned __int128 _Complex char *x281; /* { dg-error "" } */
|
||||
unsigned __int128 _Complex short *x282; /* { dg-error "" } */
|
||||
unsigned __int128 _Complex int *x283; /* { dg-error "" } */
|
||||
unsigned __int128 _Complex __int128 *x284; /* { dg-error "" } */
|
||||
unsigned __int128 _Complex long *x285; /* { dg-error "" } */
|
||||
unsigned __int128 _Complex float *x286; /* { dg-error "" } */
|
||||
unsigned __int128 _Complex double *x287; /* { dg-error "" } */
|
||||
unsigned __int128 _Complex signed *x288; /* { dg-error "" } */
|
||||
unsigned __int128 _Complex unsigned *x289; /* { dg-error "" } */
|
||||
unsigned __int128 _Complex _Bool *x290; /* { dg-error "" } */
|
||||
unsigned __int128 _Complex _Complex *x291; /* { dg-error "" } */
|
||||
unsigned long int __int128 *x292; /* { dg-error "" } */
|
||||
unsigned long long __int128 *x293; /* { dg-error "" } */
|
||||
unsigned long _Complex __int128 *x294; /* { dg-error "" } */
|
||||
unsigned _Complex char __int128 *x295; /* { dg-error "" } */
|
||||
unsigned _Complex short __int128 *x296; /* { dg-error "" } */
|
||||
unsigned _Complex int __int128 *x297; /* { dg-error "" } */
|
||||
unsigned _Complex __int128 void *x298; /* { dg-error "" } */
|
||||
unsigned _Complex __int128 char *x299; /* { dg-error "" } */
|
||||
unsigned _Complex __int128 short *x300; /* { dg-error "" } */
|
||||
unsigned _Complex __int128 int *x301; /* { dg-error "" } */
|
||||
unsigned _Complex __int128 __int128 *x302; /* { dg-error "" } */
|
||||
unsigned _Complex __int128 long *x303; /* { dg-error "" } */
|
||||
unsigned _Complex __int128 float *x304; /* { dg-error "" } */
|
||||
unsigned _Complex __int128 double *x305; /* { dg-error "" } */
|
||||
unsigned _Complex __int128 signed *x306; /* { dg-error "" } */
|
||||
unsigned _Complex __int128 unsigned *x307; /* { dg-error "" } */
|
||||
unsigned _Complex __int128 _Bool *x308; /* { dg-error "" } */
|
||||
unsigned _Complex __int128 _Complex *x309; /* { dg-error "" } */
|
||||
unsigned _Complex long __int128 *x310; /* { dg-error "" } */
|
||||
_Complex char signed __int128 *x311; /* { dg-error "" } */
|
||||
_Complex char unsigned __int128 *x312; /* { dg-error "" } */
|
||||
_Complex short int __int128 *x313; /* { dg-error "" } */
|
||||
_Complex short signed __int128 *x314; /* { dg-error "" } */
|
||||
_Complex short unsigned __int128 *x315; /* { dg-error "" } */
|
||||
_Complex int short __int128 *x316; /* { dg-error "" } */
|
||||
_Complex int long __int128 *x317; /* { dg-error "" } */
|
||||
_Complex int signed __int128 *x318; /* { dg-error "" } */
|
||||
_Complex int unsigned __int128 *x319; /* { dg-error "" } */
|
||||
_Complex __int128 signed void *x320; /* { dg-error "" } */
|
||||
_Complex __int128 signed char *x321; /* { dg-error "" } */
|
||||
_Complex __int128 signed short *x322; /* { dg-error "" } */
|
||||
_Complex __int128 signed int *x323; /* { dg-error "" } */
|
||||
_Complex __int128 signed __int128 *x324; /* { dg-error "" } */
|
||||
_Complex __int128 signed long *x325; /* { dg-error "" } */
|
||||
_Complex __int128 signed float *x326; /* { dg-error "" } */
|
||||
_Complex __int128 signed double *x327; /* { dg-error "" } */
|
||||
_Complex __int128 signed signed *x328; /* { dg-error "" } */
|
||||
_Complex __int128 signed unsigned *x329; /* { dg-error "" } */
|
||||
_Complex __int128 signed _Bool *x330; /* { dg-error "" } */
|
||||
_Complex __int128 signed _Complex *x331; /* { dg-error "" } */
|
||||
_Complex __int128 unsigned void *x332; /* { dg-error "" } */
|
||||
_Complex __int128 unsigned char *x333; /* { dg-error "" } */
|
||||
_Complex __int128 unsigned short *x334; /* { dg-error "" } */
|
||||
_Complex __int128 unsigned int *x335; /* { dg-error "" } */
|
||||
_Complex __int128 unsigned __int128 *x336; /* { dg-error "" } */
|
||||
_Complex __int128 unsigned long *x337; /* { dg-error "" } */
|
||||
_Complex __int128 unsigned float *x338; /* { dg-error "" } */
|
||||
_Complex __int128 unsigned double *x339; /* { dg-error "" } */
|
||||
_Complex __int128 unsigned signed *x340; /* { dg-error "" } */
|
||||
_Complex __int128 unsigned unsigned *x341; /* { dg-error "" } */
|
||||
_Complex __int128 unsigned _Bool *x342; /* { dg-error "" } */
|
||||
_Complex __int128 unsigned _Complex *x343; /* { dg-error "" } */
|
||||
_Complex long int __int128 *x344; /* { dg-error "" } */
|
||||
_Complex long long __int128 *x345; /* { dg-error "" } */
|
||||
_Complex long double __int128 *x346; /* { dg-error "" } */
|
||||
_Complex long signed __int128 *x347; /* { dg-error "" } */
|
||||
_Complex long unsigned __int128 *x348; /* { dg-error "" } */
|
||||
_Complex double long __int128 *x349; /* { dg-error "" } */
|
||||
_Complex signed char __int128 *x350; /* { dg-error "" } */
|
||||
_Complex signed short __int128 *x351; /* { dg-error "" } */
|
||||
_Complex signed int __int128 *x352; /* { dg-error "" } */
|
||||
_Complex signed __int128 void *x353; /* { dg-error "" } */
|
||||
_Complex signed __int128 char *x354; /* { dg-error "" } */
|
||||
_Complex signed __int128 short *x355; /* { dg-error "" } */
|
||||
_Complex signed __int128 int *x356; /* { dg-error "" } */
|
||||
_Complex signed __int128 __int128 *x357; /* { dg-error "" } */
|
||||
_Complex signed __int128 long *x358; /* { dg-error "" } */
|
||||
_Complex signed __int128 float *x359; /* { dg-error "" } */
|
||||
_Complex signed __int128 double *x360; /* { dg-error "" } */
|
||||
_Complex signed __int128 signed *x361; /* { dg-error "" } */
|
||||
_Complex signed __int128 unsigned *x362; /* { dg-error "" } */
|
||||
_Complex signed __int128 _Bool *x363; /* { dg-error "" } */
|
||||
_Complex signed __int128 _Complex *x364; /* { dg-error "" } */
|
||||
_Complex signed long __int128 *x365; /* { dg-error "" } */
|
||||
_Complex unsigned char __int128 *x366; /* { dg-error "" } */
|
||||
_Complex unsigned short __int128 *x367; /* { dg-error "" } */
|
||||
_Complex unsigned int __int128 *x368; /* { dg-error "" } */
|
||||
_Complex unsigned __int128 void *x369; /* { dg-error "" } */
|
||||
_Complex unsigned __int128 char *x370; /* { dg-error "" } */
|
||||
_Complex unsigned __int128 short *x371; /* { dg-error "" } */
|
||||
_Complex unsigned __int128 int *x372; /* { dg-error "" } */
|
||||
_Complex unsigned __int128 __int128 *x373; /* { dg-error "" } */
|
||||
_Complex unsigned __int128 long *x374; /* { dg-error "" } */
|
||||
_Complex unsigned __int128 float *x375; /* { dg-error "" } */
|
||||
_Complex unsigned __int128 double *x376; /* { dg-error "" } */
|
||||
_Complex unsigned __int128 signed *x377; /* { dg-error "" } */
|
||||
_Complex unsigned __int128 unsigned *x378; /* { dg-error "" } */
|
||||
_Complex unsigned __int128 _Bool *x379; /* { dg-error "" } */
|
||||
_Complex unsigned __int128 _Complex *x380; /* { dg-error "" } */
|
||||
_Complex unsigned long __int128 *x381; /* { dg-error "" } */
|
||||
short int signed _Complex __int128 *x382; /* { dg-error "" } */
|
||||
short int unsigned _Complex __int128 *x383; /* { dg-error "" } */
|
||||
short int _Complex signed __int128 *x384; /* { dg-error "" } */
|
||||
short int _Complex unsigned __int128 *x385; /* { dg-error "" } */
|
||||
short signed int _Complex __int128 *x386; /* { dg-error "" } */
|
||||
short signed _Complex int __int128 *x387; /* { dg-error "" } */
|
||||
short unsigned int _Complex __int128 *x388; /* { dg-error "" } */
|
||||
short unsigned _Complex int __int128 *x389; /* { dg-error "" } */
|
||||
short _Complex int signed __int128 *x390; /* { dg-error "" } */
|
||||
short _Complex int unsigned __int128 *x391; /* { dg-error "" } */
|
||||
short _Complex signed int __int128 *x392; /* { dg-error "" } */
|
||||
short _Complex unsigned int __int128 *x393; /* { dg-error "" } */
|
||||
int short signed _Complex __int128 *x394; /* { dg-error "" } */
|
||||
int short unsigned _Complex __int128 *x395; /* { dg-error "" } */
|
||||
int short _Complex signed __int128 *x396; /* { dg-error "" } */
|
||||
int short _Complex unsigned __int128 *x397; /* { dg-error "" } */
|
||||
int long long signed __int128 *x398; /* { dg-error "" } */
|
||||
int long long unsigned __int128 *x399; /* { dg-error "" } */
|
||||
int long long _Complex __int128 *x400; /* { dg-error "" } */
|
||||
int long signed long __int128 *x401; /* { dg-error "" } */
|
||||
int long signed _Complex __int128 *x402; /* { dg-error "" } */
|
||||
int long unsigned long __int128 *x403; /* { dg-error "" } */
|
||||
int long unsigned _Complex __int128 *x404; /* { dg-error "" } */
|
||||
int long _Complex long __int128 *x405; /* { dg-error "" } */
|
||||
int long _Complex signed __int128 *x406; /* { dg-error "" } */
|
||||
int long _Complex unsigned __int128 *x407; /* { dg-error "" } */
|
||||
int signed short _Complex __int128 *x408; /* { dg-error "" } */
|
||||
int signed long long __int128 *x409; /* { dg-error "" } */
|
||||
int signed long _Complex __int128 *x410; /* { dg-error "" } */
|
||||
int signed _Complex short __int128 *x411; /* { dg-error "" } */
|
||||
int signed _Complex long __int128 *x412; /* { dg-error "" } */
|
||||
int unsigned short _Complex __int128 *x413; /* { dg-error "" } */
|
||||
int unsigned long long __int128 *x414; /* { dg-error "" } */
|
||||
int unsigned long _Complex __int128 *x415; /* { dg-error "" } */
|
||||
int unsigned _Complex short __int128 *x416; /* { dg-error "" } */
|
||||
int unsigned _Complex long __int128 *x417; /* { dg-error "" } */
|
||||
int _Complex short signed __int128 *x418; /* { dg-error "" } */
|
||||
int _Complex short unsigned __int128 *x419; /* { dg-error "" } */
|
||||
int _Complex long long __int128 *x420; /* { dg-error "" } */
|
||||
int _Complex long signed __int128 *x421; /* { dg-error "" } */
|
||||
int _Complex long unsigned __int128 *x422; /* { dg-error "" } */
|
||||
int _Complex signed short __int128 *x423; /* { dg-error "" } */
|
||||
int _Complex signed long __int128 *x424; /* { dg-error "" } */
|
||||
int _Complex unsigned short __int128 *x425; /* { dg-error "" } */
|
||||
int _Complex unsigned long __int128 *x426; /* { dg-error "" } */
|
||||
long int long signed __int128 *x427; /* { dg-error "" } */
|
||||
long int long unsigned __int128 *x428; /* { dg-error "" } */
|
||||
long int long _Complex __int128 *x429; /* { dg-error "" } */
|
||||
long int signed long __int128 *x430; /* { dg-error "" } */
|
||||
long int signed _Complex __int128 *x431; /* { dg-error "" } */
|
||||
long int unsigned long __int128 *x432; /* { dg-error "" } */
|
||||
long int unsigned _Complex __int128 *x433; /* { dg-error "" } */
|
||||
long int _Complex long __int128 *x434; /* { dg-error "" } */
|
||||
long int _Complex signed __int128 *x435; /* { dg-error "" } */
|
||||
long int _Complex unsigned __int128 *x436; /* { dg-error "" } */
|
||||
long long int signed __int128 *x437; /* { dg-error "" } */
|
||||
long long int unsigned __int128 *x438; /* { dg-error "" } */
|
||||
long long int _Complex __int128 *x439; /* { dg-error "" } */
|
||||
long long signed int __int128 *x440; /* { dg-error "" } */
|
||||
long long signed _Complex __int128 *x441; /* { dg-error "" } */
|
||||
long long unsigned int __int128 *x442; /* { dg-error "" } */
|
||||
long long unsigned _Complex __int128 *x443; /* { dg-error "" } */
|
||||
long long _Complex int __int128 *x444; /* { dg-error "" } */
|
||||
long long _Complex signed __int128 *x445; /* { dg-error "" } */
|
||||
long long _Complex unsigned __int128 *x446; /* { dg-error "" } */
|
||||
long signed int long __int128 *x447; /* { dg-error "" } */
|
||||
long signed int _Complex __int128 *x448; /* { dg-error "" } */
|
||||
long signed long int __int128 *x449; /* { dg-error "" } */
|
||||
long signed long _Complex __int128 *x450; /* { dg-error "" } */
|
||||
long signed _Complex int __int128 *x451; /* { dg-error "" } */
|
||||
long signed _Complex long __int128 *x452; /* { dg-error "" } */
|
||||
long unsigned int long __int128 *x453; /* { dg-error "" } */
|
||||
long unsigned int _Complex __int128 *x454; /* { dg-error "" } */
|
||||
long unsigned long int __int128 *x455; /* { dg-error "" } */
|
||||
long unsigned long _Complex __int128 *x456; /* { dg-error "" } */
|
||||
long unsigned _Complex int __int128 *x457; /* { dg-error "" } */
|
||||
long unsigned _Complex long __int128 *x458; /* { dg-error "" } */
|
||||
long _Complex int long __int128 *x459; /* { dg-error "" } */
|
||||
long _Complex int signed __int128 *x460; /* { dg-error "" } */
|
||||
long _Complex int unsigned __int128 *x461; /* { dg-error "" } */
|
||||
long _Complex long int __int128 *x462; /* { dg-error "" } */
|
||||
long _Complex long signed __int128 *x463; /* { dg-error "" } */
|
||||
long _Complex long unsigned __int128 *x464; /* { dg-error "" } */
|
||||
long _Complex signed int __int128 *x465; /* { dg-error "" } */
|
||||
long _Complex signed long __int128 *x466; /* { dg-error "" } */
|
||||
long _Complex unsigned int __int128 *x467; /* { dg-error "" } */
|
||||
long _Complex unsigned long __int128 *x468; /* { dg-error "" } */
|
||||
signed short int _Complex __int128 *x469; /* { dg-error "" } */
|
||||
signed short _Complex int __int128 *x470; /* { dg-error "" } */
|
||||
signed int short _Complex __int128 *x471; /* { dg-error "" } */
|
||||
signed int long long __int128 *x472; /* { dg-error "" } */
|
||||
signed int long _Complex __int128 *x473; /* { dg-error "" } */
|
||||
signed int _Complex short __int128 *x474; /* { dg-error "" } */
|
||||
signed int _Complex long __int128 *x475; /* { dg-error "" } */
|
||||
signed long int long __int128 *x476; /* { dg-error "" } */
|
||||
signed long int _Complex __int128 *x477; /* { dg-error "" } */
|
||||
signed long long int __int128 *x478; /* { dg-error "" } */
|
||||
signed long long _Complex __int128 *x479; /* { dg-error "" } */
|
||||
signed long _Complex int __int128 *x480; /* { dg-error "" } */
|
||||
signed long _Complex long __int128 *x481; /* { dg-error "" } */
|
||||
signed _Complex short int __int128 *x482; /* { dg-error "" } */
|
||||
signed _Complex int short __int128 *x483; /* { dg-error "" } */
|
||||
signed _Complex int long __int128 *x484; /* { dg-error "" } */
|
||||
signed _Complex long int __int128 *x485; /* { dg-error "" } */
|
||||
signed _Complex long long __int128 *x486; /* { dg-error "" } */
|
||||
unsigned short int _Complex __int128 *x487; /* { dg-error "" } */
|
||||
unsigned short _Complex int __int128 *x488; /* { dg-error "" } */
|
||||
unsigned int short _Complex __int128 *x489; /* { dg-error "" } */
|
||||
unsigned int long long __int128 *x490; /* { dg-error "" } */
|
||||
unsigned int long _Complex __int128 *x491; /* { dg-error "" } */
|
||||
unsigned int _Complex short __int128 *x492; /* { dg-error "" } */
|
||||
unsigned int _Complex long __int128 *x493; /* { dg-error "" } */
|
||||
unsigned long int long __int128 *x494; /* { dg-error "" } */
|
||||
unsigned long int _Complex __int128 *x495; /* { dg-error "" } */
|
||||
unsigned long long int __int128 *x496; /* { dg-error "" } */
|
||||
unsigned long long _Complex __int128 *x497; /* { dg-error "" } */
|
||||
unsigned long _Complex int __int128 *x498; /* { dg-error "" } */
|
||||
unsigned long _Complex long __int128 *x499; /* { dg-error "" } */
|
||||
unsigned _Complex short int __int128 *x500; /* { dg-error "" } */
|
||||
unsigned _Complex int short __int128 *x501; /* { dg-error "" } */
|
||||
unsigned _Complex int long __int128 *x502; /* { dg-error "" } */
|
||||
unsigned _Complex long int __int128 *x503; /* { dg-error "" } */
|
||||
unsigned _Complex long long __int128 *x504; /* { dg-error "" } */
|
||||
_Complex short int signed __int128 *x505; /* { dg-error "" } */
|
||||
_Complex short int unsigned __int128 *x506; /* { dg-error "" } */
|
||||
_Complex short signed int __int128 *x507; /* { dg-error "" } */
|
||||
_Complex short unsigned int __int128 *x508; /* { dg-error "" } */
|
||||
_Complex int short signed __int128 *x509; /* { dg-error "" } */
|
||||
_Complex int short unsigned __int128 *x510; /* { dg-error "" } */
|
||||
_Complex int long long __int128 *x511; /* { dg-error "" } */
|
||||
_Complex int long signed __int128 *x512; /* { dg-error "" } */
|
||||
_Complex int long unsigned __int128 *x513; /* { dg-error "" } */
|
||||
_Complex int signed short __int128 *x514; /* { dg-error "" } */
|
||||
_Complex int signed long __int128 *x515; /* { dg-error "" } */
|
||||
_Complex int unsigned short __int128 *x516; /* { dg-error "" } */
|
||||
_Complex int unsigned long __int128 *x517; /* { dg-error "" } */
|
||||
_Complex long int long __int128 *x518; /* { dg-error "" } */
|
||||
_Complex long int signed __int128 *x519; /* { dg-error "" } */
|
||||
_Complex long int unsigned __int128 *x520; /* { dg-error "" } */
|
||||
_Complex long long int __int128 *x521; /* { dg-error "" } */
|
||||
_Complex long long signed __int128 *x522; /* { dg-error "" } */
|
||||
_Complex long long unsigned __int128 *x523; /* { dg-error "" } */
|
||||
_Complex long signed int __int128 *x524; /* { dg-error "" } */
|
||||
_Complex long signed long __int128 *x525; /* { dg-error "" } */
|
||||
_Complex long unsigned int __int128 *x526; /* { dg-error "" } */
|
||||
_Complex long unsigned long __int128 *x527; /* { dg-error "" } */
|
||||
_Complex signed short int __int128 *x528; /* { dg-error "" } */
|
||||
_Complex signed int short __int128 *x529; /* { dg-error "" } */
|
||||
_Complex signed int long __int128 *x530; /* { dg-error "" } */
|
||||
_Complex signed long int __int128 *x531; /* { dg-error "" } */
|
||||
_Complex signed long long __int128 *x532; /* { dg-error "" } */
|
||||
_Complex unsigned short int __int128 *x533; /* { dg-error "" } */
|
||||
_Complex unsigned int short __int128 *x534; /* { dg-error "" } */
|
||||
_Complex unsigned int long __int128 *x535; /* { dg-error "" } */
|
||||
_Complex unsigned long int __int128 *x536; /* { dg-error "" } */
|
||||
_Complex unsigned long long __int128 *x537; /* { dg-error "" } */
|
||||
int long long signed _Complex __int128 *x538; /* { dg-error "" } */
|
||||
int long long unsigned _Complex __int128 *x539; /* { dg-error "" } */
|
||||
int long long _Complex signed __int128 *x540; /* { dg-error "" } */
|
||||
int long long _Complex unsigned __int128 *x541; /* { dg-error "" } */
|
||||
int long signed long _Complex __int128 *x542; /* { dg-error "" } */
|
||||
int long signed _Complex long __int128 *x543; /* { dg-error "" } */
|
||||
int long unsigned long _Complex __int128 *x544; /* { dg-error "" } */
|
||||
int long unsigned _Complex long __int128 *x545; /* { dg-error "" } */
|
||||
int long _Complex long signed __int128 *x546; /* { dg-error "" } */
|
||||
int long _Complex long unsigned __int128 *x547; /* { dg-error "" } */
|
||||
int long _Complex signed long __int128 *x548; /* { dg-error "" } */
|
||||
int long _Complex unsigned long __int128 *x549; /* { dg-error "" } */
|
||||
int signed long long _Complex __int128 *x550; /* { dg-error "" } */
|
||||
int signed long _Complex long __int128 *x551; /* { dg-error "" } */
|
||||
int signed _Complex long long __int128 *x552; /* { dg-error "" } */
|
||||
int unsigned long long _Complex __int128 *x553; /* { dg-error "" } */
|
||||
int unsigned long _Complex long __int128 *x554; /* { dg-error "" } */
|
||||
int unsigned _Complex long long __int128 *x555; /* { dg-error "" } */
|
||||
int _Complex long long signed __int128 *x556; /* { dg-error "" } */
|
||||
int _Complex long long unsigned __int128 *x557; /* { dg-error "" } */
|
||||
int _Complex long signed long __int128 *x558; /* { dg-error "" } */
|
||||
int _Complex long unsigned long __int128 *x559; /* { dg-error "" } */
|
||||
int _Complex signed long long __int128 *x560; /* { dg-error "" } */
|
||||
int _Complex unsigned long long __int128 *x561; /* { dg-error "" } */
|
||||
long int long signed _Complex __int128 *x562; /* { dg-error "" } */
|
||||
long int long unsigned _Complex __int128 *x563; /* { dg-error "" } */
|
||||
long int long _Complex signed __int128 *x564; /* { dg-error "" } */
|
||||
long int long _Complex unsigned __int128 *x565; /* { dg-error "" } */
|
||||
long int signed long _Complex __int128 *x566; /* { dg-error "" } */
|
||||
long int signed _Complex long __int128 *x567; /* { dg-error "" } */
|
||||
long int unsigned long _Complex __int128 *x568; /* { dg-error "" } */
|
||||
long int unsigned _Complex long __int128 *x569; /* { dg-error "" } */
|
||||
long int _Complex long signed __int128 *x570; /* { dg-error "" } */
|
||||
long int _Complex long unsigned __int128 *x571; /* { dg-error "" } */
|
||||
long int _Complex signed long __int128 *x572; /* { dg-error "" } */
|
||||
long int _Complex unsigned long __int128 *x573; /* { dg-error "" } */
|
||||
long long int signed _Complex __int128 *x574; /* { dg-error "" } */
|
||||
long long int unsigned _Complex __int128 *x575; /* { dg-error "" } */
|
||||
long long int _Complex signed __int128 *x576; /* { dg-error "" } */
|
||||
long long int _Complex unsigned __int128 *x577; /* { dg-error "" } */
|
||||
long long signed int _Complex __int128 *x578; /* { dg-error "" } */
|
||||
long long signed _Complex int __int128 *x579; /* { dg-error "" } */
|
||||
long long unsigned int _Complex __int128 *x580; /* { dg-error "" } */
|
||||
long long unsigned _Complex int __int128 *x581; /* { dg-error "" } */
|
||||
long long _Complex int signed __int128 *x582; /* { dg-error "" } */
|
||||
long long _Complex int unsigned __int128 *x583; /* { dg-error "" } */
|
||||
long long _Complex signed int __int128 *x584; /* { dg-error "" } */
|
||||
long long _Complex unsigned int __int128 *x585; /* { dg-error "" } */
|
||||
long signed int long _Complex __int128 *x586; /* { dg-error "" } */
|
||||
long signed int _Complex long __int128 *x587; /* { dg-error "" } */
|
||||
long signed long int _Complex __int128 *x588; /* { dg-error "" } */
|
||||
long signed long _Complex int __int128 *x589; /* { dg-error "" } */
|
||||
long signed _Complex int long __int128 *x590; /* { dg-error "" } */
|
||||
long signed _Complex long int __int128 *x591; /* { dg-error "" } */
|
||||
long unsigned int long _Complex __int128 *x592; /* { dg-error "" } */
|
||||
long unsigned int _Complex long __int128 *x593; /* { dg-error "" } */
|
||||
long unsigned long int _Complex __int128 *x594; /* { dg-error "" } */
|
||||
long unsigned long _Complex int __int128 *x595; /* { dg-error "" } */
|
||||
long unsigned _Complex int long __int128 *x596; /* { dg-error "" } */
|
||||
long unsigned _Complex long int __int128 *x597; /* { dg-error "" } */
|
||||
long _Complex int long signed __int128 *x598; /* { dg-error "" } */
|
||||
long _Complex int long unsigned __int128 *x599; /* { dg-error "" } */
|
||||
long _Complex int signed long __int128 *x600; /* { dg-error "" } */
|
||||
long _Complex int unsigned long __int128 *x601; /* { dg-error "" } */
|
||||
long _Complex long int signed __int128 *x602; /* { dg-error "" } */
|
||||
long _Complex long int unsigned __int128 *x603; /* { dg-error "" } */
|
||||
long _Complex long signed int __int128 *x604; /* { dg-error "" } */
|
||||
long _Complex long unsigned int __int128 *x605; /* { dg-error "" } */
|
||||
long _Complex signed int long __int128 *x606; /* { dg-error "" } */
|
||||
long _Complex signed long int __int128 *x607; /* { dg-error "" } */
|
||||
long _Complex unsigned int long __int128 *x608; /* { dg-error "" } */
|
||||
long _Complex unsigned long int __int128 *x609; /* { dg-error "" } */
|
||||
signed int long long _Complex __int128 *x610; /* { dg-error "" } */
|
||||
signed int long _Complex long __int128 *x611; /* { dg-error "" } */
|
||||
signed int _Complex long long __int128 *x612; /* { dg-error "" } */
|
||||
signed long int long _Complex __int128 *x613; /* { dg-error "" } */
|
||||
signed long int _Complex long __int128 *x614; /* { dg-error "" } */
|
||||
signed long long int _Complex __int128 *x615; /* { dg-error "" } */
|
||||
signed long long _Complex int __int128 *x616; /* { dg-error "" } */
|
||||
signed long _Complex int long __int128 *x617; /* { dg-error "" } */
|
||||
signed long _Complex long int __int128 *x618; /* { dg-error "" } */
|
||||
signed _Complex int long long __int128 *x619; /* { dg-error "" } */
|
||||
signed _Complex long int long __int128 *x620; /* { dg-error "" } */
|
||||
signed _Complex long long int __int128 *x621; /* { dg-error "" } */
|
||||
unsigned int long long _Complex __int128 *x622; /* { dg-error "" } */
|
||||
unsigned int long _Complex long __int128 *x623; /* { dg-error "" } */
|
||||
unsigned int _Complex long long __int128 *x624; /* { dg-error "" } */
|
||||
unsigned long int long _Complex __int128 *x625; /* { dg-error "" } */
|
||||
unsigned long int _Complex long __int128 *x626; /* { dg-error "" } */
|
||||
unsigned long long int _Complex __int128 *x627; /* { dg-error "" } */
|
||||
unsigned long long _Complex int __int128 *x628; /* { dg-error "" } */
|
||||
unsigned long _Complex int long __int128 *x629; /* { dg-error "" } */
|
||||
unsigned long _Complex long int __int128 *x630; /* { dg-error "" } */
|
||||
unsigned _Complex int long long __int128 *x631; /* { dg-error "" } */
|
||||
unsigned _Complex long int long __int128 *x632; /* { dg-error "" } */
|
||||
unsigned _Complex long long int __int128 *x633; /* { dg-error "" } */
|
||||
_Complex int long long signed __int128 *x634; /* { dg-error "" } */
|
||||
_Complex int long long unsigned __int128 *x635; /* { dg-error "" } */
|
||||
_Complex int long signed long __int128 *x636; /* { dg-error "" } */
|
||||
_Complex int long unsigned long __int128 *x637; /* { dg-error "" } */
|
||||
_Complex int signed long long __int128 *x638; /* { dg-error "" } */
|
||||
_Complex int unsigned long long __int128 *x639; /* { dg-error "" } */
|
||||
_Complex long int long signed __int128 *x640; /* { dg-error "" } */
|
||||
_Complex long int long unsigned __int128 *x641; /* { dg-error "" } */
|
||||
_Complex long int signed long __int128 *x642; /* { dg-error "" } */
|
||||
_Complex long int unsigned long __int128 *x643; /* { dg-error "" } */
|
||||
_Complex long long int signed __int128 *x644; /* { dg-error "" } */
|
||||
_Complex long long int unsigned __int128 *x645; /* { dg-error "" } */
|
||||
_Complex long long signed int __int128 *x646; /* { dg-error "" } */
|
||||
_Complex long long unsigned int __int128 *x647; /* { dg-error "" } */
|
||||
_Complex long signed int long __int128 *x648; /* { dg-error "" } */
|
||||
_Complex long signed long int __int128 *x649; /* { dg-error "" } */
|
||||
_Complex long unsigned int long __int128 *x650; /* { dg-error "" } */
|
||||
_Complex long unsigned long int __int128 *x651; /* { dg-error "" } */
|
||||
_Complex signed int long long __int128 *x652; /* { dg-error "" } */
|
||||
_Complex signed long int long __int128 *x653; /* { dg-error "" } */
|
||||
_Complex signed long long int __int128 *x654; /* { dg-error "" } */
|
||||
_Complex unsigned int long long __int128 *x655; /* { dg-error "" } */
|
||||
_Complex unsigned long int long __int128 *x656; /* { dg-error "" } */
|
||||
_Complex unsigned long long int __int128 *x657; /* { dg-error "" } */
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
// { dg-do compile { target int128 } }
|
||||
// { dg-options "" }
|
||||
|
||||
struct S {
|
||||
S(void) { m_i128 = 0; m_u128 = 0; }
|
||||
~S(void) { }
|
||||
__int128 get1 (void) { return m_i128; }
|
||||
unsigned __int128 get2 (void) { return m_u128; }
|
||||
void set1 (__int128 i) { m_i128 = i; }
|
||||
void set2 (unsigned int i) { m_u128 = 1; }
|
||||
__int128 m_i128;
|
||||
unsigned __int128 m_u128;
|
||||
};
|
||||
|
||||
struct S glb;
|
||||
|
||||
__int128 fo1 (void) { return glb.get1 (); }
|
||||
unsigned __int128 fo2 (void) { return glb.get2 (); }
|
||||
__int128 fo3 (__int128 i) { __int128 v = fo1 (); glb.set1 (i); return v; }
|
||||
unsigned __int128 fo4 (unsigned __int128 i)
|
||||
{
|
||||
unsigned __int128 v = fo2 (); glb.set2 (i);
|
||||
return v;
|
||||
}
|
||||
|
||||
__int128 fo5 (__int128 i)
|
||||
{
|
||||
return fo3 (i);
|
||||
}
|
||||
|
||||
__int128 fo5 (unsigned __int128 i)
|
||||
{
|
||||
return (__int128) fo4 (i);
|
||||
}
|
||||
|
||||
|
||||
// { dg-final { scan-assembler "\n_?_Z3fo1v\[: \t\n\]" } }
|
||||
// { dg-final { scan-assembler "\n_?_Z3fo2v\[: \t\n\]" } }
|
||||
// { dg-final { scan-assembler "\n_?_Z3fo3n\[: \t\n\]" } }
|
||||
// { dg-final { scan-assembler "\n_?_Z3fo4o\[: \t\n\]" } }
|
||||
// { dg-final { scan-assembler "\n_?_Z3fo5n\[: \t\n\]" } }
|
||||
// { dg-final { scan-assembler "\n_?_Z3fo5o\[: \t\n\]" } }
|
||||
|
||||
|
|
@ -3,7 +3,11 @@
|
|||
|
||||
// Test cast to int
|
||||
|
||||
#define unsigned
|
||||
__extension__ typedef __SIZE_TYPE__ ssize_t;
|
||||
#undef unsigned
|
||||
|
||||
const int n4 = static_cast<const int>(nullptr); // { dg-error "invalid static_cast " }
|
||||
const short int n5 = reinterpret_cast<short int>(nullptr); // { dg-error "loses precision" }
|
||||
const long int n6 = reinterpret_cast<long int>(nullptr);
|
||||
const long int n7 = (long int)nullptr;
|
||||
const ssize_t n6 = reinterpret_cast<ssize_t>(nullptr);
|
||||
const ssize_t n7 = (ssize_t)nullptr;
|
||||
|
|
|
|||
|
|
@ -1,6 +1,14 @@
|
|||
/* { dg-options "-Wno-overflow" } */
|
||||
|
||||
#ifndef __SIZEOF_INT128__
|
||||
#define UNACCEPT 0xffffffffffffffffLL
|
||||
#else
|
||||
#define UNACCEPT ~((unsigned __int128) 0)
|
||||
#endif
|
||||
|
||||
enum test {
|
||||
acceptable = -1,
|
||||
unacceptable = 0xffffffffffffffffLL
|
||||
unacceptable = UNACCEPT
|
||||
}; // { dg-error "" }
|
||||
|
||||
enum test t = acceptable, u = unacceptable;
|
||||
|
|
|
|||
|
|
@ -1,11 +1,15 @@
|
|||
/* { dg-do compile } */
|
||||
#include <limits.h>
|
||||
|
||||
#ifdef _WIN64
|
||||
#define DIM ULLONG_MAX>>1
|
||||
#else
|
||||
#ifdef __LP64__
|
||||
#define DIM UINT_MAX>>1
|
||||
#else
|
||||
#define DIM USHRT_MAX>>1
|
||||
#endif
|
||||
#endif
|
||||
|
||||
int
|
||||
sub (int *a)
|
||||
|
|
|
|||
|
|
@ -2,10 +2,14 @@
|
|||
|
||||
/* { dg-do compile } */
|
||||
|
||||
#define unsigned
|
||||
__extension__ typedef __SIZE_TYPE__ ssize_t;
|
||||
#undef unsigned
|
||||
|
||||
struct sockaddr_un {
|
||||
char sun_path[1];
|
||||
};
|
||||
const unsigned SI_SUN_HEAD_LEN = (long)(((struct sockaddr_un *)0)->sun_path);
|
||||
const unsigned SI_SUN_HEAD_LEN = (ssize_t)(((struct sockaddr_un *)0)->sun_path);
|
||||
int SiGetPeerName ()
|
||||
{
|
||||
return SI_SUN_HEAD_LEN;
|
||||
|
|
|
|||
|
|
@ -5,6 +5,7 @@
|
|||
|
||||
void g(int) {}
|
||||
void g(long) {}
|
||||
void g(long long) {}
|
||||
extern void g(void*);
|
||||
|
||||
template <int I>
|
||||
|
|
@ -21,6 +22,9 @@ void l(int) {}
|
|||
template <>
|
||||
void l(long) {}
|
||||
|
||||
template <>
|
||||
void l(long long) {}
|
||||
|
||||
int main()
|
||||
{
|
||||
int i = NULL; // { dg-warning "" } converting NULL to non-pointer type
|
||||
|
|
|
|||
|
|
@ -5,6 +5,7 @@
|
|||
|
||||
void g(int) {}
|
||||
void g(long) {}
|
||||
void g(long long) {}
|
||||
extern void g(void*);
|
||||
|
||||
template <int I>
|
||||
|
|
@ -21,6 +22,9 @@ void l(int) {}
|
|||
template <>
|
||||
void l(long) {}
|
||||
|
||||
template <>
|
||||
void l(long long) {}
|
||||
|
||||
int main()
|
||||
{
|
||||
int i = NULL; // converting NULL to non-pointer type
|
||||
|
|
|
|||
|
|
@ -9,9 +9,9 @@ void use_longlong ()
|
|||
{
|
||||
unsigned long long x1, x2, x3; // { dg-error "ISO C\\+\\+ 1998 does not support 'long long'" }
|
||||
// make sure we error with hex, decimal and octal
|
||||
x1 = 0x1b27da572ef3cd86; // { dg-error "integer constant is too large for 'long' type" "long long" { target ilp32 } }
|
||||
x2 = 1956772631100509574; // { dg-error "integer constant is too large for 'long' type" "long long" { target ilp32 } }
|
||||
x3 = 0154476645345674746606; // { dg-error "integer constant is too large for 'long' type" "long long" { target ilp32 } }
|
||||
x1 = 0x1b27da572ef3cd86; // { dg-error "integer constant is too large for 'long' type" "long long" { target { llp64 || ilp32 } } }
|
||||
x2 = 1956772631100509574; // { dg-error "integer constant is too large for 'long' type" "long long" { target { llp64 || ilp32 } } }
|
||||
x3 = 0154476645345674746606; // { dg-error "integer constant is too large for 'long' type" "long long" { target { llp64 || ilp32 } } }
|
||||
}
|
||||
|
||||
void use_longlong2 ()
|
||||
|
|
|
|||
|
|
@ -9,9 +9,9 @@ void use_longlong ()
|
|||
{
|
||||
unsigned long long x1, x2, x3; // { dg-warning "ISO C\\+\\+ 1998 does not support 'long long'" }
|
||||
// make sure we warn with hex, decimal and octal
|
||||
x1 = 0x1b27da572ef3cd86; // { dg-warning "integer constant is too large for 'long' type" "long long" { target ilp32 } }
|
||||
x2 = 1956772631100509574; // { dg-warning "integer constant is too large for 'long' type" "long long" { target ilp32 } }
|
||||
x3 = 0154476645345674746606; // { dg-warning "integer constant is too large for 'long' type" "long long" { target ilp32 } }
|
||||
x1 = 0x1b27da572ef3cd86; // { dg-warning "integer constant is too large for 'long' type" "long long" { target { llp64 || ilp32 } } }
|
||||
x2 = 1956772631100509574; // { dg-warning "integer constant is too large for 'long' type" "long long" { target { llp64 || ilp32 } } }
|
||||
x3 = 0154476645345674746606; // { dg-warning "integer constant is too large for 'long' type" "long long" { target { llp64 || ilp32 } } }
|
||||
}
|
||||
|
||||
void use_longlong2 ()
|
||||
|
|
|
|||
|
|
@ -1500,6 +1500,19 @@ proc check_effective_target_vect_intfloat_cvt { } {
|
|||
return $et_vect_intfloat_cvt_saved
|
||||
}
|
||||
|
||||
#Return 1 if we're supporting __int128 for target, 0 otherwise.
|
||||
|
||||
proc check_effective_target_int128 { } {
|
||||
return [check_no_compiler_messages int128 object {
|
||||
int dummy[
|
||||
#ifndef __SIZEOF_INT128__
|
||||
-1
|
||||
#else
|
||||
1
|
||||
#endif
|
||||
];
|
||||
}]
|
||||
}
|
||||
|
||||
# Return 1 if the target supports unsigned int->float conversion
|
||||
#
|
||||
|
|
|
|||
15
gcc/tree.c
15
gcc/tree.c
|
|
@ -8709,6 +8709,9 @@ make_or_reuse_type (unsigned size, int unsignedp)
|
|||
if (size == LONG_LONG_TYPE_SIZE)
|
||||
return (unsignedp ? long_long_unsigned_type_node
|
||||
: long_long_integer_type_node);
|
||||
if (size == 128 && int128_integer_type_node)
|
||||
return (unsignedp ? int128_unsigned_type_node
|
||||
: int128_integer_type_node);
|
||||
|
||||
if (unsignedp)
|
||||
return make_unsigned_type (size);
|
||||
|
|
@ -8824,7 +8827,17 @@ build_common_tree_nodes (bool signed_char)
|
|||
long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
|
||||
long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
|
||||
long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
|
||||
|
||||
#if HOST_BITS_PER_WIDE_INT >= 64
|
||||
/* TODO: This isn't correct, but as logic depends at the moment on
|
||||
host's instead of target's wide-integer.
|
||||
If there is a target not supporting TImode, but has an 128-bit
|
||||
integer-scalar register, this target check needs to be adjusted. */
|
||||
if (targetm.scalar_mode_supported_p (TImode))
|
||||
{
|
||||
int128_integer_type_node = make_signed_type (128);
|
||||
int128_unsigned_type_node = make_unsigned_type (128);
|
||||
}
|
||||
#endif
|
||||
/* Define a boolean type. This type only represents boolean values but
|
||||
may be larger than char depending on the value of BOOL_TYPE_SIZE.
|
||||
Front ends which want to override this size (i.e. Java) can redefine
|
||||
|
|
|
|||
|
|
@ -3845,6 +3845,8 @@ enum integer_type_kind
|
|||
itk_unsigned_long,
|
||||
itk_long_long,
|
||||
itk_unsigned_long_long,
|
||||
itk_int128,
|
||||
itk_unsigned_int128,
|
||||
itk_none
|
||||
};
|
||||
|
||||
|
|
@ -3865,6 +3867,8 @@ extern GTY(()) tree integer_types[itk_none];
|
|||
#define long_unsigned_type_node integer_types[itk_unsigned_long]
|
||||
#define long_long_integer_type_node integer_types[itk_long_long]
|
||||
#define long_long_unsigned_type_node integer_types[itk_unsigned_long_long]
|
||||
#define int128_integer_type_node integer_types[itk_int128]
|
||||
#define int128_unsigned_type_node integer_types[itk_unsigned_int128]
|
||||
|
||||
/* Set to the default thread-local storage (tls) model to use. */
|
||||
|
||||
|
|
|
|||
|
|
@ -1,3 +1,8 @@
|
|||
2ß1ß-05-26 Kai Tietz <kai.tietz@onevision.com>
|
||||
|
||||
* testsuite/demangle-expected: Add tests for __int128
|
||||
and unsigned __int128 types.
|
||||
|
||||
2010-05-06 Magnus Fromreide <magfr@lysator.liu.se>
|
||||
Jason Merrill <jason@redhat.com>
|
||||
|
||||
|
|
|
|||
|
|
@ -3220,6 +3220,16 @@ _26_GLOBAL_$N$_tmp_n.iilg4Gya$app_instance
|
|||
{anonymous}::app_instance
|
||||
{anonymous}::app_instance
|
||||
#
|
||||
--format=gnu-v3 --no-params
|
||||
_Z3fo5n
|
||||
fo5(__int128)
|
||||
fo5
|
||||
#
|
||||
--format=gnu-v3 --no-params
|
||||
_Z3fo5o
|
||||
fo5(unsigned __int128)
|
||||
fo5
|
||||
#
|
||||
--format=java
|
||||
_ZN4java3awt10ScrollPane7addImplEPNS0_9ComponentEPNS_4lang6ObjectEi
|
||||
java.awt.ScrollPane.addImpl(java.awt.Component, java.lang.Object, int)
|
||||
|
|
|
|||
Loading…
Reference in New Issue