From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mx0b-001b2d01.pphosted.com (mx0b-001b2d01.pphosted.com [148.163.158.5]) by sourceware.org (Postfix) with ESMTPS id 7EF443858D1E for ; Sun, 16 Apr 2023 13:21:00 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 7EF443858D1E Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=linux.ibm.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=linux.ibm.com Received: from pps.filterd (m0098421.ppops.net [127.0.0.1]) by mx0a-001b2d01.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 33GAF68J032523; Sun, 16 Apr 2023 13:20:58 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ibm.com; h=message-id : date : mime-version : to : cc : from : subject : content-type : content-transfer-encoding; s=pp1; bh=PuKdnAmZoacKeLmAKnnTdD3YrsoyzLz3h6D2Ht8OwAM=; b=Sz+ii3cH3SOmyryiR5sXZMaqfBGQ6eh3AhSoiwiImYAUfqKrwWmnZuOH6xf9777uAubT DJSh+3BZZy5EZmQoIFOPL2XhxomySfOMEoqFLq0+uun3cNZRSzuavsHa+qEiwxIjd7hm gnRAoD4IB5l7kp+5Y3C1EdLdG2RI0mnmXuFNpDUWKSUnrs7Q+Z8On8BSAQZfIqsu5AVl /n6IjAlAPsUhBlZT7rn7jjWgyX2JiCOAoi738M+Lmy7kbIxXNEr/+7oQdgptfR9gjotw nHKFJMbORUR7k2rrhin37I5Sq1T9kPxTGkN7zSq/Q7TdDuvECFTzAWex62L1HRfaoL1P Ww== Received: from pps.reinject (localhost [127.0.0.1]) by mx0a-001b2d01.pphosted.com (PPS) with ESMTPS id 3q0f3kbcb2-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Sun, 16 Apr 2023 13:20:58 +0000 Received: from m0098421.ppops.net (m0098421.ppops.net [127.0.0.1]) by pps.reinject (8.17.1.5/8.17.1.5) with ESMTP id 33GDJIOK030613; Sun, 16 Apr 2023 13:20:58 GMT Received: from ppma02wdc.us.ibm.com (aa.5b.37a9.ip4.static.sl-reverse.com [169.55.91.170]) by mx0a-001b2d01.pphosted.com (PPS) with ESMTPS id 3q0f3kbcav-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Sun, 16 Apr 2023 13:20:58 +0000 Received: from pps.filterd (ppma02wdc.us.ibm.com [127.0.0.1]) by ppma02wdc.us.ibm.com (8.17.1.19/8.17.1.19) with ESMTP id 33GCTUDC024277; Sun, 16 Apr 2023 13:20:57 GMT Received: from smtprelay07.wdc07v.mail.ibm.com ([9.208.129.116]) by ppma02wdc.us.ibm.com (PPS) with ESMTPS id 3pykj76ax2-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Sun, 16 Apr 2023 13:20:57 +0000 Received: from smtpav01.wdc07v.mail.ibm.com (smtpav01.wdc07v.mail.ibm.com [10.39.53.228]) by smtprelay07.wdc07v.mail.ibm.com (8.14.9/8.14.9/NCO v10.0) with ESMTP id 33GDKuSb15991342 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Sun, 16 Apr 2023 13:20:56 GMT Received: from smtpav01.wdc07v.mail.ibm.com (unknown [127.0.0.1]) by IMSVA (Postfix) with ESMTP id 643BE58059; Sun, 16 Apr 2023 13:20:56 +0000 (GMT) Received: from smtpav01.wdc07v.mail.ibm.com (unknown [127.0.0.1]) by IMSVA (Postfix) with ESMTP id 0B1B75804B; Sun, 16 Apr 2023 13:20:54 +0000 (GMT) Received: from [9.43.11.115] (unknown [9.43.11.115]) by smtpav01.wdc07v.mail.ibm.com (Postfix) with ESMTP; Sun, 16 Apr 2023 13:20:53 +0000 (GMT) Message-ID: Date: Sun, 16 Apr 2023 18:50:51 +0530 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:102.0) Gecko/20100101 Thunderbird/102.9.1 Content-Language: en-US To: gcc-patches Cc: Segher Boessenkool , Peter Bergner , Richard Biener , Jeff Law From: Ajit Agarwal Subject: [PATCH] tree-ssa-sink: Improve code sinking pass. Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit X-TM-AS-GCONF: 00 X-Proofpoint-ORIG-GUID: 7UeVLSr3ZDL_JkKwgA8DIesbSDMgP9QQ X-Proofpoint-GUID: PmCvd2fgug8LuW0bRPuv-ZbhAAO7E7yf X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.254,Aquarius:18.0.942,Hydra:6.0.573,FMLib:17.11.170.22 definitions=2023-04-16_08,2023-04-14_01,2023-02-09_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 spamscore=0 malwarescore=0 impostorscore=0 suspectscore=0 mlxscore=0 mlxlogscore=999 phishscore=0 priorityscore=1501 bulkscore=0 lowpriorityscore=0 clxscore=1015 adultscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2303200000 definitions=main-2304160121 X-Spam-Status: No, score=-12.0 required=5.0 tests=BAYES_00,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_EF,GIT_PATCH_0,RCVD_IN_MSPIKE_H2,SPF_HELO_NONE,SPF_PASS,TXREP,T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org List-Id: Hello All: This patch improves code sinking pass to sink the blocks before calls in the use blocks or immediate dominator blocks that reduces register pressure. Bootstrapped and regtested on powerpc64-linux-gnu. Thanks & Regards Ajit tree-ssa-sink: Improve code sinking pass. Code Sinking sinks the blocks after call. This increases register pressure for callee-saved registers. Improves code sinking before call in the use blocks or immediate dominator of use blocks. 2023-04-16 Ajit Kumar Agarwal gcc/ChangeLog: * tree-ssa-sink.cc (statement_sink_location): Modifed to move statements before calls. (block_call_p): New function. (def_use_same_block): New function. (select_best_block): Add heuristics to select the best blocks in the immediate post dominator. gcc/testsuite/ChangeLog: * gcc.dg/tree-ssa/ssa-sink-20.c: New testcase. * gcc.dg/tree-ssa/ssa-sink-21.c: New testcase. --- gcc/testsuite/gcc.dg/tree-ssa/ssa-sink-20.c | 16 +++ gcc/testsuite/gcc.dg/tree-ssa/ssa-sink-21.c | 20 +++ gcc/tree-ssa-sink.cc | 134 +++++++++++++++++++- 3 files changed, 164 insertions(+), 6 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/ssa-sink-20.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/ssa-sink-21.c diff --git a/gcc/testsuite/gcc.dg/tree-ssa/ssa-sink-20.c b/gcc/testsuite/gcc.dg/tree-ssa/ssa-sink-20.c new file mode 100644 index 00000000000..716bc1f9257 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/ssa-sink-20.c @@ -0,0 +1,16 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-sink -fdump-tree-optimized -fdump-tree-sink-stats" } */ + +void bar(); +int j; +void foo(int a, int b, int c, int d, int e, int f) +{ + int l; + l = a + b + c + d +e + f; + if (a != 5) + { + bar(); + j = l; + } +} +/* { dg-final { scan-tree-dump-times "Sunk statements: 5" 1 "sink" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/ssa-sink-21.c b/gcc/testsuite/gcc.dg/tree-ssa/ssa-sink-21.c new file mode 100644 index 00000000000..ff41e2ea8ae --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/ssa-sink-21.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-sink-stats -fdump-tree-sink-stats" } */ + +void bar(); +int j, x; +void foo(int a, int b, int c, int d, int e, int f) +{ + int l; + l = a + b + c + d +e + f; + if (a != 5) + { + bar(); + if (b != 3) + x = 3; + else + x = 5; + j = l; + } +} +/* { dg-final { scan-tree-dump-times "Sunk statements: 5" 1 "sink" } } */ diff --git a/gcc/tree-ssa-sink.cc b/gcc/tree-ssa-sink.cc index 87b1d40c174..12babf73321 100644 --- a/gcc/tree-ssa-sink.cc +++ b/gcc/tree-ssa-sink.cc @@ -171,6 +171,70 @@ nearest_common_dominator_of_uses (def_operand_p def_p, bool *debug_stmts) return commondom; } +/* Check def and use stmts are in same block. */ + +bool +def_use_same_block (gimple *use) +{ + use_operand_p use_p; + def_operand_p def_p; + imm_use_iterator imm_iter; + ssa_op_iter iter; + + FOR_EACH_SSA_DEF_OPERAND (def_p, use, iter, SSA_OP_DEF) + { + FOR_EACH_IMM_USE_FAST (use_p, imm_iter, DEF_FROM_PTR (def_p)) + { + if (is_gimple_debug (USE_STMT (use_p))) + continue; + + if (use_p + && (gimple_bb(USE_STMT (use_p)) == gimple_bb (use))) + return true; + } + } + return false; +} + +/* Check if the block has only calls. */ + +bool +block_call_p (basic_block bb) +{ + int i = 0; + bool is_call = false; + gimple_stmt_iterator gsi = gsi_last_bb (bb); + gimple *last_stmt = gsi_stmt (gsi); + + if (last_stmt && gimple_code (last_stmt) == GIMPLE_COND) + { + if (!gsi_end_p (gsi)) + gsi_prev (&gsi); + + for (; !gsi_end_p (gsi);) + { + gimple *stmt = gsi_stmt (gsi); + + if (is_gimple_debug (stmt)) + return false; + + if (is_gimple_call (stmt)) + is_call = true; + else + return false; + + if (!gsi_end_p (gsi)) + gsi_prev (&gsi); + + ++i; + } + } + if (is_call && i == 1) + return true; + + return false; +} + /* Given EARLY_BB and LATE_BB, two blocks in a path through the dominator tree, return the best basic block between them (inclusive) to place statements. @@ -190,7 +254,8 @@ nearest_common_dominator_of_uses (def_operand_p def_p, bool *debug_stmts) static basic_block select_best_block (basic_block early_bb, basic_block late_bb, - gimple *stmt) + gimple *stmt, + gimple *use = 0) { basic_block best_bb = late_bb; basic_block temp_bb = late_bb; @@ -230,7 +295,28 @@ select_best_block (basic_block early_bb, if (threshold > 100) threshold = 100; } + if (bb_loop_depth (best_bb) == bb_loop_depth (early_bb) + && !(best_bb->count * 100 >= early_bb->count * threshold)) + { + basic_block new_best_bb = get_immediate_dominator (CDI_DOMINATORS, best_bb); + + if (new_best_bb && use + && (new_best_bb != best_bb) + && (new_best_bb != early_bb) + && !is_gimple_call (stmt) + && gsi_end_p (gsi_start_phis (new_best_bb)) + && (gimple_bb (use) != early_bb) + && !is_gimple_call (use) + && dominated_by_p (CDI_POST_DOMINATORS, new_best_bb, gimple_bb(use)) + && dominated_by_p (CDI_DOMINATORS, new_best_bb, early_bb) + && block_call_p (new_best_bb)) + { + if (def_use_same_block (use)) + return best_bb; + return new_best_bb; + } + } /* If BEST_BB is at the same nesting level, then require it to have significantly lower execution frequency to avoid gratuitous movement. */ if (bb_loop_depth (best_bb) == bb_loop_depth (early_bb) @@ -456,19 +542,55 @@ statement_sink_location (gimple *stmt, basic_block frombb, continue; break; } + use = USE_STMT (one_use); if (gimple_code (use) != GIMPLE_PHI) { - sinkbb = select_best_block (frombb, gimple_bb (use), stmt); + sinkbb = select_best_block (frombb, gimple_bb (use), stmt, use); if (sinkbb == frombb) return false; - if (sinkbb == gimple_bb (use)) - *togsi = gsi_for_stmt (use); - else - *togsi = gsi_after_labels (sinkbb); + gimple *def_stmt = SSA_NAME_DEF_STMT (DEF_FROM_PTR (def_p)); + + if ((gimple_bb (def_stmt) == gimple_bb (use)) + && (gimple_bb (use) != sinkbb)) + sinkbb = gimple_bb (use); + + if (sinkbb == gimple_bb (use)) + { + gimple_stmt_iterator gsi = gsi_last_bb (sinkbb); + gimple *def_stmt = SSA_NAME_DEF_STMT (DEF_FROM_PTR (def_p)); + gimple *last_stmt = gsi_stmt (gsi); + + if (gsi_stmt (gsi) == use + && !is_gimple_call (last_stmt) + && (gimple_code (last_stmt) != GIMPLE_SWITCH) + && (gimple_code (last_stmt) != GIMPLE_COND) + && (gimple_code (last_stmt) != GIMPLE_GOTO) + && (!gimple_vdef (use) || !def_use_same_block (def_stmt))) + { + if (!gsi_end_p (gsi)) + gsi_prev (&gsi); + + gimple *stmt = gsi_stmt (gsi); + + if (!gsi_end_p (gsi)) + gsi_prev (&gsi); + + if (gsi_end_p (gsi) && stmt && is_gimple_call (stmt) + && gsi_end_p (gsi_start_phis (sinkbb)) + && !is_gimple_call (def_stmt)) + *togsi = gsi_for_stmt (stmt); + else + *togsi = gsi_for_stmt (use); + } + else + *togsi = gsi_for_stmt(use); + } + else + *togsi = gsi_after_labels (sinkbb); return true; } -- 2.31.1