From a97390bf6e92f6f9b0f4e20aff4390ca5c609e37 Mon Sep 17 00:00:00 2001 From: Richard Sandiford Date: Wed, 30 Aug 2017 11:21:04 +0000 Subject: [PATCH] [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 Alan Hayward David Sherwood 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 Co-Authored-By: David Sherwood From-SVN: r251527 --- gcc/ChangeLog | 13 ++++++++++++ gcc/coretypes.h | 2 ++ gcc/function.c | 5 +++-- gcc/gdbhooks.py | 3 ++- gcc/genmodes.c | 4 ++++ gcc/go/ChangeLog | 6 ++++++ gcc/go/go-lang.c | 8 +++---- gcc/machmode.h | 54 ++++++++++++++++++++++++++++++++++++++++++++++++ 8 files changed, 88 insertions(+), 7 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index bb813131eeb..9d89d47c55d 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,16 @@ +2017-08-30 Richard Sandiford + Alan Hayward + David Sherwood + + * 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 Alan Hayward David Sherwood diff --git a/gcc/coretypes.h b/gcc/coretypes.h index 8ccf16e5e4a..21ea8d97a0d 100644 --- 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 class opt_mode; typedef opt_mode opt_scalar_mode; typedef opt_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 af5e050b8a6..4c77e19973e 100644 --- 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 acf54351e23..1b3f95361b6 100644 --- 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 ab3f999c999..97ed949c255 100644 --- 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 ea47870590d..83138d35c28 100644 --- a/gcc/go/ChangeLog +++ b/gcc/go/ChangeLog @@ -1,3 +1,9 @@ +2017-08-30 Richard Sandiford + Alan Hayward + David Sherwood + + * go-lang.c (go_langhook_type_for_mode): Use is_complex_float_mode. + 2017-08-30 Richard Sandiford Alan Hayward David Sherwood diff --git a/gcc/go/go-lang.c b/gcc/go/go-lang.c index d470d5ab20a..81eeb5c9cdc 100644 --- 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 73c45beb655..b331f07b4fd 100644 --- 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::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 +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 +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. */ -- 2.30.2