The attached update adds the MEM_REF type in pointy braces like
in the -gimple format, but without the access size:
MEM <short int> [(char *)&a] = 1;
Martin
On 6/4/19 4:57 AM, Richard Biener wrote:
On Mon, Jun 3, 2019 at 5:13 PM Martin Sebor <mse...@gmail.com> wrote:
On 6/3/19 4:34 AM, Richard Biener wrote:
On Mon, Jun 3, 2019 at 10:57 AM Jakub Jelinek <ja...@redhat.com> wrote:
On Mon, Jun 03, 2019 at 10:36:42AM +0200, Richard Biener wrote:
To avoid this confusion the attached patch adds to the dump
a cast to the MEM_REF type for accesses whose size is not equal
to the size of the operand (when the sizes are the same no new
cast is prepended). The effect is that with store merging in
effect, the dump for the above becomes
MEM[(short int *)(char *)&a] = 1;
I think this is confusing syntax. Iff you absolutely refuse to
make the -gimple dump the default for MEM_REF and you insist
on fixing this issue then please follow how we dump VIEW_CONVERT_EXPR
which is the only other tree code we dump the access type, thus
I must say I prefer the current MEM[ over the -gimple for human readable
dumps.
Sure, but then why ask for all information to be present when in the cases
you are curious you can look at -gimple dumps? A similar thing I've
hacked the pretty printer locally for debugging in the past is alignment info.
MEM<short int *>[(char *)&a] = 1;
Wouldn't that be
MEM<short int>[(char *)&a] instead?
Err, yes.
Couldn't we do it only if the TREE_TYPE (TREE_TYPE (TREE_OPERAND (mem, 1)))
is not compatible with TREE_TYPE (mem), so keep what we were doing in most
cases?
We could. Like we dump MEM_REF as * in some cases.
The question is still why fix things half-way if a complete solution
is already there?
Because it restores the important detail for those of us who
are accustomed to the "legacy" format. That's without a doubt
the majority of users. Note that godbolt.org only exposes
the classic dumps and doesn't make it possible to select
the -gimple form.
Those with a preference for the -gimple syntax are presumably
already using the -gimple dumps so they shouldn't be bothered
by a change to the legacy format.
But those with a preference for the traditional syntax will
not appreciate having the syntax changed. Scripts that parse
those dumps (like GCC's own test harness) have a reasonable
chance of continuing to be able to parse the syntax even with
the additional cast. They will certainly not be able to parse
it if it changes to MEM<T>(...)).
But if you refuse to accept the patch as is and insist on
the syntax with the pointy brackets please let me know. I
think it's more important get the size of the access restored
than the details of the syntax so I'm willing to spend the time
to adjust the fix, even at the risk of breaking scripts and
making some users unhappy.
I think introducing inconsistencies (and I find two "casts"
confusing as well) with existing VIEW_CONVERT_EXPR
dumping isn't good. So yes, I'd rather prefer
MEM <access-type> [(alias-pointer-type) ptr]
note access-type isn't a pointer type to the access type.
I can definitely live with this incremental but consistent change.
Also consider eliding access-type dumping as Jakub suggested
(when equal to *alias-pointer-type).
As said in the PR dump format changes have the chance
to make testcases testing for sth _not_ to appear no longer
testing what they want to test for (one reason those testcases
are broken). A quick grep for MEM on a scan-*-dump-not
might reveal candidates that could need a second look.
Note that it was pure laziness on my side that I didn't change
the "legacy" format for the way the GIMPLE FE likes it :/
And I feel sorry about that.
Richard.
Martin
Btw, VIEW_CONVERT dumping uses () instead of [], that I used
[] when I introduced MEM_REF was probably a mistake...
Is it just the parens kind you dislike?
Richard.
Jakub
PR middle-end/90676 - default GIMPLE dumps lack information
gcc/ChangeLog:
PR middle-end/90676
* tree-pretty-print.c (dump_mem_ref): New function. Include
MEM_REF type in output when different size than operand.
(dump_generic_node): Move code to dump_mem_ref and call it.
gcc/testsuite/ChangeLog:
PR middle-end/90676
* gcc.dg/tree-ssa/dump-6.c: New test.
* g++.dg/tree-ssa/pr19807.C: Adjust expected output.
* g++.dg/tree-ssa/ssa-dse-1.C: Same.
* gcc.dg/tree-prof/stringop-2.c
* gcc.dg/tree-ssa/pr30375.c: Same.
* gcc.dg/tree-ssa/slsr-27.c (f): Same.
* gcc.dg/tree-ssa/slsr-28.c (f): Same.
* gcc.dg/tree-ssa/slsr-29.c (f): Same.
* gcc.dg/tree-ssa/ssa-dse-24.c: Same.
diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr19807.C b/gcc/testsuite/g++.dg/tree-ssa/pr19807.C
index cbe06b4ce62..10de295e14d 100644
--- a/gcc/testsuite/g++.dg/tree-ssa/pr19807.C
+++ b/gcc/testsuite/g++.dg/tree-ssa/pr19807.C
@@ -11,7 +11,8 @@ void foo(void)
z = 1 + &a[1];
}
-/* { dg-final { scan-tree-dump-times "&MEM\\\[\\\(void .\\\)&a \\\+ 8B\\\]" 3 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "&MEM\\\[\\\(void .\\\)&a \\\+ 8B\\\]" 3 "optimized" { target { ! store_merge } } } }
+ { dg-final { scan-tree-dump-times "&MEM <int> \\\[\\\(void .\\\)&a \\\+ 8B\\\]" 3 "optimized" { target { store_merge } } } } */
void bar(int i)
diff --git a/gcc/testsuite/g++.dg/tree-ssa/ssa-dse-1.C b/gcc/testsuite/g++.dg/tree-ssa/ssa-dse-1.C
index 1fd8dec99e9..7bcb65af13c 100644
--- a/gcc/testsuite/g++.dg/tree-ssa/ssa-dse-1.C
+++ b/gcc/testsuite/g++.dg/tree-ssa/ssa-dse-1.C
@@ -97,5 +97,5 @@ int main()
}
-/* { dg-final { scan-tree-dump-times "MEM\\\[\\(struct FixBuf \\*\\)&<retval> \\+ \[0-9\]+B\\\] = {}" 1 "dse1" } } */
-
+/* { dg-final { scan-tree-dump-times "MEM\\\[\\(struct FixBuf \\*\\)&<retval> \\+ \[0-9\]+B\\\] = {}" 1 "dse1" { target { ! store_merge } } } }
+ { dg-final { scan-tree-dump-times "MEM <char\\\[176]> \\\[\\(struct FixBuf \\*\\)&<retval> \\+ \[0-9\]+B\\\] = {}" 1 "dse1" { target { store_merge } } } } */
diff --git a/gcc/testsuite/gcc.dg/store_merging_5.c b/gcc/testsuite/gcc.dg/store_merging_5.c
index e6c349767bc..e46d6e5563a 100644
--- a/gcc/testsuite/gcc.dg/store_merging_5.c
+++ b/gcc/testsuite/gcc.dg/store_merging_5.c
@@ -26,5 +26,6 @@ foo1 (struct bar *p, char tmp)
}
-/* { dg-final { scan-tree-dump-times "Merging successful" 1 "store-merging" } } */
-/* { dg-final { scan-tree-dump-times "MEM\\\[.*\\\]" 1 "store-merging" } } */
+/* { dg-final { scan-tree-dump-times "Merging successful" 1 "store-merging" } }
+ { dg-final { scan-tree-dump-times "MEM\\\[.*\\\]" 1 "store-merging" { target { ! store_merge } } } }
+ { dg-final { scan-tree-dump-times "MEM <unsigned long>\\\[.*\\\]" 1 "store-merging" { target { store_merge } } } } */
diff --git a/gcc/testsuite/gcc.dg/tree-prof/stringop-2.c b/gcc/testsuite/gcc.dg/tree-prof/stringop-2.c
index 3242cf5b8a2..c1f757388fd 100644
--- a/gcc/testsuite/gcc.dg/tree-prof/stringop-2.c
+++ b/gcc/testsuite/gcc.dg/tree-prof/stringop-2.c
@@ -21,5 +21,6 @@ main()
}
/* autofdo doesn't support value profiling for now: */
/* { dg-final-use-not-autofdo { scan-ipa-dump "Transformation done: single value 4 stringop" "profile"} } */
-/* The versioned memset of size 4 should be optimized to an assignment. */
-/* { dg-final-use-not-autofdo { scan-tree-dump "MEM\\\[\\(void .\\)&a\\\] = 168430090" "optimized"} } */
+/* The versioned memset of size 4 should be optimized to an assignment.
+ { dg-final-use-not-autofdo { scan-tree-dump "MEM\\\[\\(void .\\)&a\\\] = 168430090" "optimized" { target { ! store_merge } } } }
+ { dg-final-use-not-autofdo { scan-tree-dump "MEM <\[a-z \]+> \\\[\\(void .\\)&a\\\] = 168430090" "optimized" { target { store_merge } } } } */
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/dump-6.c b/gcc/testsuite/gcc.dg/tree-ssa/dump-6.c
new file mode 100644
index 00000000000..b66d3486e88
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/dump-6.c
@@ -0,0 +1,37 @@
+/* PR middle-end/90676 - default GIMPLE dumps lack information
+ { dg-do compile }
+ { dg-options "-O2 -fdump-tree-store-merging" }
+ { dg-require-effective-target int32plus }
+ { dg-require-effective-target store_merge } */
+
+
+extern char a2[2];
+
+void f2 (void)
+{
+ a2[0] = 1;
+ a2[1] = 0;
+}
+
+extern char a4[4];
+
+void f4 (void)
+{
+ a4[0] = 1;
+ a4[1] = 0;
+ a4[2] = 0;
+ a4[3] = 0;
+}
+
+extern char a8[8];
+
+void f8 (void)
+{
+ a8[0] = 1;
+ for (int i = 1; i != 8; ++i)
+ a8[i] = 0;
+}
+
+/* { dg-final { scan-tree-dump "MEM <unsigned short> \\\[\\(char \\*\\)\\&a2] = " "store-merging"} }
+ { dg-final { scan-tree-dump "MEM <unsigned int> \\\[\\(char \\*\\)\\&a4] = " "store-merging"} }
+ { dg-final { scan-tree-dump "MEM <unsigned long> \\\[\\(char \\*\\)\\&a8] = " "store-merging"} } */
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr30375.c b/gcc/testsuite/gcc.dg/tree-ssa/pr30375.c
index 4494a2b0bd6..5c068a3ddc0 100644
--- a/gcc/testsuite/gcc.dg/tree-ssa/pr30375.c
+++ b/gcc/testsuite/gcc.dg/tree-ssa/pr30375.c
@@ -22,5 +22,6 @@ void test_signed_msg_encoding(void)
f();
}
-/* { dg-final { scan-tree-dump-times "MEM\\\[\\(struct _s \\*\\)&signInfo \\+ \[0-9\]+B\\\] = {}" 1 "dse1" } } */
+/* { dg-final { scan-tree-dump-times "MEM\\\[\\(struct _s \\*\\)&signInfo \\+ \[0-9\]+B\\\] = {}" 1 "dse1" { target { ! store_merge } } } }
+ { dg-final { scan-tree-dump-times "MEM <char\\\[8]> \\\[\\(struct _s \\*\\)&signInfo \\+ \[0-9\]+B\\\] = {}" 1 "dse1" { target { store_merge } } } } */
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/slsr-27.c b/gcc/testsuite/gcc.dg/tree-ssa/slsr-27.c
index 35b3d00ee44..e3560ee5d9a 100644
--- a/gcc/testsuite/gcc.dg/tree-ssa/slsr-27.c
+++ b/gcc/testsuite/gcc.dg/tree-ssa/slsr-27.c
@@ -19,4 +19,5 @@ f (struct x *p, unsigned int n)
/* { dg-final { scan-tree-dump-times "\\* 4;" 1 "dom3" { target { int32 } } } } */
/* { dg-final { scan-tree-dump-times "\\* 2;" 1 "dom3" { target { int16 } } } } */
/* { dg-final { scan-tree-dump-times "p_\\d\+\\(D\\) \\+ \[^\r\n\]*_\\d\+;" 1 "dom3" } } */
-/* { dg-final { scan-tree-dump-times "MEM\\\[\\(struct x \\*\\)\[^\r\n\]*_\\d\+" 3 "dom3" } } */
+/* { dg-final { scan-tree-dump-times "MEM\\\[\\(struct x \\*\\)\[^\r\n\]*_\\d\+" 3 "dom3" { target { ! store_merge } } } } */
+/* { dg-final { scan-tree-dump-times "MEM <int> \\\[\\(struct x \\*\\)\[^\r\n\]*_\\d\+" 3 "dom3" { target { store_merge } } } } */
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/slsr-28.c b/gcc/testsuite/gcc.dg/tree-ssa/slsr-28.c
index 732d2324db5..0db27af76ce 100644
--- a/gcc/testsuite/gcc.dg/tree-ssa/slsr-28.c
+++ b/gcc/testsuite/gcc.dg/tree-ssa/slsr-28.c
@@ -23,4 +23,5 @@ f (struct x *p, unsigned int n)
/* { dg-final { scan-tree-dump-times "\\* 4;" 1 "dom3" { target { int32 } } } } */
/* { dg-final { scan-tree-dump-times "\\* 2;" 1 "dom3" { target { int16 } } } } */
/* { dg-final { scan-tree-dump-times "p_\\d\+\\(D\\) \\+ \[^\r\n\]*_\\d\+" 1 "dom3" } } */
-/* { dg-final { scan-tree-dump-times "MEM\\\[\\(struct x \\*\\)\[^\r\n\]*_\\d\+" 9 "dom3" } } */
+/* { dg-final { scan-tree-dump-times "MEM\\\[\\(struct x \\*\\)\[^\r\n\]*_\\d\+" 9 "dom3" { target { ! store_merge } } } } */
+/* { dg-final { scan-tree-dump-times "MEM <int> \\\[\\(struct x \\*\\)\[^\r\n\]*_\\d\+" 9 "dom3" { target { store_merge } } } } */
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/slsr-29.c b/gcc/testsuite/gcc.dg/tree-ssa/slsr-29.c
index a22cc7906da..0f6169df312 100644
--- a/gcc/testsuite/gcc.dg/tree-ssa/slsr-29.c
+++ b/gcc/testsuite/gcc.dg/tree-ssa/slsr-29.c
@@ -25,4 +25,5 @@ f (struct x *p, unsigned int n)
/* { dg-final { scan-tree-dump-times "\\* 4;" 1 "dom3" { target { int32 } } } } */
/* { dg-final { scan-tree-dump-times "\\* 2;" 1 "dom3" { target { int16 } } } } */
/* { dg-final { scan-tree-dump-times "p_\\d\+\\(D\\) \\+ \[^\r\n\]*_\\d\+" 1 "dom3" } } */
-/* { dg-final { scan-tree-dump-times "MEM\\\[\\(struct x \\*\\)\[^\r\n\]*_\\d\+" 9 "dom3" } } */
+/* { dg-final { scan-tree-dump-times "MEM\\\[\\(struct x \\*\\)\[^\r\n\]*_\\d\+" 9 "dom3" { target { ! store_merge } } } } */
+/* { dg-final { scan-tree-dump-times "MEM <int> \\\[\\(struct x \\*\\)\[^\r\n\]*_\\d\+" 9 "dom3" { target { store_merge } } } } */
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-24.c b/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-24.c
index 282194c1e32..240c9063717 100644
--- a/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-24.c
+++ b/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-24.c
@@ -59,4 +59,5 @@ void foo(int prec,
bar (&info);
}
-/* { dg-final { scan-tree-dump-times "MEM\\\[\\(struct printf_info \\*\\)&info \\+ \[0-9\]+B\\\] = {}" 1 "dse1" } } */
+/* { dg-final { scan-tree-dump-times "MEM\\\[\\(struct printf_info \\*\\)&info \\+ \[0-9\]+B\\\] = {}" 1 "dse1" { target { ! store_merge } } } }
+ { dg-final { scan-tree-dump-times "MEM <char[4]> \\\[\\(struct printf_info \\*\\)&info \\+ \[0-9\]+B\\\] = {}" 1 "dse1" { target { store_merge } } } } */
diff --git a/gcc/tree-pretty-print.c b/gcc/tree-pretty-print.c
index 1e6c96813bb..41dd6db53a9 100644
--- a/gcc/tree-pretty-print.c
+++ b/gcc/tree-pretty-print.c
@@ -1378,6 +1378,126 @@ dump_omp_atomic_memory_order (pretty_printer *pp, enum omp_memory_order mo)
}
}
+/* Helper to dump a MEM_REF node. */
+
+static void
+dump_mem_ref (pretty_printer *pp, tree node, int spc, dump_flags_t flags)
+{
+ if (flags & TDF_GIMPLE)
+ {
+ pp_string (pp, "__MEM <");
+ dump_generic_node (pp, TREE_TYPE (node),
+ spc, flags | TDF_SLIM, false);
+ if (TYPE_ALIGN (TREE_TYPE (node))
+ != TYPE_ALIGN (TYPE_MAIN_VARIANT (TREE_TYPE (node))))
+ {
+ pp_string (pp, ", ");
+ pp_decimal_int (pp, TYPE_ALIGN (TREE_TYPE (node)));
+ }
+ pp_greater (pp);
+ pp_string (pp, " (");
+ if (TREE_TYPE (TREE_OPERAND (node, 0))
+ != TREE_TYPE (TREE_OPERAND (node, 1)))
+ {
+ pp_left_paren (pp);
+ dump_generic_node (pp, TREE_TYPE (TREE_OPERAND (node, 1)),
+ spc, flags | TDF_SLIM, false);
+ pp_right_paren (pp);
+ }
+ dump_generic_node (pp, TREE_OPERAND (node, 0),
+ spc, flags | TDF_SLIM, false);
+ if (! integer_zerop (TREE_OPERAND (node, 1)))
+ {
+ pp_string (pp, " + ");
+ dump_generic_node (pp, TREE_OPERAND (node, 1),
+ spc, flags | TDF_SLIM, false);
+ }
+ pp_right_paren (pp);
+ }
+ else if (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. */
+ && TREE_CODE (TREE_OPERAND (node, 0)) != INTEGER_CST
+ /* Released SSA_NAMES have no TREE_TYPE. */
+ && TREE_TYPE (TREE_OPERAND (node, 0)) != NULL_TREE
+ /* Same pointer types, but ignoring POINTER_TYPE vs.
+ REFERENCE_TYPE. */
+ && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 0)))
+ == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1))))
+ && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 0)))
+ == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 1))))
+ && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 0)))
+ == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 1))))
+ /* Same value types ignoring qualifiers. */
+ && (TYPE_MAIN_VARIANT (TREE_TYPE (node))
+ == TYPE_MAIN_VARIANT
+ (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1)))))
+ && (!(flags & TDF_ALIAS)
+ || MR_DEPENDENCE_CLIQUE (node) == 0))
+ {
+ if (TREE_CODE (TREE_OPERAND (node, 0)) != ADDR_EXPR)
+ {
+ /* Enclose pointers to arrays in parentheses. */
+ tree op0 = TREE_OPERAND (node, 0);
+ tree op0type = TREE_TYPE (op0);
+ if (POINTER_TYPE_P (op0type)
+ && TREE_CODE (TREE_TYPE (op0type)) == ARRAY_TYPE)
+ pp_left_paren (pp);
+ pp_star (pp);
+ dump_generic_node (pp, op0, spc, flags, false);
+ if (POINTER_TYPE_P (op0type)
+ && TREE_CODE (TREE_TYPE (op0type)) == ARRAY_TYPE)
+ pp_right_paren (pp);
+ }
+ else
+ dump_generic_node (pp,
+ TREE_OPERAND (TREE_OPERAND (node, 0), 0),
+ spc, flags, false);
+ }
+ else
+ {
+ pp_string (pp, "MEM");
+
+ tree nodetype = TREE_TYPE (node);
+ tree op0 = TREE_OPERAND (node, 0);
+ tree op1 = TREE_OPERAND (node, 1);
+ tree op1type = TYPE_MAIN_VARIANT (TREE_TYPE (op1));
+
+ if (!tree_int_cst_equal (TYPE_SIZE (nodetype),
+ TYPE_SIZE (TREE_TYPE (op1type))))
+ {
+ pp_string (pp, " <");
+ /* If the size of the type of the operand is not the same
+ as the size of the MEM_REF expression include the type
+ of the latter similar to the TDF_GIMPLE output to make
+ it clear how many bytes of memory are being accessed. */
+ dump_generic_node (pp, nodetype, spc, flags | TDF_SLIM, false);
+ pp_string (pp, "> ");
+ }
+
+ pp_string (pp, "[(");
+ 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)))
+ {
+ pp_string (pp, " + ");
+ dump_generic_node (pp, op1, spc, flags, false);
+ }
+ if ((flags & TDF_ALIAS)
+ && MR_DEPENDENCE_CLIQUE (node) != 0)
+ {
+ pp_string (pp, " clique ");
+ pp_unsigned_wide_integer (pp, MR_DEPENDENCE_CLIQUE (node));
+ pp_string (pp, " base ");
+ pp_unsigned_wide_integer (pp, MR_DEPENDENCE_BASE (node));
+ }
+ pp_right_bracket (pp);
+ }
+ }
+
/* Dump the node NODE on the pretty_printer PP, SPC spaces of
indent. FLAGS specifies details to show in the dump (see TDF_* in
dumpfile.h). If IS_STMT is true, the object printed is considered
@@ -1636,109 +1756,8 @@ dump_generic_node (pretty_printer *pp, tree node, int spc, dump_flags_t flags,
break;
case MEM_REF:
- {
- if (flags & TDF_GIMPLE)
- {
- pp_string (pp, "__MEM <");
- dump_generic_node (pp, TREE_TYPE (node),
- spc, flags | TDF_SLIM, false);
- if (TYPE_ALIGN (TREE_TYPE (node))
- != TYPE_ALIGN (TYPE_MAIN_VARIANT (TREE_TYPE (node))))
- {
- pp_string (pp, ", ");
- pp_decimal_int (pp, TYPE_ALIGN (TREE_TYPE (node)));
- }
- pp_greater (pp);
- pp_string (pp, " (");
- if (TREE_TYPE (TREE_OPERAND (node, 0))
- != TREE_TYPE (TREE_OPERAND (node, 1)))
- {
- pp_left_paren (pp);
- dump_generic_node (pp, TREE_TYPE (TREE_OPERAND (node, 1)),
- spc, flags | TDF_SLIM, false);
- pp_right_paren (pp);
- }
- dump_generic_node (pp, TREE_OPERAND (node, 0),
- spc, flags | TDF_SLIM, false);
- if (! integer_zerop (TREE_OPERAND (node, 1)))
- {
- pp_string (pp, " + ");
- dump_generic_node (pp, TREE_OPERAND (node, 1),
- spc, flags | TDF_SLIM, false);
- }
- pp_right_paren (pp);
- }
- else if (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. */
- && TREE_CODE (TREE_OPERAND (node, 0)) != INTEGER_CST
- /* Released SSA_NAMES have no TREE_TYPE. */
- && TREE_TYPE (TREE_OPERAND (node, 0)) != NULL_TREE
- /* Same pointer types, but ignoring POINTER_TYPE vs.
- REFERENCE_TYPE. */
- && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 0)))
- == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1))))
- && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 0)))
- == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 1))))
- && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 0)))
- == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 1))))
- /* Same value types ignoring qualifiers. */
- && (TYPE_MAIN_VARIANT (TREE_TYPE (node))
- == TYPE_MAIN_VARIANT
- (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1)))))
- && (!(flags & TDF_ALIAS)
- || MR_DEPENDENCE_CLIQUE (node) == 0))
- {
- if (TREE_CODE (TREE_OPERAND (node, 0)) != ADDR_EXPR)
- {
- /* Enclose pointers to arrays in parentheses. */
- tree op0 = TREE_OPERAND (node, 0);
- tree op0type = TREE_TYPE (op0);
- if (POINTER_TYPE_P (op0type)
- && TREE_CODE (TREE_TYPE (op0type)) == ARRAY_TYPE)
- pp_left_paren (pp);
- pp_star (pp);
- dump_generic_node (pp, op0, spc, flags, false);
- if (POINTER_TYPE_P (op0type)
- && TREE_CODE (TREE_TYPE (op0type)) == ARRAY_TYPE)
- pp_right_paren (pp);
- }
- else
- dump_generic_node (pp,
- TREE_OPERAND (TREE_OPERAND (node, 0), 0),
- spc, flags, false);
- }
- else
- {
- tree ptype;
-
- pp_string (pp, "MEM[");
- pp_left_paren (pp);
- ptype = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (node, 1)));
- dump_generic_node (pp, ptype,
- spc, flags | TDF_SLIM, false);
- pp_right_paren (pp);
- dump_generic_node (pp, TREE_OPERAND (node, 0),
- spc, flags, false);
- if (!integer_zerop (TREE_OPERAND (node, 1)))
- {
- pp_string (pp, " + ");
- dump_generic_node (pp, TREE_OPERAND (node, 1),
- spc, flags, false);
- }
- if ((flags & TDF_ALIAS)
- && MR_DEPENDENCE_CLIQUE (node) != 0)
- {
- pp_string (pp, " clique ");
- pp_unsigned_wide_integer (pp, MR_DEPENDENCE_CLIQUE (node));
- pp_string (pp, " base ");
- pp_unsigned_wide_integer (pp, MR_DEPENDENCE_BASE (node));
- }
- pp_right_bracket (pp);
- }
- break;
- }
+ dump_mem_ref (pp, node, spc, flags);
+ break;
case TARGET_MEM_REF:
{
