[77/77] Add a complex_mode class

This patch adds another machine_mode wrapper for modes that are
known to be COMPLEX_MODE_P.  There aren't yet many places that make
use of it, but that might change in future.

2017-08-30  Richard Sandiford  <richard.sandiford@linaro.org>
	    Alan Hayward  <alan.hayward@arm.com>
	    David Sherwood  <david.sherwood@arm.com>

gcc/
	* coretypes.h (complex_mode): New type.
	* gdbhooks.py (build_pretty_printer): Handle it.
	* machmode.h (complex_mode): New class.
	(complex_mode::includes_p): New function.
	(is_complex_int_mode): Likewise.
	(is_complex_float_mode): Likewise.
	* genmodes.c (get_mode_class): Handle complex mode classes.
	* function.c (expand_function_end): Use is_complex_int_mode.

gcc/go/
	* go-lang.c (go_langhook_type_for_mode): Use is_complex_float_mode.

Co-Authored-By: Alan Hayward <alan.hayward@arm.com>
Co-Authored-By: David Sherwood <david.sherwood@arm.com>
From-SVN: r251527

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index bb813131eeb3a8cc60c4fdbb16d886cc6fe3715e..9d89d47c55de0b37f10623e92ddae6edb42f0dcf 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,16 @@
+2017-08-30  Richard Sandiford  <richard.sandiford@linaro.org>
+           Alan Hayward  <alan.hayward@arm.com>
+           David Sherwood  <david.sherwood@arm.com>
+
+       * coretypes.h (complex_mode): New type.
+       * gdbhooks.py (build_pretty_printer): Handle it.
+       * machmode.h (complex_mode): New class.
+       (complex_mode::includes_p): New function.
+       (is_complex_int_mode): Likewise.
+       (is_complex_float_mode): Likewise.
+       * genmodes.c (get_mode_class): Handle complex mode classes.
+       * function.c (expand_function_end): Use is_complex_int_mode.
+
 2017-08-30  Richard Sandiford  <richard.sandiford@linaro.org>
            Alan Hayward  <alan.hayward@arm.com>
            David Sherwood  <david.sherwood@arm.com>

diff --git a/gcc/coretypes.h b/gcc/coretypes.h
index 8ccf16e5e4ad06ad92fcbee9080e07ede29b3a5e..21ea8d97a0d5b318ea1bcb40edda891e27387479 100644 (file)
--- a/gcc/coretypes.h
+++ b/gcc/coretypes.h
@@ -58,6 +58,7 @@ typedef const struct rtx_def *const_rtx;
 class scalar_mode;
 class scalar_int_mode;
 class scalar_float_mode;
+class complex_mode;
 template<typename> class opt_mode;
 typedef opt_mode<scalar_mode> opt_scalar_mode;
 typedef opt_mode<scalar_int_mode> opt_scalar_int_mode;
@@ -323,6 +324,7 @@ union _dont_use_tree_here_;
 typedef struct scalar_mode scalar_mode;
 typedef struct scalar_int_mode scalar_int_mode;
 typedef struct scalar_float_mode scalar_float_mode;
+typedef struct complex_mode complex_mode;
 
 #endif
 

diff --git a/gcc/function.c b/gcc/function.c
index af5e050b8a6f50bc6ec0eb163b5e04aabbbec6ea..4c77e19973e1e5e3666c5718f6efcc128ddf1fe9 100644 (file)
--- a/gcc/function.c
+++ b/gcc/function.c
@@ -5491,6 +5491,7 @@ expand_function_end (void)
          : DECL_REGISTER (decl_result))
        {
          rtx real_decl_rtl = crtl->return_rtx;
+         complex_mode cmode;
 
          /* This should be set in assign_parms.  */
          gcc_assert (REG_FUNCTION_VALUE_P (real_decl_rtl));
@@ -5531,8 +5532,8 @@ expand_function_end (void)
             need to generate some non-trivial bitfield insertions.  Do that
             on a pseudo and not the hard register.  */
          else if (GET_CODE (decl_rtl) == CONCAT
-                  && GET_MODE_CLASS (GET_MODE (decl_rtl)) == MODE_COMPLEX_INT
-                  && GET_MODE_BITSIZE (GET_MODE (decl_rtl)) <= BITS_PER_WORD)
+                  && is_complex_int_mode (GET_MODE (decl_rtl), &cmode)
+                  && GET_MODE_BITSIZE (cmode) <= BITS_PER_WORD)
            {
              int old_generating_concat_p;
              rtx tmp;

diff --git a/gcc/gdbhooks.py b/gcc/gdbhooks.py
index acf54351e23ad6121f7fbc2728aa82886935c6ba..1b3f95361b6f415c4ba2646a321fc35178ccbfbb 100644 (file)
--- a/gcc/gdbhooks.py
+++ b/gcc/gdbhooks.py
@@ -551,7 +551,8 @@ def build_pretty_printer():
     pp.add_printer_for_types(['scalar_int_mode_pod',
                               'scalar_mode_pod'],
                              'pod_mode', MachineModePrinter)
-    for mode in 'scalar_mode', 'scalar_int_mode', 'scalar_float_mode':
+    for mode in ('scalar_mode', 'scalar_int_mode', 'scalar_float_mode',
+                 'complex_mode'):
         pp.add_printer_for_types([mode], mode, MachineModePrinter)
 
     return pp

diff --git a/gcc/genmodes.c b/gcc/genmodes.c
index ab3f999c9995e78a403f21a21064c69ca502c6a6..97ed949c255aa87cd0550973781d45db87cc078d 100644 (file)
--- a/gcc/genmodes.c
+++ b/gcc/genmodes.c
@@ -1152,6 +1152,10 @@ get_mode_class (struct mode_data *mode)
     case MODE_DECIMAL_FLOAT:
       return "scalar_float_mode";
 
+    case MODE_COMPLEX_INT:
+    case MODE_COMPLEX_FLOAT:
+      return "complex_mode";
+
     default:
       return NULL;
     }

