From patchwork Sat Jun 12 16:40:40 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jason Merrill X-Patchwork-Id: 1491309 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=2620:52:3:1:0:246e:9693:128c; helo=sourceware.org; envelope-from=gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=) Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.a=rsa-sha256 header.s=default header.b=i6RlVA4I; dkim-atps=neutral Received: from sourceware.org (server2.sourceware.org [IPv6:2620:52:3:1:0:246e:9693:128c]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 4G2NlR06qKz9sWl for ; Sun, 13 Jun 2021 02:41:37 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 5D978385500E for ; Sat, 12 Jun 2021 16:41:33 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 5D978385500E DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1623516093; bh=5q0d04xMftv4qDQb/WsG0UjCqjGzZU2LO/eGIhtOJ8A=; h=To:Subject:Date:List-Id:List-Unsubscribe:List-Archive:List-Post: List-Help:List-Subscribe:From:Reply-To:From; b=i6RlVA4I8glEI+09RMaJFKQdBQ7C9GN41vjOKUzJnX2hZuziAiUwUKJJMS+9eYkH3 MPTCjVXs1RxV4QMav4GRSplMJDbw6oVWQtWud/axssIAKp1UOap/PyfPIjcqrX5aHz vGvAtxhbapVQe9+9vCCCXLN5zuCR1Bk1CDrWr5Zo= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by sourceware.org (Postfix) with ESMTP id C3E043858023 for ; Sat, 12 Jun 2021 16:40:46 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org C3E043858023 Received: from mail-qk1-f198.google.com (mail-qk1-f198.google.com [209.85.222.198]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-582-R_bT9gNoPoSU6L_uWkUtuA-1; Sat, 12 Jun 2021 12:40:44 -0400 X-MC-Unique: R_bT9gNoPoSU6L_uWkUtuA-1 Received: by mail-qk1-f198.google.com with SMTP id o186-20020a37bec30000b02903aa376d30fdso18141211qkf.22 for ; Sat, 12 Jun 2021 09:40:44 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:subject:date:message-id:mime-version :content-transfer-encoding; bh=5q0d04xMftv4qDQb/WsG0UjCqjGzZU2LO/eGIhtOJ8A=; b=STwHzEBo0+/hP6VLpdVUttlkRxNNhPohyx4F57pWNUcTfQr78TrYJk3h/pX4wBf7KO jFYJMf+A03+2lQN+s5gIkVTOj3dzhXyK01KyJf2U0jwJh1dBVRLk1+thG0M5ecWHU/5h N44BcQUJXYRHqiHS4xjUiA13WZ6zhaBdFcpv/gwzYgwC6WVijhT8Wyx99xA8UdUSnOP1 HIdqC8EGlQM1cNjFJVBv9dnfIBX6+JhmXYVjfrpPHFvRzeXmPp8c2sWsLuDeymlSZwfL nDjdenHK1YP4PEV3YoqhXNJjYWmBAIPZS4CPJ0VkMqDzsr6ayJgDRlPvynBCUoBxIvZk UjBg== X-Gm-Message-State: AOAM532D1OY2mIEHs2BiiXgRtsXDjA8P5HU/L6pC6wVHp4eXfi8bbQZk mLK/jisvMnRdmWHMg3uwVPAb4bHD/czD+oqm9BPuMyiH5d2wsb0T/IxxR4c2U5Fpu6PvRIcx4LQ WyCzWCd81L2vud1iceZGR7yTjeQQaM9EiuJd6Y+lLAUaCsDd5fb2xiKZcgF2yOy9vrw== X-Received: by 2002:a05:6214:1909:: with SMTP id er9mr10353332qvb.13.1623516044057; Sat, 12 Jun 2021 09:40:44 -0700 (PDT) X-Google-Smtp-Source: ABdhPJy2eqO+m0t4vSz+VBR2r511BKTrxjE2QCz7H1A4FUWaDW2ixYX5EE8/1G60ErnrBDaOL8Zb4w== X-Received: by 2002:a05:6214:1909:: with SMTP id er9mr10353302qvb.13.1623516043626; Sat, 12 Jun 2021 09:40:43 -0700 (PDT) Received: from barrymore.redhat.com ([130.44.159.43]) by smtp.gmail.com with ESMTPSA id a28sm6615343qkl.78.2021.06.12.09.40.42 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 12 Jun 2021 09:40:42 -0700 (PDT) To: gcc-patches@gcc.gnu.org Subject: [pushed] c++: constexpr and array[0] [PR101029] Date: Sat, 12 Jun 2021 12:40:40 -0400 Message-Id: <20210612164040.1615596-1-jason@redhat.com> X-Mailer: git-send-email 2.27.0 MIME-Version: 1.0 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com X-Spam-Status: No, score=-13.2 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H4, RCVD_IN_MSPIKE_WL, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.2 X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Jason Merrill via Gcc-patches From: Jason Merrill Reply-To: Jason Merrill Errors-To: gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org Sender: "Gcc-patches" build_vec_init_elt exits early if we're initializing a zero-element array, so build_vec_init needs to do the same to avoid trying to instantiate things after we've already started throwing important bits away. Tested x86_64-pc-linux-gnu, applying to trunk. PR c++/101029 gcc/cp/ChangeLog: * init.c (build_vec_init): Shortcut [0] case. gcc/testsuite/ChangeLog: * g++.dg/ext/array4.C: New test. --- gcc/cp/init.c | 8 ++ gcc/testsuite/g++.dg/ext/array4.C | 172 ++++++++++++++++++++++++++++++ 2 files changed, 180 insertions(+) create mode 100644 gcc/testsuite/g++.dg/ext/array4.C base-commit: c4e50e500da7692aad53a4488aff32e056149b3c diff --git a/gcc/cp/init.c b/gcc/cp/init.c index 1b161d526f6..622d6e9d0c5 100644 --- a/gcc/cp/init.c +++ b/gcc/cp/init.c @@ -4222,6 +4222,14 @@ build_vec_init (tree base, tree maxindex, tree init, else ptype = atype; + if (integer_all_onesp (maxindex)) + { + /* Shortcut zero element case to avoid unneeded constructor synthesis. */ + if (init && TREE_SIDE_EFFECTS (init)) + base = build2 (COMPOUND_EXPR, void_type_node, init, base); + return base; + } + /* The code we are generating looks like: ({ T* t1 = (T*) base; diff --git a/gcc/testsuite/g++.dg/ext/array4.C b/gcc/testsuite/g++.dg/ext/array4.C new file mode 100644 index 00000000000..0068ea854e1 --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/array4.C @@ -0,0 +1,172 @@ +// PR c++/101029 +// { dg-do compile { target c++11 } } +// { dg-options "" } allow [0] + +template struct integral_constant { + static constexpr int value = __v; + typedef int value_type; + constexpr operator value_type() { return __v; } +}; +template using __bool_constant = integral_constant<__v>; +template struct conditional; +template struct __and_; +template +struct __and_<_B1, _B2, _B3, _Bn...> : conditional<_B1::value, _B1> {}; +template +constexpr integral_constant __is_complete_or_unbounded(_Tp) { + return {}; +} +struct Trans_NS_std_formatter; +template +struct is_default_constructible : integral_constant { + static_assert(__is_complete_or_unbounded(_Tp{}), ""); +}; +template +struct is_same : integral_constant<__is_same_as(_Tp, _Up)> {}; +template struct enable_if; +template struct conditional { + typedef _Iffalse type; +}; +struct pair { + template , _U2, + int>::valuebool>::type> + pair(); +}; + +class BucketLogger; +struct __shared_ptr_access { + using element_type = BucketLogger; + element_type *operator->(); +}; +struct DcpProducer { + __shared_ptr_access logger; + void bufferAcknowledgement(); +}; +struct atomic { + atomic(long); +}; +inline namespace v7 { +template +using conditional_t = typename conditional::type; +template struct basic_string_view { basic_string_view(int, int); }; +template struct formatter; +template +using has_formatter = + __bool_constant<__is_constructible(Trans_NS_std_formatter)>; +struct fallback_formatter; +template struct custom_value { + using parse_context = typename Context::parse_context_type; + void (*format)(const void *, parse_context &, Context &); +}; +template struct value { + float float_value; + custom_value custom; + template value(T) { + custom.format = + format_custom_arg::value, + typename Context::formatter_type, + fallback_formatter>>; + } + template + static void format_custom_arg(const void *arg, + typename Context::parse_context_type &, + Context &ctx) { + Formatter f; + f.format(*static_cast(arg), ctx); + } +}; +enum { max_packed_args }; +template struct basic_format_arg { value value_; }; +template +void visit_format_arg(Visitor vis, Context arg) { + vis(arg.value_.float_value); +} +template basic_format_arg make_arg(T); +struct basic_format_context { + using char_type = int; + using parse_context_type = int; + template using formatter_type = formatter; +}; +struct format_arg_store { + using value_type = conditional_t>; + value_type data_; +}; +template +auto make_args_checked(S, Args... args) -> format_arg_store { + return {args...}; +} +struct basic_format_specs {}; +template +void write(OutputIt, T, Char) { + if (is_same()) + ; +} +struct arg_formatter_base { + using iterator = int; + using format_specs = basic_format_specs; + iterator out_; + template void operator()(T value) { + auto specs = format_specs(); + write(out_, value, specs); + } +}; +struct arg_formatter : arg_formatter_base { + using context_type = basic_format_context; + arg_formatter(context_type, int *, format_specs *); +}; +template struct formatter { + template void format(T val, FormatContext ctx) { + using af = arg_formatter; + basic_format_arg __trans_tmp_2 = make_arg(val); + visit_format_arg(af(ctx, nullptr, &specs_), __trans_tmp_2); + } + basic_format_specs specs_; +}; +} // namespace v7 +namespace level { +enum level_enum { warn }; +} +struct BucketLogger { + template + void log(level::level_enum, const S &, Args &&...); + template void warn(const char *, const Args &...); +}; +namespace v7 { +struct fallback_formatter : formatter, int> { + template void format(int, OutputIt ctx) { + basic_string_view str(0, 0); + formatter::format(str, ctx); + } +}; +} // namespace v7 +template +void BucketLogger::log(level::level_enum, const S &fmt, Args &&...args) { + make_args_checked(fmt, args...); +} +template +void BucketLogger::warn(const char *fmt, const Args &...args) { + log(level::warn, fmt, args...); +} +template struct AtomicHashArray { + static void create(); + atomic isFull_; + atomic numErases_; + pair cells_[0]; + AtomicHashArray(int, KeyT, KeyT, KeyT, double, unsigned); +}; +template +AtomicHashArray::AtomicHashArray(int, KeyT, KeyT, KeyT, double, unsigned) + : isFull_(0), numErases_(0) {} +template void AtomicHashArray::create() { + int c_4, capacity; + double c_3; + char c_2, c_1, c_0; + AtomicHashArray(capacity, c_0, c_1, c_2, c_3, c_4); +} +int bufferAcknowledgement_vbucket; +void DcpProducer::bufferAcknowledgement() { + logger->warn("", bufferAcknowledgement_vbucket); +} +void (*makeStreamsMap_p)() = AtomicHashArray::create;