From 8827e622768702e4602f034ad90a407bc52c92ac Mon Sep 17 00:00:00 2001
From: David Malcolm <dmalcolm@redhat.com>
Date: Tue, 8 Nov 2016 10:43:48 -0500
Subject: [PATCH 06/18] (committed) print-rtl-function.c: add (param) directive
 to dump (v2)

On Wed, 2016-11-09 at 12:59 +0100, Bernd Schmidt wrote:
> On 11/08/2016 07:03 PM, David Malcolm wrote:
> > int __RTL("rtl-combine") f1 (int n)
> > {
> > (function "f1"
> >   (param "n"
> >     (DECL_RTL
> >       (reg/v:SI %1 [ n ])
> >     ) ;; DECL_RTL
>
> The ;; DECL_RTL etc. comments seem somewhat redundant and add
> clutter.
> Please remove those.

Done.

> Also, why is the closing paren on its own line? That doesn't seem
> right.

It's because of the m_sawclose when calling print_rtx, which leads to
a leading newline.

I fixed this by introducing a rtx_writer::finish_directive method to
unset m_sawclose.  (That field seems misnamed; perhaps it should be
renamed to m_force_newline or somesuch?  That feels like a separate
patch though).

> Later (not for this patch) I'd really like to see some logic not to
> add
> linebreaks before simple expressions, so that we'd have (DECL_RTL
> (reg:SI xyz)) on a single line.

I've been thinking about a patch that would track indentation, which
would only insert newlines when close to some column limit, and would
line up the open parentheses for siblings.
That way you'd get things like:

    (DECL_RTL (mem/c:SI (plus:DI (reg/f:DI virtual-stack-vars)
                                 (const_int -4)) [1 i+0 S4 A32]))

where the newline is auto-inserted to fit things within e.g. an
80 char column, and where "const_int" gets indented to be underneath
the "reg", since they're both operands of the same "plus".

Anyway, the following updated version of the patch eliminates
the newlines and comments.

Updated examples: aarch64 function taking one argument:

(function "times_two"
  (param "i"
    (DECL_RTL (mem/c:SI (plus:DI (reg/f:DI virtual-stack-vars)
        (const_int -4)) [1 i+0 S4 A32]))
    (DECL_RTL_INCOMING (reg:SI x0 [ i ])))
  (insn-chain
     ;; etc

x86_64 function taking three ints:

(function "test_1"
  (param "i"
    (DECL_RTL (mem/c:SI (plus:DI (reg/f:DI virtual-stack-vars)
        (const_int -4)) [1 i+0 S4 A32]))
    (DECL_RTL_INCOMING (reg:SI di [ i ])))
  (param "j"
    (DECL_RTL (mem/c:SI (plus:DI (reg/f:DI virtual-stack-vars)
        (const_int -8)) [1 j+0 S4 A32]))
    (DECL_RTL_INCOMING (reg:SI si [ j ])))
  (param "k"
    (DECL_RTL (mem/c:SI (plus:DI (reg/f:DI virtual-stack-vars)
        (const_int -12)) [1 k+0 S4 A32]))
    (DECL_RTL_INCOMING (reg:SI dx [ k ])))
  (insn-chain
     ;; etc

As before, only lightly tested so far.

OK for trunk if it passes bootstrap and regrtest?

gcc/ChangeLog:
	* print-rtl-function.c: Include varasm.h.
	(print_any_param_name): New function.
	(print_param): New function.
	(print_rtx_function): Call print_param for each argument.
	* print-rtl.c (rtx_writer::finish_directive): New function.
	* print-rtl.h (rtx_writer::finish_directive): New decl.
---
 gcc/print-rtl-function.c | 36 ++++++++++++++++++++++++++++++++++++
 gcc/print-rtl.c          |  9 +++++++++
 gcc/print-rtl.h          |  2 ++
 3 files changed, 47 insertions(+)

diff --git a/gcc/print-rtl-function.c b/gcc/print-rtl-function.c
index f37e1b7..8842226 100644
--- a/gcc/print-rtl-function.c
+++ b/gcc/print-rtl-function.c
@@ -33,6 +33,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "langhooks.h"
 #include "memmodel.h"
 #include "emit-rtl.h"
+#include "varasm.h"
 
 /* Print an "(edge-from)" or "(edge-to)" directive describing E
    to OUTFILE.  */
@@ -127,6 +128,37 @@ can_have_basic_block_p (const rtx_insn *insn)
   return true;
 }
 
+/* Subroutine of print_param.  Write the name of ARG, if any, to OUTFILE.  */
+
+static void
+print_any_param_name (FILE *outfile, tree arg)
+{
+  if (DECL_NAME (arg))
+    fprintf (outfile, " \"%s\"", IDENTIFIER_POINTER (DECL_NAME (arg)));
+}
+
+/* Print a "(param)" directive for ARG to OUTFILE.  */
+
+static void
+print_param (FILE *outfile, rtx_writer &w, tree arg)
+{
+  fprintf (outfile, "  (param");
+  print_any_param_name (outfile, arg);
+  fprintf (outfile, "\n");
+
+  /* Print the value of DECL_RTL (without lazy-evaluation).  */
+  fprintf (outfile, "    (DECL_RTL ");
+  w.print_rtx (DECL_RTL_IF_SET (arg));
+  w.finish_directive ();
+
+  /* Print DECL_INCOMING_RTL.  */
+  fprintf (outfile, "    (DECL_RTL_INCOMING ");
+  w.print_rtx (DECL_INCOMING_RTL (arg));
+  fprintf (outfile, ")");
+
+  w.finish_directive ();
+}
+
 /* Write FN to OUTFILE in a form suitable for parsing, with indentation
    and comments to make the structure easy for a human to grok.  Track
    the basic blocks of insns in the chain, wrapping those that are within
@@ -197,6 +229,10 @@ print_rtx_function (FILE *outfile, function *fn, bool compact)
 
   fprintf (outfile, "(function \"%s\"\n", dname);
 
+  /* Params.  */
+  for (tree arg = DECL_ARGUMENTS (fdecl); arg; arg = DECL_CHAIN (arg))
+    print_param (outfile, w, arg);
+
   /* The instruction chain.  */
   fprintf (outfile, "  (insn-chain\n");
   basic_block curr_bb = NULL;
diff --git a/gcc/print-rtl.c b/gcc/print-rtl.c
index 3f15a21..e7368c7 100644
--- a/gcc/print-rtl.c
+++ b/gcc/print-rtl.c
@@ -804,6 +804,15 @@ rtx_writer::print_rtx (const_rtx in_rtx)
   m_sawclose = 1;
 }
 
+/* Emit a closing parenthesis and newline.  */
+
+void
+rtx_writer::finish_directive ()
+{
+  fprintf (m_outfile, ")\n");
+  m_sawclose = 0;
+}
+
 /* Print an rtx on the current line of FILE.  Initially indent IND
    characters.  */
 
diff --git a/gcc/print-rtl.h b/gcc/print-rtl.h
index 68db057..e722038 100644
--- a/gcc/print-rtl.h
+++ b/gcc/print-rtl.h
@@ -31,6 +31,8 @@ class rtx_writer
   void print_rtl (const_rtx rtx_first);
   int print_rtl_single_with_indent (const_rtx x, int ind);
 
+  void finish_directive ();
+
  private:
   void print_rtx_operand_code_0 (const_rtx in_rtx, int idx);
   void print_rtx_operand_code_e (const_rtx in_rtx, int idx);
-- 
1.8.5.3

