From 095a2d76a26fa4ee17fa56bff21bf4f269db2368 Mon Sep 17 00:00:00 2001 From: Richard Sandiford Date: Wed, 30 Aug 2017 11:18:59 +0000 Subject: [PATCH] [62/77] Big machine_mode to scalar_int_mode replacement 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. 2017-08-30 Richard Sandiford Alan Hayward David Sherwood gcc/ * 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 (simplify_if_then_else): Use scalar_int_mode for local variables. (make_extraction): Likewise. (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/powerpcspe/powerpcspe.c (rs6000_abi_word_mode): Likewise. (rs6000_eh_return_filter_mode): Likewise. * config/rs6000/rs6000.c (rs6000_abi_word_mode): Likewise. (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. (scompare_loc_descriptor_wide): Likewise. (scompare_loc_descriptor_narrow): 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. (emit_store_flag_int): 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. * 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 (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. Co-Authored-By: Alan Hayward Co-Authored-By: David Sherwood From-SVN: r251513 --- gcc/ChangeLog | 168 +++++++++++++++++++++++++++++ gcc/builtins.c | 18 ++-- gcc/builtins.h | 4 +- gcc/cfgexpand.c | 2 +- gcc/combine.c | 12 +-- gcc/config/aarch64/aarch64.c | 2 +- gcc/config/alpha/alpha.c | 4 +- gcc/config/avr/avr.c | 4 +- gcc/config/cr16/cr16.c | 2 +- gcc/config/ft32/ft32.c | 6 +- gcc/config/ia64/ia64.c | 4 +- gcc/config/m32c/m32c.c | 6 +- gcc/config/mips/mips.c | 4 +- gcc/config/msp430/msp430.c | 4 +- gcc/config/powerpcspe/powerpcspe.c | 4 +- gcc/config/rl78/rl78.c | 8 +- gcc/config/rs6000/rs6000.c | 4 +- gcc/config/s390/s390.c | 8 +- gcc/config/spu/spu.c | 10 +- gcc/config/tilegx/tilegx.c | 2 +- gcc/doc/tm.texi | 16 +-- gcc/dojump.c | 6 +- gcc/dwarf2cfi.c | 2 +- gcc/dwarf2out.c | 6 +- gcc/emit-rtl.c | 4 +- gcc/except.c | 6 +- gcc/explow.c | 9 +- gcc/expmed.c | 34 +++--- gcc/expmed.h | 3 +- gcc/expr.c | 26 ++--- gcc/expr.h | 2 +- gcc/final.c | 2 +- gcc/fold-const.c | 2 +- gcc/internal-fn.c | 5 +- gcc/loop-doloop.c | 4 +- gcc/optabs.c | 18 ++-- gcc/rtl.h | 10 +- gcc/rtlanal.c | 2 +- gcc/stor-layout.c | 4 +- gcc/target.def | 18 ++-- gcc/targhooks.c | 19 ++-- gcc/targhooks.h | 18 ++-- gcc/tree-ssa-address.c | 4 +- gcc/tree-ssa-loop-ivopts.c | 2 +- gcc/tree-switch-conversion.c | 2 +- gcc/tree-vrp.c | 2 +- gcc/var-tracking.c | 2 +- 47 files changed, 336 insertions(+), 168 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 8c829dc2fe2..d7ee5c29afa 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,171 @@ +2017-08-30 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 (simplify_if_then_else): Use scalar_int_mode for local + variables. + (make_extraction): Likewise. + (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/powerpcspe/powerpcspe.c (rs6000_abi_word_mode): Likewise. + (rs6000_eh_return_filter_mode): Likewise. + * config/rs6000/rs6000.c (rs6000_abi_word_mode): Likewise. + (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. + (scompare_loc_descriptor_wide): Likewise. + (scompare_loc_descriptor_narrow): 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. + (emit_store_flag_int): 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. + * 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 (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. + 2017-08-30 Richard Sandiford Alan Hayward David Sherwood diff --git a/gcc/builtins.c b/gcc/builtins.c index 1343e9ddc07..35be33531b1 100644 --- a/gcc/builtins.c +++ b/gcc/builtins.c @@ -93,7 +93,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); @@ -119,7 +119,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_memchr (tree, rtx); static rtx expand_builtin_memcpy (tree, rtx); static rtx expand_builtin_memcpy_with_bounds (tree, rtx); @@ -136,7 +136,7 @@ static rtx expand_builtin_stpcpy (tree, rtx, machine_mode); static rtx expand_builtin_stpncpy (tree, rtx); 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); @@ -669,7 +669,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; @@ -2883,7 +2883,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; @@ -3744,7 +3744,7 @@ expand_builtin_stpncpy (tree exp, rtx) rtx builtin_strncpy_read_str (void *data, HOST_WIDE_INT offset, - machine_mode mode) + scalar_int_mode mode) { const char *str = (const char *) data; @@ -3952,7 +3952,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)); @@ -3969,7 +3969,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; @@ -5302,7 +5302,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 f590f617400..4ae70566f59 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 34350de2e82..a32f7648d41 100644 --- a/gcc/cfgexpand.c +++ b/gcc/cfgexpand.c @@ -3962,7 +3962,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 022a5b5f15c..bc31280ec3b 100644 --- a/gcc/combine.c +++ b/gcc/combine.c @@ -6494,7 +6494,7 @@ simplify_if_then_else (rtx x) rtx cond_op0 = XEXP (cond, 0); rtx cond_op1 = XEXP (cond, 1); enum rtx_code op = UNKNOWN, extend_op = UNKNOWN; - machine_mode m = int_mode; + scalar_int_mode m = int_mode; rtx z = 0, c1 = NULL_RTX; if ((GET_CODE (t) == PLUS || GET_CODE (t) == MINUS @@ -7427,9 +7427,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; @@ -10316,9 +10316,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 7ca12db76e4..09f592718c6 100644 --- a/gcc/config/aarch64/aarch64.c +++ b/gcc/config/aarch64/aarch64.c @@ -2653,7 +2653,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 64d80a684f0..dbfd29862fc 100644 --- a/gcc/config/alpha/alpha.c +++ b/gcc/config/alpha/alpha.c @@ -209,7 +209,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 @@ -819,7 +819,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 d3d69367e00..ad777e081fd 100644 --- a/gcc/config/avr/avr.c +++ b/gcc/config/avr/avr.c @@ -12929,7 +12929,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; @@ -12938,7 +12938,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 ab6ef7adf1d..729eec80c91 100644 --- a/gcc/config/cr16/cr16.c +++ b/gcc/config/cr16/cr16.c @@ -2092,7 +2092,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 78c5edc8f09..fada9248329 100644 --- a/gcc/config/ft32/ft32.c +++ b/gcc/config/ft32/ft32.c @@ -792,7 +792,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; @@ -801,7 +801,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; @@ -809,7 +809,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 720c16bd003..57975160510 100644 --- a/gcc/config/ia64/ia64.c +++ b/gcc/config/ia64/ia64.c @@ -299,7 +299,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; @@ -10728,7 +10728,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 aceefe0f17a..8552ae69a11 100644 --- a/gcc/config/m32c/m32c.c +++ b/gcc/config/m32c/m32c.c @@ -1437,7 +1437,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 @@ -1930,7 +1930,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) @@ -1947,7 +1947,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 d646f612591..1f42c567149 100644 --- a/gcc/config/mips/mips.c +++ b/gcc/config/mips/mips.c @@ -13262,7 +13262,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) @@ -13274,7 +13274,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 dc803e003e0..d597812ec3e 100644 --- a/gcc/config/msp430/msp430.c +++ b/gcc/config/msp430/msp430.c @@ -1023,7 +1023,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) @@ -1043,7 +1043,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/powerpcspe/powerpcspe.c b/gcc/config/powerpcspe/powerpcspe.c index 5fdba021377..3f418b027fa 100644 --- a/gcc/config/powerpcspe/powerpcspe.c +++ b/gcc/config/powerpcspe/powerpcspe.c @@ -11881,7 +11881,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; @@ -39148,7 +39148,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/rl78/rl78.c b/gcc/config/rl78/rl78.c index 01e0591c5fe..429e934f37a 100644 --- a/gcc/config/rl78/rl78.c +++ b/gcc/config/rl78/rl78.c @@ -998,7 +998,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) @@ -1038,7 +1038,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) @@ -1059,7 +1059,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); } @@ -4638,7 +4638,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 9a0b42af89a..97a7005e2cd 100644 --- a/gcc/config/rs6000/rs6000.c +++ b/gcc/config/rs6000/rs6000.c @@ -11316,7 +11316,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; @@ -35905,7 +35905,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/s390/s390.c b/gcc/config/s390/s390.c index e4d14fbc01d..e013751c7ad 100644 --- a/gcc/config/s390/s390.c +++ b/gcc/config/s390/s390.c @@ -1209,19 +1209,19 @@ s390_got_symbol (void) return got_symbol; } -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; @@ -13138,7 +13138,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 b917609bb60..20c88e6953d 100644 --- a/gcc/config/spu/spu.c +++ b/gcc/config/spu/spu.c @@ -5323,7 +5323,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; @@ -6699,7 +6699,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) @@ -6714,7 +6714,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) @@ -6860,7 +6860,7 @@ spu_init_expanders (void) } } -static machine_mode +static scalar_int_mode spu_libgcc_cmp_return_mode (void) { @@ -6869,7 +6869,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 1dcac599967..250bb34917f 100644 --- a/gcc/config/tilegx/tilegx.c +++ b/gcc/config/tilegx/tilegx.c @@ -188,7 +188,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 59c26677457..b415bf82d77 100644 --- a/gcc/doc/tm.texi +++ b/gcc/doc/tm.texi @@ -1339,21 +1339,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 @@ -4203,7 +4203,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}. @@ -10527,19 +10527,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, @@ -10802,7 +10802,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 cda6f48eb7a..db8b278b982 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 *, profile_probability); @@ -161,7 +161,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)); @@ -427,7 +427,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 8c934842bf8..b2ee8d6cf02 100644 --- a/gcc/dwarf2cfi.c +++ b/gcc/dwarf2cfi.c @@ -232,7 +232,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 ed0824ee198..f857a2773a2 100644 --- a/gcc/dwarf2out.c +++ b/gcc/dwarf2out.c @@ -13890,7 +13890,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; @@ -13935,7 +13935,7 @@ compare_loc_descriptor (enum dwarf_location_atom op, dw_loc_descr_ref op0, static dw_loc_descr_ref scompare_loc_descriptor_wide (enum dwarf_location_atom op, - machine_mode op_mode, + scalar_int_mode op_mode, dw_loc_descr_ref op0, dw_loc_descr_ref op1) { dw_die_ref type_die = base_type_for_mode (op_mode, 0); @@ -13962,7 +13962,7 @@ scompare_loc_descriptor_wide (enum dwarf_location_atom op, static dw_loc_descr_ref scompare_loc_descriptor_narrow (enum dwarf_location_atom op, rtx rtl, - machine_mode op_mode, + scalar_int_mode op_mode, dw_loc_descr_ref op0, dw_loc_descr_ref op1) { int shift = (DWARF2_ADDR_SIZE - GET_MODE_SIZE (op_mode)) * BITS_PER_UNIT; diff --git a/gcc/emit-rtl.c b/gcc/emit-rtl.c index 0391bea259b..f0c09ffebe7 100644 --- a/gcc/emit-rtl.c +++ b/gcc/emit-rtl.c @@ -2211,12 +2211,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 4068b68f31f..1159b188c57 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; @@ -2073,7 +2073,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 c5af8ee82ef..5079629bf6f 100644 --- a/gcc/explow.c +++ b/gcc/explow.c @@ -275,7 +275,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) @@ -284,7 +284,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; @@ -380,7 +380,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); } @@ -394,7 +395,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 3839c762243..5873df42383 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; @@ -478,7 +478,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), @@ -2269,7 +2269,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; @@ -2600,9 +2600,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 @@ -3645,7 +3645,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; @@ -3670,7 +3670,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; @@ -3689,7 +3689,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); @@ -3804,7 +3804,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).require (); @@ -3868,7 +3868,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; @@ -3965,7 +3965,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; @@ -5630,7 +5630,7 @@ emit_store_flag_1 (rtx target, enum rtx_code code, rtx op0, rtx op1, rtx emit_store_flag_int (rtx target, rtx subtarget, enum rtx_code code, rtx op0, - rtx op1, machine_mode mode, int unsignedp, + rtx op1, scalar_int_mode mode, int unsignedp, int normalizep, rtx trueval) { machine_mode target_mode = target ? GET_MODE (target) : VOIDmode; diff --git a/gcc/expmed.h b/gcc/expmed.h index a1940a55264..712c7715ec8 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, rtx *); 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 481ad643956..fcad2e39445 100644 --- a/gcc/expr.c +++ b/gcc/expr.c @@ -842,7 +842,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); @@ -944,7 +944,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); @@ -1277,7 +1277,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; @@ -1356,7 +1356,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) @@ -1383,7 +1383,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; } @@ -7706,7 +7706,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; @@ -7891,8 +7891,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; @@ -7910,9 +7910,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); @@ -9999,7 +9999,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); @@ -11538,7 +11538,7 @@ try_casesi (tree index_type, tree index_expr, tree minval, tree range, profile_probability 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 b92ff3ce8a6..0603797d867 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 8af1f17886b..eff2ee6c496 100644 --- a/gcc/final.c +++ b/gcc/final.c @@ -1276,7 +1276,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 492d7f16169..e61195d9763 100644 --- a/gcc/fold-const.c +++ b/gcc/fold-const.c @@ -1944,7 +1944,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 f8a02f309fc..051f78715c2 100644 --- a/gcc/internal-fn.c +++ b/gcc/internal-fn.c @@ -568,7 +568,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))); @@ -1460,8 +1460,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 d1004a2dc5e..5769d9deccb 100644 --- a/gcc/loop-doloop.c +++ b/gcc/loop-doloop.c @@ -418,7 +418,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; widest_int iterations; jump_insn = BB_END (loop_end); @@ -609,7 +609,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/optabs.c b/gcc/optabs.c index 3cc37c3ef13..86b5926af21 100644 --- a/gcc/optabs.c +++ b/gcc/optabs.c @@ -435,7 +435,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, @@ -518,7 +518,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, @@ -601,7 +601,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, @@ -2167,7 +2167,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); @@ -2238,7 +2238,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; @@ -2278,7 +2278,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), @@ -2555,7 +2555,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; @@ -4067,13 +4067,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 736134f5c52..7363bd65352 100644 --- a/gcc/rtl.h +++ b/gcc/rtl.h @@ -2865,9 +2865,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) @@ -3066,7 +3066,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); @@ -3800,8 +3800,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 63009a2f008..1765dbeb904 100644 --- a/gcc/rtlanal.c +++ b/gcc/rtlanal.c @@ -5793,7 +5793,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 ad42c040e07..012602d2298 100644 --- a/gcc/stor-layout.c +++ b/gcc/stor-layout.c @@ -2917,8 +2917,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 ba8b8a27693..b4f6cb4d617 100644 --- a/gcc/target.def +++ b/gcc/target.def @@ -2009,7 +2009,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. */ @@ -2019,7 +2019,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. */ @@ -2029,7 +2029,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. */ @@ -2037,7 +2037,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. */ @@ -3156,7 +3156,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"))). */ @@ -3165,7 +3165,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. */ @@ -3190,7 +3190,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. */ @@ -3199,7 +3199,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"))) @@ -3213,7 +3213,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 ebc2e9cda2b..48a339f1db3 100644 --- a/gcc/targhooks.c +++ b/gcc/targhooks.c @@ -216,25 +216,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; @@ -259,8 +259,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; } @@ -1256,7 +1255,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); } @@ -1291,7 +1290,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; @@ -1300,7 +1299,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; @@ -1310,7 +1309,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 7c7e7488155..a1f55e52e9a 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 8257fde5240..5e354a17ce9 100644 --- a/gcc/tree-ssa-address.c +++ b/gcc/tree-ssa-address.c @@ -191,8 +191,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 008df2e549c..bbea619171a 100644 --- a/gcc/tree-ssa-loop-ivopts.c +++ b/gcc/tree-ssa-loop-ivopts.c @@ -3960,7 +3960,7 @@ adjust_setup_cost (struct ivopts_data *data, unsigned cost, 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 82961d8985c..d0d08972804 100644 --- a/gcc/tree-switch-conversion.c +++ b/gcc/tree-switch-conversion.c @@ -1051,7 +1051,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 dc5f00ed0ec..84cdd178bfa 100644 --- a/gcc/tree-vrp.c +++ b/gcc/tree-vrp.c @@ -10095,7 +10095,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 9909c4ce0bd..06673ccb4f9 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)) -- 2.30.2