From patchwork Sat Nov 16 14:05:58 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Richard Sandiford X-Patchwork-Id: 1196123 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=209.132.180.131; helo=sourceware.org; envelope-from=gcc-patches-return-513791-incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=arm.com Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.b="U6nU2TwV"; dkim-atps=neutral Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 47FcT835nfz9sP3 for ; Sun, 17 Nov 2019 01:06:18 +1100 (AEDT) DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:from :to:cc:subject:date:message-id:mime-version:content-type; q=dns; s=default; b=yZ2ZIzcSHNyQfk4t6GH8pJkhuiCiJL9SduaggiJG4nmIgc0qRT r1N6stDwmKvE9jkiKs3lfIr4dZhMnp7kV+GY8Dc8a0yvY4qmHhBEwiT3QazF/Bfo WuwHYHfAgRmxwB+R8nfJLoF9xjYZuhZCRACtTMziPLGhITYoTedKDfrUE= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:from :to:cc:subject:date:message-id:mime-version:content-type; s= default; bh=wWh9PK5NKIkRYyoKYwPj8QvznPY=; b=U6nU2TwVS2ksppj5Pzzv KtFNurnR2sUcW6kX1cIqV3+Onnm2oFOgDOGEy84coyXj1QtqcUGXQuGWukYIfUUa zoezPoyxcl7EyCeVOnIpKpnBQelJBDln9Z2mqIJTbTFVivOmd1e62QduTTifjgtW UBeM2UBk7yJKeo75iBLecgU= Received: (qmail 19815 invoked by alias); 16 Nov 2019 14:06:08 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Received: (qmail 19797 invoked by uid 89); 16 Nov 2019 14:06:08 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-11.8 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, KAM_ASCII_DIVIDERS, KAM_SHORT, SPF_PASS autolearn=ham version=3.3.1 spammy=1418, Casting, intention X-HELO: foss.arm.com Received: from foss.arm.com (HELO foss.arm.com) (217.140.110.172) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Sat, 16 Nov 2019 14:06:02 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 53D2130E; Sat, 16 Nov 2019 06:06:00 -0800 (PST) Received: from localhost (e121540-lin.manchester.arm.com [10.32.98.126]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 78DB93F6C4; Sat, 16 Nov 2019 06:05:59 -0800 (PST) From: Richard Sandiford To: gcc-patches@gcc.gnu.org Mail-Followup-To: gcc-patches@gcc.gnu.org, jason@redhat.com, nathan@acm.org, richard.sandiford@arm.com Cc: jason@redhat.com, nathan@acm.org Subject: [C++] Pass type uses through the verify_type_context hook Date: Sat, 16 Nov 2019 14:05:58 +0000 Message-ID: User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/26.1 (gnu/linux) MIME-Version: 1.0 X-IsSubscribed: yes This patch makes the C++ frontend work with the verify_type_context hook [https://gcc.gnu.org/ml/gcc-patches/2019-11/msg00942.html]. We need some new type contexts for features that don't exist in C, but otherwise the patch is very similar to the C one. TCTX_CAPTURE_BY_COPY could really be treated as an instance of TCTX_FIELD, but the error message is better if we split it out. Tested on aarch64-linux-gnu and x86_64-linux-gnu. OK to install? Richard 2019-11-16 Richard Sandiford gcc/ * target.h (TCTX_ALLOCATION, TCTX_DEALLOCATION, TCTX_EXCEPTIONS) (TCTX_CAPTURE_BY_COPY): New type_context_kinds. * config/aarch64/aarch64-sve-builtins.cc (verify_type_context): Handle them. gcc/cp/ * decl.c (start_decl_1): Use verify_type_context to check whether the target allows variables of a particular type to have static or thread-local storage duration. (check_array_initializer): Use verify_type_context to check whether the target allows a particular type to be used as an array element. (create_array_type_for_decl): Likewise. (cp_finish_decl): Use verify_type_context to check whether the target allows static member variables of a particular type. (grokdeclarator): Likewise. Also use verify_type_context to check whether the target allows non-static member variables of a particular type. * except.c: Include target.h. (is_admissible_throw_operand_or_catch_parameter): Use verify_type_context to check whether the target allows particular types to be thrown and caught. * typeck2.c (add_exception_specifier): Likewise. * init.c (build_new_1): Use verify_type_context to check whether the target allows particular types to be dynamically allocated. (build_vec_delete_1, build_delete): Use verify_type_context to check whether the target allows particular types to be deleted. * lambda.c (add_capture): Use verify_type_context to check whether the target allows particular types to be captured by copy. * pt.c: Include target.h. (instantiate_class_template_1): Use verify_type_context to check whether the target allows non-static member variables of a particular type. * typeck.c (cxx_alignof_expr): Use verify_type_context to check whether the target allows the alignment of a particular type to be measured. (pointer_diff, cp_build_unary_op): Use verify_type_context to check whether the target allows arithmetic involving pointers to particular types. gcc/testsuite/ * g++.dg/ext/sve-sizeless-1.C: New test. * g++.dg/ext/sve-sizeless-2.C: Likewise. Index: gcc/target.h =================================================================== --- gcc/target.h 2019-11-16 14:03:08.992929894 +0000 +++ gcc/target.h 2019-11-16 14:03:16.436877583 +0000 @@ -249,7 +249,19 @@ enum type_context_kind { /* Adding to or subtracting from a pointer to T, or computing the difference between two pointers when one of them is a pointer to T. */ - TCTX_POINTER_ARITH + TCTX_POINTER_ARITH, + + /* Dynamically allocating objects of type T. */ + TCTX_ALLOCATION, + + /* Dynamically deallocating objects of type T. */ + TCTX_DEALLOCATION, + + /* Throwing or catching an object of type T. */ + TCTX_EXCEPTIONS, + + /* Capturing objects of type T by value in a closure. */ + TCTX_CAPTURE_BY_COPY }; extern bool verify_type_context (location_t, type_context_kind, const_tree, Index: gcc/config/aarch64/aarch64-sve-builtins.cc =================================================================== --- gcc/config/aarch64/aarch64-sve-builtins.cc 2019-11-16 14:03:08.972930034 +0000 +++ gcc/config/aarch64/aarch64-sve-builtins.cc 2019-11-16 14:03:16.420877696 +0000 @@ -3341,6 +3341,26 @@ verify_type_context (location_t loc, typ if (!silent_p) error_at (loc, "array elements cannot have SVE type %qT", type); return false; + + case TCTX_ALLOCATION: + if (!silent_p) + error_at (loc, "cannot allocate objects with SVE type %qT", type); + return false; + + case TCTX_DEALLOCATION: + if (!silent_p) + error_at (loc, "cannot delete objects with SVE type %qT", type); + return false; + + case TCTX_EXCEPTIONS: + if (!silent_p) + error_at (loc, "cannot throw or catch SVE type %qT", type); + return false; + + case TCTX_CAPTURE_BY_COPY: + if (!silent_p) + error_at (loc, "capture by copy of SVE type %qT", type); + return false; } gcc_unreachable (); } Index: gcc/cp/decl.c =================================================================== --- gcc/cp/decl.c 2019-11-16 14:03:01.000000000 +0000 +++ gcc/cp/decl.c 2019-11-16 14:03:16.424877668 +0000 @@ -5464,6 +5464,13 @@ start_decl_1 (tree decl, bool initialize cp_apply_type_quals_to_decl (cp_type_quals (type), decl); } + if (is_global_var (decl)) + { + type_context_kind context = (DECL_THREAD_LOCAL_P (decl) + ? TCTX_THREAD_STORAGE + : TCTX_STATIC_STORAGE); + verify_type_context (input_location, context, TREE_TYPE (decl)); + } if (initialized) /* Is it valid for this decl to have an initializer at all? */ { @@ -6499,6 +6506,12 @@ check_array_initializer (tree decl, tree error ("elements of array %q#T have incomplete type", type); return true; } + + location_t loc = (decl && DECL_P (decl) + ? DECL_SOURCE_LOCATION (decl) : input_location); + if (!verify_type_context (loc, TCTX_ARRAY_ELEMENT, element_type)) + return true; + /* A compound literal can't have variable size. */ if (init && !decl && ((COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type))) @@ -7407,6 +7420,8 @@ cp_finish_decl (tree decl, tree init, bo if (VAR_P (decl) && DECL_CLASS_SCOPE_P (decl) + && verify_type_context (DECL_SOURCE_LOCATION (decl), + TCTX_STATIC_STORAGE, type) && DECL_INITIALIZED_IN_CLASS_P (decl)) check_static_variable_definition (decl, type); @@ -10475,6 +10490,10 @@ create_array_type_for_decl (tree name, t break; } + if (!verify_type_context (name ? loc : input_location, + TCTX_ARRAY_ELEMENT, type)) + return error_mark_node; + /* [dcl.array] The constant expressions that specify the bounds of the arrays @@ -13179,6 +13198,14 @@ grokdeclarator (const cp_declarator *dec decl = NULL_TREE; } } + else if (!verify_type_context (input_location, + staticp + ? TCTX_STATIC_STORAGE + : TCTX_FIELD, type)) + { + type = error_mark_node; + decl = NULL_TREE; + } else { if (friendp) Index: gcc/cp/except.c =================================================================== --- gcc/cp/except.c 2019-11-16 14:03:01.000000000 +0000 +++ gcc/cp/except.c 2019-11-16 14:03:16.424877668 +0000 @@ -29,6 +29,7 @@ the Free Software Foundation; either ver #include "trans-mem.h" #include "attribs.h" #include "tree-iterator.h" +#include "target.h" static void push_eh_cleanup (tree); static tree prepare_eh_type (tree); @@ -927,6 +928,14 @@ is_admissible_throw_operand_or_catch_par if (!complete_ptr_ref_or_void_ptr_p (type, expr)) return false; + else if (!verify_type_context (input_location, TCTX_EXCEPTIONS, type)) + return false; + + else if (TYPE_REF_P (type) + && !verify_type_context (input_location, TCTX_EXCEPTIONS, + TREE_TYPE (type))) + return false; + /* 10.4/3 An abstract class shall not be used as a parameter type, as a function return type or as type of an explicit conversion. */ Index: gcc/cp/typeck2.c =================================================================== --- gcc/cp/typeck2.c 2019-11-16 14:03:01.000000000 +0000 +++ gcc/cp/typeck2.c 2019-11-16 14:03:16.436877583 +0000 @@ -33,6 +33,7 @@ the Free Software Foundation; either ver #include "varasm.h" #include "intl.h" #include "gcc-rich-location.h" +#include "target.h" static tree process_init_constructor (tree type, tree init, int nested, int flags, @@ -2385,6 +2386,9 @@ add_exception_specifier (tree list, tree ok = true; else if (processing_template_decl) ok = true; + else if (!verify_type_context (input_location, TCTX_EXCEPTIONS, core, + !(complain & tf_error))) + return error_mark_node; else { ok = true; Index: gcc/cp/init.c =================================================================== --- gcc/cp/init.c 2019-11-16 14:03:01.000000000 +0000 +++ gcc/cp/init.c 2019-11-16 14:03:16.428877639 +0000 @@ -3058,6 +3058,10 @@ build_new_1 (vec **placemen complain); } + if (!verify_type_context (input_location, TCTX_ALLOCATION, elt_type, + !(complain & tf_error))) + return error_mark_node; + if (variably_modified_type_p (elt_type, NULL_TREE) && (complain & tf_error)) { error ("variably modified type not allowed in new-expression"); @@ -3942,6 +3946,10 @@ build_vec_delete_1 (tree base, tree maxi if (base == error_mark_node || maxindex == error_mark_node) return error_mark_node; + if (!verify_type_context (input_location, TCTX_DEALLOCATION, type, + !(complain & tf_error))) + return error_mark_node; + if (!COMPLETE_TYPE_P (type)) { if (complain & tf_warning) @@ -4827,6 +4835,11 @@ build_delete (tree otype, tree addr, spe if (!VOID_TYPE_P (type)) { complete_type (type); + if (deleting + && !verify_type_context (input_location, TCTX_DEALLOCATION, type, + !(complain & tf_error))) + return error_mark_node; + if (!COMPLETE_TYPE_P (type)) { if (complain & tf_warning) Index: gcc/cp/lambda.c =================================================================== --- gcc/cp/lambda.c 2019-11-16 14:03:01.000000000 +0000 +++ gcc/cp/lambda.c 2019-11-16 14:03:16.428877639 +0000 @@ -30,6 +30,7 @@ #include "tree-iterator.h" #include "toplev.h" #include "gimplify.h" +#include "target.h" /* Constructor for a lambda expression. */ @@ -579,6 +580,9 @@ add_capture (tree lambda, tree id, tree cxx_incomplete_type_inform (type); return error_mark_node; } + else if (!verify_type_context (input_location, + TCTX_CAPTURE_BY_COPY, type)) + return error_mark_node; } } Index: gcc/cp/pt.c =================================================================== --- gcc/cp/pt.c 2019-11-16 14:03:01.000000000 +0000 +++ gcc/cp/pt.c 2019-11-16 14:03:16.432877611 +0000 @@ -42,6 +42,7 @@ the Free Software Foundation; either ver #include "gimplify.h" #include "gcc-rich-location.h" #include "selftest.h" +#include "target.h" /* The type of functions taking a tree, and some additional data, and returning an int. */ @@ -11766,6 +11767,9 @@ instantiate_class_template_1 (tree type) error ("flexible array member %qD in union", r); TREE_TYPE (r) = error_mark_node; } + else if (!verify_type_context (input_location, + TCTX_FIELD, rtype)) + TREE_TYPE (r) = error_mark_node; } /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE, Index: gcc/cp/typeck.c =================================================================== --- gcc/cp/typeck.c 2019-11-16 14:03:01.000000000 +0000 +++ gcc/cp/typeck.c 2019-11-16 14:03:16.436877583 +0000 @@ -1820,7 +1820,14 @@ cxx_alignof_expr (tree e, tsubst_flags_t e = mark_type_use (e); - if (VAR_P (e)) + if (!verify_type_context (input_location, TCTX_ALIGNOF, TREE_TYPE (e), + !(complain & tf_error))) + { + if (!(complain & tf_error)) + return error_mark_node; + t = size_one_node; + } + else if (VAR_P (e)) t = size_int (DECL_ALIGN_UNIT (e)); else if (bitfield_p (e)) { @@ -5764,6 +5771,13 @@ pointer_diff (location_t loc, tree op0, else return error_mark_node; } + else if (!verify_type_context (loc, TCTX_POINTER_ARITH, + TREE_TYPE (TREE_TYPE (op0)), + !(complain & tf_error)) + || !verify_type_context (loc, TCTX_POINTER_ARITH, + TREE_TYPE (TREE_TYPE (op1)), + !(complain & tf_error))) + return error_mark_node; /* Determine integer type result of the subtraction. This will usually be the same as the result type (ptrdiff_t), but may need to be a wider @@ -6549,6 +6563,10 @@ cp_build_unary_op (enum tree_code code, else return error_mark_node; } + else if (!verify_type_context (location, TCTX_POINTER_ARITH, + TREE_TYPE (argtype), + !(complain & tf_error))) + return error_mark_node; inc = cxx_sizeof_nowarn (TREE_TYPE (argtype)); } Index: gcc/testsuite/g++.dg/ext/sve-sizeless-1.C =================================================================== --- /dev/null 2019-09-17 11:41:18.176664108 +0100 +++ gcc/testsuite/g++.dg/ext/sve-sizeless-1.C 2019-11-16 14:03:16.436877583 +0000 @@ -0,0 +1,418 @@ +// { dg-do compile { target aarch64*-*-* } } +// { dg-options "-Wclass-memaccess" } + +typedef __SIZE_TYPE__ size_t; +inline void *operator new (size_t, void *__p) throw() { return __p; } + +#include + +typedef signed char int8x32_t __attribute__((__vector_size__ (32))); + +// Sizeless objects with global scope. + +svint8_t global_sve_sc; // { dg-error {SVE type 'svint8_t' does not have a fixed size} } +static svint8_t local_sve_sc; // { dg-error {SVE type 'svint8_t' does not have a fixed size} } +extern svint8_t extern_sve_sc; // { dg-error {SVE type 'svint8_t' does not have a fixed size} } +__thread svint8_t tls_sve_sc; // { dg-error {variables of type 'svint8_t' cannot have thread-local storage duration} } + +// Sizeless arrays. + +typedef svint8_t array_type[2]; // { dg-error {array elements cannot have SVE type 'svint8_t'} } +extern svint8_t extern_array[]; // { dg-error {array elements cannot have SVE type 'svint8_t'} } + +// Sizeless member variables. + +struct struct1 { + svint8_t a; // { dg-error {member variables cannot have SVE type 'svint8_t'} } +}; + +union union1 { + svint8_t a; // { dg-error {member variables cannot have SVE type 'svint8_t'} } +}; + +#if __cplusplus >= 201103L +struct static_sve_sc { + static svint8_t sve_sc1 = {}; // { dg-error {SVE type 'svint8_t' does not have a fixed size} "" { target c++11 } } +}; +#endif + +// Sizeless member variables in templated structures. + +template +struct templated_struct1 { + svint8_t a; // { dg-error {member variables cannot have SVE type 'svint8_t'} } +}; + +template +struct templated_struct2 { + T a; // { dg-error {member variables cannot have SVE type '(svint8_t|__SVInt8_t)'} } +}; + +template class templated_struct2; + +template +struct templated_struct3 { + T &a; +}; + +template class templated_struct3; + +#if __cplusplus >= 201103L +template +struct templated_struct4 { + static T a; // { dg-error {SVE type '(svint8_t|__SVInt8_t)' does not have a fixed size} "" { target c++11 } } + static T b = {}; // { dg-error {SVE type '(svint8_t|__SVInt8_t)' does not have a fixed size} "" { target c++11 } } +}; + +template class templated_struct4; +#endif + +template struct templated_struct5 : T {}; // { dg-error {base type '[^']*' fails to be a struct or class type} } +template class templated_struct5; + +#if __cplusplus >= 201103L +template using typedef_sizeless1 = svint8_t; +template using typedef_sizeless1 = svint8_t; // { dg-error {redefinition of 'template using typedef_sizeless1 = svint8_t'} "" { target c++11 } } +template using array = T[2]; +#endif + +// Pointers to sizeless types. + +svint8_t *global_sve_sc_ptr; + +// Sizeless arguments and return values. + +void ext_consume_sve_sc (svint8_t); +void ext_consume_const_int_ref (const int &); +void ext_consume_varargs (int, ...); +svint8_t ext_produce_sve_sc (); + +// Sizeless types in throw specifications. + +#if __cplusplus < 201103L +void thrower1 () throw (svint8_t); // { dg-error {cannot throw or catch SVE type 'svint8_t'} "" { target c++98_only } } +void thrower2 () throw (svint8_t); // { dg-error {cannot throw or catch SVE type 'svint8_t'} "" { target c++98_only } } +void thrower3 () throw (svint8_t); // { dg-error {cannot throw or catch SVE type 'svint8_t'} "" { target c++98_only } } +#endif + +// Main tests for statements and expressions. + +void +statements (int n) +{ + // Local declarations. + + svint8_t sve_sc1, sve_sc2; + volatile svint8_t volatile_sve_sc1; + int8x32_t gnu_sc1; + svint16_t sve_sh1; + + // Layout queries. + + sizeof (svint8_t); // { dg-error {SVE type 'svint8_t' does not have a fixed size} } + sizeof (sve_sc1); // { dg-error {SVE type 'svint8_t' does not have a fixed size} } + sizeof (ext_produce_sve_sc ()); // { dg-error {SVE type 'svint8_t' does not have a fixed size} } + __alignof (svint8_t); // { dg-error {SVE type 'svint8_t' does not have a defined alignment} } + __alignof (sve_sc1); // { dg-error {SVE type 'svint8_t' does not have a defined alignment} } + __alignof (ext_produce_sve_sc ()); // { dg-error {SVE type 'svint8_t' does not have a defined alignment} } + +#if __cplusplus >= 201103L + array foo = {}; // { dg-error {array elements cannot have SVE type '(svint8_t|__SVInt8_t)'} "" { target c++11 } } +#endif + + // Initialization. + + int init_int1 = sve_sc1; // { dg-error {cannot convert 'svint8_t' to 'int' in initialization} } + int init_int2 = { sve_sc1 }; // { dg-error {cannot convert 'svint8_t' to 'int' in initialization} } + + svint8_t init_sve_sc1 (sve_sc1); + svint8_t init_sve_sc2 (sve_sh1); // { dg-error {cannot convert 'svint16_t' to 'svint8_t'} } + svint8_t init_sve_sc3 = sve_sc1; + svint8_t init_sve_sc4 = sve_sh1; // { dg-error {cannot convert 'svint16_t' to 'svint8_t'} } + svint8_t init_sve_sc5 = {}; + svint8_t init_sve_sc6 = { sve_sc1 }; + svint8_t init_sve_sc7 = { sve_sh1 }; // { dg-error {cannot convert 'svint16_t' to 'svint8_t'} } + + // Constructor calls. + + (0, svint8_t ()); + + // Lvalue reference binding + + svint8_t &lvalue_ref_sve_sc1 = sve_sc1; + svint8_t &lvalue_ref_sve_sc2 = ext_produce_sve_sc (); // { dg-error {cannot bind non-const lvalue reference of type 'svint8_t&' to an rvalue of type 'svint8_t'} } + svint8_t &lvalue_ref_sve_sc3 = sve_sh1; // { dg-error {invalid initialization of reference of type 'svint8_t&' from expression of type 'svint16_t'} } + + const svint8_t &const_lvalue_ref_sve_sc1 = sve_sc1; + const svint8_t &const_lvalue_ref_sve_sc2 = ext_produce_sve_sc (); + const svint8_t &const_lvalue_ref_sve_sc3 = sve_sh1; // { dg-error {invalid initialization of reference of type 'const svint8_t&' from expression of type 'svint16_t'} } + + // Compound literals. + + (int) { sve_sc1 }; // { dg-error {cannot convert 'svint8_t' to 'int' in initialization} } + + // Arrays. + + svint8_t array[2]; // { dg-error {array elements cannot have SVE type 'svint8_t'} } + svint8_t zero_length_array[0]; // { dg-error {array elements cannot have SVE type 'svint8_t'} } + svint8_t empty_init_array[] = {}; // { dg-error {array elements cannot have SVE type 'svint8_t'} } + + // Assignment. + + n = sve_sc1; // { dg-error {cannot convert 'svint8_t' to 'int' in assignment} } + + sve_sc1 = 0; // { dg-error {cannot convert 'int' to 'svint8_t' in assignment} } + sve_sc1 = sve_sc1; + sve_sc1 = gnu_sc1; // { dg-error {cannot convert 'int8x32_t'[^\n]* to 'svint8_t' in assignment} } + gnu_sc1 = sve_sc1; // { dg-error {cannot convert 'svint8_t' to 'int8x32_t'} } + sve_sc1 = sve_sh1; // { dg-error {cannot convert 'svint16_t' to 'svint8_t'} } + + // Casting. + + (void) sve_sc1; + (void) volatile_sve_sc1; + (void) *&volatile_sve_sc1; + + // Addressing and dereferencing. + + svint8_t *sve_sc_ptr = &sve_sc1; + int8x32_t *gnu_sc_ptr = &gnu_sc1; + sve_sc_ptr = (svint16_t *) 0; // { dg-error {cannot convert 'svint16_t\*' to 'svint8_t\*' in assignment} } + + // Pointer assignment. + + gnu_sc_ptr = sve_sc_ptr; // { dg-error {cannot convert 'svint8_t\*' to 'int8x32_t\*'} } + sve_sc_ptr = gnu_sc_ptr; // { dg-error {cannot convert 'int8x32_t\*'[^\n]* to 'svint8_t\*'} } + + // Pointer arithmetic. + + ++sve_sc_ptr; // { dg-error {arithmetic on pointer to SVE type 'svint8_t'} } + --sve_sc_ptr; // { dg-error {arithmetic on pointer to SVE type 'svint8_t'} } + sve_sc_ptr++; // { dg-error {arithmetic on pointer to SVE type 'svint8_t'} } + sve_sc_ptr--; // { dg-error {arithmetic on pointer to SVE type 'svint8_t'} } + sve_sc_ptr += 0; // { dg-error {arithmetic on pointer to SVE type 'svint8_t'} } + sve_sc_ptr += 1; // { dg-error {arithmetic on pointer to SVE type 'svint8_t'} } + sve_sc_ptr -= 0; // { dg-error {arithmetic on pointer to SVE type 'svint8_t'} } + sve_sc_ptr -= 1; // { dg-error {arithmetic on pointer to SVE type 'svint8_t'} } + sve_sc_ptr - sve_sc_ptr; // { dg-error {arithmetic on pointer to SVE type 'svint8_t'} } + gnu_sc_ptr - sve_sc_ptr; // { dg-error {invalid operands of types 'int8x32_t\*'[^\n]* and 'svint8_t\*' to binary 'operator-'} } + sve_sc_ptr - gnu_sc_ptr; // { dg-error {invalid operands of types 'svint8_t\*' and 'int8x32_t\*'[^\n]* to binary 'operator-'} } + sve_sc1 = sve_sc_ptr[0]; // { dg-error {arithmetic on pointer to SVE type 'svint8_t'} } + sve_sc1 = sve_sc_ptr[1]; // { dg-error {arithmetic on pointer to SVE type 'svint8_t'} } + + // Pointer comparison. + + sve_sc_ptr == &sve_sc1; + sve_sc_ptr != &sve_sc1; + sve_sc_ptr < &sve_sc1; + sve_sc_ptr <= &sve_sc1; + sve_sc_ptr > &sve_sc1; + sve_sc_ptr >= &sve_sc1; + gnu_sc_ptr == sve_sc_ptr; // { dg-error {comparison between distinct pointer types [^\n]*lacks a cast} } + gnu_sc_ptr != sve_sc_ptr; // { dg-error {comparison between distinct pointer types [^\n]*lacks a cast} } + gnu_sc_ptr < sve_sc_ptr; // { dg-error {comparison between distinct pointer types [^\n]*lacks a cast} } + gnu_sc_ptr <= sve_sc_ptr; // { dg-error {comparison between distinct pointer types [^\n]*lacks a cast} } + gnu_sc_ptr > sve_sc_ptr; // { dg-error {comparison between distinct pointer types [^\n]*lacks a cast} } + gnu_sc_ptr >= sve_sc_ptr; // { dg-error {comparison between distinct pointer types [^\n]*lacks a cast} } + sve_sc_ptr == gnu_sc_ptr; // { dg-error {comparison between distinct pointer types [^\n]*lacks a cast} } + sve_sc_ptr != gnu_sc_ptr; // { dg-error {comparison between distinct pointer types [^\n]*lacks a cast} } + sve_sc_ptr < gnu_sc_ptr; // { dg-error {comparison between distinct pointer types [^\n]*lacks a cast} } + sve_sc_ptr <= gnu_sc_ptr; // { dg-error {comparison between distinct pointer types [^\n]*lacks a cast} } + sve_sc_ptr > gnu_sc_ptr; // { dg-error {comparison between distinct pointer types [^\n]*lacks a cast} } + sve_sc_ptr >= gnu_sc_ptr; // { dg-error {comparison between distinct pointer types [^\n]*lacks a cast} } + + // New and delete. + + new svint8_t; // { dg-error {cannot allocate objects with SVE type 'svint8_t'} } + new svint8_t (); // { dg-error {cannot allocate objects with SVE type 'svint8_t'} } + + new (global_sve_sc_ptr) svint8_t; // { dg-error {cannot allocate objects with SVE type 'svint8_t'} } + new (global_sve_sc_ptr) svint8_t (); // { dg-error {cannot allocate objects with SVE type 'svint8_t'} } + + sve_sc1.~svint8_t(); // { dg-error {expected class-name before '\(' token} } + delete sve_sc_ptr; // { dg-error {cannot delete objects with SVE type '(svint8_t|__SVInt8_t)'} } + delete[] sve_sc_ptr; // { dg-error {cannot delete objects with SVE type 'svint8_t'} } + + // Conditional expressions. + + 0 ? sve_sc1 : sve_sc1; + 0 ? sve_sc1 : sve_sh1; // { dg-error {different types 'svint8_t' and 'svint16_t'} } + 0 ? sve_sc1 : 0; // { dg-error {different types 'svint8_t' and 'int'} } + 0 ? 0 : sve_sc1; // { dg-error {different types 'int' and 'svint8_t'} } + 0 ? sve_sc1 : sve_sc1; + 0 ? sve_sc_ptr : sve_sc_ptr; + 0 ? sve_sc_ptr : gnu_sc_ptr; // { dg-error {conditional expression between distinct pointer types [^\n]*lacks a cast} } + 0 ? gnu_sc_ptr : sve_sc_ptr; // { dg-error {conditional expression between distinct pointer types [^\n]*lacks a cast} } + + // Function arguments. + + ext_consume_sve_sc (sve_sc1); + ext_consume_sve_sc (sve_sh1); // { dg-error {cannot convert 'svint16_t' to 'svint8_t'} } + ext_consume_const_int_ref (sve_sc1); // { dg-error {invalid initialization of reference of type 'const int&' from expression of type 'svint8_t'} } + ext_consume_varargs (sve_sc1); // { dg-error {cannot convert 'svint8_t' to 'int'} } + ext_consume_varargs (1, sve_sc1); + + // Function returns. + + ext_produce_sve_sc (); + sve_sc1 = ext_produce_sve_sc (); + sve_sh1 = ext_produce_sve_sc (); // { dg-error {cannot convert 'svint8_t' to 'svint16_t' in assignment} } + + // Auto + +#if __cplusplus >= 201103L + auto auto_sve_sc1 = sve_sc1; + auto auto_sve_sc1_return = ext_produce_sve_sc (); +#endif + + // Varargs processing. + + __builtin_va_list valist; + __builtin_va_arg (valist, svint8_t); + + // Other built-ins + + __builtin_launder (sve_sc1); // { dg-error {non-pointer argument to '__builtin_launder'} } + __builtin_memcpy (&sve_sc1, &sve_sc2, 2); + + // Lambdas + +#if __cplusplus >= 201103L + [sve_sc1] () {}; // { dg-error {capture by copy of SVE type 'svint8_t'} "" { target c++11 } } + [=] () { &sve_sc1; }; // { dg-error {capture by copy of SVE type 'svint8_t'} "" { target c++11 } } + [&sve_sc1] () { sve_sc1 = sve_sc2; }; // { dg-error {'sve_sc2' is not captured} "" { target c++11 } } + [&sve_sc1, &sve_sc2] () { sve_sc1 = sve_sc2; }; + [&] () { sve_sc1 = sve_sc2; }; + [] () { return ext_produce_sve_sc (); } (); +#endif + + // Exceptions + + throw svint8_t (); // { dg-error {cannot throw or catch SVE type 'svint8_t'} } + try {} catch (svint8_t x) {} // { dg-error {cannot throw or catch SVE type 'svint8_t'} } + try {} catch (svint8_t &x) {} // { dg-error {cannot throw or catch SVE type 'svint8_t'} } + try {} catch (svint8_t *x) {} +#if __cplusplus < 201103L + thrower2 (); +#endif + + // Use in traits. Doesn't use static_assert so that tests work with + // earlier -std=s. + + { typedef int f[__has_nothrow_assign (svint8_t) ? 1 : -1]; } + { typedef int f[__has_trivial_assign (svint8_t) ? 1 : -1]; } + { typedef int f[__has_nothrow_constructor (svint8_t) ? 1 : -1]; } + { typedef int f[__has_trivial_constructor (svint8_t) ? 1 : -1]; } + { typedef int f[__has_nothrow_copy (svint8_t) ? 1 : -1]; } + { typedef int f[__has_trivial_copy (svint8_t) ? 1 : -1]; } + { typedef int f[__has_trivial_destructor (svint8_t) ? 1 : -1]; } + { typedef int f[__has_unique_object_representations (svint8_t) ? 1 : -1]; } + { typedef int f[!__has_virtual_destructor (svint8_t) ? 1 : -1]; } + { typedef int f[!__is_abstract (svint8_t) ? 1 : -1]; } + { typedef int f[!__is_aggregate (svint8_t) ? 1 : -1]; } + { typedef int f[!__is_base_of (svint8_t, svint8_t) ? 1 : -1]; } + { typedef int f[!__is_base_of (svint8_t, svint16_t) ? 1 : -1]; } + { typedef int f[!__is_class (svint8_t) ? 1 : -1]; } + { typedef int f[!__is_empty (svint8_t) ? 1 : -1]; } + { typedef int f[!__is_enum (svint8_t) ? 1 : -1]; } + { typedef int f[!__is_final (svint8_t) ? 1 : -1]; } + { typedef int f[__is_pod (svint8_t) ? 1 : -1]; } + { typedef int f[!__is_polymorphic (svint8_t) ? 1 : -1]; } + { typedef int f[__is_same_as (svint8_t, svint8_t) ? 1 : -1]; } + { typedef int f[!__is_same_as (svint8_t, int8x32_t) ? 1 : -1]; } + { typedef int f[!__is_same_as (int8x32_t, svint8_t) ? 1 : -1]; } + { typedef int f[__is_same_as (svint8_t *, svint8_t *) ? 1 : -1]; } + { typedef int f[!__is_same_as (svint8_t *, int8x32_t *) ? 1 : -1]; } + { typedef int f[!__is_same_as (int8x32_t *, svint8_t *) ? 1 : -1]; } + { typedef int f[!__is_same_as (svint8_t, int) ? 1 : -1]; } + { typedef int f[!__is_same_as (svint8_t, svint16_t) ? 1 : -1]; } + { typedef int f[__is_trivial (svint8_t) ? 1 : -1]; } + { typedef int f[!__is_union (svint8_t) ? 1 : -1]; } + { typedef int f[__is_trivially_copyable (svint8_t) ? 1 : -1]; } + /* The intention is that svint8_t should behave like int8x32_t here. If the behavior + for int8x32_t changes then the behavior for svint8_t should change in the same + way. */ + { typedef int f[!__is_trivially_assignable (int8x32_t, int8x32_t) ? 1 : -1]; } + { typedef int f[!__is_trivially_assignable (svint8_t, svint8_t) ? 1 : -1]; } + { typedef int f[!__is_trivially_assignable (svint8_t, int8x32_t) ? 1 : -1]; } + { typedef int f[!__is_trivially_assignable (int8x32_t, svint8_t) ? 1 : -1]; } + { typedef int f[!__is_trivially_assignable (svint8_t, int) ? 1 : -1]; } + { typedef int f[!__is_trivially_assignable (svint8_t, svint16_t) ? 1 : -1]; } + { typedef int f[!__is_assignable (int8x32_t, int8x32_t) ? 1 : -1]; } + { typedef int f[!__is_assignable (svint8_t, svint8_t) ? 1 : -1]; } + { typedef int f[!__is_assignable (svint8_t, int8x32_t) ? 1 : -1]; } + { typedef int f[!__is_assignable (int8x32_t, svint8_t) ? 1 : -1]; } + { typedef int f[!__is_assignable (svint8_t, int) ? 1 : -1]; } + { typedef int f[!__is_assignable (svint8_t, svint16_t) ? 1 : -1]; } + { typedef int f[__is_trivially_constructible (svint8_t) ? 1 : -1]; } + { typedef int f[__is_trivially_constructible (int8x32_t, int8x32_t) ? 1 : -1]; } + { typedef int f[__is_trivially_constructible (svint8_t, svint8_t) ? 1 : -1]; } + { typedef int f[!__is_trivially_constructible (svint8_t, int8x32_t) ? 1 : -1]; } + { typedef int f[!__is_trivially_constructible (int8x32_t, svint8_t) ? 1 : -1]; } + { typedef int f[!__is_trivially_constructible (svint8_t, int) ? 1 : -1]; } + { typedef int f[!__is_trivially_constructible (svint8_t, svint16_t) ? 1 : -1]; } + { typedef int f[__is_constructible (svint8_t) ? 1 : -1]; } + { typedef int f[__is_constructible (int8x32_t, int8x32_t) ? 1 : -1]; } + { typedef int f[__is_constructible (svint8_t, svint8_t) ? 1 : -1]; } + { typedef int f[!__is_constructible (svint8_t, int8x32_t) ? 1 : -1]; } + { typedef int f[!__is_constructible (int8x32_t, svint8_t) ? 1 : -1]; } + { typedef int f[!__is_constructible (svint8_t, int) ? 1 : -1]; } + { typedef int f[!__is_constructible (svint8_t, svint16_t) ? 1 : -1]; } +} + +// Function parameters in definitions. + +void +unnamed_st1 (svint8_t) +{ +} + +void +named_st1 (svint8_t param1) +{ + svint8_t sve_sc1 = param1; +} + +// Function return values in definitions. + +svint8_t +ret_st1 (svint8_t param) +{ + return param; +} + +svint8_t +bad_ret_st1 (svint16_t param) +{ + return param; // { dg-error {cannot convert 'svint16_t' to 'svint8_t' in return} } +} + +#if __cplusplus >= 201103L +template +void +const_to_sve_sc (T i) +{ + constexpr svint8_t a = (svint8_t) i; +} +#endif + +template +int +get_x (T *a) +{ + return a->a; // { dg-error {request for member 'a' in '\* a', which is of non-class type} } +} +template int get_x(svint8_t *); + +#if __cplusplus < 201103L +void thrower3 () throw (svint8_t) {} // { dg-error {cannot throw or catch SVE type 'svint8_t'} "" { target c++98_only } } +#endif + +// Using "auto" as a return type. + +#if __cplusplus >= 201402L +auto auto_ret_sve_sc (svint8_t *ptr) { return *ptr; } +const auto &auto_ret_const_sve_sc_ref (svint8_t *ptr) { return *ptr; } +auto &auto_ret_sve_sc_ref (svint8_t *ptr) { return *ptr; } +auto &&auto_ret_sve_sc_rvalue_ref (svint8_t *ptr) { return *ptr; } +#endif Index: gcc/testsuite/g++.dg/ext/sve-sizeless-2.C =================================================================== --- /dev/null 2019-09-17 11:41:18.176664108 +0100 +++ gcc/testsuite/g++.dg/ext/sve-sizeless-2.C 2019-11-16 14:03:16.436877583 +0000 @@ -0,0 +1,418 @@ +// { dg-do compile { target aarch64*-*-* } } +// { dg-options "-Wclass-memaccess -msve-vector-bits=256" } + +typedef __SIZE_TYPE__ size_t; +inline void *operator new (size_t, void *__p) throw() { return __p; } + +#include + +typedef signed char int8x32_t __attribute__((__vector_size__ (32))); + +// Sizeless objects with global scope. + +svint8_t global_sve_sc; // { dg-error {SVE type 'svint8_t' does not have a fixed size} } +static svint8_t local_sve_sc; // { dg-error {SVE type 'svint8_t' does not have a fixed size} } +extern svint8_t extern_sve_sc; // { dg-error {SVE type 'svint8_t' does not have a fixed size} } +__thread svint8_t tls_sve_sc; // { dg-error {variables of type 'svint8_t' cannot have thread-local storage duration} } + +// Sizeless arrays. + +typedef svint8_t array_type[2]; // { dg-error {array elements cannot have SVE type 'svint8_t'} } +extern svint8_t extern_array[]; // { dg-error {array elements cannot have SVE type 'svint8_t'} } + +// Sizeless member variables. + +struct struct1 { + svint8_t a; // { dg-error {member variables cannot have SVE type 'svint8_t'} } +}; + +union union1 { + svint8_t a; // { dg-error {member variables cannot have SVE type 'svint8_t'} } +}; + +#if __cplusplus >= 201103L +struct static_sve_sc { + static svint8_t sve_sc1 = {}; // { dg-error {SVE type 'svint8_t' does not have a fixed size} "" { target c++11 } } +}; +#endif + +// Sizeless member variables in templated structures. + +template +struct templated_struct1 { + svint8_t a; // { dg-error {member variables cannot have SVE type 'svint8_t'} } +}; + +template +struct templated_struct2 { + T a; // { dg-error {member variables cannot have SVE type '(svint8_t|__SVInt8_t)'} } +}; + +template class templated_struct2; + +template +struct templated_struct3 { + T &a; +}; + +template class templated_struct3; + +#if __cplusplus >= 201103L +template +struct templated_struct4 { + static T a; // { dg-error {SVE type '(svint8_t|__SVInt8_t)' does not have a fixed size} "" { target c++11 } } + static T b = {}; // { dg-error {SVE type '(svint8_t|__SVInt8_t)' does not have a fixed size} "" { target c++11 } } +}; + +template class templated_struct4; +#endif + +template struct templated_struct5 : T {}; // { dg-error {base type '[^']*' fails to be a struct or class type} } +template class templated_struct5; + +#if __cplusplus >= 201103L +template using typedef_sizeless1 = svint8_t; +template using typedef_sizeless1 = svint8_t; // { dg-error {redefinition of 'template using typedef_sizeless1 = svint8_t'} "" { target c++11 } } +template using array = T[2]; +#endif + +// Pointers to sizeless types. + +svint8_t *global_sve_sc_ptr; + +// Sizeless arguments and return values. + +void ext_consume_sve_sc (svint8_t); +void ext_consume_const_int_ref (const int &); +void ext_consume_varargs (int, ...); +svint8_t ext_produce_sve_sc (); + +// Sizeless types in throw specifications. + +#if __cplusplus < 201103L +void thrower1 () throw (svint8_t); // { dg-error {cannot throw or catch SVE type 'svint8_t'} "" { target c++98_only } } +void thrower2 () throw (svint8_t); // { dg-error {cannot throw or catch SVE type 'svint8_t'} "" { target c++98_only } } +void thrower3 () throw (svint8_t); // { dg-error {cannot throw or catch SVE type 'svint8_t'} "" { target c++98_only } } +#endif + +// Main tests for statements and expressions. + +void +statements (int n) +{ + // Local declarations. + + svint8_t sve_sc1, sve_sc2; + volatile svint8_t volatile_sve_sc1; + int8x32_t gnu_sc1; + svint16_t sve_sh1; + + // Layout queries. + + sizeof (svint8_t); // { dg-error {SVE type 'svint8_t' does not have a fixed size} } + sizeof (sve_sc1); // { dg-error {SVE type 'svint8_t' does not have a fixed size} } + sizeof (ext_produce_sve_sc ()); // { dg-error {SVE type 'svint8_t' does not have a fixed size} } + __alignof (svint8_t); // { dg-error {SVE type 'svint8_t' does not have a defined alignment} } + __alignof (sve_sc1); // { dg-error {SVE type 'svint8_t' does not have a defined alignment} } + __alignof (ext_produce_sve_sc ()); // { dg-error {SVE type 'svint8_t' does not have a defined alignment} } + +#if __cplusplus >= 201103L + array foo = {}; // { dg-error {array elements cannot have SVE type '(svint8_t|__SVInt8_t)'} "" { target c++11 } } +#endif + + // Initialization. + + int init_int1 = sve_sc1; // { dg-error {cannot convert 'svint8_t' to 'int' in initialization} } + int init_int2 = { sve_sc1 }; // { dg-error {cannot convert 'svint8_t' to 'int' in initialization} } + + svint8_t init_sve_sc1 (sve_sc1); + svint8_t init_sve_sc2 (sve_sh1); // { dg-error {cannot convert 'svint16_t' to 'svint8_t'} } + svint8_t init_sve_sc3 = sve_sc1; + svint8_t init_sve_sc4 = sve_sh1; // { dg-error {cannot convert 'svint16_t' to 'svint8_t'} } + svint8_t init_sve_sc5 = {}; + svint8_t init_sve_sc6 = { sve_sc1 }; + svint8_t init_sve_sc7 = { sve_sh1 }; // { dg-error {cannot convert 'svint16_t' to 'svint8_t'} } + + // Constructor calls. + + (0, svint8_t ()); + + // Lvalue reference binding + + svint8_t &lvalue_ref_sve_sc1 = sve_sc1; + svint8_t &lvalue_ref_sve_sc2 = ext_produce_sve_sc (); // { dg-error {cannot bind non-const lvalue reference of type 'svint8_t&' to an rvalue of type 'svint8_t'} } + svint8_t &lvalue_ref_sve_sc3 = sve_sh1; // { dg-error {invalid initialization of reference of type 'svint8_t&' from expression of type 'svint16_t'} } + + const svint8_t &const_lvalue_ref_sve_sc1 = sve_sc1; + const svint8_t &const_lvalue_ref_sve_sc2 = ext_produce_sve_sc (); + const svint8_t &const_lvalue_ref_sve_sc3 = sve_sh1; // { dg-error {invalid initialization of reference of type 'const svint8_t&' from expression of type 'svint16_t'} } + + // Compound literals. + + (int) { sve_sc1 }; // { dg-error {cannot convert 'svint8_t' to 'int' in initialization} } + + // Arrays. + + svint8_t array[2]; // { dg-error {array elements cannot have SVE type 'svint8_t'} } + svint8_t zero_length_array[0]; // { dg-error {array elements cannot have SVE type 'svint8_t'} } + svint8_t empty_init_array[] = {}; // { dg-error {array elements cannot have SVE type 'svint8_t'} } + + // Assignment. + + n = sve_sc1; // { dg-error {cannot convert 'svint8_t' to 'int' in assignment} } + + sve_sc1 = 0; // { dg-error {cannot convert 'int' to 'svint8_t' in assignment} } + sve_sc1 = sve_sc1; + sve_sc1 = gnu_sc1; + gnu_sc1 = sve_sc1; + sve_sc1 = sve_sh1; // { dg-error {cannot convert 'svint16_t' to 'svint8_t'} } + + // Casting. + + (void) sve_sc1; + (void) volatile_sve_sc1; + (void) *&volatile_sve_sc1; + + // Addressing and dereferencing. + + svint8_t *sve_sc_ptr = &sve_sc1; + int8x32_t *gnu_sc_ptr = &gnu_sc1; + sve_sc_ptr = (svint16_t *) 0; // { dg-error {cannot convert 'svint16_t\*' to 'svint8_t\*' in assignment} } + + // Pointer assignment. + + gnu_sc_ptr = sve_sc_ptr; + sve_sc_ptr = gnu_sc_ptr; + + // Pointer arithmetic. + + ++sve_sc_ptr; // { dg-error {arithmetic on pointer to SVE type 'svint8_t'} } + --sve_sc_ptr; // { dg-error {arithmetic on pointer to SVE type 'svint8_t'} } + sve_sc_ptr++; // { dg-error {arithmetic on pointer to SVE type 'svint8_t'} } + sve_sc_ptr--; // { dg-error {arithmetic on pointer to SVE type 'svint8_t'} } + sve_sc_ptr += 0; // { dg-error {arithmetic on pointer to SVE type 'svint8_t'} } + sve_sc_ptr += 1; // { dg-error {arithmetic on pointer to SVE type 'svint8_t'} } + sve_sc_ptr -= 0; // { dg-error {arithmetic on pointer to SVE type 'svint8_t'} } + sve_sc_ptr -= 1; // { dg-error {arithmetic on pointer to SVE type 'svint8_t'} } + sve_sc_ptr - sve_sc_ptr; // { dg-error {arithmetic on pointer to SVE type 'svint8_t'} } + gnu_sc_ptr - sve_sc_ptr; // { dg-error {arithmetic on pointer to SVE type 'svint8_t'} } + sve_sc_ptr - gnu_sc_ptr; // { dg-error {arithmetic on pointer to SVE type 'svint8_t'} } + sve_sc1 = sve_sc_ptr[0]; // { dg-error {arithmetic on pointer to SVE type 'svint8_t'} } + sve_sc1 = sve_sc_ptr[1]; // { dg-error {arithmetic on pointer to SVE type 'svint8_t'} } + + // Pointer comparison. + + sve_sc_ptr == &sve_sc1; + sve_sc_ptr != &sve_sc1; + sve_sc_ptr < &sve_sc1; + sve_sc_ptr <= &sve_sc1; + sve_sc_ptr > &sve_sc1; + sve_sc_ptr >= &sve_sc1; + gnu_sc_ptr == sve_sc_ptr; + gnu_sc_ptr != sve_sc_ptr; + gnu_sc_ptr < sve_sc_ptr; + gnu_sc_ptr <= sve_sc_ptr; + gnu_sc_ptr > sve_sc_ptr; + gnu_sc_ptr >= sve_sc_ptr; + sve_sc_ptr == gnu_sc_ptr; + sve_sc_ptr != gnu_sc_ptr; + sve_sc_ptr < gnu_sc_ptr; + sve_sc_ptr <= gnu_sc_ptr; + sve_sc_ptr > gnu_sc_ptr; + sve_sc_ptr >= gnu_sc_ptr; + + // New and delete. + + new svint8_t; // { dg-error {cannot allocate objects with SVE type 'svint8_t'} } + new svint8_t (); // { dg-error {cannot allocate objects with SVE type 'svint8_t'} } + + new (global_sve_sc_ptr) svint8_t; // { dg-error {cannot allocate objects with SVE type 'svint8_t'} } + new (global_sve_sc_ptr) svint8_t (); // { dg-error {cannot allocate objects with SVE type 'svint8_t'} } + + sve_sc1.~svint8_t(); // { dg-error {expected class-name before '\(' token} } + delete sve_sc_ptr; // { dg-error {cannot delete objects with SVE type '(svint8_t|__SVInt8_t)'} } + delete[] sve_sc_ptr; // { dg-error {cannot delete objects with SVE type 'svint8_t'} } + + // Conditional expressions. + + 0 ? sve_sc1 : sve_sc1; + 0 ? sve_sc1 : sve_sh1; // { dg-error {different types 'svint8_t' and 'svint16_t'} } + 0 ? sve_sc1 : 0; // { dg-error {different types 'svint8_t' and 'int'} } + 0 ? 0 : sve_sc1; // { dg-error {different types 'int' and 'svint8_t'} } + 0 ? sve_sc1 : sve_sc1; + 0 ? sve_sc_ptr : sve_sc_ptr; + 0 ? sve_sc_ptr : gnu_sc_ptr; + 0 ? gnu_sc_ptr : sve_sc_ptr; + + // Function arguments. + + ext_consume_sve_sc (sve_sc1); + ext_consume_sve_sc (sve_sh1); // { dg-error {cannot convert 'svint16_t' to 'svint8_t'} } + ext_consume_const_int_ref (sve_sc1); // { dg-error {invalid initialization of reference of type 'const int&' from expression of type 'svint8_t'} } + ext_consume_varargs (sve_sc1); // { dg-error {cannot convert 'svint8_t' to 'int'} } + ext_consume_varargs (1, sve_sc1); + + // Function returns. + + ext_produce_sve_sc (); + sve_sc1 = ext_produce_sve_sc (); + sve_sh1 = ext_produce_sve_sc (); // { dg-error {cannot convert 'svint8_t' to 'svint16_t' in assignment} } + + // Auto + +#if __cplusplus >= 201103L + auto auto_sve_sc1 = sve_sc1; + auto auto_sve_sc1_return = ext_produce_sve_sc (); +#endif + + // Varargs processing. + + __builtin_va_list valist; + __builtin_va_arg (valist, svint8_t); + + // Other built-ins + + __builtin_launder (sve_sc1); // { dg-error {non-pointer argument to '__builtin_launder'} } + __builtin_memcpy (&sve_sc1, &sve_sc2, 2); + + // Lambdas + +#if __cplusplus >= 201103L + [sve_sc1] () {}; // { dg-error {capture by copy of SVE type 'svint8_t'} "" { target c++11 } } + [=] () { &sve_sc1; }; // { dg-error {capture by copy of SVE type 'svint8_t'} "" { target c++11 } } + [&sve_sc1] () { sve_sc1 = sve_sc2; }; // { dg-error {'sve_sc2' is not captured} "" { target c++11 } } + [&sve_sc1, &sve_sc2] () { sve_sc1 = sve_sc2; }; + [&] () { sve_sc1 = sve_sc2; }; + [] () { return ext_produce_sve_sc (); } (); +#endif + + // Exceptions + + throw svint8_t (); // { dg-error {cannot throw or catch SVE type 'svint8_t'} } + try {} catch (svint8_t x) {} // { dg-error {cannot throw or catch SVE type 'svint8_t'} } + try {} catch (svint8_t &x) {} // { dg-error {cannot throw or catch SVE type 'svint8_t'} } + try {} catch (svint8_t *x) {} +#if __cplusplus < 201103L + thrower2 (); +#endif + + // Use in traits. Doesn't use static_assert so that tests work with + // earlier -std=s. + + { typedef int f[__has_nothrow_assign (svint8_t) ? 1 : -1]; } + { typedef int f[__has_trivial_assign (svint8_t) ? 1 : -1]; } + { typedef int f[__has_nothrow_constructor (svint8_t) ? 1 : -1]; } + { typedef int f[__has_trivial_constructor (svint8_t) ? 1 : -1]; } + { typedef int f[__has_nothrow_copy (svint8_t) ? 1 : -1]; } + { typedef int f[__has_trivial_copy (svint8_t) ? 1 : -1]; } + { typedef int f[__has_trivial_destructor (svint8_t) ? 1 : -1]; } + { typedef int f[__has_unique_object_representations (svint8_t) ? 1 : -1]; } + { typedef int f[!__has_virtual_destructor (svint8_t) ? 1 : -1]; } + { typedef int f[!__is_abstract (svint8_t) ? 1 : -1]; } + { typedef int f[!__is_aggregate (svint8_t) ? 1 : -1]; } + { typedef int f[!__is_base_of (svint8_t, svint8_t) ? 1 : -1]; } + { typedef int f[!__is_base_of (svint8_t, svint16_t) ? 1 : -1]; } + { typedef int f[!__is_class (svint8_t) ? 1 : -1]; } + { typedef int f[!__is_empty (svint8_t) ? 1 : -1]; } + { typedef int f[!__is_enum (svint8_t) ? 1 : -1]; } + { typedef int f[!__is_final (svint8_t) ? 1 : -1]; } + { typedef int f[__is_pod (svint8_t) ? 1 : -1]; } + { typedef int f[!__is_polymorphic (svint8_t) ? 1 : -1]; } + { typedef int f[__is_same_as (svint8_t, svint8_t) ? 1 : -1]; } + { typedef int f[__is_same_as (svint8_t, int8x32_t) ? 1 : -1]; } + { typedef int f[__is_same_as (int8x32_t, svint8_t) ? 1 : -1]; } + { typedef int f[__is_same_as (svint8_t *, svint8_t *) ? 1 : -1]; } + { typedef int f[__is_same_as (svint8_t *, int8x32_t *) ? 1 : -1]; } + { typedef int f[__is_same_as (int8x32_t *, svint8_t *) ? 1 : -1]; } + { typedef int f[!__is_same_as (svint8_t, int) ? 1 : -1]; } + { typedef int f[!__is_same_as (svint8_t, svint16_t) ? 1 : -1]; } + { typedef int f[__is_trivial (svint8_t) ? 1 : -1]; } + { typedef int f[!__is_union (svint8_t) ? 1 : -1]; } + { typedef int f[__is_trivially_copyable (svint8_t) ? 1 : -1]; } + /* The intention is that svint8_t should behave like int8x32_t here. If the behavior + for int8x32_t changes then the behavior for svint8_t should change in the same + way. */ + { typedef int f[!__is_trivially_assignable (int8x32_t, int8x32_t) ? 1 : -1]; } + { typedef int f[!__is_trivially_assignable (svint8_t, svint8_t) ? 1 : -1]; } + { typedef int f[!__is_trivially_assignable (svint8_t, int8x32_t) ? 1 : -1]; } + { typedef int f[!__is_trivially_assignable (int8x32_t, svint8_t) ? 1 : -1]; } + { typedef int f[!__is_trivially_assignable (svint8_t, int) ? 1 : -1]; } + { typedef int f[!__is_trivially_assignable (svint8_t, svint16_t) ? 1 : -1]; } + { typedef int f[!__is_assignable (int8x32_t, int8x32_t) ? 1 : -1]; } + { typedef int f[!__is_assignable (svint8_t, svint8_t) ? 1 : -1]; } + { typedef int f[!__is_assignable (svint8_t, int8x32_t) ? 1 : -1]; } + { typedef int f[!__is_assignable (int8x32_t, svint8_t) ? 1 : -1]; } + { typedef int f[!__is_assignable (svint8_t, int) ? 1 : -1]; } + { typedef int f[!__is_assignable (svint8_t, svint16_t) ? 1 : -1]; } + { typedef int f[__is_trivially_constructible (svint8_t) ? 1 : -1]; } + { typedef int f[__is_trivially_constructible (int8x32_t, int8x32_t) ? 1 : -1]; } + { typedef int f[__is_trivially_constructible (svint8_t, svint8_t) ? 1 : -1]; } + { typedef int f[__is_trivially_constructible (svint8_t, int8x32_t) ? 1 : -1]; } + { typedef int f[__is_trivially_constructible (int8x32_t, svint8_t) ? 1 : -1]; } + { typedef int f[!__is_trivially_constructible (svint8_t, int) ? 1 : -1]; } + { typedef int f[!__is_trivially_constructible (svint8_t, svint16_t) ? 1 : -1]; } + { typedef int f[__is_constructible (svint8_t) ? 1 : -1]; } + { typedef int f[__is_constructible (int8x32_t, int8x32_t) ? 1 : -1]; } + { typedef int f[__is_constructible (svint8_t, svint8_t) ? 1 : -1]; } + { typedef int f[__is_constructible (svint8_t, int8x32_t) ? 1 : -1]; } + { typedef int f[__is_constructible (int8x32_t, svint8_t) ? 1 : -1]; } + { typedef int f[!__is_constructible (svint8_t, int) ? 1 : -1]; } + { typedef int f[!__is_constructible (svint8_t, svint16_t) ? 1 : -1]; } +} + +// Function parameters in definitions. + +void +unnamed_st1 (svint8_t) +{ +} + +void +named_st1 (svint8_t param1) +{ + svint8_t sve_sc1 = param1; +} + +// Function return values in definitions. + +svint8_t +ret_st1 (svint8_t param) +{ + return param; +} + +svint8_t +bad_ret_st1 (svint16_t param) +{ + return param; // { dg-error {cannot convert 'svint16_t' to 'svint8_t' in return} } +} + +#if __cplusplus >= 201103L +template +void +const_to_sve_sc (T i) +{ + constexpr svint8_t a = (svint8_t) i; +} +#endif + +template +int +get_x (T *a) +{ + return a->a; // { dg-error {request for member 'a' in '\* a', which is of non-class type} } +} +template int get_x(svint8_t *); + +#if __cplusplus < 201103L +void thrower3 () throw (svint8_t) {} // { dg-error {cannot throw or catch SVE type 'svint8_t'} "" { target c++98_only } } +#endif + +// Using "auto" as a return type. + +#if __cplusplus >= 201402L +auto auto_ret_sve_sc (svint8_t *ptr) { return *ptr; } +const auto &auto_ret_const_sve_sc_ref (svint8_t *ptr) { return *ptr; } +auto &auto_ret_sve_sc_ref (svint8_t *ptr) { return *ptr; } +auto &&auto_ret_sve_sc_rvalue_ref (svint8_t *ptr) { return *ptr; } +#endif