[28/31] RTL: Add `const_double_zero' syntactic rtx

Message ID alpine.LFD.2.21.2011200301110.656242@eddie.linux-mips.org
State New
Headers show
Series
  • VAX: Bring the port up to date (yes, MODE_CC conversion is included)
Related show

Commit Message

Maciej W. Rozycki Nov. 20, 2020, 3:36 a.m.
The use of a constant double zero is required for post-reload compare
elimination to be able to discard redundant floating-point comparisons,
for example with a VAX RTL instruction stream like:

(insn 34 4 3 2 (parallel [
            (set (reg/v:DF 0 %r0 [orig:24 x ] [24])
                (mem/c:DF (plus:SI (reg/f:SI 12 %ap)
                        (const_int 4 [0x4])) [1 x+0 S8 A32]))
            (clobber (reg:CC 16 %psl))
        ]) ".../gcc/testsuite/gcc.target/vax/cmpelim-eq-movdf.c":9:1 37 {*movdf}
     (nil))
(note 3 34 35 2 NOTE_INSN_FUNCTION_BEG)
(insn 35 3 36 2 (set (reg:CCZ 16 %psl)
        (compare:CCZ (reg/v:DF 0 %r0 [orig:24 x ] [24])
            (const_double:DF 0.0 [0x0.0p+0]))) ".../gcc/testsuite/gcc.target/vax/cmpelim-eq-movdf.c":10:6 21 {*cmpdf_ccz}
     (nil))
(jump_insn 36 35 9 2 (set (pc)
        (if_then_else (eq (reg:CCZ 16 %psl)
                (const_int 0 [0]))
            (label_ref 11)
            (pc))) ".../gcc/testsuite/gcc.target/vax/cmpelim-eq-movdf.c":10:6 537 {*branch_ccz}
     (int_list:REG_BR_PROB 536870916 (nil))
 -> 11)

that we want to transform into:

(insn 34 4 3 2 (parallel [
            (set (reg:CCZ 16 %psl)
                (compare:CCZ (mem/c:DF (plus:SI (reg/f:SI 12 %ap)
                            (const_int 4 [0x4])) [1 x+0 S8 A32])
                    (const_double:DF 0.0 [0x0.0p+0])))
            (set (reg/v:DF 0 %r0 [orig:24 x ] [24])
                (mem/c:DF (plus:SI (reg/f:SI 12 %ap)
                        (const_int 4 [0x4])) [1 x+0 S8 A32]))
        ]) ".../gcc/testsuite/gcc.target/vax/cmpelim-eq-movdf.c":9:1 40 {*movdf_ccz}
     (nil))
(note 3 34 36 2 NOTE_INSN_FUNCTION_BEG)
(jump_insn 36 3 9 2 (set (pc)
        (if_then_else (eq (reg:CCZ 16 %psl)
                (const_int 0 [0]))
            (label_ref 11)
            (pc))) ".../gcc/testsuite/gcc.target/vax/cmpelim-eq-movdf.c":10:6 537 {*branch_ccz}
     (int_list:REG_BR_PROB 536870916 (nil))
 -> 11)

with the upcoming MODE_CC representation.

For this we need to express the `const_double:DF 0.0 [0x0.0p+0]' rtx as
recorded above in the relevant pattern(s) in machine description.  The
way we represent double constants, as a host-dependent number of wide
integers, however means that we currently have no portable way to encode
a double zero constant in machine description.

Define a syntactic rtx alias then to represent `(const_double 0 0 ...)'
as if the suitable number of zeros have been supplied according to the
host-specific definition of CONST_DOUBLE_FORMAT.

	gcc/
	* read-rtl.c (rtx_reader::read_rtx_code): Handle syntactic
	`const_double_zero' rtx.
	* doc/rtl.texi (Constant Expression Types): Document it.
---
 gcc/doc/rtl.texi | 18 ++++++++++++++++++
 gcc/read-rtl.c   | 10 ++++++++++
 2 files changed, 28 insertions(+)

-- 
2.11.0

Comments

Qing Zhao via Gcc-patches Nov. 21, 2020, 5:29 p.m. | #1
On 11/19/20 8:36 PM, Maciej W. Rozycki wrote:
> The use of a constant double zero is required for post-reload compare

> elimination to be able to discard redundant floating-point comparisons,

> for example with a VAX RTL instruction stream like:

>

> (insn 34 4 3 2 (parallel [

>             (set (reg/v:DF 0 %r0 [orig:24 x ] [24])

>                 (mem/c:DF (plus:SI (reg/f:SI 12 %ap)

>                         (const_int 4 [0x4])) [1 x+0 S8 A32]))

>             (clobber (reg:CC 16 %psl))

>         ]) ".../gcc/testsuite/gcc.target/vax/cmpelim-eq-movdf.c":9:1 37 {*movdf}

>      (nil))

> (note 3 34 35 2 NOTE_INSN_FUNCTION_BEG)

