From patchwork Fri Sep 20 16:40:27 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Siddhesh Poyarekar X-Patchwork-Id: 97768 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 1C3813858420 for ; Fri, 20 Sep 2024 16:41:35 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from beige.elm.relay.mailchannels.net (beige.elm.relay.mailchannels.net [23.83.212.16]) by sourceware.org (Postfix) with ESMTPS id A0E053858C66; Fri, 20 Sep 2024 16:40:47 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org A0E053858C66 Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=gotplt.org Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=gotplt.org ARC-Filter: OpenARC Filter v1.0.0 sourceware.org A0E053858C66 Authentication-Results: server2.sourceware.org; arc=pass smtp.remote-ip=23.83.212.16 ARC-Seal: i=2; a=rsa-sha256; d=sourceware.org; s=key; t=1726850449; cv=pass; b=Aabxw3Dmd5XtJez6omUUzEZcV6s7GRM3LbGQzPFAyJSzYbtxz5wq21gHShLoQOZ/CRn23DO3h/nydKfZSCu31KTkK1DRFTrK6+98Kck748UmvVyIK8PPXiO1tXjnKUFI/Tt8KCksCQzDj+t70Qz+LacVpVv7yvO4WZp1+ruDZNw= ARC-Message-Signature: i=2; a=rsa-sha256; d=sourceware.org; s=key; t=1726850449; c=relaxed/simple; bh=EGvKiW0fiyuqdPSoSvWgSNH5B+dlLWylFj+O+yWTi1E=; h=DKIM-Signature:From:To:Subject:Date:Message-ID:MIME-Version; b=ZU1/x1TqJMHmqqT6Zv3yp4CEmX4DeLxATyPkQB7vY6wlhg/I4RjyYzPADpsl4AA+X8t9gYO/4m6pi7yR9XJw4DgKmr5mIU6f0bRTe4gmmo1J0GFsL+THjIX0lvzldLhnHW8oadxrdqRTcvxI/aPPHm6wsyRTaIHIu8C14F1XKRk= ARC-Authentication-Results: i=2; server2.sourceware.org X-Sender-Id: dreamhost|x-authsender|siddhesh@gotplt.org Received: from relay.mailchannels.net (localhost [127.0.0.1]) by relay.mailchannels.net (Postfix) with ESMTP id 9CA691A6383; Fri, 20 Sep 2024 16:40:46 +0000 (UTC) Received: from pdx1-sub0-mail-a312.dreamhost.com (100-99-68-57.trex-nlb.outbound.svc.cluster.local [100.99.68.57]) (Authenticated sender: dreamhost) by relay.mailchannels.net (Postfix) with ESMTPA id 410691A236A; Fri, 20 Sep 2024 16:40:46 +0000 (UTC) ARC-Seal: i=1; s=arc-2022; d=mailchannels.net; t=1726850446; a=rsa-sha256; cv=none; b=6F+3R1X+FHYJuMEu5zPOSLIbHUvcnarVP4kxdJ74/XITyGpxlO6xEfmdfertEi3NXgkZsv oQSVzRV4w/+oco7HGQ+xo96SsruvrnQlAIqXzSGxQ6+LHIRAO+BuxhC/iIbYjHBMm1iSqv 3L/ktLM9WVbtnD6StcRc1N51TP7Wexy8hQDrbrVCsJQ4uDDtViANn2dj/T4dMkE+o853F9 S7VS109rag+GnWIXx1YYaOGM/97eZq2ZXo6gwR/H/fAUcspI53ToZCJ3cYfieMvGbLzaOd tcHmjbCV/O0ZT+820RZ/xi1rpqUXKu/GLFL/atVept3qqiquvucVlsLGgf9fIw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=mailchannels.net; s=arc-2022; t=1726850446; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=o9TDWwqXoyPzTrjXb9xur51IlQFiX6wirNjEqlWR4dY=; b=IISlYxNa5B013dYw5xhcgRMMIfvb8tFayN4yK8Eu1/EbSphmsoTdYQxW5vJD1n6bVhaUO+ NIdpfMvSrpNXJyPW6NY4XX6REkytP43cNzrF1jde+FtMTWJdiLfNXMuF0XgVBQX9HLH7y+ Ifp8WZuAS8pxbDyCmUAOu/XwTCg7Lh4ajSQylPoSkTIlO5oK5zsZKCG74zyVGDTcKSHiiG 0shjhR225U19hL+aXcAjVlLDq3ORAT2PpY9YI0NGy0gj539U4UPZz/BKYSNoFqX+jTsZG3 bAh+efB0PQD7e4U5fT+IMkmzD0NvpT9Ta/SDZkDRluAMPjkjvLOm7JAZ+S1D/A== ARC-Authentication-Results: i=1; rspamd-5b46bcd97f-5x2s4; auth=pass smtp.auth=dreamhost smtp.mailfrom=siddhesh@gotplt.org X-Sender-Id: dreamhost|x-authsender|siddhesh@gotplt.org X-MC-Relay: Neutral X-MailChannels-SenderId: dreamhost|x-authsender|siddhesh@gotplt.org X-MailChannels-Auth-Id: dreamhost X-Cellar-Illustrious: 4c0c190a42770ac4_1726850446545_658108161 X-MC-Loop-Signature: 1726850446545:3897719161 X-MC-Ingress-Time: 1726850446545 Received: from pdx1-sub0-mail-a312.dreamhost.com (pop.dreamhost.com [64.90.62.162]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384) by 100.99.68.57 (trex/7.0.2); Fri, 20 Sep 2024 16:40:46 +0000 Received: from fedora.redhat.com (bras-base-toroon4859w-grc-66-76-71-1-128.dsl.bell.ca [76.71.1.128]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits) server-digest SHA256) (No client certificate requested) (Authenticated sender: siddhesh@gotplt.org) by pdx1-sub0-mail-a312.dreamhost.com (Postfix) with ESMTPSA id 4X9J6P6X75zS4; Fri, 20 Sep 2024 09:40:45 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gotplt.org; s=dreamhost; t=1726850446; bh=o9TDWwqXoyPzTrjXb9xur51IlQFiX6wirNjEqlWR4dY=; h=From:To:Cc:Subject:Date:Content-Transfer-Encoding; b=wKrreNv1NBJpp/UQjpqpSPtfU8sMMDi8KlOIJfzKp9oLYgGnzKW00HmG9sOEOgREf uSCytmFhv2R68mMg6FREnSFQZ+IkDnhwrHT727ZtET2RKZkwzDDyJkdeSYSy9B3wX0 cVpC1v11/Kn9PVbme0+N8iB747WXfihYR4WIfaHdYVADSfD8zOj42N4SKi95HxwuLG YuGYWX7DFyU9EYB9Y+Qt+ddb+3KBWLh9alkpRkKZzRRzK1HqmuSQfgSdHPE8oYEXvn ykKYJAtfAroNyZF7TazLAIrtQS0lZasLQaU0KWKguozOzMjoQXAwp+z1/bC/VQFpMK hFo+FrQMn7wTg== From: Siddhesh Poyarekar To: gcc-patches@gcc.gnu.org Cc: pinskia@gcc.gnu.org Subject: [PATCH v2 2/4] tree-object-size: Fold PHI node offsets with constants [PR116556] Date: Fri, 20 Sep 2024 12:40:27 -0400 Message-ID: <20240920164029.63843-3-siddhesh@gotplt.org> X-Mailer: git-send-email 2.45.1 In-Reply-To: <20240920164029.63843-1-siddhesh@gotplt.org> References: <20240914123049.2746225-1-siddhesh@gotplt.org> <20240920164029.63843-1-siddhesh@gotplt.org> MIME-Version: 1.0 X-Spam-Status: No, score=-3036.8 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, RCVD_IN_MSPIKE_H2, SPF_HELO_NONE, SPF_PASS, 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~patchwork=sourceware.org@gcc.gnu.org In PTR + OFFSET cases, try harder to see if the target offset could result in a constant. Specifically, if the offset is a PHI node with all constant branches, return the minimum (or maximum for OST_MINIMUM) of the possible values. gcc/ChangeLog: PR tree-optimization/116556 * tree-object-size.cc (try_collapsing_offset): New function. (plus_stmt_object_size): Use it. * gcc/testsuite/gcc.dg/builtin-object-size-1.c (test12, test13): New functions. (main): Call them. * gcc/testsuite/gcc.dg/builtin-object-size-3.c (test12, test13): New functions. (main): Call them. Signed-off-by: Siddhesh Poyarekar --- gcc/testsuite/gcc.dg/builtin-object-size-1.c | 63 ++++++++++++++++++++ gcc/testsuite/gcc.dg/builtin-object-size-3.c | 63 ++++++++++++++++++++ gcc/tree-object-size.cc | 60 +++++++++++++++++++ 3 files changed, 186 insertions(+) diff --git a/gcc/testsuite/gcc.dg/builtin-object-size-1.c b/gcc/testsuite/gcc.dg/builtin-object-size-1.c index d6d13c5ef7a..1f5cd5d99a1 100644 --- a/gcc/testsuite/gcc.dg/builtin-object-size-1.c +++ b/gcc/testsuite/gcc.dg/builtin-object-size-1.c @@ -712,6 +712,65 @@ test11 (void) } #endif +void +__attribute__ ((noinline)) +test12 (unsigned cond) +{ + char *buf2 = malloc (10); + char *p; + size_t t; + + if (cond) + t = 8; + else + t = 4; + + p = &buf2[t]; + +#ifdef __builtin_object_size + if (__builtin_object_size (p, 0) != (cond ? 2 : 6)) + FAIL (); +#else + if (__builtin_object_size (p, 0) != 6) + FAIL (); +#endif +} + +void +__attribute__ ((noinline)) +test13 (unsigned cond) +{ + char *buf2 = malloc (10); + char *p = &buf2[4]; + int t; + + if (cond) + t = -1; + else + t = -2; + +#ifdef __builtin_object_size + if (__builtin_object_size (&p[t], 0) != (cond ? 7 : 8)) + FAIL (); +#else + if (__builtin_object_size (&p[t], 0) != 8) + FAIL (); +#endif + + if (cond) + t = 1; + else + t = -3; + +#ifdef __builtin_object_size + if (__builtin_object_size (&p[t], 0) != (cond ? 5 : 9)) + FAIL (); +#else + if (__builtin_object_size (&p[t], 0) != 9) + FAIL (); +#endif +} + int main (void) { @@ -729,6 +788,10 @@ main (void) test10 (); #ifndef SKIP_STRNDUP test11 (); + test12 (1); + test12 (0); + test13 (1); + test13 (0); #endif DONE (); } diff --git a/gcc/testsuite/gcc.dg/builtin-object-size-3.c b/gcc/testsuite/gcc.dg/builtin-object-size-3.c index ec2c62c9640..7fad106fc27 100644 --- a/gcc/testsuite/gcc.dg/builtin-object-size-3.c +++ b/gcc/testsuite/gcc.dg/builtin-object-size-3.c @@ -720,6 +720,65 @@ test11 (void) } #endif +void +__attribute__ ((noinline)) +test12 (unsigned cond) +{ + char *buf2 = malloc (10); + char *p; + size_t t; + + if (cond) + t = 8; + else + t = 4; + + p = &buf2[t]; + +#ifdef __builtin_object_size + if (__builtin_object_size (p, 2) != (cond ? 2 : 6)) + FAIL (); +#else + if (__builtin_object_size (p, 2) != 2) + FAIL (); +#endif +} + +void +__attribute__ ((noinline)) +test13 (unsigned cond) +{ + char *buf2 = malloc (10); + char *p = &buf2[4]; + size_t t; + + if (cond) + t = -1; + else + t = -2; + +#ifdef __builtin_object_size + if (__builtin_object_size (&p[t], 2) != (cond ? 7 : 8)) + FAIL (); +#else + if (__builtin_object_size (&p[t], 2) != 7) + FAIL (); +#endif + + if (cond) + t = 1; + else + t = -3; + +#ifdef __builtin_object_size + if (__builtin_object_size (&p[t], 2) != (cond ? 5 : 9)) + FAIL (); +#else + if (__builtin_object_size (&p[t], 2) != 5) + FAIL (); +#endif +} + int main (void) { @@ -738,5 +797,9 @@ main (void) #ifndef SKIP_STRNDUP test11 (); #endif + test12 (1); + test12 (0); + test13 (1); + test13 (0); DONE (); } diff --git a/gcc/tree-object-size.cc b/gcc/tree-object-size.cc index f8fae0cbc82..2dfc28407ab 100644 --- a/gcc/tree-object-size.cc +++ b/gcc/tree-object-size.cc @@ -1468,6 +1468,63 @@ merge_object_sizes (struct object_size_info *osi, tree dest, tree orig) return bitmap_bit_p (osi->reexamine, SSA_NAME_VERSION (orig)); } +/* For constant sizes, try collapsing a non-constant offset to a constant if + possible. The case handled at the moment is when the offset is a PHI node + with all of its targets are constants. */ + +static tree +try_collapsing_offset (tree op, int object_size_type) +{ + gcc_assert (!(object_size_type & OST_DYNAMIC)); + + if (TREE_CODE (op) != SSA_NAME) + return op; + + gimple *stmt = SSA_NAME_DEF_STMT (op); + + switch (gimple_code (stmt)) + { + case GIMPLE_ASSIGN: + /* Peek through casts. */ + if (gimple_assign_rhs_code (stmt) == NOP_EXPR) + { + tree ret = try_collapsing_offset (gimple_assign_rhs1 (stmt), + object_size_type); + if (TREE_CODE (ret) == INTEGER_CST) + return ret; + } + break; + case GIMPLE_PHI: + { + tree off = ((object_size_type & OST_MINIMUM) + ? TYPE_MIN_VALUE (ptrdiff_type_node) + : TYPE_MAX_VALUE (ptrdiff_type_node)); + + for (unsigned i = 0; i < gimple_phi_num_args (stmt); i++) + { + tree rhs = gimple_phi_arg_def (stmt, i); + + if (TREE_CODE (rhs) != INTEGER_CST) + return op; + + /* Note that this is the *opposite* of what we usually do with + sizes, because the maximum offset estimate here will give us a + minimum size estimate and vice versa. */ + enum tree_code code = (object_size_type & OST_MINIMUM + ? MAX_EXPR : MIN_EXPR); + + off = fold_build2 (code, ptrdiff_type_node, off, + fold_convert (ptrdiff_type_node, rhs)); + } + return fold_convert (sizetype, off); + } + default: + break; + } + + /* Nothing worked, so return OP untouched. */ + return op; +} /* Compute object_sizes for VAR, defined to the result of an assignment with operator POINTER_PLUS_EXPR. Return true if the object size might @@ -1500,6 +1557,9 @@ plus_stmt_object_size (struct object_size_info *osi, tree var, gimple *stmt) if (object_sizes_unknown_p (object_size_type, varno)) return false; + if (!(object_size_type & OST_DYNAMIC) && TREE_CODE (op1) != INTEGER_CST) + op1 = try_collapsing_offset (op1, object_size_type); + /* Handle PTR + OFFSET here. */ if (size_valid_p (op1, object_size_type) && (TREE_CODE (op0) == SSA_NAME || TREE_CODE (op0) == ADDR_EXPR))