From patchwork Fri Oct 13 18:53:01 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Marek Polacek X-Patchwork-Id: 152700 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a05:612c:2908:b0:403:3b70:6f57 with SMTP id ib8csp2091021vqb; Fri, 13 Oct 2023 11:53:33 -0700 (PDT) X-Google-Smtp-Source: AGHT+IGrO+HkaYck7wkqn128D07u2OaNsrM0bNMe9MxG+a38DcP1mWzEKEGlZl+zYoC/dzPt6L8K X-Received: by 2002:ae9:e00b:0:b0:774:2abc:eadd with SMTP id m11-20020ae9e00b000000b007742abceaddmr28347108qkk.61.1697223213665; Fri, 13 Oct 2023 11:53:33 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1697223213; cv=none; d=google.com; s=arc-20160816; b=Y4czz4iNp0YOjpxgNZ45NiwJygBGHM7gJXBl+qUkTLfSlvioGXVMb3Y3fzxWivElcf Zj+bi8RcCwpXD4FTaUFpDQEcHxRw0fDn4+as9KZYkjbwXTFo3d7TnKeQoBfZEN9CcWgt /U4AXjV0CmalFqUz9fi6FmL9t9Jm5RDJGd6q+fbnNW2Y2zIZ9f/DyxIhKp8JvnMosCI4 tNxpMYaKXYpWkokI4HQNvCXSz84Q8uBmUz7fl5xlDFiC/LyY6pXaRx4vwqx2sO8YXe7q UgxMP+BfpGyPLob7J5mE8VB+wAPE3i+8Y2qQmHkU+pOoXshXTd6RRNjVIBEcyDx1SeNn WR9w== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=errors-to:list-subscribe:list-help:list-post:list-archive :list-unsubscribe:list-id:precedence:content-disposition:user-agent :in-reply-to:mime-version:references:message-id:subject:cc:to:from :date:dkim-signature:dmarc-filter:delivered-to; bh=QYORaEfuOkWN1v4TKJKdh+9yU466zeW7aPUgcKK0Le4=; fh=rsfJLMIL/7j+58qzkgIXBlfQSah3iXypQc76SN5PqTs=; b=ZmjBUP+wwaOmr6IvgjcVNNwbI3Dk2g6WwRv/k8e1G3zpFeocYrMRc64L7FLLV+VccO tcVE3TAlGOvEfkIf+JFTd2lYXckKpf/zy54MJlQL/TOjpVt5cgDZlDHVhGKA5AEadnU1 TIHGpl8dAIyTZe1vPNetHLvQIHdtNA4YcEWG0HYmBtn0BF0yE69rYuIsqA6dqdLswbCJ +h4FrupQhS+DOyP75OlmWJZmFmsZkXI9DikVm3HAI9T70RmZ1VT33cGI6QPR8R1YxOsK Vou48Zi9CtrNT4FSTLlgffNROspoEsohME6l/7L9+sjg4Z+g81NR212dC9w+AsM7ef1G ICZg== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@redhat.com header.s=mimecast20190719 header.b=IwwiHLE9; spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 8.43.85.97 as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=redhat.com Received: from server2.sourceware.org (ip-8-43-85-97.sourceware.org. [8.43.85.97]) by mx.google.com with ESMTPS id m11-20020a05620a24cb00b0076ca9dc9770si1705529qkn.661.2023.10.13.11.53.33 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 13 Oct 2023 11:53:33 -0700 (PDT) Received-SPF: pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 8.43.85.97 as permitted sender) client-ip=8.43.85.97; Authentication-Results: mx.google.com; dkim=pass header.i=@redhat.com header.s=mimecast20190719 header.b=IwwiHLE9; spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 8.43.85.97 as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=redhat.com Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 6B3813858005 for ; Fri, 13 Oct 2023 18:53:33 +0000 (GMT) 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 ESMTPS id A97093858D1E for ; Fri, 13 Oct 2023 18:53:07 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org A97093858D1E Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=redhat.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=redhat.com DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1697223187; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: in-reply-to:in-reply-to:references:references; bh=QYORaEfuOkWN1v4TKJKdh+9yU466zeW7aPUgcKK0Le4=; b=IwwiHLE9BZKnZJxKahRzHVRqJXeRnTAi2Hl+dYmJpBfpTPdsdlfGXDrnZLvZ52xfBLW8UA YsYOvbBpiTs5jF2QEpZTIJga/e8/E7+Q3sKm24unQ2lNe8Y/uovsiOU8b7NZQAsG71ur6p rhMelIHJpI5KdQ6qzcDfuMlAhc4/bxE= Received: from mail-qv1-f70.google.com (mail-qv1-f70.google.com [209.85.219.70]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-252-VvSJx_5sNOS80zXHjCpU9w-1; Fri, 13 Oct 2023 14:53:05 -0400 X-MC-Unique: VvSJx_5sNOS80zXHjCpU9w-1 Received: by mail-qv1-f70.google.com with SMTP id 6a1803df08f44-65b13c48253so27267606d6.3 for ; Fri, 13 Oct 2023 11:53:05 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1697223185; x=1697827985; h=user-agent:in-reply-to:content-disposition:mime-version:references :message-id:subject:cc:to:from:date:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=QYORaEfuOkWN1v4TKJKdh+9yU466zeW7aPUgcKK0Le4=; b=XxJNHvEfFRMnzeeDUCw+Abn47B2y3WyaItuFgmF6cvgTFnxZINTsMrCQYw7y9u+shj 3+3IDTeZgxPlS175nhPaOclV5Y+7FulSV1gAzNfumEVoPLwf0gMgsoiF5ffpVB2+JFfZ pFGiahreM2GRLumfcVW9xQPCpoXUDjtWmF/Ndfn6fkjolCazWEDpUr/GvxWYOoMIs+W4 +dVp3SZtQFMrl9q/QNb2z/q4deI0fS41NIYqOw/TVQXKRjSLHJkbfTy5cEwgFKjM6gj+ FDGR2EgTIyYK+dhuI7Q2vskZ95IswwlLBKZmfa/8Pjr1MWTl/EJutniQVfO/9TO7OCCD m6Lw== X-Gm-Message-State: AOJu0YyHWH34MFK9xu9mpFTCJdZ9TxJiCEOefIFwWK9WsXXgCJz4tO+Z rQ7Vj0mmKOdOT7Cj3NXZB7xu+5AGhhqBqUsSt+8eEiEuqZ7oX3/Z02Kj4RYow4P1sF60E8h//BM 4M5slnV9kTQHgVjxqTAYch35QUQ== X-Received: by 2002:a05:620a:a13:b0:775:7339:68f8 with SMTP id i19-20020a05620a0a1300b00775733968f8mr28440488qka.57.1697223184699; Fri, 13 Oct 2023 11:53:04 -0700 (PDT) X-Received: by 2002:a05:620a:a13:b0:775:7339:68f8 with SMTP id i19-20020a05620a0a1300b00775733968f8mr28440468qka.57.1697223184265; Fri, 13 Oct 2023 11:53:04 -0700 (PDT) Received: from redhat.com (2603-7000-9500-34a5-0000-0000-0000-1db4.res6.spectrum.com. [2603:7000:9500:34a5::1db4]) by smtp.gmail.com with ESMTPSA id g15-20020a05620a108f00b0077413b342e9sm846271qkk.128.2023.10.13.11.53.03 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 13 Oct 2023 11:53:03 -0700 (PDT) Date: Fri, 13 Oct 2023 14:53:01 -0400 From: Marek Polacek To: Jason Merrill Cc: GCC Patches Subject: [PATCH v2] c++: Fix compile-time-hog in cp_fold_immediate_r [PR111660] Message-ID: References: <20231012210426.755503-1-polacek@redhat.com> <58e6893f-178e-4732-9c96-b52c38ad37c5@redhat.com> MIME-Version: 1.0 In-Reply-To: <58e6893f-178e-4732-9c96-b52c38ad37c5@redhat.com> User-Agent: Mutt/2.2.9 (2022-11-12) X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Disposition: inline X-Spam-Status: No, score=-12.4 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_NONE, RCVD_IN_MSPIKE_H3, RCVD_IN_MSPIKE_WL, SPF_HELO_NONE, SPF_NONE, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1779585207875623275 X-GMAIL-MSGID: 1779667528703268510 On Thu, Oct 12, 2023 at 09:41:43PM -0400, Jason Merrill wrote: > On 10/12/23 17:04, Marek Polacek wrote: > > Bootstrapped/regtested on x86_64-pc-linux-gnu, ok for trunk? > > > > -- >8 -- > > My recent patch introducing cp_fold_immediate_r caused exponential > > compile time with nested COND_EXPRs. The problem is that the COND_EXPR > > case recursively walks the arms of a COND_EXPR, but after processing > > both arms it doesn't end the walk; it proceeds to walk the > > sub-expressions of the outermost COND_EXPR, triggering again walking > > the arms of the nested COND_EXPR, and so on. This patch brings the > > compile time down to about 0m0.033s. > > > > I've added some debug prints to make sure that the rest of cp_fold_r > > is still performed as before. > > > > PR c++/111660 > > > > gcc/cp/ChangeLog: > > > > * cp-gimplify.cc (cp_fold_immediate_r) : Return > > integer_zero_node instead of break;. > > (cp_fold_immediate): Return true if cp_fold_immediate_r returned > > error_mark_node. > > > > gcc/testsuite/ChangeLog: > > > > * g++.dg/cpp0x/hog1.C: New test. > > --- > > gcc/cp/cp-gimplify.cc | 9 ++-- > > gcc/testsuite/g++.dg/cpp0x/hog1.C | 77 +++++++++++++++++++++++++++++++ > > 2 files changed, 82 insertions(+), 4 deletions(-) > > create mode 100644 gcc/testsuite/g++.dg/cpp0x/hog1.C > > > > diff --git a/gcc/cp/cp-gimplify.cc b/gcc/cp/cp-gimplify.cc > > index bdf6e5f98ff..ca622ca169a 100644 > > --- a/gcc/cp/cp-gimplify.cc > > +++ b/gcc/cp/cp-gimplify.cc > > @@ -1063,16 +1063,16 @@ cp_fold_immediate_r (tree *stmt_p, int *walk_subtrees, void *data_) > > break; > > if (TREE_OPERAND (stmt, 1) > > && cp_walk_tree (&TREE_OPERAND (stmt, 1), cp_fold_immediate_r, data, > > - nullptr)) > > + nullptr) == error_mark_node) > > return error_mark_node; > > if (TREE_OPERAND (stmt, 2) > > && cp_walk_tree (&TREE_OPERAND (stmt, 2), cp_fold_immediate_r, data, > > - nullptr)) > > + nullptr) == error_mark_node) > > return error_mark_node; > > /* We're done here. Don't clear *walk_subtrees here though: we're called > > from cp_fold_r and we must let it recurse on the expression with > > cp_fold. */ > > - break; > > + return integer_zero_node; > > I'm concerned this will end up missing something like > > 1 ? 1 : ((1 ? 1 : 1), immediate()) > > as the integer_zero_node from the inner ?: will prevent walk_tree from > looking any farther. You are right. The line above works as expected, but 1 ? 1 : ((1 ? 1 : id (42)), id (i)); shows the problem (when the expression isn't used as an initializer). > Maybe we want to handle COND_EXPR in cp_fold_r instead of here? I hope this version is better. Bootstrapped/regtested on x86_64-pc-linux-gnu, ok for trunk? -- >8 -- My recent patch introducing cp_fold_immediate_r caused exponential compile time with nested COND_EXPRs. The problem is that the COND_EXPR case recursively walks the arms of a COND_EXPR, but after processing both arms it doesn't end the walk; it proceeds to walk the sub-expressions of the outermost COND_EXPR, triggering again walking the arms of the nested COND_EXPR, and so on. This patch brings the compile time down to about 0m0.033s. The ff_fold_immediate flag is unused after this patch but since I'm using it in the P2564 patch, I'm not removing it now. PR c++/111660 gcc/cp/ChangeLog: * cp-gimplify.cc (cp_fold_immediate_r) : Don't handle it here. (cp_fold_r): Handle COND_EXPR here. gcc/testsuite/ChangeLog: * g++.dg/cpp0x/hog1.C: New test. * g++.dg/cpp2a/consteval36.C: New test. --- gcc/cp/cp-gimplify.cc | 38 +++++------- gcc/testsuite/g++.dg/cpp0x/hog1.C | 77 ++++++++++++++++++++++++ gcc/testsuite/g++.dg/cpp2a/consteval36.C | 18 ++++++ 3 files changed, 111 insertions(+), 22 deletions(-) create mode 100644 gcc/testsuite/g++.dg/cpp0x/hog1.C create mode 100644 gcc/testsuite/g++.dg/cpp2a/consteval36.C base-commit: 8be20f3b0bded7f9b690b27cbee58b283dbe827b diff --git a/gcc/cp/cp-gimplify.cc b/gcc/cp/cp-gimplify.cc index bdf6e5f98ff..801cba141cb 100644 --- a/gcc/cp/cp-gimplify.cc +++ b/gcc/cp/cp-gimplify.cc @@ -1052,27 +1052,6 @@ cp_fold_immediate_r (tree *stmt_p, int *walk_subtrees, void *data_) switch (TREE_CODE (stmt)) { - /* Unfortunately we must handle code like - false ? bar () : 42 - where we have to check bar too. The cp_fold call in cp_fold_r could - fold the ?: into a constant before we see it here. */ - case COND_EXPR: - /* If we are called from cp_fold_immediate, we don't need to worry about - cp_fold folding away the COND_EXPR. */ - if (data->flags & ff_fold_immediate) - break; - if (TREE_OPERAND (stmt, 1) - && cp_walk_tree (&TREE_OPERAND (stmt, 1), cp_fold_immediate_r, data, - nullptr)) - return error_mark_node; - if (TREE_OPERAND (stmt, 2) - && cp_walk_tree (&TREE_OPERAND (stmt, 2), cp_fold_immediate_r, data, - nullptr)) - return error_mark_node; - /* We're done here. Don't clear *walk_subtrees here though: we're called - from cp_fold_r and we must let it recurse on the expression with - cp_fold. */ - break; case PTRMEM_CST: if (TREE_CODE (PTRMEM_CST_MEMBER (stmt)) == FUNCTION_DECL && DECL_IMMEDIATE_FUNCTION_P (PTRMEM_CST_MEMBER (stmt))) @@ -1163,7 +1142,22 @@ cp_fold_r (tree *stmt_p, int *walk_subtrees, void *data_) enum tree_code code = TREE_CODE (stmt); if (cxx_dialect > cxx17) - cp_fold_immediate_r (stmt_p, walk_subtrees, data); + { + /* Unfortunately we must handle code like + false ? bar () : 42 + where we have to check bar too. The cp_fold call below could + fold the ?: into a constant before we've checked it. */ + if (code == COND_EXPR) + { + if (TREE_OPERAND (stmt, 1)) + cp_walk_tree (&TREE_OPERAND (stmt, 1), cp_fold_immediate_r, data, + nullptr); + if (TREE_OPERAND (stmt, 2)) + cp_walk_tree (&TREE_OPERAND (stmt, 2), cp_fold_immediate_r, data, + nullptr); + } + cp_fold_immediate_r (stmt_p, walk_subtrees, data); + } *stmt_p = stmt = cp_fold (*stmt_p, data->flags); diff --git a/gcc/testsuite/g++.dg/cpp0x/hog1.C b/gcc/testsuite/g++.dg/cpp0x/hog1.C new file mode 100644 index 00000000000..105a2e912c4 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/hog1.C @@ -0,0 +1,77 @@ +// PR c++/111660 +// { dg-do compile { target c++11 } } + +enum Value { + LPAREN, + RPAREN, + LBRACE, + RBRACE, + LBRACK, + RBRACK, + CONDITIONAL, + COLON, + SEMICOLON, + COMMA, + PERIOD, + BIT_OR, + BIT_AND, + BIT_XOR, + BIT_NOT, + NOT, + LT, + GT, + MOD, + ASSIGN, + ADD, + SUB, + MUL, + DIV, + PRIVATE_NAME, + STRING, + TEMPLATE_SPAN, + IDENTIFIER, + WHITESPACE, + ILLEGAL, +}; + +constexpr Value GetOneCharToken(char c) { + return + c == '(' ? LPAREN : + c == ')' ? RPAREN : + c == '{' ? LBRACE : + c == '}' ? RBRACE : + c == '[' ? LBRACK : + c == ']' ? RBRACK : + c == '?' ? CONDITIONAL : + c == ':' ? COLON : + c == ';' ? SEMICOLON : + c == ',' ? COMMA : + c == '.' ? PERIOD : + c == '|' ? BIT_OR : + c == '&' ? BIT_AND : + c == '^' ? BIT_XOR : + c == '~' ? BIT_NOT : + c == '!' ? NOT : + c == '<' ? LT : + c == '>' ? GT : + c == '%' ? MOD : + c == '=' ? ASSIGN : + c == '+' ? ADD : + c == '-' ? SUB : + c == '*' ? MUL : + c == '/' ? DIV : + c == '#' ? PRIVATE_NAME : + c == '"' ? STRING : + c == '\'' ? STRING : + c == '`' ? TEMPLATE_SPAN : + c == '\\' ? IDENTIFIER : + c == ' ' ? WHITESPACE : + c == '\t' ? WHITESPACE : + c == '\v' ? WHITESPACE : + c == '\f' ? WHITESPACE : + c == '\r' ? WHITESPACE : + c == '\n' ? WHITESPACE : + ILLEGAL; +} + +int main() {} diff --git a/gcc/testsuite/g++.dg/cpp2a/consteval36.C b/gcc/testsuite/g++.dg/cpp2a/consteval36.C new file mode 100644 index 00000000000..d6aea214d61 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp2a/consteval36.C @@ -0,0 +1,18 @@ +// PR c++/111660 +// { dg-do compile { target c++20 } } + +consteval int id (int i) { return i; } + +void +g (int i) +{ + 1 ? 1 : ((1 ? 1 : 1), id (i)); // { dg-error "'i' is not a constant expression" } + 1 ? 1 : ((1 ? 1 : 1), id (i), 1); // { dg-error "'i' is not a constant expression" } + 1 ? 1 : ((i ? 1 : 1), id (i), 1); // { dg-error "'i' is not a constant expression" } + 1 ? 1 : ((1 ? i : 1), id (i), 1); // { dg-error "'i' is not a constant expression" } + 1 ? 1 : ((1 ? 1 : i), id (i), 1); // { dg-error "'i' is not a constant expression" } + 1 ? 1 : ((i ? -i : i), id (i), 1); // { dg-error "'i' is not a constant expression" } + 1 ? 1 : ((1 ? 1 : id (i)), id (42), 1); // { dg-error "'i' is not a constant expression" } + 1 ? 1 : ((1 ? 1 : id (42)), id (i)); // { dg-error "'i' is not a constant expression" } + 1 ? 1 : ((1 ? 1 : id (42)), id (i), 1); // { dg-error "'i' is not a constant expression" } +}