> (insn 35 3 36 2 (set (reg:CCZ 16 %psl)

>         (compare:CCZ (reg/v:DF 0 %r0 [orig:24 x ] [24])

>             (const_double:DF 0.0 [0x0.0p+0]))) ".../gcc/testsuite/gcc.target/vax/cmpelim-eq-movdf.c":10:6 21 {*cmpdf_ccz}

>      (nil))

> (jump_insn 36 35 9 2 (set (pc)

>         (if_then_else (eq (reg:CCZ 16 %psl)

>                 (const_int 0 [0]))

>             (label_ref 11)

>             (pc))) ".../gcc/testsuite/gcc.target/vax/cmpelim-eq-movdf.c":10:6 537 {*branch_ccz}

>      (int_list:REG_BR_PROB 536870916 (nil))

>  -> 11)

>

> that we want to transform into:

>

> (insn 34 4 3 2 (parallel [

>             (set (reg:CCZ 16 %psl)

>                 (compare:CCZ (mem/c:DF (plus:SI (reg/f:SI 12 %ap)

>                             (const_int 4 [0x4])) [1 x+0 S8 A32])

>                     (const_double:DF 0.0 [0x0.0p+0])))

>             (set (reg/v:DF 0 %r0 [orig:24 x ] [24])

>                 (mem/c:DF (plus:SI (reg/f:SI 12 %ap)

>                         (const_int 4 [0x4])) [1 x+0 S8 A32]))

>         ]) ".../gcc/testsuite/gcc.target/vax/cmpelim-eq-movdf.c":9:1 40 {*movdf_ccz}

>      (nil))

> (note 3 34 36 2 NOTE_INSN_FUNCTION_BEG)

> (jump_insn 36 3 9 2 (set (pc)

>         (if_then_else (eq (reg:CCZ 16 %psl)

>                 (const_int 0 [0]))

>             (label_ref 11)

>             (pc))) ".../gcc/testsuite/gcc.target/vax/cmpelim-eq-movdf.c":10:6 537 {*branch_ccz}

>      (int_list:REG_BR_PROB 536870916 (nil))

>  -> 11)

>

> with the upcoming MODE_CC representation.

>

> For this we need to express the `const_double:DF 0.0 [0x0.0p+0]' rtx as

> recorded above in the relevant pattern(s) in machine description.  The

> way we represent double constants, as a host-dependent number of wide

> integers, however means that we currently have no portable way to encode

> a double zero constant in machine description.

>

> Define a syntactic rtx alias then to represent `(const_double 0 0 ...)'

> as if the suitable number of zeros have been supplied according to the

> host-specific definition of CONST_DOUBLE_FORMAT.

>

> 	gcc/

> 	* read-rtl.c (rtx_reader::read_rtx_code): Handle syntactic

> 	`const_double_zero' rtx.

> 	* doc/rtl.texi (Constant Expression Types): Document it.

OK
jeff

Patch

diff --git a/gcc/doc/rtl.texi b/gcc/doc/rtl.texi
index 22af5731bb6..f7a715d93cb 100644
--- a/gcc/doc/rtl.texi
+++ b/gcc/doc/rtl.texi
@@ -1705,6 +1705,24 @@  machine's or host machine's floating point format.  To convert them to
 the precise bit pattern used by the target machine, use the macro
 @code{REAL_VALUE_TO_TARGET_DOUBLE} and friends (@pxref{Data Output}).
 
+@findex const_double_zero
+The host dependency for the number of integers used to store a double
+value makes it problematic for machine descriptions to use expressions
+of code @code{const_double} and therefore a syntactic alias has been
+provided:
+
+@smallexample
+(const_double_zero)
+@end smallexample
+
+standing for:
+
+@smallexample
+(const_double 0 0 @dots{})
+@end smallexample
+
+for matching the floating-point value zero, possibly the only useful one.
+
 @findex CONST_WIDE_INT
 @item (const_wide_int:@var{m} @var{nunits} @var{elt0} @dots{})
 This contains an array of @code{HOST_WIDE_INT}s that is large enough
diff --git a/gcc/read-rtl.c b/gcc/read-rtl.c
index 403f254f3cb..2922af5d111 100644
--- a/gcc/read-rtl.c
+++ b/gcc/read-rtl.c
@@ -1651,6 +1651,16 @@  rtx_reader::read_rtx_code (const char *code_name)
       return return_rtx;
     }
 
+  /* Handle "const_double_zero".  */
+  if (strcmp (code_name, "const_double_zero") == 0)
+    {
+      code = CONST_DOUBLE;
+      return_rtx = rtx_alloc (code);
+      memset (return_rtx, 0, RTX_CODE_SIZE (code));
+      PUT_CODE (return_rtx, code);
+      return return_rtx;
+    }
+
   /* If we end up with an insn expression then we free this space below.  */
   return_rtx = rtx_alloc_for_name (code_name);
   code = GET_CODE (return_rtx);