From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 1725) id 57A3B3940CF0; Fri, 28 Aug 2020 13:43:22 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 57A3B3940CF0 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1598622202; bh=87TOTa4EGeYD1BQEt4nTGm+ZDsFlsIs9ZmjGwnkV9W4=; h=From:To:Subject:Date:From; b=TBDV/H9bU2gcTqRjsY2uD5aWn5k3+qNw44/lajcZtLQ8MxQIdfGS1qPEU1UNl+N3E PJ/CZH0Pp2zLvPh3032MxiZ19DjkSMy1dHLltJCfz5ZFQlRfjprOcAIVhHafCSK8I8 8KBz3VORg5PsKNMEtuF+5T8bubtLRIMzsWGYzsgQ= Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: William Schmidt To: gcc-cvs@gcc.gnu.org Subject: [gcc(refs/users/wschmidt/heads/sibfix)] streamline TARGET_MEM_REF dumping X-Act-Checkin: gcc X-Git-Author: Richard Biener X-Git-Refname: refs/users/wschmidt/heads/sibfix X-Git-Oldrev: 6b3034eaba83935d9f6dfb20d2efbdb34b5b00bf X-Git-Newrev: 9ceb3b8d8f6dd088f3efd590aae9e54a265e5b07 Message-Id: <20200828134322.57A3B3940CF0@sourceware.org> Date: Fri, 28 Aug 2020 13:43:22 +0000 (GMT) X-BeenThere: gcc-cvs@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-cvs mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Fri, 28 Aug 2020 13:43:22 -0000 https://gcc.gnu.org/g:9ceb3b8d8f6dd088f3efd590aae9e54a265e5b07 commit 9ceb3b8d8f6dd088f3efd590aae9e54a265e5b07 Author: Richard Biener Date: Thu Aug 27 13:04:19 2020 +0200 streamline TARGET_MEM_REF dumping The following streamlines TARGET_MEM_REF dumping building on what we do for MEM_REF and thus dumping things like access type, TBAA type and base/clique. I've changed it to do semantic dumping aka base + offset + step * index rather than the odd base: A, step: way. 2020-08-27 Richard Biener * tree-pretty-print.c (dump_mem_ref): Handle TARGET_MEM_REFs. (dump_generic_node): Use dump_mem_ref also for TARGET_MEM_REF. * gcc.dg/tree-ssa/loop-19.c: Adjust. * gcc.dg/tree-ssa/loop-2.c: Likewise. * gcc.dg/tree-ssa/loop-3.c: Likewise. Diff: --- gcc/testsuite/gcc.dg/tree-ssa/loop-19.c | 4 +- gcc/testsuite/gcc.dg/tree-ssa/loop-2.c | 1 - gcc/testsuite/gcc.dg/tree-ssa/loop-3.c | 3 +- gcc/tree-pretty-print.c | 89 ++++++++++----------------------- 4 files changed, 30 insertions(+), 67 deletions(-) diff --git a/gcc/testsuite/gcc.dg/tree-ssa/loop-19.c b/gcc/testsuite/gcc.dg/tree-ssa/loop-19.c index af7a3daddec..0c73111c1ee 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/loop-19.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/loop-19.c @@ -22,6 +22,6 @@ void tuned_STREAM_Copy() However, due to a bug in jump threading, we end up peeling one iteration from the loop, which creates an additional occurrence. */ -/* { dg-final { scan-tree-dump-times "MEM.(base: &|symbol: )a," 2 "optimized" } } */ -/* { dg-final { scan-tree-dump-times "MEM.(base: &|symbol: )c," 2 "optimized" } } */ +/* { dg-final { scan-tree-dump-times "MEM\[^;\]*&a" 1 "optimized" } } */ +/* { dg-final { scan-tree-dump-times "MEM\[^;\]*&c" 1 "optimized" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/loop-2.c b/gcc/testsuite/gcc.dg/tree-ssa/loop-2.c index bda25167353..e58561a6650 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/loop-2.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/loop-2.c @@ -27,7 +27,6 @@ void xxx(void) /* { dg-final { scan-tree-dump-times " \\* \[^\\n\\r\]*=" 0 "optimized" } } */ /* { dg-final { scan-tree-dump-times "\[^\\n\\r\]*= \\* " 0 "optimized" } } */ -/* { dg-final { scan-tree-dump-times "MEM\\\[base" 1 "optimized" } } */ /* 17 * iter should be strength reduced. */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/loop-3.c b/gcc/testsuite/gcc.dg/tree-ssa/loop-3.c index d3b26b7ad19..74491f80e49 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/loop-3.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/loop-3.c @@ -20,8 +20,7 @@ void xxx(void) /* Access to arr_base[iter].y should not be strength reduced, since we have a memory mode including multiplication by 4. */ -/* { dg-final { scan-tree-dump-times "MEM" 1 "optimized" } } */ -/* { dg-final { scan-tree-dump-times "step:" 1 "optimized" } } */ +/* { dg-final { scan-tree-dump-times "MEM\[^;\]* \* 4" 1 "optimized" } } */ /* And original induction variable should be preserved. */ diff --git a/gcc/tree-pretty-print.c b/gcc/tree-pretty-print.c index 655061c174d..075a3fca766 100644 --- a/gcc/tree-pretty-print.c +++ b/gcc/tree-pretty-print.c @@ -1441,7 +1441,7 @@ dump_omp_atomic_memory_order (pretty_printer *pp, enum omp_memory_order mo) static void dump_mem_ref (pretty_printer *pp, tree node, int spc, dump_flags_t flags) { - if (flags & TDF_GIMPLE) + if (TREE_CODE (node) == MEM_REF && (flags & TDF_GIMPLE)) { pp_string (pp, "__MEM <"); dump_generic_node (pp, TREE_TYPE (node), @@ -1472,7 +1472,8 @@ dump_mem_ref (pretty_printer *pp, tree node, int spc, dump_flags_t flags) } pp_right_paren (pp); } - else if (integer_zerop (TREE_OPERAND (node, 1)) + else if (TREE_CODE (node) == MEM_REF + && integer_zerop (TREE_OPERAND (node, 1)) /* Dump the types of INTEGER_CSTs explicitly, for we can't infer them and MEM_ATTR caching will share MEM_REFs with differently-typed op0s. */ @@ -1541,12 +1542,33 @@ dump_mem_ref (pretty_printer *pp, tree node, int spc, dump_flags_t flags) dump_generic_node (pp, op1type, spc, flags | TDF_SLIM, false); pp_right_paren (pp); dump_generic_node (pp, op0, spc, flags, false); - if (!integer_zerop (op1)) - if (!integer_zerop (TREE_OPERAND (node, 1))) + if (TREE_CODE (node) == MEM_REF + && !integer_zerop (op1)) { pp_string (pp, " + "); dump_generic_node (pp, op1, spc, flags, false); } + if (TREE_CODE (node) == TARGET_MEM_REF) + { + tree tmp = TMR_INDEX2 (node); + if (tmp) + { + pp_string (pp, " + "); + dump_generic_node (pp, tmp, spc, flags, false); + } + tmp = TMR_INDEX (node); + if (tmp) + { + pp_string (pp, " + "); + dump_generic_node (pp, tmp, spc, flags, false); + tmp = TMR_STEP (node); + pp_string (pp, " * "); + if (tmp) + dump_generic_node (pp, tmp, spc, flags, false); + else + pp_string (pp, "1"); + } + } if ((flags & TDF_ALIAS) && MR_DEPENDENCE_CLIQUE (node) != 0) { @@ -1854,65 +1876,8 @@ dump_generic_node (pretty_printer *pp, tree node, int spc, dump_flags_t flags, break; case MEM_REF: - dump_mem_ref (pp, node, spc, flags); - break; - case TARGET_MEM_REF: - { - const char *sep = ""; - tree tmp; - - pp_string (pp, "MEM["); - - if (TREE_CODE (TMR_BASE (node)) == ADDR_EXPR) - { - pp_string (pp, sep); - sep = ", "; - pp_string (pp, "symbol: "); - dump_generic_node (pp, TREE_OPERAND (TMR_BASE (node), 0), - spc, flags, false); - } - else - { - pp_string (pp, sep); - sep = ", "; - pp_string (pp, "base: "); - dump_generic_node (pp, TMR_BASE (node), spc, flags, false); - } - tmp = TMR_INDEX2 (node); - if (tmp) - { - pp_string (pp, sep); - sep = ", "; - pp_string (pp, "base: "); - dump_generic_node (pp, tmp, spc, flags, false); - } - tmp = TMR_INDEX (node); - if (tmp) - { - pp_string (pp, sep); - sep = ", "; - pp_string (pp, "index: "); - dump_generic_node (pp, tmp, spc, flags, false); - } - tmp = TMR_STEP (node); - if (tmp) - { - pp_string (pp, sep); - sep = ", "; - pp_string (pp, "step: "); - dump_generic_node (pp, tmp, spc, flags, false); - } - tmp = TMR_OFFSET (node); - if (tmp) - { - pp_string (pp, sep); - sep = ", "; - pp_string (pp, "offset: "); - dump_generic_node (pp, tmp, spc, flags, false); - } - pp_right_bracket (pp); - } + dump_mem_ref (pp, node, spc, flags); break; case ARRAY_TYPE: