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  <rguenther@suse.de>

	* 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.

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 af7a3da..0c73111 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 bda2516..e58561a 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 d3b26b7..74491f8 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 655061c..075a3fc 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: