From patchwork Thu Jul 13 08:40:24 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Richard Sandiford X-Patchwork-Id: 107593 Delivered-To: patch@linaro.org Received: by 10.140.101.44 with SMTP id t41csp1925049qge; Thu, 13 Jul 2017 01:40:51 -0700 (PDT) X-Received: by 10.99.120.132 with SMTP id t126mr7845762pgc.276.1499935251117; Thu, 13 Jul 2017 01:40:51 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1499935251; cv=none; d=google.com; s=arc-20160816; b=0d3HmNh/1kluKFQDB2gDe/+hV8TvyGcHF+E9ETUBevZNHivFV1WmcFJccBM8FfhAPP jd5yn6vnaLqeVb1jXyjibyPEYvOkAsE3Z/iy0Lx9GSENC4CoLhfbXvW9QJGjfz+EdSOZ JRU0b5w3ZYjVjVwdckPLoFJdLFEatxmglbbSyDUMIScS6J6j4c3TGT0iwRMOoWOdGPTe UJMl8684vJ5C9hoWpnEUwInvF89Vodg0Ih6YLo/ZDF6uLl6I1etwAJMLOrdzWQqvY9/S xx2YtQ4F+vHwxTfy5uMJlXXzflHzWRXq9lGEPT9KZIbf5Em1sfukQbxnzcAjFYjYh2y0 lphQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=mime-version:user-agent:message-id:in-reply-to:date:references :subject:mail-followup-to:to:from:delivered-to:sender:list-help :list-post:list-archive:list-unsubscribe:list-id:precedence :mailing-list:dkim-signature:domainkey-signature :arc-authentication-results; bh=0o6XNEOUF0D3ZNO9a19m/MfRjQptQQoL/Zjd2eEToBI=; b=FCpVhQAiMx0xAFrhqweXg5eyraKYmgrVCIUm1AiZvjbGSM/syf78wdqMwLNzsOTTjT nrYZ6W5y2KVCWSbdDRVZHzwMb/TsFelBq8j0yQbXyVZrH4zFcjrx8G5O2ykVr2XOoL6v PRT/YRCBpcYtvWWCnbRpF7SpTXpo+P+xWNZsFL57dQgjmFZVyHRB19/Z9ySCIeO2DqC8 cI6YoRhE4hT3cxCVoMFxPE79IZvxbG1QsYax3yDnmH1nJ6Eceblgk3EbN2f/oapW14Xb ukEf84HakBZs/ykLylQWu4MjNrG+Hn3sc6xVP2caLQAuo8pKeId299HRRi75Mn0HEuDd Qslg== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@gcc.gnu.org header.b=kHhTtmZc; spf=pass (google.com: domain of gcc-patches-return-457997-patch=linaro.org@gcc.gnu.org designates 209.132.180.131 as permitted sender) smtp.mailfrom=gcc-patches-return-457997-patch=linaro.org@gcc.gnu.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from sourceware.org (server1.sourceware.org. [209.132.180.131]) by mx.google.com with ESMTPS id q6si3770665pgq.8.2017.07.13.01.40.50 for (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Thu, 13 Jul 2017 01:40:51 -0700 (PDT) Received-SPF: pass (google.com: domain of gcc-patches-return-457997-patch=linaro.org@gcc.gnu.org designates 209.132.180.131 as permitted sender) client-ip=209.132.180.131; Authentication-Results: mx.google.com; dkim=pass header.i=@gcc.gnu.org header.b=kHhTtmZc; spf=pass (google.com: domain of gcc-patches-return-457997-patch=linaro.org@gcc.gnu.org designates 209.132.180.131 as permitted sender) smtp.mailfrom=gcc-patches-return-457997-patch=linaro.org@gcc.gnu.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=linaro.org DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:from :to:subject:references:date:in-reply-to:message-id:mime-version :content-type; q=dns; s=default; b=WXQO1kGVkK7vBkQirWHlNVYnvHHla MebdjBugouPqp2dhs8GJng3V0eYEkaFJZpu+7GyojKPA7UO0q57TsZCG6ozRNi2V f1hBsHUxYZ451f+9rRjsYhjNWOiRDEsk1Q8OTc9E9mHT2omm1nQnhxMb0eMgGX5z ZUtoEGVxJ40K3I= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:from :to:subject:references:date:in-reply-to:message-id:mime-version :content-type; s=default; bh=SwmoqeN8DTWecavRe9HsAD/1mmk=; b=kHh TtmZcC9PbEiP64Ph3+xRrmf37akxBtoouJ65pL+NU9Gj13NJl3rvmef9sPobsl0n Yxqi++AkGWiBRvMvIg3130bPm3ft+Sl/NqDgh8l8AJKNXDE1iQiCKOyntQsoAx6a pP2dRmH/enNgfVro8EQzv/cHgg7jmNuM5/M/iCSg= Received: (qmail 24491 invoked by alias); 13 Jul 2017 08:40:35 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Received: (qmail 24223 invoked by uid 89); 13 Jul 2017 08:40:35 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-10.6 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_2, GIT_PATCH_3, KAM_ASCII_DIVIDERS, RCVD_IN_DNSWL_NONE, RCVD_IN_SORBS_SPAM, SPF_PASS autolearn=ham version=3.3.2 spammy= X-HELO: mail-wr0-f179.google.com Received: from mail-wr0-f179.google.com (HELO mail-wr0-f179.google.com) (209.85.128.179) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Thu, 13 Jul 2017 08:40:29 +0000 Received: by mail-wr0-f179.google.com with SMTP id r103so49407622wrb.0 for ; Thu, 13 Jul 2017 01:40:29 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:mail-followup-to:subject:references:date :in-reply-to:message-id:user-agent:mime-version; bh=0o6XNEOUF0D3ZNO9a19m/MfRjQptQQoL/Zjd2eEToBI=; b=b8SEMmr8TP4Lpnvutzh7jS43PrSKqIQwKb3Pq9MpNz1iZg3Bfs4wsk6XSEEKgfVxWm St7OutoVXvw5FVbZYTPOaW3uuj5PPhCPqVO08jDlbObKfD0dc6Qizwc9piSTjYngIBtj eAlXDzeW7yAr2vc2C/EU9f/iV8q6/6B3pTQrkCDwmME3pSfjCXH4xGpjRpTkuYflw3Jj gtQOOjxKIs0Hkh8Y/zHjiAHVTFXaGAIIwcZ4shofRm+YEq75c+JOZYEeUHwZjSVFMXU5 Ef0coxuo6JEvDEIXyvG9mydcyYSajhVu6spg6/mBdIN+4JF/HRAGSVG3kC9+igi1SbYY br+w== X-Gm-Message-State: AIVw1104zFSeYHiqGbK/bb3AQuhQNmFAAjzjudDtQQ/INwkB40UPnmTY jlatJXwAPbCCe3nQbrm7mQ== X-Received: by 10.223.128.42 with SMTP id 39mr1043737wrk.175.1499935227089; Thu, 13 Jul 2017 01:40:27 -0700 (PDT) Received: from localhost (92.40.249.184.threembb.co.uk. [92.40.249.184]) by smtp.gmail.com with ESMTPSA id w96sm4077166wrc.33.2017.07.13.01.40.26 for (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Thu, 13 Jul 2017 01:40:26 -0700 (PDT) From: Richard Sandiford To: gcc-patches@gcc.gnu.org Mail-Followup-To: gcc-patches@gcc.gnu.org, richard.sandiford@linaro.org Subject: [07/77] Add scalar_float_mode References: <8760ewohsv.fsf@linaro.org> Date: Thu, 13 Jul 2017 09:40:24 +0100 In-Reply-To: <8760ewohsv.fsf@linaro.org> (Richard Sandiford's message of "Thu, 13 Jul 2017 09:35:44 +0100") Message-ID: <87bmoon30n.fsf@linaro.org> User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/25.2 (gnu/linux) MIME-Version: 1.0 This patch adds a scalar_float_mode class, which wraps a mode enum that is known to satisfy SCALAR_FLOAT_MODE_P. Things like "SFmode" now give a scalar_float_mode object instead of a machine_mode. This in turn needs a change to the real.h format_helper, so that it can accept both machine_modes and scalar_float_modes. 2017-07-13 Richard Sandiford Alan Hayward David Sherwood gcc/ * coretypes.h (scalar_float_mode): New type. * machmode.h (mode_traits::from_int): Use machine_mode if USE_ENUM_MODES is defined. (is_a): New function. (as_a): Likewise. (dyn_cast): Likewise. (scalar_float_mode): New class. (scalar_float_mode::includes_p): New function. (is_float_mode): Likewise. * gdbhooks.py (MachineModePrinter): New class. (build_pretty_printer): Use it for scalar_float_mode. * real.h (FLOAT_MODE_FORMAT): Use as_a . (format_helper::format_helper): Turn into a template. * genmodes.c (get_mode_class): New function. (emit_insn_modes_h): Give modes the class returned by get_mode_class, or machine_mode if none. * config/aarch64/aarch64.c (aarch64_simd_valid_immediate): Use as_a . * dwarf2out.c (mem_loc_descriptor): Likewise. (insert_float): Likewise. (add_const_value_attribute): Likewise. * simplify-rtx.c (simplify_immed_subreg): Likewise. * optabs.c (expand_absneg_bit): Take a scalar_float_mode. (expand_unop): Update accordingly. (expand_abs_nojump): Likewise. (expand_copysign_absneg): Take a scalar_float_mode. (expand_copysign_bit): Likewise. (expand_copysign): Update accordingly. gcc/ada/ * gcc-interface/utils.c (gnat_type_for_mode): Use is_a instead of SCALAR_FLOAT_MODE_P. gcc/go/ * go-lang.c (go_langhook_type_for_mode): Use is_float_mode. Index: gcc/coretypes.h =================================================================== --- gcc/coretypes.h 2017-07-13 09:18:22.924279021 +0100 +++ gcc/coretypes.h 2017-07-13 09:18:23.795186280 +0100 @@ -55,6 +55,7 @@ typedef const struct simple_bitmap_def * struct rtx_def; typedef struct rtx_def *rtx; typedef const struct rtx_def *const_rtx; +class scalar_float_mode; template class opt_mode; /* Subclasses of rtx_def, using indentation to show the class @@ -311,6 +312,8 @@ #define rtx_insn struct _dont_use_rtx_in #define tree union _dont_use_tree_here_ * #define const_tree union _dont_use_tree_here_ * +typedef struct scalar_float_mode scalar_float_mode; + #endif /* Classes of functions that compiler needs to check Index: gcc/machmode.h =================================================================== --- gcc/machmode.h 2017-07-13 09:18:22.930278376 +0100 +++ gcc/machmode.h 2017-07-13 09:18:23.798185961 +0100 @@ -46,9 +46,15 @@ struct mode_traits res = T (typename mode_traits::from_int (mode)); when assigning to a value RES that must be assignment-compatible - with (but possibly not the same as) T. - - Here we use an enum type distinct from machine_mode but with the + with (but possibly not the same as) T. */ +#ifdef USE_ENUM_MODES + /* Allow direct conversion of enums to specific mode classes only + when USE_ENUM_MODES is defined. This is only intended for use + by gencondmd, so that it can tell more easily when .md conditions + are always false. */ + typedef machine_mode from_int; +#else + /* Here we use an enum type distinct from machine_mode but with the same range as machine_mode. T should have a constructor that accepts this enum type; it should not have a constructor that accepts machine_mode. @@ -58,6 +64,7 @@ struct mode_traits unoptimized code, the return statement above would construct the returned T directly from the numerical value of MODE. */ enum from_int { dummy = MAX_MACHINE_MODE }; +#endif }; template<> @@ -287,6 +294,75 @@ opt_mode::exists (U *mode) const return false; } +/* Return true if mode M has type T. */ + +template +inline bool +is_a (machine_mode m) +{ + return T::includes_p (m); +} + +/* Assert that mode M has type T, and return it in that form. */ + +template +inline T +as_a (machine_mode m) +{ + gcc_checking_assert (T::includes_p (m)); + return typename mode_traits::from_int (m); +} + +/* Convert M to an opt_mode. */ + +template +inline opt_mode +dyn_cast (machine_mode m) +{ + if (T::includes_p (m)) + return T (typename mode_traits::from_int (m)); + return opt_mode (); +} + +/* Return true if mode M has type T, storing it as a T in *RESULT + if so. */ + +template +inline bool +is_a (machine_mode m, U *result) +{ + if (T::includes_p (m)) + { + *result = T (typename mode_traits::from_int (m)); + return true; + } + return false; +} + +/* Represents a machine mode that is known to be a SCALAR_FLOAT_MODE_P. */ +class scalar_float_mode +{ +public: + typedef mode_traits::from_int from_int; + + ALWAYS_INLINE scalar_float_mode () {} + ALWAYS_INLINE scalar_float_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 scalar_float_mode. */ + +inline bool +scalar_float_mode::includes_p (machine_mode m) +{ + return SCALAR_FLOAT_MODE_P (m); +} + /* Return the base GET_MODE_SIZE value for MODE. */ ALWAYS_INLINE unsigned short @@ -548,6 +624,21 @@ struct int_n_data_t { extern bool int_n_enabled_p[NUM_INT_N_ENTS]; extern const int_n_data_t int_n_data[NUM_INT_N_ENTS]; +/* Return true if MODE has class MODE_FLOAT, storing it as a + scalar_float_mode in *FLOAT_MODE if so. */ + +template +inline bool +is_float_mode (machine_mode mode, T *float_mode) +{ + if (GET_MODE_CLASS (mode) == MODE_FLOAT) + { + *float_mode = scalar_float_mode (scalar_float_mode::from_int (mode)); + return true; + } + return false; +} + namespace mode_iterator { /* Start mode iterator *ITER at the first mode in class MCLASS, if any. */ Index: gcc/gdbhooks.py =================================================================== --- gcc/gdbhooks.py 2017-07-13 09:18:22.928278591 +0100 +++ gcc/gdbhooks.py 2017-07-13 09:18:23.798185961 +0100 @@ -422,6 +422,16 @@ class VecPrinter: ###################################################################### +class MachineModePrinter: + def __init__(self, gdbval): + self.gdbval = gdbval + + def to_string (self): + name = str(self.gdbval['m_mode']) + return name[2:] if name.startswith('E_') else name + +###################################################################### + class OptMachineModePrinter: def __init__(self, gdbval): self.gdbval = gdbval @@ -532,6 +542,8 @@ def build_pretty_printer(): pp.add_printer_for_regex(r'opt_mode<(\S+)>', 'opt_mode', OptMachineModePrinter) + pp.add_printer_for_types(['scalar_float_mode'], + 'scalar_float_mode', MachineModePrinter) return pp Index: gcc/real.h =================================================================== --- gcc/real.h 2017-06-12 17:05:22.266750229 +0100 +++ gcc/real.h 2017-07-13 09:18:23.799185854 +0100 @@ -183,8 +183,7 @@ #define REAL_MODE_FORMAT(MODE) \ : (gcc_unreachable (), 0)]) #define FLOAT_MODE_FORMAT(MODE) \ - (REAL_MODE_FORMAT (SCALAR_FLOAT_MODE_P (MODE)? (MODE) \ - : GET_MODE_INNER (MODE))) + (REAL_MODE_FORMAT (as_a (GET_MODE_INNER (MODE)))) /* The following macro determines whether the floating point format is composite, i.e. may contain non-consecutive mantissa bits, in which @@ -212,7 +211,7 @@ #define MODE_HAS_SIGN_DEPENDENT_ROUNDING { public: format_helper (const real_format *format) : m_format (format) {} - format_helper (machine_mode m); + template format_helper (const T &); const real_format *operator-> () const { return m_format; } operator const real_format *() const { return m_format; } @@ -222,7 +221,8 @@ #define MODE_HAS_SIGN_DEPENDENT_ROUNDING const real_format *m_format; }; -inline format_helper::format_helper (machine_mode m) +template +inline format_helper::format_helper (const T &m) : m_format (m == VOIDmode ? 0 : REAL_MODE_FORMAT (m)) {} Index: gcc/genmodes.c =================================================================== --- gcc/genmodes.c 2017-07-13 09:18:20.866501621 +0100 +++ gcc/genmodes.c 2017-07-13 09:18:23.798185961 +0100 @@ -1129,6 +1129,23 @@ mode_unit_precision_inline (machine_mode }\n"); } +/* Return the best machine mode class for MODE, or null if machine_mode + should be used. */ + +static const char * +get_mode_class (struct mode_data *mode) +{ + switch (mode->cl) + { + case MODE_FLOAT: + case MODE_DECIMAL_FLOAT: + return "scalar_float_mode"; + + default: + return NULL; + } +} + static void emit_insn_modes_h (void) { @@ -1158,8 +1175,12 @@ enum machine_mode\n{"); printf ("#ifdef USE_ENUM_MODES\n"); printf ("#define %smode E_%smode\n", m->name, m->name); printf ("#else\n"); - printf ("#define %smode ((void) 0, E_%smode)\n", - m->name, m->name); + if (const char *mode_class = get_mode_class (m)) + printf ("#define %smode (%s ((%s::from_int) E_%smode))\n", + m->name, mode_class, mode_class, m->name); + else + printf ("#define %smode ((void) 0, E_%smode)\n", + m->name, m->name); printf ("#endif\n"); } Index: gcc/config/aarch64/aarch64.c =================================================================== --- gcc/config/aarch64/aarch64.c 2017-07-13 09:18:19.014705954 +0100 +++ gcc/config/aarch64/aarch64.c 2017-07-13 09:18:23.795186280 +0100 @@ -11354,8 +11354,12 @@ #define CHECK(STRIDE, ELSIZE, CLASS, TES if (info) { - info->value = CONST_VECTOR_ELT (op, 0); - info->element_width = GET_MODE_BITSIZE (GET_MODE (info->value)); + rtx elt = CONST_VECTOR_ELT (op, 0); + scalar_float_mode elt_mode + = as_a (GET_MODE (elt)); + + info->value = elt; + info->element_width = GET_MODE_BITSIZE (elt_mode); info->mvn = false; info->shift = 0; } Index: gcc/dwarf2out.c =================================================================== --- gcc/dwarf2out.c 2017-07-13 09:17:39.971572405 +0100 +++ gcc/dwarf2out.c 2017-07-13 09:18:23.797186067 +0100 @@ -15242,7 +15242,8 @@ mem_loc_descriptor (rtx rtl, machine_mod else #endif { - unsigned int length = GET_MODE_SIZE (mode); + scalar_float_mode float_mode = as_a (mode); + unsigned int length = GET_MODE_SIZE (float_mode); unsigned char *array = ggc_vec_alloc (length); insert_float (rtl, array); @@ -18539,11 +18540,12 @@ insert_float (const_rtx rtl, unsigned ch { long val[4]; int i; + scalar_float_mode mode = as_a (GET_MODE (rtl)); - real_to_target (val, CONST_DOUBLE_REAL_VALUE (rtl), GET_MODE (rtl)); + real_to_target (val, CONST_DOUBLE_REAL_VALUE (rtl), mode); /* real_to_target puts 32-bit pieces in each long. Pack them. */ - for (i = 0; i < GET_MODE_SIZE (GET_MODE (rtl)) / 4; i++) + for (i = 0; i < GET_MODE_SIZE (mode) / 4; i++) { insert_int (val[i], 4, array); array += 4; @@ -18587,21 +18589,19 @@ add_const_value_attribute (dw_die_ref di floating-point constant. A CONST_DOUBLE is used whenever the constant requires more than one word in order to be adequately represented. */ - { - machine_mode mode = GET_MODE (rtl); - - if (TARGET_SUPPORTS_WIDE_INT == 0 && !SCALAR_FLOAT_MODE_P (mode)) - add_AT_double (die, DW_AT_const_value, - CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl)); - else - { - unsigned int length = GET_MODE_SIZE (mode); - unsigned char *array = ggc_vec_alloc (length); + if (TARGET_SUPPORTS_WIDE_INT == 0 + && !SCALAR_FLOAT_MODE_P (GET_MODE (rtl))) + add_AT_double (die, DW_AT_const_value, + CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl)); + else + { + scalar_float_mode mode = as_a (GET_MODE (rtl)); + unsigned int length = GET_MODE_SIZE (mode); + unsigned char *array = ggc_vec_alloc (length); - insert_float (rtl, array); - add_AT_vec (die, DW_AT_const_value, length / 4, 4, array); - } - } + insert_float (rtl, array); + add_AT_vec (die, DW_AT_const_value, length / 4, 4, array); + } return true; case CONST_VECTOR: Index: gcc/simplify-rtx.c =================================================================== --- gcc/simplify-rtx.c 2017-07-05 16:29:19.600761904 +0100 +++ gcc/simplify-rtx.c 2017-07-13 09:18:23.800185748 +0100 @@ -5802,9 +5802,11 @@ simplify_immed_subreg (machine_mode oute { /* This is big enough for anything on the platform. */ long tmp[MAX_BITSIZE_MODE_ANY_MODE / 32]; - int bitsize = GET_MODE_BITSIZE (GET_MODE (el)); + scalar_float_mode el_mode; + + el_mode = as_a (GET_MODE (el)); + int bitsize = GET_MODE_BITSIZE (el_mode); - gcc_assert (SCALAR_FLOAT_MODE_P (GET_MODE (el))); gcc_assert (bitsize <= elem_bitsize); gcc_assert (bitsize % value_bit == 0); Index: gcc/optabs.c =================================================================== --- gcc/optabs.c 2017-07-13 09:18:22.935277839 +0100 +++ gcc/optabs.c 2017-07-13 09:18:23.799185854 +0100 @@ -2551,7 +2551,7 @@ lowpart_subreg_maybe_copy (machine_mode logical operation on the sign bit. */ static rtx -expand_absneg_bit (enum rtx_code code, machine_mode mode, +expand_absneg_bit (enum rtx_code code, scalar_float_mode mode, rtx op0, rtx target) { const struct real_format *fmt; @@ -2697,6 +2697,7 @@ expand_unop (machine_mode mode, optab un { enum mode_class mclass = GET_MODE_CLASS (mode); machine_mode wider_mode; + scalar_float_mode float_mode; rtx temp; rtx libfunc; @@ -2887,9 +2888,9 @@ expand_unop (machine_mode mode, optab un if (optab_to_code (unoptab) == NEG) { /* Try negating floating point values by flipping the sign bit. */ - if (SCALAR_FLOAT_MODE_P (mode)) + if (is_a (mode, &float_mode)) { - temp = expand_absneg_bit (NEG, mode, op0, target); + temp = expand_absneg_bit (NEG, float_mode, op0, target); if (temp) return temp; } @@ -3086,9 +3087,10 @@ expand_abs_nojump (machine_mode mode, rt return temp; /* For floating point modes, try clearing the sign bit. */ - if (SCALAR_FLOAT_MODE_P (mode)) + scalar_float_mode float_mode; + if (is_a (mode, &float_mode)) { - temp = expand_absneg_bit (ABS, mode, op0, target); + temp = expand_absneg_bit (ABS, float_mode, op0, target); if (temp) return temp; } @@ -3243,7 +3245,7 @@ expand_one_cmpl_abs_nojump (machine_mode and not playing with subregs so much, will help the register allocator. */ static rtx -expand_copysign_absneg (machine_mode mode, rtx op0, rtx op1, rtx target, +expand_copysign_absneg (scalar_float_mode mode, rtx op0, rtx op1, rtx target, int bitpos, bool op0_is_abs) { machine_mode imode; @@ -3327,7 +3329,7 @@ expand_copysign_absneg (machine_mode mod is true if op0 is known to have its sign bit clear. */ static rtx -expand_copysign_bit (machine_mode mode, rtx op0, rtx op1, rtx target, +expand_copysign_bit (scalar_float_mode mode, rtx op0, rtx op1, rtx target, int bitpos, bool op0_is_abs) { machine_mode imode; @@ -3425,12 +3427,12 @@ expand_copysign_bit (machine_mode mode, rtx expand_copysign (rtx op0, rtx op1, rtx target) { - machine_mode mode = GET_MODE (op0); + scalar_float_mode mode; const struct real_format *fmt; bool op0_is_abs; rtx temp; - gcc_assert (SCALAR_FLOAT_MODE_P (mode)); + mode = as_a (GET_MODE (op0)); gcc_assert (GET_MODE (op1) == mode); /* First try to do it with a special instruction. */ Index: gcc/ada/gcc-interface/utils.c =================================================================== --- gcc/ada/gcc-interface/utils.c 2017-06-22 12:22:56.060377637 +0100 +++ gcc/ada/gcc-interface/utils.c 2017-07-13 09:18:23.793186493 +0100 @@ -3464,8 +3464,10 @@ gnat_type_for_mode (machine_mode mode, i if (COMPLEX_MODE_P (mode)) return NULL_TREE; - if (SCALAR_FLOAT_MODE_P (mode)) - return float_type_for_precision (GET_MODE_PRECISION (mode), mode); + scalar_float_mode float_mode; + if (is_a (mode, &float_mode)) + return float_type_for_precision (GET_MODE_PRECISION (float_mode), + float_mode); if (SCALAR_INT_MODE_P (mode)) return gnat_type_for_size (GET_MODE_BITSIZE (mode), unsignedp); Index: gcc/go/go-lang.c =================================================================== --- gcc/go/go-lang.c 2017-06-12 17:05:23.068757522 +0100 +++ gcc/go/go-lang.c 2017-07-13 09:18:23.798185961 +0100 @@ -382,12 +382,13 @@ go_langhook_type_for_mode (machine_mode return NULL_TREE; } + scalar_float_mode fmode; enum mode_class mc = GET_MODE_CLASS (mode); if (mc == MODE_INT) return go_langhook_type_for_size (GET_MODE_BITSIZE (mode), unsignedp); - else if (mc == MODE_FLOAT) + else if (is_float_mode (mode, &fmode)) { - switch (GET_MODE_BITSIZE (mode)) + switch (GET_MODE_BITSIZE (fmode)) { case 32: return float_type_node; @@ -396,7 +397,7 @@ go_langhook_type_for_mode (machine_mode default: // We have to check for long double in order to support // i386 excess precision. - if (mode == TYPE_MODE(long_double_type_node)) + if (fmode == TYPE_MODE(long_double_type_node)) return long_double_type_node; } }