diff --git a/gcc/go/ChangeLog b/gcc/go/ChangeLog
index ea47870590d99a0038ed01a4e7a4389d31b76259..83138d35c281b94cedeebbe0ba64d46706c40054 100644 (file)
--- a/gcc/go/ChangeLog
+++ b/gcc/go/ChangeLog
@@ -1,3 +1,9 @@
+2017-08-30  Richard Sandiford  <richard.sandiford@linaro.org>
+           Alan Hayward  <alan.hayward@arm.com>
+           David Sherwood  <david.sherwood@arm.com>
+
+       * go-lang.c (go_langhook_type_for_mode): Use is_complex_float_mode.
+
 2017-08-30  Richard Sandiford  <richard.sandiford@linaro.org>
            Alan Hayward  <alan.hayward@arm.com>
            David Sherwood  <david.sherwood@arm.com>

diff --git a/gcc/go/go-lang.c b/gcc/go/go-lang.c
index d470d5ab20a244e80857420ab06da231c26f94d6..81eeb5c9cdcea54709470635463d843a3c0ce400 100644 (file)
--- a/gcc/go/go-lang.c
+++ b/gcc/go/go-lang.c
@@ -384,7 +384,7 @@ go_langhook_type_for_mode (machine_mode mode, int unsignedp)
 
   scalar_int_mode imode;
   scalar_float_mode fmode;
-  enum mode_class mc = GET_MODE_CLASS (mode);
+  complex_mode cmode;
   if (is_int_mode (mode, &imode))
     return go_langhook_type_for_size (GET_MODE_BITSIZE (imode), unsignedp);
   else if (is_float_mode (mode, &fmode))
@@ -402,9 +402,9 @@ go_langhook_type_for_mode (machine_mode mode, int unsignedp)
            return long_double_type_node;
        }
     }
-  else if (mc == MODE_COMPLEX_FLOAT)
+  else if (is_complex_float_mode (mode, &cmode))
     {
-      switch (GET_MODE_BITSIZE (mode))
+      switch (GET_MODE_BITSIZE (cmode))
        {
        case 64:
          return complex_float_type_node;
@@ -413,7 +413,7 @@ go_langhook_type_for_mode (machine_mode mode, int unsignedp)
        default:
          // We have to check for long double in order to support
          // i386 excess precision.
-         if (mode == TYPE_MODE(complex_long_double_type_node))
+         if (cmode == TYPE_MODE(complex_long_double_type_node))
            return complex_long_double_type_node;
        }
     }

diff --git a/gcc/machmode.h b/gcc/machmode.h
index 73c45beb65550b201c62bd593d87b233feae399d..b331f07b4fd8fb73c727901895c6d49f0e798d29 100644 (file)
--- a/gcc/machmode.h
+++ b/gcc/machmode.h
@@ -450,6 +450,30 @@ scalar_mode::includes_p (machine_mode m)
     }
 }
 
+/* Represents a machine mode that is known to be a COMPLEX_MODE_P.  */
+class complex_mode
+{
+public:
+  typedef mode_traits<complex_mode>::from_int from_int;
+
+  ALWAYS_INLINE complex_mode () {}
+  ALWAYS_INLINE complex_mode (from_int m) : m_mode (machine_mode (m)) {}
+  ALWAYS_INLINE operator machine_mode () const { return m_mode; }
+
+  static bool includes_p (machine_mode);
+
+protected:
+  machine_mode m_mode;
+};
+
+/* Return true if M is a complex_mode.  */
+
+inline bool
+complex_mode::includes_p (machine_mode m)
+{
+  return COMPLEX_MODE_P (m);
+}
+
 /* Return the base GET_MODE_SIZE value for MODE.  */
 
 ALWAYS_INLINE unsigned short
@@ -771,6 +795,36 @@ is_float_mode (machine_mode mode, T *float_mode)
   return false;
 }
 
+/* Return true if MODE has class MODE_COMPLEX_INT, storing it as
+   a complex_mode in *CMODE if so.  */
+
+template<typename T>
+inline bool
+is_complex_int_mode (machine_mode mode, T *cmode)
+{
+  if (GET_MODE_CLASS (mode) == MODE_COMPLEX_INT)
+    {
+      *cmode = complex_mode (complex_mode::from_int (mode));
+      return true;
+    }
+  return false;
+}
+
+/* Return true if MODE has class MODE_COMPLEX_FLOAT, storing it as
+   a complex_mode in *CMODE if so.  */
+
+template<typename T>
+inline bool
+is_complex_float_mode (machine_mode mode, T *cmode)
+{
+  if (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT)
+    {
+      *cmode = complex_mode (complex_mode::from_int (mode));
+      return true;
+    }
+  return false;
+}
+
 namespace mode_iterator
 {
   /* Start mode iterator *ITER at the first mode in class MCLASS, if any.  */