From patchwork Fri Dec 9 13:37:57 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Richard Sandiford X-Patchwork-Id: 704551 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 3tZtbs18KPz9vDV for ; Sat, 10 Dec 2016 00:38:32 +1100 (AEDT) Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.b="yVUUOIOb"; dkim-atps=neutral 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=flPe8Mz4MBa3JcbAY8heFk2f8rjCW 6/F3FY6lOoDi3wrovZRh28M4gc51QGE1sMkqJnZgaZgL/nxly2AABAHxKv4S+rVt E8enXZNgdN6BLmTKnLW9IoYZ/htgRWg7gJ/66KlkLBzl4Xige1ukEHC9kBbP5URA OzaAR3VP33s6Vs= 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=pSA0sEqSueFKE7Yh8iTP89dk2vc=; b=yVU UOIOb97ttyf6pCq0MTG7GyJBP/i/2QDh6h3ElEL2Q5f9SzMvoFra0giBQDxVJ9RN Nw8F44p6fge1oWhGm+zg+3285sfRnUyYeKtG9GBtims/2L66dKSJAczOZhEJujPk PJ3Y48PB5oR2alh3r02c99MgfGuaaBWHIhIYKh6w= Received: (qmail 11698 invoked by alias); 9 Dec 2016 13:38:13 -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 11680 invoked by uid 89); 9 Dec 2016 13:38:12 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-2.1 required=5.0 tests=BAYES_00, RP_MATCHES_RCVD, SPF_PASS, UNWANTED_LANGUAGE_BODY autolearn=ham version=3.3.2 spammy=quantities, sk:built_i, ao_ref, memref X-HELO: foss.arm.com Received: from foss.arm.com (HELO foss.arm.com) (217.140.101.70) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Fri, 09 Dec 2016 13:38:01 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.72.51.249]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 4A34E707; Fri, 9 Dec 2016 05:38:00 -0800 (PST) Received: from localhost (e105548-lin.manchester.arm.com [10.45.32.67]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 96EE13F477 for ; Fri, 9 Dec 2016 05:37:59 -0800 (PST) From: Richard Sandiford To: gcc-patches@gcc.gnu.org Mail-Followup-To: gcc-patches@gcc.gnu.org, richard.sandiford@arm.com Subject: [62/67] Big machine_mode to scalar_int_mode replacement References: <87h96dp8u6.fsf@e105548-lin.cambridge.arm.com> Date: Fri, 09 Dec 2016 13:37:57 +0000 In-Reply-To: <87h96dp8u6.fsf@e105548-lin.cambridge.arm.com> (Richard Sandiford's message of "Fri, 09 Dec 2016 12:48:01 +0000") Message-ID: <871sxhfcju.fsf@e105548-lin.cambridge.arm.com> User-Agent: Gnus/5.130012 (Ma Gnus v0.12) Emacs/24.3 (gnu/linux) MIME-Version: 1.0 This patch changes the types of various things from machine_mode to scalar_int_mode, in cases where (after previous patches) simply changing the type is enough on its own. The patch does nothing other than that. gcc/ 2016-11-24 Richard Sandiford Alan Hayward David Sherwood * builtins.h (builtin_strncpy_read_str): Take a scalar_int_mode instead of a machine_mode. (builtin_memset_read_str): Likewise. * builtins.c (c_readstr): Likewise. (builtin_memcpy_read_str): Likewise. (builtin_strncpy_read_str): Likewise. (builtin_memset_read_str): Likewise. (builtin_memset_gen_str): Likewise. (expand_builtin_signbit): Use scalar_int_mode for local variables. * cfgexpand.c (convert_debug_memory_address): Take a scalar_int_mode instead of a machine_mode. * combine.c (make_extraction): Use scalar_int_mode for local variables. (try_widen_shift_mode): Take and return scalar_int_modes instead of machine_modes. * config/aarch64/aarch64.c (aarch64_libgcc_cmp_return_mode): Return a scalar_int_mode instead of a machine_mode. * config/avr/avr.c (avr_addr_space_address_mode): Likewise. (avr_addr_space_pointer_mode): Likewise. * config/cr16/cr16.c (cr16_unwind_word_mode): Likewise. * config/msp430/msp430.c (msp430_addr_space_pointer_mode): Likewise. (msp430_unwind_word_mode): Likewise. * config/spu/spu.c (spu_unwind_word_mode): Likewise. (spu_addr_space_pointer_mode): Likewise. (spu_addr_space_address_mode): Likewise. (spu_libgcc_cmp_return_mode): Likewise. (spu_libgcc_shift_count_mode): Likewise. * config/rl78/rl78.c (rl78_addr_space_address_mode): Likewise. (rl78_addr_space_pointer_mode): Likewise. (fl78_unwind_word_mode): Likewise. (rl78_valid_pointer_mode): Take a scalar_int_mode instead of a machine_mode. * config/alpha/alpha.c (vms_valid_pointer_mode): Likewise. * config/ia64/ia64.c (ia64_vms_valid_pointer_mode): Likewise. * config/mips/mips.c (mips_mode_rep_extended): Likewise. (mips_valid_pointer_mode): Likewise. * config/tilegx/tilegx.c (tilegx_mode_rep_extended): Likewise. * config/ft32/ft32.c (ft32_valid_pointer_mode): Likewise. (ft32_addr_space_pointer_mode): Return a scalar_int_mode instead of a machine_mode. (ft32_addr_space_address_mode): Likewise. * config/m32c/m32c.c (m32c_valid_pointer_mode): Take a scalar_int_mode instead of a machine_mode. (m32c_addr_space_pointer_mode): Return a scalar_int_mode instead of a machine_mode. (m32c_addr_space_address_mode): Likewise. * config/rs6000/rs6000.h (rs6000_pmode): Change type from machine_mode to scalar_int_mode. * config/rs6000/rs6000.c (rs6000_pmode): Likewise. (rs6000_abi_word_mode): Return a scalar_int_mode rather than a machine_mode. (rs6000_eh_return_filter_mode): Likewise. * config/s390/s390.c (s390_libgcc_cmp_return_mode): Likewise. (s390_libgcc_shift_count_mode): Likewise. (s390_unwind_word_mode): Likewise. (s390_valid_pointer_mode): Take a scalar_int_mode rather than a machine_mode. * target.def (mode_rep_extended): Likewise. (valid_pointer_mode): Likewise. (addr_space.valid_pointer_mode): Likewise. (eh_return_filter_mode): Return a scalar_int_mode rather than a machine_mode. (libgcc_cmp_return_mode): Likewise. (libgcc_shift_count_mode): Likewise. (unwind_word_mode): Likewise. (addr_space.pointer_mode): Likewise. (addr_space.address_mode): Likewise. * doc/tm.texi: Regenerate. * dojump.c (prefer_and_bit_test): Take a scalar_int_mode rather than a machine_mode. (do_jump): Use scalar_int_mode for local variables. * dwarf2cfi.c (init_return_column_size): Take a scalar_int_mode rather than a machine_mode. * dwarf2out.c (convert_descriptor_to_mode): Likewise. * emit-rtl.c (adjust_address_1): Use scalar_int_mode for local variables. * except.c (sjlj_emit_dispatch_table): Likewise. (expand_builtin_eh_copy_values): Likewise. * explow.c (convert_memory_address_addr_space_1): Likewise. Take a scalar_int_mode rather than a machine_mode. (convert_memory_address_addr_space): Take a scalar_int_mode rather than a machine_mode. (memory_address_addr_space): Use scalar_int_mode for local variables. * expmed.h (expand_mult_highpart_adjust): Take a scalar_int_mode rather than a machine_mode. * expmed.c (mask_rtx): Likewise. (init_expmed_one_conv): Likewise. (expand_mult_highpart_adjust): Likewise. (extract_high_half): Likewise. (expmed_mult_highpart_optab): Likewise. (expmed_mult_highpart): Likewise. (expand_smod_pow2): Likewise. (expand_sdiv_pow2): Likewise. (adjust_bit_field_mem_for_reg): Use scalar_int_mode for local variables. (extract_low_bits): Likewise. * expr.h (by_pieces_constfn): Take a scalar_int_mode rather than a machine_mode. * expr.c (pieces_addr:adjust): Likewise. (can_store_by_pieces): Likewise. (store_by_pieces): Likewise. (clear_by_pieces_1): Likewise. (expand_expr_addr_expr_1): Likewise. (expand_expr_addr_expr): Use scalar_int_mode for local variables. (expand_expr_real_1): Likewise. (try_casesi): Likewise. * final.c (shorten_branches): Likewise. * fold-const.c (fold_convert_const_int_from_fixed): Change the type of "mode" to machine_mode. * internal-fn.c (expand_arith_overflow_result_store): Take a scalar_int_mode rather than a machine_mode. (expand_mul_overflow): Use scalar_int_mode for local variables. * loop-doloop.c (doloop_modify): Likewise. (doloop_optimize): Likewise. * lower-subreg.h (target_lower_subreg::x_twice_word_mode): Change type to scalar_int_mode. * optabs.c (expand_subword_shift): Take a scalar_int_mode rather than a machine_mode. (expand_doubleword_shift_condmove): Likewise. (expand_doubleword_shift): Likewise. (expand_doubleword_clz): Likewise. (expand_doubleword_popcount): Likewise. (expand_doubleword_parity): Likewise. (expand_absneg_bit): Use scalar_int_mode for local variables. (prepare_float_lib_cmp): Likewise. * rtl.h (convert_memory_address_addr_space_1): Take a scalar_int_mode rather than a machine_mode. (convert_memory_address_addr_space): Likewise. (get_mode_bounds): Likewise. (get_address_mode): Return a scalar_int_mode rather than a machine_mode. * rtlanal.c (get_address_mode): Likewise. * stor-layout.c (get_mode_bounds): Take a scalar_int_mode rather than a machine_mode. * targhooks.c (default_mode_rep_extended): Likewise. (default_valid_pointer_mode): Likewise. (default_addr_space_valid_pointer_mode): Likewise. (default_eh_return_filter_mode): Return a scalar_int_mode rather than a machine_mode. (default_libgcc_cmp_return_mode): Likewise. (default_libgcc_shift_count_mode): Likewise. (default_unwind_word_mode): Likewise. (default_addr_space_pointer_mode): Likewise. (default_addr_space_address_mode): Likewise. * targhooks.h (default_eh_return_filter_mode): Likewise. (default_libgcc_cmp_return_mode): Likewise. (default_libgcc_shift_count_mode): Likewise. (default_unwind_word_mode): Likewise. (default_addr_space_pointer_mode): Likewise. (default_addr_space_address_mode): Likewise. (default_mode_rep_extended): Take a scalar_int_mode rather than a machine_mode. (default_valid_pointer_mode): Likewise. (default_addr_space_valid_pointer_mode): Likewise. * tree-ssa-address.c (addr_for_mem_ref): Use scalar_int_mode for local variables. * tree-ssa-loop-ivopts.c (compute_max_addr_offset): Likewise. (get_address_cost): Likewise. (get_shiftadd_cost): Take a scalar_int_mode rather than a machine_mode. * tree-switch-conversion.c (array_value_type): Use scalar_int_mode for local variables. * tree-vrp.c (simplify_float_conversion_using_ranges): Likewise. * var-tracking.c (use_narrower_mode): Take a scalar_int_mode rather than a machine_mode. diff --git a/gcc/builtins.c b/gcc/builtins.c index cf22e96..860b1a8 100644 --- a/gcc/builtins.c +++ b/gcc/builtins.c @@ -91,7 +91,7 @@ builtin_info_type builtin_info[(int)END_BUILTINS]; /* Non-zero if __builtin_constant_p should be folded right away. */ bool force_folding_builtin_constant_p; -static rtx c_readstr (const char *, machine_mode); +static rtx c_readstr (const char *, scalar_int_mode); static int target_char_cast (tree, char *); static rtx get_memory_rtx (tree, tree); static int apply_args_size (void); @@ -117,7 +117,7 @@ static rtx expand_builtin_va_end (tree); static rtx expand_builtin_va_copy (tree); static rtx expand_builtin_strcmp (tree, rtx); static rtx expand_builtin_strncmp (tree, rtx, machine_mode); -static rtx builtin_memcpy_read_str (void *, HOST_WIDE_INT, machine_mode); +static rtx builtin_memcpy_read_str (void *, HOST_WIDE_INT, scalar_int_mode); static rtx expand_builtin_memcpy (tree, rtx); static rtx expand_builtin_memcpy_with_bounds (tree, rtx); static rtx expand_builtin_memcpy_args (tree, tree, tree, rtx, tree); @@ -131,7 +131,7 @@ static rtx expand_builtin_strcpy_args (tree, tree, rtx); static rtx expand_builtin_stpcpy (tree, rtx, machine_mode); static rtx expand_builtin_strncat (tree, rtx); static rtx expand_builtin_strncpy (tree, rtx); -static rtx builtin_memset_gen_str (void *, HOST_WIDE_INT, machine_mode); +static rtx builtin_memset_gen_str (void *, HOST_WIDE_INT, scalar_int_mode); static rtx expand_builtin_memset (tree, rtx, machine_mode); static rtx expand_builtin_memset_with_bounds (tree, rtx, machine_mode); static rtx expand_builtin_memset_args (tree, tree, tree, rtx, machine_mode, tree); @@ -662,7 +662,7 @@ c_strlen (tree src, int only_value) GET_MODE_BITSIZE (MODE) bits from string constant STR. */ static rtx -c_readstr (const char *str, machine_mode mode) +c_readstr (const char *str, scalar_int_mode mode) { HOST_WIDE_INT ch; unsigned int i, j; @@ -2857,7 +2857,7 @@ expand_builtin_strlen (tree exp, rtx target, static rtx builtin_memcpy_read_str (void *data, HOST_WIDE_INT offset, - machine_mode mode) + scalar_int_mode mode) { const char *str = (const char *) data; @@ -3693,7 +3693,7 @@ expand_builtin_stpcpy (tree exp, rtx target, machine_mode mode) rtx builtin_strncpy_read_str (void *data, HOST_WIDE_INT offset, - machine_mode mode) + scalar_int_mode mode) { const char *str = (const char *) data; @@ -3908,7 +3908,7 @@ expand_builtin_strncpy (tree exp, rtx target) rtx builtin_memset_read_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED, - machine_mode mode) + scalar_int_mode mode) { const char *c = (const char *) data; char *p = XALLOCAVEC (char, GET_MODE_SIZE (mode)); @@ -3925,7 +3925,7 @@ builtin_memset_read_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED, static rtx builtin_memset_gen_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED, - machine_mode mode) + scalar_int_mode mode) { rtx target, coeff; size_t size; @@ -5211,7 +5211,7 @@ expand_builtin_signbit (tree exp, rtx target) { const struct real_format *fmt; scalar_float_mode fmode; - machine_mode imode, rmode; + scalar_int_mode rmode, imode; tree arg; int word, bitpos; enum insn_code icode; diff --git a/gcc/builtins.h b/gcc/builtins.h index 5e83646..5ce3f4f 100644 --- a/gcc/builtins.h +++ b/gcc/builtins.h @@ -63,8 +63,8 @@ extern void expand_builtin_setjmp_receiver (rtx); extern void expand_builtin_update_setjmp_buf (rtx); extern tree mathfn_built_in (tree, enum built_in_function fn); extern tree mathfn_built_in (tree, combined_fn); -extern rtx builtin_strncpy_read_str (void *, HOST_WIDE_INT, machine_mode); -extern rtx builtin_memset_read_str (void *, HOST_WIDE_INT, machine_mode); +extern rtx builtin_strncpy_read_str (void *, HOST_WIDE_INT, scalar_int_mode); +extern rtx builtin_memset_read_str (void *, HOST_WIDE_INT, scalar_int_mode); extern rtx expand_builtin_saveregs (void); extern tree std_build_builtin_va_list (void); extern tree std_fn_abi_va_list (tree); diff --git a/gcc/cfgexpand.c b/gcc/cfgexpand.c index c4863dd..3d9f3ac 100644 --- a/gcc/cfgexpand.c +++ b/gcc/cfgexpand.c @@ -3951,7 +3951,7 @@ round_udiv_adjust (machine_mode mode, rtx mod, rtx op1) any rtl. */ static rtx -convert_debug_memory_address (machine_mode mode, rtx x, +convert_debug_memory_address (scalar_int_mode mode, rtx x, addr_space_t as) { #ifndef POINTERS_EXTEND_UNSIGNED diff --git a/gcc/combine.c b/gcc/combine.c index dd7f1fa..f1a89d8 100644 --- a/gcc/combine.c +++ b/gcc/combine.c @@ -7405,9 +7405,9 @@ make_extraction (machine_mode mode, rtx inner, HOST_WIDE_INT pos, ignore the POS lowest bits, etc. */ machine_mode is_mode = GET_MODE (inner); machine_mode inner_mode; - machine_mode wanted_inner_mode; - machine_mode wanted_inner_reg_mode = word_mode; - machine_mode pos_mode = word_mode; + scalar_int_mode wanted_inner_mode; + scalar_int_mode wanted_inner_reg_mode = word_mode; + scalar_int_mode pos_mode = word_mode; machine_mode extraction_mode = word_mode; rtx new_rtx = 0; rtx orig_pos_rtx = pos_rtx; @@ -10294,9 +10294,9 @@ merge_outer_ops (enum rtx_code *pop0, HOST_WIDE_INT *pconst0, enum rtx_code op1, result of the shift is subject to operation OUTER_CODE with operand OUTER_CONST. */ -static machine_mode +static scalar_int_mode try_widen_shift_mode (enum rtx_code code, rtx op, int count, - machine_mode orig_mode, machine_mode mode, + scalar_int_mode orig_mode, scalar_int_mode mode, enum rtx_code outer_code, HOST_WIDE_INT outer_const) { gcc_assert (GET_MODE_PRECISION (mode) > GET_MODE_PRECISION (orig_mode)); diff --git a/gcc/config/aarch64/aarch64.c b/gcc/config/aarch64/aarch64.c index d8019bf..9981f55 100644 --- a/gcc/config/aarch64/aarch64.c +++ b/gcc/config/aarch64/aarch64.c @@ -2576,7 +2576,7 @@ aarch64_pad_reg_upward (machine_mode mode, const_tree type, return !BYTES_BIG_ENDIAN; } -static machine_mode +static scalar_int_mode aarch64_libgcc_cmp_return_mode (void) { return SImode; diff --git a/gcc/config/alpha/alpha.c b/gcc/config/alpha/alpha.c index 59774bf..620a442 100644 --- a/gcc/config/alpha/alpha.c +++ b/gcc/config/alpha/alpha.c @@ -206,7 +206,7 @@ static void alpha_override_options_after_change (void); #if TARGET_ABI_OPEN_VMS static void alpha_write_linkage (FILE *, const char *); -static bool vms_valid_pointer_mode (machine_mode); +static bool vms_valid_pointer_mode (scalar_int_mode); #else #define vms_patch_builtins() gcc_unreachable() #endif @@ -816,7 +816,7 @@ alpha_in_small_data_p (const_tree exp) #if TARGET_ABI_OPEN_VMS static bool -vms_valid_pointer_mode (machine_mode mode) +vms_valid_pointer_mode (scalar_int_mode mode) { return (mode == SImode || mode == DImode); } diff --git a/gcc/config/avr/avr.c b/gcc/config/avr/avr.c index e3a611f..105ceb1 100644 --- a/gcc/config/avr/avr.c +++ b/gcc/config/avr/avr.c @@ -12542,7 +12542,7 @@ avr_case_values_threshold (void) /* Implement `TARGET_ADDR_SPACE_ADDRESS_MODE'. */ -static machine_mode +static scalar_int_mode avr_addr_space_address_mode (addr_space_t as) { return avr_addrspace[as].pointer_size == 3 ? PSImode : HImode; @@ -12551,7 +12551,7 @@ avr_addr_space_address_mode (addr_space_t as) /* Implement `TARGET_ADDR_SPACE_POINTER_MODE'. */ -static machine_mode +static scalar_int_mode avr_addr_space_pointer_mode (addr_space_t as) { return avr_addr_space_address_mode (as); diff --git a/gcc/config/cr16/cr16.c b/gcc/config/cr16/cr16.c index cc24fa5..3686409 100644 --- a/gcc/config/cr16/cr16.c +++ b/gcc/config/cr16/cr16.c @@ -2090,7 +2090,7 @@ notice_update_cc (rtx exp) return; } -static machine_mode +static scalar_int_mode cr16_unwind_word_mode (void) { return SImode; diff --git a/gcc/config/ft32/ft32.c b/gcc/config/ft32/ft32.c index 5679dad..fe4e6b5 100644 --- a/gcc/config/ft32/ft32.c +++ b/gcc/config/ft32/ft32.c @@ -790,7 +790,7 @@ ft32_is_mem_pm (rtx o) #undef TARGET_VALID_POINTER_MODE #define TARGET_VALID_POINTER_MODE ft32_valid_pointer_mode static bool -ft32_valid_pointer_mode (machine_mode mode) +ft32_valid_pointer_mode (scalar_int_mode mode) { if (mode == SImode) return 1; @@ -799,7 +799,7 @@ ft32_valid_pointer_mode (machine_mode mode) #undef TARGET_ADDR_SPACE_POINTER_MODE #define TARGET_ADDR_SPACE_POINTER_MODE ft32_addr_space_pointer_mode -static machine_mode +static scalar_int_mode ft32_addr_space_pointer_mode (addr_space_t addrspace ATTRIBUTE_UNUSED) { return Pmode; @@ -807,7 +807,7 @@ ft32_addr_space_pointer_mode (addr_space_t addrspace ATTRIBUTE_UNUSED) #undef TARGET_ADDR_SPACE_ADDRESS_MODE #define TARGET_ADDR_SPACE_ADDRESS_MODE ft32_addr_space_address_mode -static machine_mode +static scalar_int_mode ft32_addr_space_address_mode (addr_space_t addrspace ATTRIBUTE_UNUSED) { return Pmode; diff --git a/gcc/config/ia64/ia64.c b/gcc/config/ia64/ia64.c index d43edc8..91bf0a0 100644 --- a/gcc/config/ia64/ia64.c +++ b/gcc/config/ia64/ia64.c @@ -298,7 +298,7 @@ static void ia64_vms_init_libfuncs (void) ATTRIBUTE_UNUSED; static void ia64_soft_fp_init_libfuncs (void) ATTRIBUTE_UNUSED; -static bool ia64_vms_valid_pointer_mode (machine_mode mode) +static bool ia64_vms_valid_pointer_mode (scalar_int_mode mode) ATTRIBUTE_UNUSED; static tree ia64_vms_common_object_attribute (tree *, tree, tree, int, bool *) ATTRIBUTE_UNUSED; @@ -10727,7 +10727,7 @@ ia64_soft_fp_init_libfuncs (void) } static bool -ia64_vms_valid_pointer_mode (machine_mode mode) +ia64_vms_valid_pointer_mode (scalar_int_mode mode) { return (mode == SImode || mode == DImode); } diff --git a/gcc/config/m32c/m32c.c b/gcc/config/m32c/m32c.c index 460ae19..3881cd3 100644 --- a/gcc/config/m32c/m32c.c +++ b/gcc/config/m32c/m32c.c @@ -1435,7 +1435,7 @@ m32c_function_arg_regno_p (int r) #undef TARGET_VALID_POINTER_MODE #define TARGET_VALID_POINTER_MODE m32c_valid_pointer_mode static bool -m32c_valid_pointer_mode (machine_mode mode) +m32c_valid_pointer_mode (scalar_int_mode mode) { if (mode == HImode || mode == PSImode @@ -1928,7 +1928,7 @@ m32c_legitimize_reload_address (rtx * x, /* Return the appropriate mode for a named address pointer. */ #undef TARGET_ADDR_SPACE_POINTER_MODE #define TARGET_ADDR_SPACE_POINTER_MODE m32c_addr_space_pointer_mode -static machine_mode +static scalar_int_mode m32c_addr_space_pointer_mode (addr_space_t addrspace) { switch (addrspace) @@ -1945,7 +1945,7 @@ m32c_addr_space_pointer_mode (addr_space_t addrspace) /* Return the appropriate mode for a named address address. */ #undef TARGET_ADDR_SPACE_ADDRESS_MODE #define TARGET_ADDR_SPACE_ADDRESS_MODE m32c_addr_space_address_mode -static machine_mode +static scalar_int_mode m32c_addr_space_address_mode (addr_space_t addrspace) { switch (addrspace) diff --git a/gcc/config/mips/mips.c b/gcc/config/mips/mips.c index 6c08aed..ae93ddb 100644 --- a/gcc/config/mips/mips.c +++ b/gcc/config/mips/mips.c @@ -13254,7 +13254,7 @@ mips_secondary_reload_class (enum reg_class rclass, /* Implement TARGET_MODE_REP_EXTENDED. */ static int -mips_mode_rep_extended (machine_mode mode, machine_mode mode_rep) +mips_mode_rep_extended (scalar_int_mode mode, scalar_int_mode mode_rep) { /* On 64-bit targets, SImode register values are sign-extended to DImode. */ if (TARGET_64BIT && mode == SImode && mode_rep == DImode) @@ -13266,7 +13266,7 @@ mips_mode_rep_extended (machine_mode mode, machine_mode mode_rep) /* Implement TARGET_VALID_POINTER_MODE. */ static bool -mips_valid_pointer_mode (machine_mode mode) +mips_valid_pointer_mode (scalar_int_mode mode) { return mode == SImode || (TARGET_64BIT && mode == DImode); } diff --git a/gcc/config/msp430/msp430.c b/gcc/config/msp430/msp430.c index 998b105..3711e45 100644 --- a/gcc/config/msp430/msp430.c +++ b/gcc/config/msp430/msp430.c @@ -1015,7 +1015,7 @@ msp430_initial_elimination_offset (int from, int to) #undef TARGET_ADDR_SPACE_ADDRESS_MODE #define TARGET_ADDR_SPACE_ADDRESS_MODE msp430_addr_space_pointer_mode -static machine_mode +static scalar_int_mode msp430_addr_space_pointer_mode (addr_space_t addrspace) { switch (addrspace) @@ -1035,7 +1035,7 @@ msp430_addr_space_pointer_mode (addr_space_t addrspace) #undef TARGET_UNWIND_WORD_MODE #define TARGET_UNWIND_WORD_MODE msp430_unwind_word_mode -static machine_mode +static scalar_int_mode msp430_unwind_word_mode (void) { /* This needs to match msp430_init_dwarf_reg_sizes_extra (below). */ diff --git a/gcc/config/rl78/rl78.c b/gcc/config/rl78/rl78.c index d5ea068..423cd5d 100644 --- a/gcc/config/rl78/rl78.c +++ b/gcc/config/rl78/rl78.c @@ -997,7 +997,7 @@ rl78_hl_b_c_addr_p (rtx op) #undef TARGET_ADDR_SPACE_ADDRESS_MODE #define TARGET_ADDR_SPACE_ADDRESS_MODE rl78_addr_space_address_mode -static machine_mode +static scalar_int_mode rl78_addr_space_address_mode (addr_space_t addrspace) { switch (addrspace) @@ -1037,7 +1037,7 @@ rl78_far_p (rtx x) #undef TARGET_ADDR_SPACE_POINTER_MODE #define TARGET_ADDR_SPACE_POINTER_MODE rl78_addr_space_pointer_mode -static machine_mode +static scalar_int_mode rl78_addr_space_pointer_mode (addr_space_t addrspace) { switch (addrspace) @@ -1058,7 +1058,7 @@ rl78_addr_space_pointer_mode (addr_space_t addrspace) #define TARGET_VALID_POINTER_MODE rl78_valid_pointer_mode static bool -rl78_valid_pointer_mode (machine_mode m) +rl78_valid_pointer_mode (scalar_int_mode m) { return (m == HImode || m == SImode); } @@ -4637,7 +4637,7 @@ rl78_asm_out_integer (rtx x, unsigned int size, int aligned_p) #undef TARGET_UNWIND_WORD_MODE #define TARGET_UNWIND_WORD_MODE rl78_unwind_word_mode -static machine_mode +static scalar_int_mode rl78_unwind_word_mode (void) { return HImode; diff --git a/gcc/config/rs6000/rs6000.c b/gcc/config/rs6000/rs6000.c index 06aae77..ac48e44 100644 --- a/gcc/config/rs6000/rs6000.c +++ b/gcc/config/rs6000/rs6000.c @@ -181,7 +181,7 @@ int dot_symbols; /* Specify the machine mode that pointers have. After generation of rtl, the compiler makes no further distinction between pointers and any other objects of this machine mode. */ -machine_mode rs6000_pmode; +scalar_int_mode rs6000_pmode; /* Width in bits of a pointer. */ unsigned rs6000_pointer_size; @@ -11273,7 +11273,7 @@ init_cumulative_args (CUMULATIVE_ARGS *cum, tree fntype, /* The mode the ABI uses for a word. This is not the same as word_mode for -m32 -mpowerpc64. This is used to implement various target hooks. */ -static machine_mode +static scalar_int_mode rs6000_abi_word_mode (void) { return TARGET_32BIT ? SImode : DImode; @@ -37643,7 +37643,7 @@ rs6000_dbx_register_number (unsigned int regno, unsigned int format) } /* target hook eh_return_filter_mode */ -static machine_mode +static scalar_int_mode rs6000_eh_return_filter_mode (void) { return TARGET_32BIT ? SImode : word_mode; diff --git a/gcc/config/rs6000/rs6000.h b/gcc/config/rs6000/rs6000.h index 0c68f28..a471d75 100644 --- a/gcc/config/rs6000/rs6000.h +++ b/gcc/config/rs6000/rs6000.h @@ -2211,7 +2211,7 @@ do { \ /* Specify the machine mode that pointers have. After generation of rtl, the compiler makes no further distinction between pointers and any other objects of this machine mode. */ -extern machine_mode rs6000_pmode; +extern scalar_int_mode rs6000_pmode; #define Pmode rs6000_pmode /* Supply definition of STACK_SIZE_MODE for allocate_dynamic_stack_space. */ diff --git a/gcc/config/s390/s390.c b/gcc/config/s390/s390.c index 510c24c..3862c15 100644 --- a/gcc/config/s390/s390.c +++ b/gcc/config/s390/s390.c @@ -1168,19 +1168,19 @@ s390_label_align (rtx_insn *label) return align_labels_log; } -static machine_mode +static scalar_int_mode s390_libgcc_cmp_return_mode (void) { return TARGET_64BIT ? DImode : SImode; } -static machine_mode +static scalar_int_mode s390_libgcc_shift_count_mode (void) { return TARGET_64BIT ? DImode : SImode; } -static machine_mode +static scalar_int_mode s390_unwind_word_mode (void) { return TARGET_64BIT ? DImode : SImode; @@ -12855,7 +12855,7 @@ s390_output_mi_thunk (FILE *file, tree thunk ATTRIBUTE_UNUSED, } static bool -s390_valid_pointer_mode (machine_mode mode) +s390_valid_pointer_mode (scalar_int_mode mode) { return (mode == SImode || (TARGET_64BIT && mode == DImode)); } diff --git a/gcc/config/spu/spu.c b/gcc/config/spu/spu.c index ea449e0..565533e 100644 --- a/gcc/config/spu/spu.c +++ b/gcc/config/spu/spu.c @@ -5322,7 +5322,7 @@ spu_rtx_costs (rtx x, machine_mode mode, int outer_code ATTRIBUTE_UNUSED, return true; } -static machine_mode +static scalar_int_mode spu_unwind_word_mode (void) { return SImode; @@ -6698,7 +6698,7 @@ spu_vector_alignment_reachable (const_tree type ATTRIBUTE_UNUSED, bool is_packed } /* Return the appropriate mode for a named address pointer. */ -static machine_mode +static scalar_int_mode spu_addr_space_pointer_mode (addr_space_t addrspace) { switch (addrspace) @@ -6713,7 +6713,7 @@ spu_addr_space_pointer_mode (addr_space_t addrspace) } /* Return the appropriate mode for a named address address. */ -static machine_mode +static scalar_int_mode spu_addr_space_address_mode (addr_space_t addrspace) { switch (addrspace) @@ -6859,7 +6859,7 @@ spu_init_expanders (void) } } -static machine_mode +static scalar_int_mode spu_libgcc_cmp_return_mode (void) { @@ -6868,7 +6868,7 @@ spu_libgcc_cmp_return_mode (void) return SImode; } -static machine_mode +static scalar_int_mode spu_libgcc_shift_count_mode (void) { /* For SPU word mode is TI mode so it is better to use SImode diff --git a/gcc/config/tilegx/tilegx.c b/gcc/config/tilegx/tilegx.c index 5c97c62..9705e23 100644 --- a/gcc/config/tilegx/tilegx.c +++ b/gcc/config/tilegx/tilegx.c @@ -187,7 +187,7 @@ tilegx_return_in_memory (const_tree type, const_tree fndecl ATTRIBUTE_UNUSED) /* Implement TARGET_MODE_REP_EXTENDED. */ static int -tilegx_mode_rep_extended (machine_mode mode, machine_mode mode_rep) +tilegx_mode_rep_extended (scalar_int_mode mode, scalar_int_mode mode_rep) { /* SImode register values are sign-extended to DImode. */ if (mode == SImode && mode_rep == DImode) diff --git a/gcc/doc/tm.texi b/gcc/doc/tm.texi index 05f0719..cc747ea 100644 --- a/gcc/doc/tm.texi +++ b/gcc/doc/tm.texi @@ -1337,21 +1337,21 @@ You would most commonly define this macro if the @code{allocate_stack} pattern needs to support both a 32- and a 64-bit mode. @end defmac -@deftypefn {Target Hook} machine_mode TARGET_LIBGCC_CMP_RETURN_MODE (void) +@deftypefn {Target Hook} scalar_int_mode TARGET_LIBGCC_CMP_RETURN_MODE (void) This target hook should return the mode to be used for the return value of compare instructions expanded to libgcc calls. If not defined @code{word_mode} is returned which is the right choice for a majority of targets. @end deftypefn -@deftypefn {Target Hook} machine_mode TARGET_LIBGCC_SHIFT_COUNT_MODE (void) +@deftypefn {Target Hook} scalar_int_mode TARGET_LIBGCC_SHIFT_COUNT_MODE (void) This target hook should return the mode to be used for the shift count operand of shift instructions expanded to libgcc calls. If not defined @code{word_mode} is returned which is the right choice for a majority of targets. @end deftypefn -@deftypefn {Target Hook} machine_mode TARGET_UNWIND_WORD_MODE (void) +@deftypefn {Target Hook} scalar_int_mode TARGET_UNWIND_WORD_MODE (void) Return machine mode to be used for @code{_Unwind_Word} type. The default is to use @code{word_mode}. @end deftypefn @@ -4194,7 +4194,7 @@ arguments to @code{va_arg}; the latter two are as in @code{gimplify.c:gimplify_expr}. @end deftypefn -@deftypefn {Target Hook} bool TARGET_VALID_POINTER_MODE (machine_mode @var{mode}) +@deftypefn {Target Hook} bool TARGET_VALID_POINTER_MODE (scalar_int_mode @var{mode}) Define this to return nonzero if the port can handle pointers with machine mode @var{mode}. The default version of this hook returns true for both @code{ptr_mode} and @code{Pmode}. @@ -10495,19 +10495,19 @@ named address space #1: c_register_addr_space ("__ea", ADDR_SPACE_EA); @end smallexample -@deftypefn {Target Hook} machine_mode TARGET_ADDR_SPACE_POINTER_MODE (addr_space_t @var{address_space}) +@deftypefn {Target Hook} scalar_int_mode TARGET_ADDR_SPACE_POINTER_MODE (addr_space_t @var{address_space}) Define this to return the machine mode to use for pointers to @var{address_space} if the target supports named address spaces. The default version of this hook returns @code{ptr_mode}. @end deftypefn -@deftypefn {Target Hook} machine_mode TARGET_ADDR_SPACE_ADDRESS_MODE (addr_space_t @var{address_space}) +@deftypefn {Target Hook} scalar_int_mode TARGET_ADDR_SPACE_ADDRESS_MODE (addr_space_t @var{address_space}) Define this to return the machine mode to use for addresses in @var{address_space} if the target supports named address spaces. The default version of this hook returns @code{Pmode}. @end deftypefn -@deftypefn {Target Hook} bool TARGET_ADDR_SPACE_VALID_POINTER_MODE (machine_mode @var{mode}, addr_space_t @var{as}) +@deftypefn {Target Hook} bool TARGET_ADDR_SPACE_VALID_POINTER_MODE (scalar_int_mode @var{mode}, addr_space_t @var{as}) Define this to return nonzero if the port can handle pointers with machine mode @var{mode} to address space @var{as}. This target hook is the same as the @code{TARGET_VALID_POINTER_MODE} target hook, @@ -10770,7 +10770,7 @@ If this is the case, making @code{TRULY_NOOP_TRUNCATION} return 0 in such cases may improve things. @end defmac -@deftypefn {Target Hook} int TARGET_MODE_REP_EXTENDED (machine_mode @var{mode}, machine_mode @var{rep_mode}) +@deftypefn {Target Hook} int TARGET_MODE_REP_EXTENDED (scalar_int_mode @var{mode}, scalar_int_mode @var{rep_mode}) The representation of an integral mode can be such that the values are always extended to a wider integral mode. Return @code{SIGN_EXTEND} if values of @var{mode} are represented in diff --git a/gcc/dojump.c b/gcc/dojump.c index c48d2ed..19539e9 100644 --- a/gcc/dojump.c +++ b/gcc/dojump.c @@ -37,7 +37,7 @@ along with GCC; see the file COPYING3. If not see #include "expr.h" #include "langhooks.h" -static bool prefer_and_bit_test (machine_mode, int); +static bool prefer_and_bit_test (scalar_int_mode, int); static void do_jump_by_parts_greater (scalar_int_mode, tree, tree, int, rtx_code_label *, rtx_code_label *, int); static void do_jump_by_parts_equality (scalar_int_mode, tree, tree, @@ -167,7 +167,7 @@ static GTY(()) rtx shift_test; is preferred. */ static bool -prefer_and_bit_test (machine_mode mode, int bitnum) +prefer_and_bit_test (scalar_int_mode mode, int bitnum) { bool speed_p; wide_int mask = wi::set_bit_in_zero (bitnum, GET_MODE_PRECISION (mode)); @@ -432,7 +432,7 @@ do_jump (tree exp, rtx_code_label *if_false_label, rtx temp; int i; tree type; - machine_mode mode; + scalar_int_mode mode; rtx_code_label *drop_through_label = NULL; switch (code) diff --git a/gcc/dwarf2cfi.c b/gcc/dwarf2cfi.c index d7b0e5c..c9145cc 100644 --- a/gcc/dwarf2cfi.c +++ b/gcc/dwarf2cfi.c @@ -234,7 +234,7 @@ expand_builtin_dwarf_sp_column (void) which has mode MODE. Initialize column C as a return address column. */ static void -init_return_column_size (machine_mode mode, rtx mem, unsigned int c) +init_return_column_size (scalar_int_mode mode, rtx mem, unsigned int c) { HOST_WIDE_INT offset = c * GET_MODE_SIZE (mode); HOST_WIDE_INT size = GET_MODE_SIZE (Pmode); diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c index accca42..ae75e57 100644 --- a/gcc/dwarf2out.c +++ b/gcc/dwarf2out.c @@ -13712,7 +13712,7 @@ base_type_for_mode (machine_mode mode, bool unsignedp) possible. */ static dw_loc_descr_ref -convert_descriptor_to_mode (machine_mode mode, dw_loc_descr_ref op) +convert_descriptor_to_mode (scalar_int_mode mode, dw_loc_descr_ref op) { machine_mode outer_mode = mode; dw_die_ref type_die; diff --git a/gcc/emit-rtl.c b/gcc/emit-rtl.c index 9fbd7a2..7267d06 100644 --- a/gcc/emit-rtl.c +++ b/gcc/emit-rtl.c @@ -2196,12 +2196,12 @@ adjust_address_1 (rtx memref, machine_mode mode, HOST_WIDE_INT offset, { rtx addr = XEXP (memref, 0); rtx new_rtx; - machine_mode address_mode; + scalar_int_mode address_mode; int pbits; struct mem_attrs attrs = *get_mem_attrs (memref), *defattrs; unsigned HOST_WIDE_INT max_align; #ifdef POINTERS_EXTEND_UNSIGNED - machine_mode pointer_mode + scalar_int_mode pointer_mode = targetm.addr_space.pointer_mode (attrs.addrspace); #endif diff --git a/gcc/except.c b/gcc/except.c index 2379fb3..1be39f0 100644 --- a/gcc/except.c +++ b/gcc/except.c @@ -1251,8 +1251,8 @@ sjlj_emit_function_exit (void) static void sjlj_emit_dispatch_table (rtx_code_label *dispatch_label, int num_dispatch) { - machine_mode unwind_word_mode = targetm.unwind_word_mode (); - machine_mode filter_mode = targetm.eh_return_filter_mode (); + scalar_int_mode unwind_word_mode = targetm.unwind_word_mode (); + scalar_int_mode filter_mode = targetm.eh_return_filter_mode (); eh_landing_pad lp; rtx mem, fc, exc_ptr_reg, filter_reg; rtx_insn *seq; @@ -2078,7 +2078,7 @@ expand_builtin_eh_copy_values (tree exp) = expand_builtin_eh_common (CALL_EXPR_ARG (exp, 0)); eh_region src = expand_builtin_eh_common (CALL_EXPR_ARG (exp, 1)); - machine_mode fmode = targetm.eh_return_filter_mode (); + scalar_int_mode fmode = targetm.eh_return_filter_mode (); if (dst->exc_ptr_reg == NULL) dst->exc_ptr_reg = gen_reg_rtx (ptr_mode); diff --git a/gcc/explow.c b/gcc/explow.c index 6348035..e615e5b 100644 --- a/gcc/explow.c +++ b/gcc/explow.c @@ -274,7 +274,7 @@ break_out_memory_refs (rtx x) it should return NULL if it can't be simplified without emitting insns. */ rtx -convert_memory_address_addr_space_1 (machine_mode to_mode ATTRIBUTE_UNUSED, +convert_memory_address_addr_space_1 (scalar_int_mode to_mode ATTRIBUTE_UNUSED, rtx x, addr_space_t as ATTRIBUTE_UNUSED, bool in_const ATTRIBUTE_UNUSED, bool no_emit ATTRIBUTE_UNUSED) @@ -283,7 +283,7 @@ convert_memory_address_addr_space_1 (machine_mode to_mode ATTRIBUTE_UNUSED, gcc_assert (GET_MODE (x) == to_mode || GET_MODE (x) == VOIDmode); return x; #else /* defined(POINTERS_EXTEND_UNSIGNED) */ - machine_mode pointer_mode, address_mode, from_mode; + scalar_int_mode pointer_mode, address_mode, from_mode; rtx temp; enum rtx_code code; @@ -379,7 +379,8 @@ convert_memory_address_addr_space_1 (machine_mode to_mode ATTRIBUTE_UNUSED, arithmetic insns can be used. */ rtx -convert_memory_address_addr_space (machine_mode to_mode, rtx x, addr_space_t as) +convert_memory_address_addr_space (scalar_int_mode to_mode, rtx x, + addr_space_t as) { return convert_memory_address_addr_space_1 (to_mode, x, as, false, false); } @@ -393,7 +394,7 @@ rtx memory_address_addr_space (machine_mode mode, rtx x, addr_space_t as) { rtx oldx = x; - machine_mode address_mode = targetm.addr_space.address_mode (as); + scalar_int_mode address_mode = targetm.addr_space.address_mode (as); x = convert_memory_address_addr_space (address_mode, x, as); diff --git a/gcc/expmed.c b/gcc/expmed.c index 8ce9d96..5da4c0b 100644 --- a/gcc/expmed.c +++ b/gcc/expmed.c @@ -72,8 +72,8 @@ static rtx extract_split_bit_field (rtx, opt_scalar_int_mode, unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, int, bool); static void do_cmp_and_jump (rtx, rtx, enum rtx_code, machine_mode, rtx_code_label *); -static rtx expand_smod_pow2 (machine_mode, rtx, HOST_WIDE_INT); -static rtx expand_sdiv_pow2 (machine_mode, rtx, HOST_WIDE_INT); +static rtx expand_smod_pow2 (scalar_int_mode, rtx, HOST_WIDE_INT); +static rtx expand_sdiv_pow2 (scalar_int_mode, rtx, HOST_WIDE_INT); /* Return a constant integer mask value of mode MODE with BITSIZE ones followed by BITPOS zeros, or the complement of that if COMPLEMENT. @@ -81,7 +81,7 @@ static rtx expand_sdiv_pow2 (machine_mode, rtx, HOST_WIDE_INT); mask is zero-extended if BITSIZE+BITPOS is too small for MODE. */ static inline rtx -mask_rtx (machine_mode mode, int bitpos, int bitsize, bool complement) +mask_rtx (scalar_int_mode mode, int bitpos, int bitsize, bool complement) { return immed_wide_int_const (wi::shifted_mask (bitpos, bitsize, complement, @@ -118,8 +118,8 @@ struct init_expmed_rtl }; static void -init_expmed_one_conv (struct init_expmed_rtl *all, machine_mode to_mode, - machine_mode from_mode, bool speed) +init_expmed_one_conv (struct init_expmed_rtl *all, scalar_int_mode to_mode, + scalar_int_mode from_mode, bool speed) { int to_size, from_size; rtx which; @@ -476,7 +476,7 @@ adjust_bit_field_mem_for_reg (enum extraction_pattern pattern, { /* Limit the search to the mode required by the corresponding register insertion or extraction instruction, if any. */ - machine_mode limit_mode = word_mode; + scalar_int_mode limit_mode = word_mode; extraction_insn insn; if (get_best_reg_extraction_insn (&insn, pattern, GET_MODE_BITSIZE (best_mode), @@ -2199,7 +2199,7 @@ extract_split_bit_field (rtx op0, opt_scalar_int_mode op0_mode, rtx extract_low_bits (machine_mode mode, machine_mode src_mode, rtx src) { - machine_mode int_mode, src_int_mode; + scalar_int_mode int_mode, src_int_mode; if (mode == src_mode) return src; @@ -2530,9 +2530,9 @@ static void synth_mult (struct algorithm *, unsigned HOST_WIDE_INT, static rtx expand_mult_const (machine_mode, rtx, HOST_WIDE_INT, rtx, const struct algorithm *, enum mult_variant); static unsigned HOST_WIDE_INT invert_mod2n (unsigned HOST_WIDE_INT, int); -static rtx extract_high_half (machine_mode, rtx); -static rtx expmed_mult_highpart (machine_mode, rtx, rtx, rtx, int, int); -static rtx expmed_mult_highpart_optab (machine_mode, rtx, rtx, rtx, +static rtx extract_high_half (scalar_int_mode, rtx); +static rtx expmed_mult_highpart (scalar_int_mode, rtx, rtx, rtx, int, int); +static rtx expmed_mult_highpart_optab (scalar_int_mode, rtx, rtx, rtx, int, int); /* Compute and return the best algorithm for multiplying by T. The algorithm must cost less than cost_limit @@ -3575,7 +3575,7 @@ invert_mod2n (unsigned HOST_WIDE_INT x, int n) MODE is the mode of operation. */ rtx -expand_mult_highpart_adjust (machine_mode mode, rtx adj_operand, rtx op0, +expand_mult_highpart_adjust (scalar_int_mode mode, rtx adj_operand, rtx op0, rtx op1, rtx target, int unsignedp) { rtx tem; @@ -3600,7 +3600,7 @@ expand_mult_highpart_adjust (machine_mode mode, rtx adj_operand, rtx op0, /* Subroutine of expmed_mult_highpart. Return the MODE high part of OP. */ static rtx -extract_high_half (machine_mode mode, rtx op) +extract_high_half (scalar_int_mode mode, rtx op) { machine_mode wider_mode; @@ -3619,7 +3619,7 @@ extract_high_half (machine_mode mode, rtx op) optab. OP1 is an rtx for the constant operand. */ static rtx -expmed_mult_highpart_optab (machine_mode mode, rtx op0, rtx op1, +expmed_mult_highpart_optab (scalar_int_mode mode, rtx op0, rtx op1, rtx target, int unsignedp, int max_cost) { rtx narrow_op1 = gen_int_mode (INTVAL (op1), mode); @@ -3734,7 +3734,7 @@ expmed_mult_highpart_optab (machine_mode mode, rtx op0, rtx op1, MAX_COST is the total allowed cost for the expanded RTL. */ static rtx -expmed_mult_highpart (machine_mode mode, rtx op0, rtx op1, +expmed_mult_highpart (scalar_int_mode mode, rtx op0, rtx op1, rtx target, int unsignedp, int max_cost) { machine_mode wider_mode = *GET_MODE_WIDER_MODE (mode); @@ -3798,7 +3798,7 @@ expmed_mult_highpart (machine_mode mode, rtx op0, rtx op1, /* Expand signed modulus of OP0 by a power of two D in mode MODE. */ static rtx -expand_smod_pow2 (machine_mode mode, rtx op0, HOST_WIDE_INT d) +expand_smod_pow2 (scalar_int_mode mode, rtx op0, HOST_WIDE_INT d) { rtx result, temp, shift; rtx_code_label *label; @@ -3895,7 +3895,7 @@ expand_smod_pow2 (machine_mode mode, rtx op0, HOST_WIDE_INT d) This routine is only called for positive values of D. */ static rtx -expand_sdiv_pow2 (machine_mode mode, rtx op0, HOST_WIDE_INT d) +expand_sdiv_pow2 (scalar_int_mode mode, rtx op0, HOST_WIDE_INT d) { rtx temp; rtx_code_label *label; diff --git a/gcc/expmed.h b/gcc/expmed.h index f22fa1e..1f95652 100644 --- a/gcc/expmed.h +++ b/gcc/expmed.h @@ -728,6 +728,7 @@ extern rtx extract_bit_field (rtx, unsigned HOST_WIDE_INT, machine_mode, machine_mode, bool); extern rtx extract_low_bits (machine_mode, machine_mode, rtx); extern rtx expand_mult (machine_mode, rtx, rtx, rtx, int); -extern rtx expand_mult_highpart_adjust (machine_mode, rtx, rtx, rtx, rtx, int); +extern rtx expand_mult_highpart_adjust (scalar_int_mode, rtx, rtx, rtx, + rtx, int); #endif // EXPMED_H diff --git a/gcc/expr.c b/gcc/expr.c index b331563..2376d69 100644 --- a/gcc/expr.c +++ b/gcc/expr.c @@ -839,7 +839,7 @@ class pieces_addr void *m_cfndata; public: pieces_addr (rtx, bool, by_pieces_constfn, void *); - rtx adjust (machine_mode, HOST_WIDE_INT); + rtx adjust (scalar_int_mode, HOST_WIDE_INT); void increment_address (HOST_WIDE_INT); void maybe_predec (HOST_WIDE_INT); void maybe_postinc (HOST_WIDE_INT); @@ -941,7 +941,7 @@ pieces_addr::decide_autoinc (machine_mode ARG_UNUSED (mode), bool reverse, but we still modify the MEM's properties. */ rtx -pieces_addr::adjust (machine_mode mode, HOST_WIDE_INT offset) +pieces_addr::adjust (scalar_int_mode mode, HOST_WIDE_INT offset) { if (m_constfn) return m_constfn (m_cfndata, offset, mode); @@ -1274,7 +1274,7 @@ store_by_pieces_d::finish_endp (int endp) int can_store_by_pieces (unsigned HOST_WIDE_INT len, - rtx (*constfun) (void *, HOST_WIDE_INT, machine_mode), + rtx (*constfun) (void *, HOST_WIDE_INT, scalar_int_mode), void *constfundata, unsigned int align, bool memsetp) { unsigned HOST_WIDE_INT l; @@ -1353,7 +1353,7 @@ can_store_by_pieces (unsigned HOST_WIDE_INT len, rtx store_by_pieces (rtx to, unsigned HOST_WIDE_INT len, - rtx (*constfun) (void *, HOST_WIDE_INT, machine_mode), + rtx (*constfun) (void *, HOST_WIDE_INT, scalar_int_mode), void *constfundata, unsigned int align, bool memsetp, int endp) { if (len == 0) @@ -1380,7 +1380,7 @@ store_by_pieces (rtx to, unsigned HOST_WIDE_INT len, Return const0_rtx unconditionally. */ static rtx -clear_by_pieces_1 (void *, HOST_WIDE_INT, machine_mode) +clear_by_pieces_1 (void *, HOST_WIDE_INT, scalar_int_mode) { return const0_rtx; } @@ -7705,7 +7705,7 @@ expand_expr_constant (tree exp, int defer, enum expand_modifier modifier) The TARGET, TMODE and MODIFIER arguments are as for expand_expr. */ static rtx -expand_expr_addr_expr_1 (tree exp, rtx target, machine_mode tmode, +expand_expr_addr_expr_1 (tree exp, rtx target, scalar_int_mode tmode, enum expand_modifier modifier, addr_space_t as) { rtx result, subtarget; @@ -7890,8 +7890,8 @@ expand_expr_addr_expr (tree exp, rtx target, machine_mode tmode, enum expand_modifier modifier) { addr_space_t as = ADDR_SPACE_GENERIC; - machine_mode address_mode = Pmode; - machine_mode pointer_mode = ptr_mode; + scalar_int_mode address_mode = Pmode; + scalar_int_mode pointer_mode = ptr_mode; machine_mode rmode; rtx result; @@ -7909,9 +7909,9 @@ expand_expr_addr_expr (tree exp, rtx target, machine_mode tmode, /* We can get called with some Weird Things if the user does silliness like "(short) &a". In that case, convert_memory_address won't do the right thing, so ignore the given target mode. */ - machine_mode new_tmode = (tmode == pointer_mode - ? pointer_mode - : address_mode); + scalar_int_mode new_tmode = (tmode == pointer_mode + ? pointer_mode + : address_mode); result = expand_expr_addr_expr_1 (TREE_OPERAND (exp, 0), target, new_tmode, modifier, as); @@ -9923,7 +9923,7 @@ expand_expr_real_1 (tree exp, rtx target, machine_mode tmode, /* Writing into CONST_DECL is always invalid, but handle it gracefully. */ addr_space_t as = TYPE_ADDR_SPACE (TREE_TYPE (exp)); - machine_mode address_mode = targetm.addr_space.address_mode (as); + scalar_int_mode address_mode = targetm.addr_space.address_mode (as); op0 = expand_expr_addr_expr_1 (exp, NULL_RTX, address_mode, EXPAND_NORMAL, as); op0 = memory_address_addr_space (mode, op0, as); @@ -11461,7 +11461,7 @@ try_casesi (tree index_type, tree index_expr, tree minval, tree range, int default_probability) { struct expand_operand ops[5]; - machine_mode index_mode = SImode; + scalar_int_mode index_mode = SImode; rtx op1, op2, index; if (! targetm.have_casesi ()) diff --git a/gcc/expr.h b/gcc/expr.h index 558721d..a2be4a6 100644 --- a/gcc/expr.h +++ b/gcc/expr.h @@ -103,7 +103,7 @@ enum block_op_methods BLOCK_OP_TAILCALL }; -typedef rtx (*by_pieces_constfn) (void *, HOST_WIDE_INT, machine_mode); +typedef rtx (*by_pieces_constfn) (void *, HOST_WIDE_INT, scalar_int_mode); extern rtx emit_block_move (rtx, rtx, rtx, enum block_op_methods); extern rtx emit_block_move_hints (rtx, rtx, rtx, enum block_op_methods, diff --git a/gcc/final.c b/gcc/final.c index 388ef64..531a8a3 100644 --- a/gcc/final.c +++ b/gcc/final.c @@ -1271,7 +1271,7 @@ shorten_branches (rtx_insn *first) rtx_insn *prev; int rel_align = 0; addr_diff_vec_flags flags; - machine_mode vec_mode; + scalar_int_mode vec_mode; /* Avoid automatic aggregate initialization. */ flags = ADDR_DIFF_VEC_FLAGS (body); diff --git a/gcc/fold-const.c b/gcc/fold-const.c index 902e22b..d9ee4fb 100644 --- a/gcc/fold-const.c +++ b/gcc/fold-const.c @@ -1919,7 +1919,7 @@ fold_convert_const_int_from_fixed (tree type, const_tree arg1) { tree t; double_int temp, temp_trunc; - unsigned int mode; + machine_mode mode; /* Right shift FIXED_CST to temp by fbit. */ temp = TREE_FIXED_CST (arg1).data; diff --git a/gcc/internal-fn.c b/gcc/internal-fn.c index 61e844f..9dd9eb5 100644 --- a/gcc/internal-fn.c +++ b/gcc/internal-fn.c @@ -580,7 +580,7 @@ expand_arith_set_overflow (tree lhs, rtx target) static void expand_arith_overflow_result_store (tree lhs, rtx target, - machine_mode mode, rtx res) + scalar_int_mode mode, rtx res) { scalar_int_mode tgtmode = as_a (GET_MODE_INNER (GET_MODE (target))); @@ -1468,8 +1468,7 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1, { struct separate_ops ops; int prec = GET_MODE_PRECISION (mode); - scalar_int_mode hmode; - machine_mode wmode; + scalar_int_mode hmode, wmode; ops.op0 = make_tree (type, op0); ops.op1 = make_tree (type, op1); ops.op2 = NULL_TREE; diff --git a/gcc/loop-doloop.c b/gcc/loop-doloop.c index b032534..528e209 100644 --- a/gcc/loop-doloop.c +++ b/gcc/loop-doloop.c @@ -409,7 +409,7 @@ doloop_modify (struct loop *loop, struct niter_desc *desc, int nonneg = 0; bool increment_count; basic_block loop_end = desc->out_edge->src; - machine_mode mode; + scalar_int_mode mode; rtx true_prob_val; widest_int iterations; @@ -606,7 +606,7 @@ record_reg_sets (rtx x, const_rtx pat ATTRIBUTE_UNUSED, void *data) static bool doloop_optimize (struct loop *loop) { - machine_mode mode; + scalar_int_mode mode; rtx doloop_reg; rtx count; widest_int iterations, iterations_max; diff --git a/gcc/lower-subreg.h b/gcc/lower-subreg.h index 82dc13b..06c2f4f 100644 --- a/gcc/lower-subreg.h +++ b/gcc/lower-subreg.h @@ -43,7 +43,7 @@ struct lower_subreg_choices { /* Target-specific information for the subreg lowering pass. */ struct target_lower_subreg { /* An integer mode that is twice as wide as word_mode. */ - machine_mode x_twice_word_mode; + scalar_int_mode x_twice_word_mode; /* What we have decided to do when optimizing for size (index 0) and speed (index 1). */ diff --git a/gcc/optabs.c b/gcc/optabs.c index cc03c9b..6aa5de1 100644 --- a/gcc/optabs.c +++ b/gcc/optabs.c @@ -434,7 +434,7 @@ expand_superword_shift (optab binoptab, rtx outof_input, rtx superword_op1, value are the same as for the parent routine. */ static bool -expand_subword_shift (machine_mode op1_mode, optab binoptab, +expand_subword_shift (scalar_int_mode op1_mode, optab binoptab, rtx outof_input, rtx into_input, rtx op1, rtx outof_target, rtx into_target, int unsignedp, enum optab_methods methods, @@ -517,7 +517,7 @@ expand_subword_shift (machine_mode op1_mode, optab binoptab, arguments are the same as the parent routine. */ static bool -expand_doubleword_shift_condmove (machine_mode op1_mode, optab binoptab, +expand_doubleword_shift_condmove (scalar_int_mode op1_mode, optab binoptab, enum rtx_code cmp_code, rtx cmp1, rtx cmp2, rtx outof_input, rtx into_input, rtx subword_op1, rtx superword_op1, @@ -600,7 +600,7 @@ expand_doubleword_shift_condmove (machine_mode op1_mode, optab binoptab, Return true if the shift could be successfully synthesized. */ static bool -expand_doubleword_shift (machine_mode op1_mode, optab binoptab, +expand_doubleword_shift (scalar_int_mode op1_mode, optab binoptab, rtx outof_input, rtx into_input, rtx op1, rtx outof_target, rtx into_target, int unsignedp, enum optab_methods methods, @@ -2165,7 +2165,7 @@ widen_leading (scalar_int_mode mode, rtx op0, rtx target, optab unoptab) /* Try calculating clz of a double-word quantity as two clz's of word-sized quantities, choosing which based on whether the high word is nonzero. */ static rtx -expand_doubleword_clz (machine_mode mode, rtx op0, rtx target) +expand_doubleword_clz (scalar_int_mode mode, rtx op0, rtx target) { rtx xop0 = force_reg (mode, op0); rtx subhi = gen_highpart (word_mode, xop0); @@ -2236,7 +2236,7 @@ expand_doubleword_clz (machine_mode mode, rtx op0, rtx target) /* Try calculating popcount of a double-word quantity as two popcount's of word-sized quantities and summing up the results. */ static rtx -expand_doubleword_popcount (machine_mode mode, rtx op0, rtx target) +expand_doubleword_popcount (scalar_int_mode mode, rtx op0, rtx target) { rtx t0, t1, t; rtx_insn *seq; @@ -2276,7 +2276,7 @@ expand_doubleword_popcount (machine_mode mode, rtx op0, rtx target) as (parity:narrow (low (x) ^ high (x))) */ static rtx -expand_doubleword_parity (machine_mode mode, rtx op0, rtx target) +expand_doubleword_parity (scalar_int_mode mode, rtx op0, rtx target) { rtx t = expand_binop (word_mode, xor_optab, operand_subword_force (op0, 0, mode), @@ -2552,7 +2552,7 @@ expand_absneg_bit (enum rtx_code code, scalar_float_mode mode, { const struct real_format *fmt; int bitpos, word, nwords, i; - machine_mode imode; + scalar_int_mode imode; rtx temp; rtx_insn *insns; @@ -4062,13 +4062,13 @@ prepare_float_lib_cmp (rtx x, rtx y, enum rtx_code comparison, enum rtx_code swapped = swap_condition (comparison); enum rtx_code reversed = reverse_condition_maybe_unordered (comparison); machine_mode orig_mode = GET_MODE (x); - machine_mode mode, cmp_mode; + machine_mode mode; rtx true_rtx, false_rtx; rtx value, target, equiv; rtx_insn *insns; rtx libfunc = 0; bool reversed_p = false; - cmp_mode = targetm.libgcc_cmp_return_mode (); + scalar_int_mode cmp_mode = targetm.libgcc_cmp_return_mode (); FOR_EACH_MODE_FROM (mode, orig_mode) { diff --git a/gcc/rtl.h b/gcc/rtl.h index 0d1dc85..35cfbe6 100644 --- a/gcc/rtl.h +++ b/gcc/rtl.h @@ -2849,9 +2849,9 @@ subreg_highpart_offset (machine_mode outermode, machine_mode innermode) extern int byte_lowpart_offset (machine_mode, machine_mode); extern rtx make_safe_from (rtx, rtx); -extern rtx convert_memory_address_addr_space_1 (machine_mode, rtx, +extern rtx convert_memory_address_addr_space_1 (scalar_int_mode, rtx, addr_space_t, bool, bool); -extern rtx convert_memory_address_addr_space (machine_mode, rtx, +extern rtx convert_memory_address_addr_space (scalar_int_mode, rtx, addr_space_t); #define convert_memory_address(to_mode,x) \ convert_memory_address_addr_space ((to_mode), (x), ADDR_SPACE_GENERIC) @@ -3051,7 +3051,7 @@ inline rtx single_set (const rtx_insn *insn) return single_set_2 (insn, PATTERN (insn)); } -extern machine_mode get_address_mode (rtx mem); +extern scalar_int_mode get_address_mode (rtx mem); extern int rtx_addr_can_trap_p (const_rtx); extern bool nonzero_address_p (const_rtx); extern int rtx_unstable_p (const_rtx); @@ -3782,8 +3782,8 @@ extern GTY(()) rtx stack_limit_rtx; extern unsigned int variable_tracking_main (void); /* In stor-layout.c. */ -extern void get_mode_bounds (machine_mode, int, machine_mode, - rtx *, rtx *); +extern void get_mode_bounds (scalar_int_mode, int, + scalar_int_mode, rtx *, rtx *); /* In loop-iv.c */ extern rtx canon_condition (rtx); diff --git a/gcc/rtlanal.c b/gcc/rtlanal.c index f74bf14..e47c50d 100644 --- a/gcc/rtlanal.c +++ b/gcc/rtlanal.c @@ -5736,7 +5736,7 @@ low_bitmask_len (machine_mode mode, unsigned HOST_WIDE_INT m) /* Return the mode of MEM's address. */ -machine_mode +scalar_int_mode get_address_mode (rtx mem) { machine_mode mode; diff --git a/gcc/stor-layout.c b/gcc/stor-layout.c index 8ff73ef..48634d9 100644 --- a/gcc/stor-layout.c +++ b/gcc/stor-layout.c @@ -2880,8 +2880,8 @@ get_best_mode (int bitsize, int bitpos, SIGN). The returned constants are made to be usable in TARGET_MODE. */ void -get_mode_bounds (machine_mode mode, int sign, - machine_mode target_mode, +get_mode_bounds (scalar_int_mode mode, int sign, + scalar_int_mode target_mode, rtx *mmin, rtx *mmax) { unsigned size = GET_MODE_PRECISION (mode); diff --git a/gcc/target.def b/gcc/target.def index c450a1d..25473c6 100644 --- a/gcc/target.def +++ b/gcc/target.def @@ -1989,7 +1989,7 @@ char *, (void), hook_charptr_void_null) DEFHOOK_UNDOC (eh_return_filter_mode, "Return machine mode for filter value.", - machine_mode, (void), + scalar_int_mode, (void), default_eh_return_filter_mode) /* Return machine mode for libgcc expanded cmp instructions. */ @@ -1999,7 +1999,7 @@ DEFHOOK of compare instructions expanded to libgcc calls. If not defined\n\ @code{word_mode} is returned which is the right choice for a majority of\n\ targets.", - machine_mode, (void), + scalar_int_mode, (void), default_libgcc_cmp_return_mode) /* Return machine mode for libgcc expanded shift instructions. */ @@ -2009,7 +2009,7 @@ DEFHOOK of shift instructions expanded to libgcc calls. If not defined\n\ @code{word_mode} is returned which is the right choice for a majority of\n\ targets.", - machine_mode, (void), + scalar_int_mode, (void), default_libgcc_shift_count_mode) /* Return machine mode to be used for _Unwind_Word type. */ @@ -2017,7 +2017,7 @@ DEFHOOK (unwind_word_mode, "Return machine mode to be used for @code{_Unwind_Word} type.\n\ The default is to use @code{word_mode}.", - machine_mode, (void), + scalar_int_mode, (void), default_unwind_word_mode) /* Given two decls, merge their attributes and return the result. */ @@ -3136,7 +3136,7 @@ extension.\n\ In order to enforce the representation of @code{mode},\n\ @code{TRULY_NOOP_TRUNCATION} should return false when truncating to\n\ @code{mode}.", - int, (machine_mode mode, machine_mode rep_mode), + int, (scalar_int_mode mode, scalar_int_mode rep_mode), default_mode_rep_extended) /* True if MODE is valid for a pointer in __attribute__((mode("MODE"))). */ @@ -3145,7 +3145,7 @@ DEFHOOK "Define this to return nonzero if the port can handle pointers\n\ with machine mode @var{mode}. The default version of this\n\ hook returns true for both @code{ptr_mode} and @code{Pmode}.", - bool, (machine_mode mode), + bool, (scalar_int_mode mode), default_valid_pointer_mode) /* Disambiguate with errno. */ @@ -3170,7 +3170,7 @@ DEFHOOK "Define this to return the machine mode to use for pointers to\n\ @var{address_space} if the target supports named address spaces.\n\ The default version of this hook returns @code{ptr_mode}.", - machine_mode, (addr_space_t address_space), + scalar_int_mode, (addr_space_t address_space), default_addr_space_pointer_mode) /* MODE to use for an address in another address space. */ @@ -3179,7 +3179,7 @@ DEFHOOK "Define this to return the machine mode to use for addresses in\n\ @var{address_space} if the target supports named address spaces.\n\ The default version of this hook returns @code{Pmode}.", - machine_mode, (addr_space_t address_space), + scalar_int_mode, (addr_space_t address_space), default_addr_space_address_mode) /* True if MODE is valid for a pointer in __attribute__((mode("MODE"))) @@ -3193,7 +3193,7 @@ except that it includes explicit named address space support. The default\n\ version of this hook returns true for the modes returned by either the\n\ @code{TARGET_ADDR_SPACE_POINTER_MODE} or @code{TARGET_ADDR_SPACE_ADDRESS_MODE}\n\ target hooks for the given address space.", - bool, (machine_mode mode, addr_space_t as), + bool, (scalar_int_mode mode, addr_space_t as), default_addr_space_valid_pointer_mode) /* True if an address is a valid memory address to a given named address diff --git a/gcc/targhooks.c b/gcc/targhooks.c index 8951bc3..df76ba1 100644 --- a/gcc/targhooks.c +++ b/gcc/targhooks.c @@ -214,25 +214,25 @@ default_pretend_outgoing_varargs_named (cumulative_args_t ca ATTRIBUTE_UNUSED) != default_setup_incoming_varargs); } -machine_mode +scalar_int_mode default_eh_return_filter_mode (void) { return targetm.unwind_word_mode (); } -machine_mode +scalar_int_mode default_libgcc_cmp_return_mode (void) { return word_mode; } -machine_mode +scalar_int_mode default_libgcc_shift_count_mode (void) { return word_mode; } -machine_mode +scalar_int_mode default_unwind_word_mode (void) { return word_mode; @@ -257,8 +257,7 @@ default_min_divisions_for_recip_mul (machine_mode mode ATTRIBUTE_UNUSED) /* The default implementation of TARGET_MODE_REP_EXTENDED. */ int -default_mode_rep_extended (machine_mode mode ATTRIBUTE_UNUSED, - machine_mode mode_rep ATTRIBUTE_UNUSED) +default_mode_rep_extended (scalar_int_mode, scalar_int_mode) { return UNKNOWN; } @@ -1260,7 +1259,7 @@ default_destroy_cost_data (void *data) /* Determine whether or not a pointer mode is valid. Assume defaults of ptr_mode or Pmode - can be overridden. */ bool -default_valid_pointer_mode (machine_mode mode) +default_valid_pointer_mode (scalar_int_mode mode) { return (mode == ptr_mode || mode == Pmode); } @@ -1295,7 +1294,7 @@ default_ref_may_alias_errno (ao_ref *ref) /* Return the mode for a pointer to a given ADDRSPACE, defaulting to ptr_mode for all address spaces. */ -machine_mode +scalar_int_mode default_addr_space_pointer_mode (addr_space_t addrspace ATTRIBUTE_UNUSED) { return ptr_mode; @@ -1304,7 +1303,7 @@ default_addr_space_pointer_mode (addr_space_t addrspace ATTRIBUTE_UNUSED) /* Return the mode for an address in a given ADDRSPACE, defaulting to Pmode for all address spaces. */ -machine_mode +scalar_int_mode default_addr_space_address_mode (addr_space_t addrspace ATTRIBUTE_UNUSED) { return Pmode; @@ -1314,7 +1313,7 @@ default_addr_space_address_mode (addr_space_t addrspace ATTRIBUTE_UNUSED) To match the above, the same modes apply to all address spaces. */ bool -default_addr_space_valid_pointer_mode (machine_mode mode, +default_addr_space_valid_pointer_mode (scalar_int_mode mode, addr_space_t as ATTRIBUTE_UNUSED) { return targetm.valid_pointer_mode (mode); diff --git a/gcc/targhooks.h b/gcc/targhooks.h index 151c0f0..c182e45 100644 --- a/gcc/targhooks.h +++ b/gcc/targhooks.h @@ -43,14 +43,14 @@ extern void default_setup_incoming_varargs (cumulative_args_t, machine_mode, tre extern rtx default_builtin_setjmp_frame_value (void); extern bool default_pretend_outgoing_varargs_named (cumulative_args_t); -extern machine_mode default_eh_return_filter_mode (void); -extern machine_mode default_libgcc_cmp_return_mode (void); -extern machine_mode default_libgcc_shift_count_mode (void); -extern machine_mode default_unwind_word_mode (void); +extern scalar_int_mode default_eh_return_filter_mode (void); +extern scalar_int_mode default_libgcc_cmp_return_mode (void); +extern scalar_int_mode default_libgcc_shift_count_mode (void); +extern scalar_int_mode default_unwind_word_mode (void); extern unsigned HOST_WIDE_INT default_shift_truncation_mask (machine_mode); extern unsigned int default_min_divisions_for_recip_mul (machine_mode); -extern int default_mode_rep_extended (machine_mode, machine_mode); +extern int default_mode_rep_extended (scalar_int_mode, scalar_int_mode); extern tree default_stack_protect_guard (void); extern tree default_external_stack_protect_fail (void); @@ -169,11 +169,11 @@ extern bool default_mode_dependent_address_p (const_rtx, addr_space_t); extern bool default_target_option_valid_attribute_p (tree, tree, tree, int); extern bool default_target_option_pragma_parse (tree, tree); extern bool default_target_can_inline_p (tree, tree); -extern bool default_valid_pointer_mode (machine_mode); +extern bool default_valid_pointer_mode (scalar_int_mode); extern bool default_ref_may_alias_errno (struct ao_ref *); -extern machine_mode default_addr_space_pointer_mode (addr_space_t); -extern machine_mode default_addr_space_address_mode (addr_space_t); -extern bool default_addr_space_valid_pointer_mode (machine_mode, +extern scalar_int_mode default_addr_space_pointer_mode (addr_space_t); +extern scalar_int_mode default_addr_space_address_mode (addr_space_t); +extern bool default_addr_space_valid_pointer_mode (scalar_int_mode, addr_space_t); extern bool default_addr_space_legitimate_address_p (machine_mode, rtx, bool, addr_space_t); diff --git a/gcc/tree-ssa-address.c b/gcc/tree-ssa-address.c index a53ade0..2de1d5f 100644 --- a/gcc/tree-ssa-address.c +++ b/gcc/tree-ssa-address.c @@ -195,8 +195,8 @@ rtx addr_for_mem_ref (struct mem_address *addr, addr_space_t as, bool really_expand) { - machine_mode address_mode = targetm.addr_space.address_mode (as); - machine_mode pointer_mode = targetm.addr_space.pointer_mode (as); + scalar_int_mode address_mode = targetm.addr_space.address_mode (as); + scalar_int_mode pointer_mode = targetm.addr_space.pointer_mode (as); rtx address, sym, bse, idx, st, off; struct mem_addr_template *templ; diff --git a/gcc/tree-ssa-loop-ivopts.c b/gcc/tree-ssa-loop-ivopts.c index 3653586..837ce65 100644 --- a/gcc/tree-ssa-loop-ivopts.c +++ b/gcc/tree-ssa-loop-ivopts.c @@ -2465,7 +2465,8 @@ compute_max_addr_offset (struct iv_use *use) HOST_WIDE_INT i, off; unsigned list_index, num; addr_space_t as; - machine_mode mem_mode, addr_mode; + machine_mode mem_mode; + scalar_int_mode addr_mode; static vec max_offset_list; as = TYPE_ADDR_SPACE (TREE_TYPE (use->iv->base)); @@ -3970,7 +3971,7 @@ get_address_cost (bool symbol_present, bool var_present, addr_space_t as, bool speed, bool stmt_after_inc, bool *may_autoinc) { - machine_mode address_mode = targetm.addr_space.address_mode (as); + scalar_int_mode address_mode = targetm.addr_space.address_mode (as); static vec address_cost_data_list; unsigned int data_index = (int) as * MAX_MACHINE_MODE + (int) mem_mode; address_cost_data *data; @@ -4285,7 +4286,7 @@ get_address_cost (bool symbol_present, bool var_present, the cost in COST. */ static bool -get_shiftadd_cost (tree expr, machine_mode mode, comp_cost cost0, +get_shiftadd_cost (tree expr, scalar_int_mode mode, comp_cost cost0, comp_cost cost1, tree mult, bool speed, comp_cost *cost) { comp_cost res; diff --git a/gcc/tree-switch-conversion.c b/gcc/tree-switch-conversion.c index e4c8a60..329ece1 100644 --- a/gcc/tree-switch-conversion.c +++ b/gcc/tree-switch-conversion.c @@ -952,7 +952,7 @@ array_value_type (gswitch *swtch, tree type, int num, return type; scalar_int_mode type_mode = SCALAR_INT_TYPE_MODE (type); - machine_mode mode = get_narrowest_mode (type_mode); + scalar_int_mode mode = get_narrowest_mode (type_mode); if (GET_MODE_SIZE (type_mode) <= GET_MODE_SIZE (mode)) return type; diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c index acd536c..41b5065 100644 --- a/gcc/tree-vrp.c +++ b/gcc/tree-vrp.c @@ -9970,7 +9970,7 @@ simplify_float_conversion_using_ranges (gimple_stmt_iterator *gsi, value_range *vr = get_value_range (rhs1); scalar_float_mode fltmode = SCALAR_FLOAT_TYPE_MODE (TREE_TYPE (gimple_assign_lhs (stmt))); - machine_mode mode; + scalar_int_mode mode; tree tem; gassign *conv; diff --git a/gcc/var-tracking.c b/gcc/var-tracking.c index bec9195..6d52bd6 100644 --- a/gcc/var-tracking.c +++ b/gcc/var-tracking.c @@ -970,7 +970,7 @@ use_narrower_mode_test (rtx x, const_rtx subreg) /* Transform X into narrower mode MODE from wider mode WMODE. */ static rtx -use_narrower_mode (rtx x, machine_mode mode, machine_mode wmode) +use_narrower_mode (rtx x, scalar_int_mode mode, scalar_int_mode wmode) { rtx op0, op1; if (CONSTANT_P (x))